use std::process::Command;
use std::sync::{Mutex, Arc};
use std::thread;

struct Server {
    path: String,
}

#[derive(Debug)]
struct Thread {
    way: Vec<Mutex<()>>,
}

impl Server {
    fn new(path: &str) -> Server {
        return Server {
            path: path.to_string(),
        }
    }

    fn start(&self, filename: &str) {
        Command::new("sh")
            .arg(filename.to_string())
            .spawn()
            .expect("Failed to execute process");
    }
}


#[warn(unused_imports)]
fn main() {

    let _pool = Arc::new(Thread { way: vec![
        Mutex::new(()),
        Mutex::new(()),
    ]});

    let servers = vec![
        Server::new("runserver.sh"),
        Server::new("run_celery.sh"),
    ];

    let handles: Vec<_> = servers.into_iter().map(|p| {
         let _pool = _pool.clone();

        thread::spawn(move || {
            p.start(&p.path);
        })
    }).collect();

    for h in handles {
        h.join().unwrap();
    }
}