Naive and broken TaskManager

manager.rs

impl TaskManager {
  pub fn start<'manager>(&'manager self) -> Result<(), Error> {
    // We'll use some local memoization shared between source and sink:
    let mut services: HashMap<String, Option<Service>> = HashMap::new();
    let mut queues : HashMap<String, Vec<Task>> = HashMap::new();

    // First prepare the source ventilator
    let source_port = self.source_port.clone();
    let source_queue_size = self.queue_size.clone();
    let source_backend_address = self.backend_address.clone();
    
    let vent_thread = thread::spawn(|| {
      let sources = Server {
        port : source_port.clone(),
        queue_size : source_queue_size.clone(),
        backend : Backend::from_address(&source_backend_address.clone())
      };
      sources.start_ventilator(&mut services, &mut queues);
    });

    // Now prepare the results sink
    let result_port = self.result_port.clone();
    let result_queue_size = self.queue_size.clone();
    let result_backend_address = self.backend_address.clone();

    let sink_thread = thread::spawn(|| {
      let results = Server {
        port : result_port.clone(),
        queue_size : result_queue_size.clone(),
        backend : Backend::from_address(&result_backend_address.clone())
      };
      results.start_sink(&services,&queues);
    });

    vent_thread.join();
    sink_thread.join();
    Ok(())
  }
}