deploy: 054b6c5

Author: rklaehn

pr/101/docs/src/iroh_blobs/store/fs/bao_file.rs.html

@@ -840,23 +840,7 @@
 <a href="#839" id="839">839</a>
 <a href="#840" id="840">840</a>
 <a href="#841" id="841">841</a>
-<a href="#842" id="842">842</a>
-<a href="#843" id="843">843</a>
-<a href="#844" id="844">844</a>
-<a href="#845" id="845">845</a>
-<a href="#846" id="846">846</a>
-<a href="#847" id="847">847</a>
-<a href="#848" id="848">848</a>
-<a href="#849" id="849">849</a>
-<a href="#850" id="850">850</a>
-<a href="#851" id="851">851</a>
-<a href="#852" id="852">852</a>
-<a href="#853" id="853">853</a>
-<a href="#854" id="854">854</a>
-<a href="#855" id="855">855</a>
-<a href="#856" id="856">856</a>
-<a href="#857" id="857">857</a>
-<a href="#858" id="858">858</a></pre></div><pre class="rust"><code><span class="kw">use </span>core::fmt;
+<a href="#842" id="842">842</a></pre></div><pre class="rust"><code><span class="kw">use </span>core::fmt;
 <span class="kw">use </span>std::{
     fs::{File, OpenOptions},
     io,
@@ -892,7 +876,7 @@
         fs::{meta::raw_outboard_size, TaskContext},
         util::{
             read_checksummed_and_truncate, write_checksummed, FixedSize, MemOrFile,
-            PartialMemStorage, SizeInfo, SparseMemFile, DD,
+            PartialMemStorage, DD,
         },
         Hash, IROH_BLOCK_SIZE,
     },
@@ -1389,21 +1373,11 @@
             <span class="kw">if </span>Arc::strong_count(<span class="kw-2">&amp;</span><span class="self">self</span>.<span class="number">0</span>) &gt; <span class="number">1 </span>{
                 <span class="kw">return </span><span class="bool-val">false</span>;
             }
-            <span class="comment">// there is the possibility that somebody else will increase the strong count
-            // here. there is nothing we can do about it, but they won't be able to
-            // access the internals of the handle because we have the lock.
-            //
-            // We poison the storage. A poisoned storage is considered dead and will
-            // have to be recreated, but only *after* we are done with persisting
-            // the bitfield.
-            </span><span class="kw">let </span>BaoFileStorage::Partial(fs) = guard.take() <span class="kw">else </span>{
+            <span class="kw">let </span>BaoFileStorage::Partial(fs) = guard.take() <span class="kw">else </span>{
                 <span class="kw">return </span><span class="bool-val">false</span>;
             };
             <span class="kw">let </span>options = <span class="kw-2">&amp;</span><span class="self">self</span>.options;
             <span class="kw">let </span>path = options.path.bitfield_path(<span class="kw-2">&amp;</span><span class="self">self</span>.hash);
-            <span class="kw">if </span>fs.bitfield.size == <span class="number">8000000 </span>{
-                <span class="macro">println!</span>(<span class="string">"PERSISTING THE TEST CASE FILE to {}"</span>, path.display());
-            }
             <span class="macro">trace!</span>(
                 <span class="string">"writing bitfield for hash {} to {}"</span>,
                 <span class="self">self</span>.hash,
@@ -1626,7 +1600,7 @@
 }
 
 <span class="kw">impl </span>PartialMemStorage {
-    <span class="doccomment">/// Persist the batch to disk, creating a FileBatch.
+    <span class="doccomment">/// Persist the batch to disk.
     </span><span class="kw">fn </span>persist(<span class="self">self</span>, ctx: <span class="kw-2">&amp;</span>TaskContext, hash: <span class="kw-2">&amp;</span>Hash) -&gt; io::Result&lt;PartialFileStorage&gt; {
         <span class="kw">let </span>options = <span class="kw-2">&amp;</span>ctx.options.path;
         ctx.protect.protect(
@@ -1654,12 +1628,6 @@
             bitfield: <span class="self">self</span>.bitfield,
         })
     }
-
-    <span class="doccomment">/// Get the parts data, outboard and sizes
-    </span><span class="attr">#[allow(dead_code)]
-    </span><span class="kw">pub fn </span>into_parts(<span class="self">self</span>) -&gt; (SparseMemFile, SparseMemFile, SizeInfo) {
-        (<span class="self">self</span>.data, <span class="self">self</span>.outboard, <span class="self">self</span>.size)
-    }
 }
 
 <span class="kw">pub struct </span>BaoFileStorageSubscriber {

pr/101/docs/src/iroh_blobs/store/fs/util/entity_manager.rs.html

@@ -1028,7 +1028,15 @@
 <a href="#1027" id="1027">1027</a>
 <a href="#1028" id="1028">1028</a>
 <a href="#1029" id="1029">1029</a>
-<a href="#1030" id="1030">1030</a></pre></div><pre class="rust"><code><span class="attr">#![allow(dead_code)]
+<a href="#1030" id="1030">1030</a>
+<a href="#1031" id="1031">1031</a>
+<a href="#1032" id="1032">1032</a>
+<a href="#1033" id="1033">1033</a>
+<a href="#1034" id="1034">1034</a>
+<a href="#1035" id="1035">1035</a>
+<a href="#1036" id="1036">1036</a>
+<a href="#1037" id="1037">1037</a>
+<a href="#1038" id="1038">1038</a></pre></div><pre class="rust"><code><span class="attr">#![allow(dead_code)]
 </span><span class="kw">use </span>std::{fmt::Debug, future::Future, hash::Hash};
 
 <span class="kw">use </span>n0_future::{future, FuturesUnordered};
@@ -1342,8 +1350,8 @@
     <span class="kw">impl</span>&lt;P: Params&gt; EntityHandle&lt;P&gt; {
         <span class="kw">pub fn </span>send(<span class="kw-2">&amp;</span><span class="self">self</span>) -&gt; <span class="kw-2">&amp;</span>mpsc::Sender&lt;entity_actor::Command&lt;P&gt;&gt; {
             <span class="kw">match </span><span class="self">self </span>{
-                EntityHandle::Live { send: sender } =&gt; sender,
-                EntityHandle::ShuttingDown { send: sender, .. } =&gt; sender,
+                EntityHandle::Live { send } =&gt; send,
+                EntityHandle::ShuttingDown { send, .. } =&gt; send,
             }
         }
     }
@@ -1456,7 +1464,10 @@
             task
         }
 
-        <span class="attr">#[must_use = <span class="string">"this function may return a future that must be spawned by the caller"</span>]
+        <span class="doccomment">/// This function needs to be polled by the owner of the actor state to advance the
+        /// entity manager state machine. If it returns a future, that future must be spawned
+        /// by the caller.
+        </span><span class="attr">#[must_use = <span class="string">"this function may return a future that must be spawned by the caller"</span>]
         </span><span class="kw">pub async fn </span>tick(<span class="kw-2">&amp;mut </span><span class="self">self</span>) -&gt; <span class="prelude-ty">Option</span>&lt;<span class="kw">impl </span>Future&lt;Output = ()&gt; + Send + <span class="lifetime">'static</span>&gt; {
             <span class="kw">if let </span><span class="prelude-val">Some</span>(cmd) = <span class="self">self</span>.internal_recv.recv().<span class="kw">await </span>{
                 <span class="kw">match </span>cmd {
@@ -1522,6 +1533,8 @@
         }
 
         <span class="doccomment">/// Get or create an entity actor for the given id.
+        ///
+        /// If this function returns a future, it must be spawned by the caller.
         </span><span class="kw">fn </span>get_or_create(
             <span class="kw-2">&amp;mut </span><span class="self">self</span>,
             id: P::EntityId,
@@ -1531,14 +1544,17 @@
         ) {
             <span class="kw">let </span><span class="kw-2">mut </span>task = <span class="prelude-val">None</span>;
             <span class="kw">let </span>handle = <span class="self">self</span>.live.entry(id.clone()).or_insert_with(|| {
-                <span class="kw">if let </span><span class="prelude-val">Some</span>((sender, <span class="kw-2">mut </span>actor)) = <span class="self">self</span>.pool.pop() {
-                    actor.state.id = id.clone();
+                <span class="kw">if let </span><span class="prelude-val">Some</span>((send, <span class="kw-2">mut </span>actor)) = <span class="self">self</span>.pool.pop() {
+                    <span class="comment">// Get an actor from the pool of inactive actors and initialize it.
+                    </span>actor.state.id = id.clone();
                     actor.state.global = <span class="self">self</span>.state.clone();
-                    actor.state.state.reset();
+                    <span class="comment">// strictly speaking this is not needed, since we reset the state when adding the actor to the pool.
+                    </span>actor.state.state.reset();
                     task = <span class="prelude-val">Some</span>(actor.run());
-                    EntityHandle::Live { send: sender }
+                    EntityHandle::Live { send }
                 } <span class="kw">else </span>{
-                    <span class="kw">let </span>(sender, recv) = mpsc::channel(<span class="self">self</span>.entity_inbox_size);
+                    <span class="comment">// Create a new entity actor and inbox.
+                    </span><span class="kw">let </span>(send, recv) = mpsc::channel(<span class="self">self</span>.entity_inbox_size);
                     <span class="kw">let </span>state: entity_actor::State&lt;P&gt; = entity_actor::State {
                         id: id.clone(),
                         global: <span class="self">self</span>.state.clone(),
@@ -1553,7 +1569,7 @@
                         ),
                     };
                     task = <span class="prelude-val">Some</span>(actor.run());
-                    EntityHandle::Live { send: sender }
+                    EntityHandle::Live { send }
                 }
             });
             (handle, task)