style: cargo fmt — merge request_response import line + wrap long boolean expression

Author: jeremymanning

src/agent/daemon.rs

@@ -24,8 +24,7 @@ use libp2p::{
     autonat, dcutr,
     futures::StreamExt,
     gossipsub::{self, IdentTopic},
-    identify, identity, ping, relay,
-    request_response,
+    identify, identity, ping, relay, request_response,
     swarm::{NetworkBehaviour, SwarmEvent},
     Multiaddr, PeerId, SwarmBuilder,
 };
@@ -493,7 +492,9 @@ pub async fn start_daemon(
 fn evaluate_offer(offer: &TaskOffer) -> bool {
     // Real implementation would consult the scheduler's broker state; for now,
     // accept any task within reasonable bounds.
-    offer.min_cpu_cores <= 64 && offer.min_memory_mb <= 512 * 1024 && offer.max_wallclock_ms <= 600_000
+    offer.min_cpu_cores <= 64
+        && offer.min_memory_mb <= 512 * 1024
+        && offer.max_wallclock_ms <= 600_000
 }
 
 /// Report current load as a fraction 0.0–1.0. Stub returns 0.1 (mostly idle).
@@ -731,11 +732,8 @@ mod tests {
             submitter_signature: vec![1u8; 64],
         };
 
-        let req = TaskDispatchRequest {
-            task_id: "t-real".into(),
-            manifest,
-            inline_inputs: Vec::new(),
-        };
+        let req =
+            TaskDispatchRequest { task_id: "t-real".into(), manifest, inline_inputs: Vec::new() };
 
         let resp = execute_dispatched_task(&req, &store);
         assert_eq!(resp.status, TaskStatus::Succeeded, "err={:?}", resp.error);
@@ -799,12 +797,7 @@ mod tests {
 
     #[test]
     fn relay_circuit_multiaddr_format() {
-        let addr = relay_circuit_multiaddr(
-            "203.0.113.1",
-            19999,
-            "12D3KooWRelay",
-            "12D3KooWTarget",
-        );
+        let addr = relay_circuit_multiaddr("203.0.113.1", 19999, "12D3KooWRelay", "12D3KooWTarget");
         assert_eq!(
             addr,
             "/ip4/203.0.113.1/tcp/19999/p2p/12D3KooWRelay/p2p-circuit/p2p/12D3KooWTarget"

src/cli/submitter.rs

@@ -115,8 +115,8 @@ pub async fn execute_remote_submit(cmd: &JobCommand) -> Result<(), Box<dyn std::
     // Parse the manifest from disk.
     let manifest_json = std::fs::read_to_string(&manifest_path)
         .map_err(|e| format!("reading manifest '{manifest_path}': {e}"))?;
-    let manifest: JobManifest = serde_json::from_str(&manifest_json)
-        .map_err(|e| format!("parsing manifest JSON: {e}"))?;
+    let manifest: JobManifest =
+        serde_json::from_str(&manifest_json).map_err(|e| format!("parsing manifest JSON: {e}"))?;
 
     // Optional inline workload.
     let inline_inputs: Vec<(String, Vec<u8>)> = if let Some(path) = workload_path {
@@ -161,8 +161,7 @@ pub async fn execute_remote_submit(cmd: &JobCommand) -> Result<(), Box<dyn std::
                     StreamProtocol::new(PROTOCOL_TASK_DISPATCH),
                     ProtocolSupport::Full,
                 )),
-                request_response::Config::default()
-                    .with_request_timeout(Duration::from_secs(300)),
+                request_response::Config::default().with_request_timeout(Duration::from_secs(300)),
             ),
             identify: identify::Behaviour::new(identify::Config::new(
                 "/worldcompute/1.0.0".into(),

src/network/discovery.rs

@@ -92,7 +92,8 @@ impl Default for DiscoveryConfig {
         let seeds: Vec<String> = std::env::var("WORLDCOMPUTE_BOOTSTRAP_SEEDS")
             .map(|s| s.split(',').map(|s| s.trim().to_string()).collect())
             .unwrap_or_else(|_| {
-                let mut v: Vec<String> = BOOTSTRAP_DNS_SEEDS.iter().map(|s| s.to_string()).collect();
+                let mut v: Vec<String> =
+                    BOOTSTRAP_DNS_SEEDS.iter().map(|s| s.to_string()).collect();
                 v.extend(PUBLIC_LIBP2P_BOOTSTRAP_RELAYS.iter().map(|s| s.to_string()));
                 v
             });

src/network/dispatch.rs

@@ -104,10 +104,8 @@ pub enum TaskStatus {
 
 /// Build the TaskOffer request-response behaviour.
 pub fn build_offer_behaviour() -> request_response::cbor::Behaviour<TaskOffer, TaskOfferResponse> {
-    let protocols = std::iter::once((
-        StreamProtocol::new(PROTOCOL_TASK_OFFER),
-        ProtocolSupport::Full,
-    ));
+    let protocols =
+        std::iter::once((StreamProtocol::new(PROTOCOL_TASK_OFFER), ProtocolSupport::Full));
     let config = request_response::Config::default()
         .with_request_timeout(Duration::from_secs(10))
         .with_max_concurrent_streams(100);
@@ -117,10 +115,8 @@ pub fn build_offer_behaviour() -> request_response::cbor::Behaviour<TaskOffer, T
 /// Build the TaskDispatch request-response behaviour.
 pub fn build_dispatch_behaviour(
 ) -> request_response::cbor::Behaviour<TaskDispatchRequest, TaskDispatchResponse> {
-    let protocols = std::iter::once((
-        StreamProtocol::new(PROTOCOL_TASK_DISPATCH),
-        ProtocolSupport::Full,
-    ));
+    let protocols =
+        std::iter::once((StreamProtocol::new(PROTOCOL_TASK_DISPATCH), ProtocolSupport::Full));
     // Dispatch has a much longer timeout — the executor is actually running the job.
     let config = request_response::Config::default()
         .with_request_timeout(Duration::from_secs(600))
@@ -153,8 +149,7 @@ mod tests {
         let mut bytes = Vec::new();
         ciborium::ser::into_writer(&offer, &mut bytes).expect("serialize");
         assert!(!bytes.is_empty());
-        let decoded: TaskOffer =
-            ciborium::de::from_reader(&bytes[..]).expect("deserialize");
+        let decoded: TaskOffer = ciborium::de::from_reader(&bytes[..]).expect("deserialize");
         assert_eq!(decoded.task_id, offer.task_id);
         assert_eq!(decoded.needs_gpu, offer.needs_gpu);
     }

tests/distributed_dispatch.rs

@@ -46,8 +46,7 @@ fn build_swarm(keypair: identity::Keypair) -> libp2p::Swarm<TestBehaviour> {
                     StreamProtocol::new(PROTOCOL_TASK_DISPATCH),
                     ProtocolSupport::Full,
                 )),
-                request_response::Config::default()
-                    .with_request_timeout(Duration::from_secs(30)),
+                request_response::Config::default().with_request_timeout(Duration::from_secs(30)),
             ),
             identify: identify::Behaviour::new(identify::Config::new(
                 "/test/1.0.0".into(),
@@ -96,8 +95,8 @@ async fn distributed_wasm_job_dispatch_end_to_end() {
         0x00, 0x61, 0x73, 0x6d, // magic
         0x01, 0x00, 0x00, 0x00, // version 1
     ];
-    let workload_cid = worldcompute::data_plane::cid_store::compute_cid(&wasm_bytes)
-        .expect("compute cid");
+    let workload_cid =
+        worldcompute::data_plane::cid_store::compute_cid(&wasm_bytes).expect("compute cid");
 
     // Executor daemon
     let executor_kp = identity::Keypair::generate_ed25519();
@@ -173,8 +172,7 @@ async fn distributed_wasm_job_dispatch_end_to_end() {
     })
     .await;
 
-    let response: TaskDispatchResponse =
-        result.expect("timed out waiting for dispatch response");
+    let response: TaskDispatchResponse = result.expect("timed out waiting for dispatch response");
     assert_eq!(response.task_id, "dist-test-001");
     assert_eq!(
         response.status,
@@ -191,11 +189,8 @@ fn execute_task_for_test(req: &TaskDispatchRequest) -> TaskDispatchResponse {
     use worldcompute::network::dispatch::TaskStatus;
 
     let start = Instant::now();
-    let wasm_bytes = req
-        .inline_inputs
-        .iter()
-        .find(|(n, _)| n == "workload")
-        .map(|(_, b)| b.clone());
+    let wasm_bytes =
+        req.inline_inputs.iter().find(|(n, _)| n == "workload").map(|(_, b)| b.clone());
 
     let wasm_bytes = match wasm_bytes {
         Some(b) => b,

tests/nat_traversal.rs

@@ -58,14 +58,11 @@ struct ClientBehaviour {
     dispatch: request_response::cbor::Behaviour<TaskDispatchRequest, TaskDispatchResponse>,
 }
 
-fn build_dispatch_behaviour() -> request_response::cbor::Behaviour<TaskDispatchRequest, TaskDispatchResponse> {
+fn build_dispatch_behaviour(
+) -> request_response::cbor::Behaviour<TaskDispatchRequest, TaskDispatchResponse> {
     request_response::cbor::Behaviour::new(
-        std::iter::once((
-            StreamProtocol::new(PROTOCOL_TASK_DISPATCH),
-            ProtocolSupport::Full,
-        )),
-        request_response::Config::default()
-            .with_request_timeout(Duration::from_secs(60)),
+        std::iter::once((StreamProtocol::new(PROTOCOL_TASK_DISPATCH), ProtocolSupport::Full)),
+        request_response::Config::default().with_request_timeout(Duration::from_secs(60)),
     )
 }
 
@@ -151,11 +148,7 @@ fn make_test_manifest(workload_cid: cid::Cid) -> JobManifest {
 fn execute_wasm_task(req: &TaskDispatchRequest) -> TaskDispatchResponse {
     use std::time::Instant;
     let start = Instant::now();
-    let wasm = req
-        .inline_inputs
-        .iter()
-        .find(|(n, _)| n == "workload")
-        .map(|(_, b)| b.clone());
+    let wasm = req.inline_inputs.iter().find(|(n, _)| n == "workload").map(|(_, b)| b.clone());
     let Some(bytes) = wasm else {
         return TaskDispatchResponse {
             task_id: req.task_id.clone(),
@@ -170,8 +163,7 @@ fn execute_wasm_task(req: &TaskDispatchRequest) -> TaskDispatchResponse {
     config.consume_fuel(true);
     let engine = wasmtime::Engine::new(&config).expect("engine");
     match worldcompute::sandbox::wasm::compile_module(&engine, &bytes) {
-        Ok(module) => match worldcompute::sandbox::wasm::run_module(&engine, &module, 10_000_000)
-        {
+        Ok(module) => match worldcompute::sandbox::wasm::run_module(&engine, &module, 10_000_000) {
             Ok(output) => TaskDispatchResponse {
                 task_id: req.task_id.clone(),
                 status: TaskStatus::Succeeded,
@@ -214,9 +206,7 @@ async fn three_node_relay_circuit_wasm_dispatch() {
     let r_kp = identity::Keypair::generate_ed25519();
     let r_peer = PeerId::from(r_kp.public());
     let mut r_swarm = build_relay_swarm(r_kp);
-    r_swarm
-        .listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
-        .expect("relay listen");
+    r_swarm.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).expect("relay listen");
 
     // Wait for relay to obtain a concrete listen address.
     let r_addr: Multiaddr = timeout(Duration::from_secs(10), async {
@@ -238,16 +228,12 @@ async fn three_node_relay_circuit_wasm_dispatch() {
     let a_kp = identity::Keypair::generate_ed25519();
     let a_peer = PeerId::from(a_kp.public());
     let mut a_swarm = build_client_swarm(a_kp);
-    a_swarm
-        .listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
-        .expect("A listen");
+    a_swarm.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).expect("A listen");
 
     // ─── Spawn client B — will dial A through R ──────────────────────────
     let b_kp = identity::Keypair::generate_ed25519();
     let mut b_swarm = build_client_swarm(b_kp);
-    b_swarm
-        .listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
-        .expect("B listen");
+    b_swarm.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).expect("B listen");
 
     // A dials R and requests a relay reservation.
     a_swarm.dial(r_addr_with_peer.clone()).expect("A->R dial");
@@ -266,8 +252,7 @@ async fn three_node_relay_circuit_wasm_dispatch() {
         0x00, 0x61, 0x73, 0x6d, // magic
         0x01, 0x00, 0x00, 0x00, // version 1
     ];
-    let workload_cid =
-        worldcompute::data_plane::cid_store::compute_cid(&wasm_bytes).expect("cid");
+    let workload_cid = worldcompute::data_plane::cid_store::compute_cid(&wasm_bytes).expect("cid");
     let dispatch_request = TaskDispatchRequest {
         task_id: "nat-test-001".into(),
         manifest: make_test_manifest(workload_cid),
@@ -429,8 +414,5 @@ async fn three_node_relay_circuit_wasm_dispatch() {
         "Dispatch via relay should succeed: {:?}",
         response.error
     );
-    println!(
-        "✓ Cross-NAT dispatch succeeded: {}ms via relay circuit",
-        response.duration_ms
-    );
+    println!("✓ Cross-NAT dispatch succeeded: {}ms via relay circuit", response.duration_ms);
 }

tests/network/test_tls.rs

@@ -17,10 +17,7 @@ fn cert_issuance_produces_valid_cert() {
     assert!(!cert.key_der.is_empty(), "issued key DER must not be empty");
     // Cert should expire approximately 90 days from now
     let days_until = (cert.not_after - chrono::Utc::now()).num_days();
-    assert!(
-        (89..=91).contains(&days_until),
-        "cert should expire in ~90 days, got {days_until}"
-    );
+    assert!((89..=91).contains(&days_until), "cert should expire in ~90 days, got {days_until}");
 }
 
 #[test]

tests/test_nat_and_discovery.rs

@@ -95,20 +95,12 @@ fn bootstrap_dns_seeds_constant_matches_config_prefix() {
     );
     // Project seeds come first.
     for (i, seed) in BOOTSTRAP_DNS_SEEDS.iter().enumerate() {
-        assert_eq!(
-            *seed,
-            config.bootstrap_seeds[i].as_str(),
-            "Project seed {i} mismatch"
-        );
+        assert_eq!(*seed, config.bootstrap_seeds[i].as_str(), "Project seed {i} mismatch");
     }
     // Public libp2p relays follow.
     for (i, seed) in PUBLIC_LIBP2P_BOOTSTRAP_RELAYS.iter().enumerate() {
         let config_idx = BOOTSTRAP_DNS_SEEDS.len() + i;
-        assert_eq!(
-            *seed,
-            config.bootstrap_seeds[config_idx].as_str(),
-            "Public relay {i} mismatch"
-        );
+        assert_eq!(*seed, config.bootstrap_seeds[config_idx].as_str(), "Public relay {i} mismatch");
     }
 }