list machines uses the network devices

openapi/api.json

@@ -154,13 +154,29 @@
             "description": "The job id used for this print.",
             "type": "string"
           },
+          "parameters": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PrintParameters"
+              }
+            ],
+            "description": "The parameters used for this print."
+          }
+        },
+        "required": [
+          "job_id",
+          "parameters"
+        ],
+        "type": "object"
+      },
+      "PrintParameters": {
+        "description": "Parameters for printing.",
+        "properties": {
           "machine_id": {
-            "description": "The machine id used for this print.",
             "type": "string"
           }
         },
         "required": [
-          "job_id",
           "machine_id"
         ],
         "type": "object"

src/main.rs

@@ -17,6 +17,7 @@
 use clap::Parser;
 use gcode::GcodeSequence;
 use machine::Machine;
+use network_printer::NetworkPrinterManufacturer;
 use opentelemetry::KeyValue;
 use opentelemetry_otlp::WithExportConfig;
 use opentelemetry_sdk::Resource;
@@ -79,8 +80,8 @@
     /// Run the server.
     Server(Server),
 
-    /// List all available USB devices.
-    ListUsbDevices,
+    /// List all available machines on the network or over USB.
+    ListMachines,
 
     /// Slice the given `file` with config from `config_file`
     SliceFile {
@@ -105,7 +106,7 @@
 }
 
 /// A subcommand for running the server.
-#[derive(Parser, Clone, Debug, Default)]
+#[derive(Parser, Clone, Debug)]
 pub struct Server {
     /// IP address and port that the server should listen
     #[clap(short, long, default_value = "0.0.0.0:8080")]
@@ -192,11 +193,32 @@
         SubCommand::Server(s) => {
             crate::server::server(s, opts).await?;
         }
-        SubCommand::ListUsbDevices => {
-            let printers = crate::usb_printer::UsbPrinter::list_all();
-            println!("Printers:");
-            for printer in printers {
-                println!("{:?}", printer);
+        SubCommand::ListMachines => {
+            // Now connect to first printer we find over serial port
+            //
+            let api_context = Arc::new(Context::new(Default::default(), opts.create_logger("print")).await?);
+
+            println!("Discovering printers...");
+            let cloned_api_context = api_context.clone();
+            // We don't care if it times out, we just want to wait for the discovery tasks to
+            // finish.
+            let _ = tokio::time::timeout(tokio::time::Duration::from_secs(10), async move {
+                let form_labs = cloned_api_context
+                    .network_printers
+                    .get(&NetworkPrinterManufacturer::Formlabs)
+                    .expect("No formlabs discover task registered");
+                let bambu = cloned_api_context
+                    .network_printers
+                    .get(&NetworkPrinterManufacturer::Bambu)
+                    .expect("No Bambu discover task registered");
+
+                tokio::join!(form_labs.discover(), bambu.discover())
+            })
+            .await;
+
+            let machines = api_context.list_machines()?;
+            for (id, machine) in machines.iter() {
+                println!("{}: {:?}", id, machine);
             }
         }
         SubCommand::SliceFile { config_file, file } => {
@@ -217,8 +239,25 @@
 
             // Now connect to first printer we find over serial port
             //
-            let api_context =
-                Arc::new(Context::new(Default::default(), opts.create_logger("print"), Default::default()).await?);
+            let api_context = Arc::new(Context::new(Default::default(), opts.create_logger("print")).await?);
+
+            println!("Discovering printers...");
+            // Start all the discovery tasks.
+            let cloned_api_context = api_context.clone();
+            let _ = tokio::time::timeout(tokio::time::Duration::from_secs(10), async move {
+                let form_labs = cloned_api_context
+                    .network_printers
+                    .get(&NetworkPrinterManufacturer::Formlabs)
+                    .expect("No formlabs discover task registered");
+                let bambu = cloned_api_context
+                    .network_printers
+                    .get(&NetworkPrinterManufacturer::Bambu)
+                    .expect("No Bambu discover task registered");
+
+                tokio::join!(form_labs.discover(), bambu.discover())
+            })
+            .await;
+
             let machine = api_context
                 .find_machine_by_id(printer_id)?
                 .expect("Printer not found by given ID");

src/network_printer/bambu_x1_carbon.rs

@@ -30,8 +30,6 @@ impl NetworkPrinter for BambuX1Carbon {
         let mut socket_buf = [0u8; 1536];
 
         while let Ok(n) = socket.recv(&mut socket_buf).await {
-            println!("Frame");
-
             // The SSDP/UPnP frames we're looking for from Bambu printers are pure ASCII, so we don't
             // mind if we end up with garbage in the resulting string. Note that other SSDP packets from
             // e.g. macOS Bonjour(?) do contain binary data which means this conversion isn't suitable

src/network_printer/formlabs.rs

@@ -39,7 +39,6 @@ impl NetworkPrinter for Formlabs {
                     manufacturer: NetworkPrinterManufacturer::Formlabs,
                     model: None,
                 };
-                println!("formlabs printer: {:#?}", printer);
                 self.printers.insert(addr.to_string(), printer);
             } else {
                 println!("formlabs printer does not advertise address: {:#?}", response);

src/server/context.rs

@@ -11,7 +11,6 @@ use crate::network_printer::{NetworkPrinter, NetworkPrinterManufacturer};
 pub struct Context {
     pub schema: serde_json::Value,
     pub logger: slog::Logger,
-    pub settings: crate::Server,
     pub usb_printers: Arc<HashMap<String, crate::usb_printer::UsbPrinterInfo>>,
     pub network_printers: Arc<HashMap<NetworkPrinterManufacturer, Box<dyn NetworkPrinter>>>,
     pub active_jobs: Mutex<HashMap<String, tokio::task::JoinHandle<anyhow::Result<()>>>>,
@@ -21,7 +20,7 @@ impl Context {
     /**
      * Return a new Context.
      */
-    pub async fn new(schema: serde_json::Value, logger: slog::Logger, settings: crate::Server) -> Result<Context> {
+    pub async fn new(schema: serde_json::Value, logger: slog::Logger) -> Result<Context> {
         let mut network_printers: HashMap<NetworkPrinterManufacturer, Box<dyn NetworkPrinter>> = HashMap::new();
 
         // Add formlabs backend.
@@ -40,7 +39,6 @@ impl Context {
         Ok(Context {
             schema,
             logger,
-            settings,
             network_printers: Arc::new(network_printers),
             usb_printers: Arc::new(crate::usb_printer::UsbPrinter::list_all()),
             active_jobs: Mutex::new(HashMap::new()),

src/server/endpoints.rs

@@ -62,8 +62,8 @@
     /// The job id used for this print.
     pub job_id: String,
 
-    /// The machine id used for this print.
-    pub machine_id: String,
+    /// The parameters used for this print.
+    pub parameters: PrintParameters,
 }
 
 /** Print a given file. File must be a sliceable 3D model. */
@@ -118,7 +118,7 @@
 
     Ok(HttpResponseOk(PrintJobResponse {
         job_id: job_id.to_string(),
-        machine_id: machine.id(),
+        parameters: params,
     }))
 }
 

src/server/mod.rs

@@ -52,7 +52,7 @@ pub async fn create_server(
     let logger = opts.create_logger("server");
     let dropshot_logger = logger.new(slog::o!("component" => "dropshot"));
 
-    let api_context = Arc::new(Context::new(schema, logger, s.clone()).await?);
+    let api_context = Arc::new(Context::new(schema, logger).await?);
 
     let server = HttpServerStarter::new(&config_dropshot, api, api_context.clone(), &dropshot_logger)
         .map_err(|error| anyhow!("failed to create server: {}", error))?