Add software check for miner port (#240)

* add miner port check to ensure external port is available

Author: outwrit

worker/src/checks/issue.rs

@@ -18,6 +18,7 @@ pub enum IssueType {
     InsufficientCpu,              // Minimum CPU cores needed
     NetworkConnectivityIssue,     // Network performance issues
     NoStoragePath,                // No storage path found
+    PortUnavailable,              // Port is unavailable
 }
 
 impl IssueType {

worker/src/checks/software/mod.rs

@@ -1,2 +1,4 @@
 pub mod docker;
+pub mod port;
 pub mod software_check;
+pub use software_check::SoftwareChecker;

worker/src/checks/software/port.rs

@@ -0,0 +1,30 @@
+use crate::checks::issue::{IssueReport, IssueType};
+use crate::console::Console;
+use anyhow::Result;
+use std::net::TcpListener;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+fn try_bind_port(port: u16) -> Result<()> {
+    let addr = format!("0.0.0.0:{}", port);
+    // If bind succeeds, port is available; if it fails, port is taken.
+    let listener = TcpListener::bind(addr)?;
+    drop(listener); // Release the port immediately.
+    Ok(())
+}
+
+pub async fn check_port_available(issues: &Arc<RwLock<IssueReport>>, port: u16) -> Result<()> {
+    let issue_tracker = issues.read().await;
+
+    match try_bind_port(port) {
+        Ok(_) => Console::success("Port is available"),
+        Err(e) => {
+            issue_tracker.add_issue(
+                IssueType::PortUnavailable,
+                format!("Port {} is not available: {}", port, e),
+            );
+        }
+    }
+
+    Ok(())
+}

worker/src/checks/software/software_check.rs

@@ -1,17 +1,33 @@
-use super::docker::check_docker_installed;
+use super::{docker::check_docker_installed, port::check_port_available};
 use crate::checks::issue::IssueReport;
 use crate::console::Console;
+use shared::models::node::Node;
 use std::sync::Arc;
 use tokio::sync::RwLock;
-pub async fn run_software_check(
-    issues: Option<Arc<RwLock<IssueReport>>>,
-) -> Result<(), Box<dyn std::error::Error>> {
-    Console::section("Software Checks");
-    let issues = issues.unwrap_or_else(|| Arc::new(RwLock::new(IssueReport::new())));
 
-    // Check Docker installation and connectivity
-    Console::title("Docker:");
-    check_docker_installed(&issues).await?;
+pub struct SoftwareChecker {
+    issues: Arc<RwLock<IssueReport>>,
+}
+
+impl SoftwareChecker {
+    pub fn new(issues: Option<Arc<RwLock<IssueReport>>>) -> Self {
+        Self {
+            issues: issues.unwrap_or_else(|| Arc::new(RwLock::new(IssueReport::new()))),
+        }
+    }
+
+    pub async fn check_software(
+        &self,
+        node_config: &Node,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        // Check Docker installation and connectivity
+        Console::title("Docker:");
+        check_docker_installed(&self.issues).await?;
+
+        // Check port availability
+        Console::title("Port:");
+        check_port_available(&self.issues, node_config.port).await?;
 
-    Ok(())
+        Ok(())
+    }
 }

worker/src/cli/command.rs

@@ -1,7 +1,7 @@
 use crate::api::server::start_server;
 use crate::checks::hardware::HardwareChecker;
 use crate::checks::issue::IssueReport;
-use crate::checks::software::software_check;
+use crate::checks::software::SoftwareChecker;
 use crate::console::Console;
 use crate::docker::taskbridge::TaskBridge;
 use crate::docker::DockerService;
@@ -291,8 +291,8 @@ pub async fn execute_command(
             let issue_tracker = Arc::new(RwLock::new(IssueReport::new()));
             let mut hardware_check = HardwareChecker::new(Some(issue_tracker.clone()));
             let node_config = hardware_check.check_hardware(node_config).await.unwrap();
-            if let Err(err) = software_check::run_software_check(Some(issue_tracker.clone())).await
-            {
+            let software_checker = SoftwareChecker::new(Some(issue_tracker.clone()));
+            if let Err(err) = software_checker.check_software(&node_config).await {
                 Console::user_error(&format!("❌ Software check failed: {}", err));
                 std::process::exit(1);
             }
@@ -634,8 +634,9 @@ pub async fn execute_command(
             Console::section("🔍 PRIME WORKER SYSTEM CHECK");
             let issues = Arc::new(RwLock::new(IssueReport::new()));
 
-            // Run hardware checks
+            // Run checks
             let mut hardware_checker = HardwareChecker::new(Some(issues.clone()));
+            let software_checker = SoftwareChecker::new(Some(issues.clone()));
             let node_config = Node {
                 id: String::new(),
                 ip_address: String::new(),
@@ -645,12 +646,15 @@ pub async fn execute_command(
                 compute_pool_id: 0,
             };
 
-            if let Err(err) = hardware_checker.check_hardware(node_config).await {
-                Console::user_error(&format!("❌ Hardware check failed: {}", err));
-                std::process::exit(1);
-            }
+            let node_config = match hardware_checker.check_hardware(node_config).await {
+                Ok(node_config) => node_config,
+                Err(err) => {
+                    Console::user_error(&format!("❌ Hardware check failed: {}", err));
+                    std::process::exit(1);
+                }
+            };
 
-            if let Err(err) = software_check::run_software_check(Some(issues.clone())).await {
+            if let Err(err) = software_checker.check_software(&node_config).await {
                 Console::user_error(&format!("❌ Software check failed: {}", err));
                 std::process::exit(1);
             }

worker/src/docker/service.rs

@@ -109,8 +109,7 @@ impl DockerService {
                     .filter(|c| {
                         c.names.iter().any(|name| name.contains(TASK_PREFIX))
                             && task_id
-                                .as_ref()
-                                .map_or(true, |id| !c.names.iter().any(|name| name.contains(id)))
+                                .as_ref().is_none_or(|id| !c.names.iter().any(|name| name.contains(id)))
                     })
                     .cloned()
                     .collect();