start using actix for interface

src/controller/mod.rs

@@ -0,0 +1,27 @@
+use bollard::Docker;
+use crate::deploy;
+
+pub struct Controller {
+    driver: Docker,
+    network: String,
+}
+
+impl Controller {
+    pub async fn new(driver: Docker, network: String, range: String) -> Result<Self, bollard::errors::Error>{
+        deploy::network::Network::new(driver.clone(), network.clone(), range).await?;
+        Ok(Controller {
+            driver: driver,
+            network: network,
+        })
+    }
+
+    pub async fn create_container(&self, domain: String, ip: String) -> String {
+        match deploy::container::Container::new(self.driver.clone(),
+                                                domain,
+                                                ip,
+                                                self.network.clone()).await {
+            Ok(c) => c.get_id(),
+            Err(e) => "error creating container".to_string(),
+        }
+    }
+}

src/deploy/mod.rs

@@ -0,0 +1,2 @@
+pub mod container;
+pub mod network;

src/main.rs

@@ -1,29 +1,9 @@
-use bollard::Docker;
-
-mod create_container;
-mod network_docker;
+mod deploy;
 mod server;
 mod conf;
+mod controller;
 
-#[tokio::main]
+#[actix_web::main]
 async fn main() {
-    let docker = match Docker::connect_with_local_defaults() {
-        Ok(d) => d,
-        Err(e) => panic!("error:{}",e.to_string()),
-    };
-
-    let net_name = String::from("customnetwork");
-    let net_range = String::from("172.20.0.0/24");
-
-    match network_docker::Network::new(docker.clone(), net_name, net_range).await {
-        Ok(_n)=> println!("va"),
-        Err(e)=> println!("err: {}", e),
-    };
-
-    match create_container::Container::new(docker, String::from("container1"),
-                            String::from("172.20.0.5"),
-                            String::from("customnetwork")).await {
-        Ok(c) => println!("id: {}", c.get_id()),
-        Err(e) => println!("error: {}", e),
-    };
+    server::start().await;
 }

src/server.rs

@@ -1,14 +1,51 @@
-use tokio::net::TcpListener;
-use tokio::io::AsyncWriteExt;
-use std::io;
+use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder,middleware::Logger};
+use bollard::Docker;
+use env_logger;
 
-pub async fn start() -> io::Result<()> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+use crate::controller::Controller;
 
-    loop {
-        let (mut socket, _) = listener.accept().await?;
-        socket.write_all(b"algo").await.unwrap();
-    }
+#[get("/")]
+async fn hello() -> impl Responder {
+    HttpResponse::Ok().body("Hello world!")
 }
 
+#[get("/create")]
+async fn create(controller:  web::Data<Controller>) -> impl Responder {
+    controller.create_container("container1".to_string(), "172.20.0.5".to_string()).await
+}
 
+#[post("/echo")]
+async fn echo(req_body: String) -> impl Responder {
+    HttpResponse::Ok().body(req_body)
+}
+
+async fn manual_hello() -> impl Responder {
+    HttpResponse::Ok().body("Hey there!")
+}
+
+pub async fn start() -> std::io::Result<()> {
+    let docker = match Docker::connect_with_local_defaults() {
+        Ok(d) => d,
+        Err(e) => panic!("error:{}",e.to_string()),
+    };
+    let controller = match Controller::new(docker,
+                                    "customnetwork".to_string(),
+                                    "172.20.0.0/24".to_string()).await {
+                    Ok(c) => c,
+                    Err(e) => panic!("error: {}",e),
+                    };
+    let data = web::Data::new(controller);
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("debug"));
+    HttpServer::new(move || {
+        App::new()
+            .wrap(Logger::default())
+            .app_data(data.clone())
+            .service(hello)
+            .service(create)
+            .service(echo)
+            .route("/hey", web::get().to(manual_hello))
+    })
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
+}