move task_status block inside the select macro

stratum-mining · Jan 5, 2025 · 6a95deb · 6a95deb
1 parent a3efa46
commit 6a95deb
Showing 1 changed file with 54 additions and 55 deletions.
diff --git a/roles/jd-client/src/lib/mod.rs b/roles/jd-client/src/lib/mod.rs
@@ -112,66 +112,65 @@ impl JobDeclaratorClient {
             }
             // Check all tasks if is_finished() is true, if so exit
             loop {
-                let task_status = select! {
-                    task_status = rx_status.recv().fuse() => task_status,
+                select! {
+                    task_status = rx_status.recv().fuse() => {
+                        if let Ok(task_status) = task_status {
+                            match task_status.state {
+                                // Should only be sent by the downstream listener
+                                status::State::DownstreamShutdown(err) => {
+                                    error!("SHUTDOWN from: {}", err);
+                                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                                    task_collector
+                                        .safe_lock(|s| {
+                                            for handle in s {
+                                                handle.abort();
+                                            }
+                                        })
+                                        .unwrap();
+                                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                                    break;
+                                }
+                                status::State::UpstreamShutdown(err) => {
+                                    error!("SHUTDOWN from: {}", err);
+                                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                                    task_collector
+                                        .safe_lock(|s| {
+                                            for handle in s {
+                                                handle.abort();
+                                            }
+                                        })
+                                        .unwrap();
+                                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                                    break;
+                                }
+                                status::State::UpstreamRogue => {
+                                    error!("Changin Pool");
+                                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                                    task_collector
+                                        .safe_lock(|s| {
+                                            for handle in s {
+                                                handle.abort();
+                                            }
+                                        })
+                                        .unwrap();
+                                    upstream_index += 1;
+                                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                                    break;
+                                }
+                                status::State::Healthy(msg) => {
+                                    info!("HEALTHY message: {}", msg);
+                                }
+                            }
+                        } else {
+                            info!("Closing channels");
+                            break 'outer;
+                        }
+                    },
                     _ = self.shutdown.notified().fuse() => {
                         info!("Shutting down gracefully...");
                         std::process::exit(0);
                     }
                 };
-                // let task_status: status::Status = task_status.unwrap();
-
-                if let Ok(task_status) = task_status {
-                    match task_status.state {
-                        // Should only be sent by the downstream listener
-                        status::State::DownstreamShutdown(err) => {
-                            error!("SHUTDOWN from: {}", err);
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            task_collector
-                                .safe_lock(|s| {
-                                    for handle in s {
-                                        handle.abort();
-                                    }
-                                })
-                                .unwrap();
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            break;
-                        }
-                        status::State::UpstreamShutdown(err) => {
-                            error!("SHUTDOWN from: {}", err);
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            task_collector
-                                .safe_lock(|s| {
-                                    for handle in s {
-                                        handle.abort();
-                                    }
-                                })
-                                .unwrap();
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            break;
-                        }
-                        status::State::UpstreamRogue => {
-                            error!("Changin Pool");
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            task_collector
-                                .safe_lock(|s| {
-                                    for handle in s {
-                                        handle.abort();
-                                    }
-                                })
-                                .unwrap();
-                            upstream_index += 1;
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            break;
-                        }
-                        status::State::Healthy(msg) => {
-                            info!("HEALTHY message: {}", msg);
-                        }
-                    }
-                } else {
-                    info!("Closing channels");
-                    break 'outer;
-                }
             }
         }
     }