Sending a sender through the channel to get a response

main.rs

use std::thread;
use std::sync::mpsc;
use std::sync::mpsc::{Sender, SyncSender};
use manager::Manager;
use console::console_task;

use rocket::State;

pub enum BackendMsg {
    Quit,
    Take,
    AutoTransition {secs: f32},
    SetPreview {id: i32},
    SetProgram {id: i32},
    GetBusStatus {sender: Sender<BackendResponse>}
}

pub enum BackendResponse {
    OK(String)
}

#[get("/")]
fn index(sender: State<SyncSender<BackendMsg>>) -> String {
    let (responseSender, responseReceiver) = mpsc::channel();
    sender.send(BackendMsg::GetBusStatus{sender: responseSender}).unwrap();
    let response = responseReceiver.recv().unwrap();

    let text = match response {
        BackendResponse::OK(x) => x,
        _ => "Bad response".to_string(),
    };

    text
}

fn main() {
    let mut manager = Manager::new("127.0.0.1:9999");
    manager.start();

    let (sender, receiver) = mpsc::sync_channel::<BackendMsg>(256);
    let sender2 = sender.clone();

    thread::spawn(move || {
        rocket::ignite().manage(sender)
                        .mount("/", routes![index])
                        .launch();
    });

    thread::spawn(move || {
        console_task(sender2);
    });

    let mut run = true;

    while run {
        let response = receiver.recv().unwrap();

        match response {
            BackendMsg::Quit => run = false,
            BackendMsg::Take => manager.take(),
            BackendMsg::AutoTransition{secs: x} => manager.transition(x),
            BackendMsg::GetBusStatus{sender: x} => x.send(BackendResponse::OK("It's good".to_string())).unwrap(),
            _ => {},
        };
    }
  
    manager.quit();

    println!("Done");
}