fix token sleep logic

hacking.md

···
 - [x] account status convergeance: if we receive commits from apparently-inactive accounts, should we check upstream status to make sure we're not stale?
 - [x] resync short-circuit: tiny repos may actually return their entire CAR for getRecord
 - [x] use jacquard's built-in inductive proof methods
-- [~] repo-stream: drop record block contents with processor fn
+- [x] repo-stream: drop record block contents with processor fn
   - [x] in getRecord before describeRepo
-  - [ ] in commit handling
-- [ ] commit CAR handling: generate a list of keys with gaps noted, to reliably detect missing adjacent keys
+  - [x] in commit handling
+- [x] commit CAR handling: generate a list of keys with gaps noted, to reliably detect missing adjacent keys
+  - [ ] watch logs for errors now that we're strict
 - [ ] meta/metrics keyspace for general stats
   - [ ] total repos (hyperloglog estimate?)
   - [ ] resync queue size
···
 - [ ] bad word filtering? (collectiondir has it)
 - [ ] check response headers and adjust self-throttling rate limits per-host if present
 - [ ] make backfill go _really fast_
+- [ ] clean up commit validation (eg we're checking signatures twice, lenient handling is weird)
 
 going to be annoying but doable
 - [ ] multi-relay subscriber

src/main.rs

···
             );
             sub.run(token)
                 .await
+                .inspect(|_| info!("firehose subscriber done."))
                 .inspect_err(|e| warn!(error = %e, "firehose exited"))
         }
     });
···
         async move {
             if backfill::run(host, db, client, token.clone(), None)
                 .await
+                .inspect(|_| info!("backfill done."))
                 .inspect_err(|e| warn!(error = %e, "backfill exited"))?
             {
                 info!("backfill task idling");
···
                 force_get_repo: args.heavy,
             })
             .await
+            .inspect(|_| info!("resync done."))
             .inspect_err(|e| warn!(error = %e, "resync exited"))
         }
     });
···
         async move {
             lightrail::server::serve(addr, db, token, admin_config)
                 .await
+                .inspect(|_| info!("server done."))
                 .inspect_err(|e| warn!(error = %e, "server exited"))
         }
     });
···
                     resolver,
                 )
                 .await
+                .inspect(|_| info!("deep crawl done."))
                 .inspect_err(|e| warn!(error = %e, "deep crawl exited"))
             }
         });
···
             eprintln!("Shutting down...");
             None
         }
-        r = tasks.join_next() => r,
+        r = tasks.join_next() => {
+            eprintln!("=== a task exited with: {r:?} ===");
+            r
+        },
     };
     token.cancel();
 

src/util.rs

···
     async fn sleep(&self, d: tokio::time::Duration) -> bool {
         self.run_until_cancelled(tokio::time::sleep(d))
             .await
-            .is_none()
+            .is_some()
     }
 }