start network creation infraestructure

src/create_container.rs

@@ -1,50 +1,87 @@
-use docker_api::opts::ContainerCreateOpts;
+use bollard::container::{StartContainerOptions, CreateContainerOptions, Config, NetworkingConfig};
+use bollard::models::{EndpointSettings, EndpointIpamConfig};
+use bollard::errors::Error;
+use std::collections::hash_map::HashMap;
 
-pub async fn list(docker: docker_api::Docker){
-    match docker.images().list(&Default::default()).await {
-        Ok(images) => {
-            for image in images {
-                println!("{0:?}", image.repo_tags);
+pub struct Container {
+    name: String,
+    start: bool,
+    ip: String,
+    net: String,
+    id: Option<String>,
+}
+
+impl Container {
+    pub async fn new(docker: bollard::Docker,
+                name: String,
+                ip: String,
+                net: String) -> Result<Container, Error> {
+
+        let mut container = Container {
+            name: name,
+            ip: ip,
+            net: net,
+            start: false,
+            id: None,
+        };
+
+        match container.create(docker).await {
+            Ok(c) => {
+                container.start=true;
+                container.id = Some(c);
+                Ok(container)
             }
-        },
-        Err(e) => println!("Something bad happened! {e}"),
+            Err(e) => Err(e),
+        }
+    }
+
+    async fn create(&self, docker: bollard::Docker) -> Result<String, Error>{
+        let create = docker.create_container(Some(
+                                        create_options(self.name.clone())),
+                                        create_config(self.ip.clone(), self.net.clone()))
+                                        .await?;
+        docker.start_container(&self.name, None::<StartContainerOptions<String>>).await?;
+        return Ok(create.id);
+    }
+
+    pub fn get_id(&self) -> String {
+        match &self.id {
+            Some(id) => id.clone(),
+            None => String::from(""),
+        }
+    }
+}
+fn create_config(ip: String, net: String) -> Config<String> {
+    let endpoint = EndpointSettings {
+        ipam_config: Some(EndpointIpamConfig{
+                ipv4_address: Some(ip),
+                ..Default::default()
+            }),
+        ..Default::default()
+    };
+    let mut hash = HashMap::new();
+    hash.insert(net, endpoint);
+    let net = NetworkingConfig {
+        endpoints_config: hash
+    };
+    let env = vec!["EULA=TRUE".to_string()];
+    Config {
+        image: Some("itzg/minecraft-server:latest".to_string()),
+        env: Some(env),
+        networking_config: Some(net),
+        ..Default::default()
     }
 }
 
-pub async fn list_c(docker: docker_api::Docker){
-    match docker.containers().list(&Default::default()).await {
-        Ok(containers) => {
-            for container in containers {
-                println!("{0:?}", container.status);
-            }
-        },
-        Err(e) => println!("Something bad happened! {e}"),
+fn create_options(name: String) -> CreateContainerOptions<String> {
+    CreateContainerOptions{
+        name: name,
+        platform: None,
     }
 }
 
-pub async fn create(docker: docker_api::Docker){
-    let env = vec!["EULA=TRUE"];
-    let opts = ContainerCreateOpts::builder()
-            .image("itzg/minecraft-server:latest")
-            .env(env)
-            //.network_config(network_config)
-            .build();
-    let cont = match docker.containers().create(&opts).await {
-                Ok(c) => {
-                    println!("OK: {c:?}");
-                    c
-                },
-                Err(e) => {eprintln!("Error: {e}"); panic!("{e}")},
-    };
-    match cont.start().await {
-        Ok(s) => {
-            println!("Ok {s:?}")
-        },
-        Err(e) => eprintln!("Error: {e}"),
-
-    };
+async fn create(docker: bollard::Docker, name: String, ip: String, net: String) -> Result<String, Error>{
+    let create = docker.create_container(Some(create_options(name.clone())), create_config(ip, net)).await?;
+    docker.start_container(&name, None::<StartContainerOptions<String>>).await?;
+    return Ok(create.id);
 }
-
-/*async fn get_network(docker: docker_api::Docker) -> Network {
-
-}*/

src/main.rs

@@ -1,13 +1,7 @@
-use futures::executor::block_on;
-use std::io;
-use tokio::net::TcpListener;
-use tokio::io::AsyncWriteExt;
-use std::collections::hash_map::HashMap;
 use bollard::Docker;
-use bollard::container::{StartContainerOptions, CreateContainerOptions, Config, NetworkingConfig};
-use bollard::models::{EndpointSettings, EndpointIpamConfig};
 
 mod create_container;
+mod network_docker;
 mod server;
 mod conf;
 
@@ -18,47 +12,18 @@ async fn main() {
         Err(e) => panic!("error:{}",e.to_string()),
     };
 
-    let options = Some(CreateContainerOptions{
-        name: "my-new-container",
-        //platform: None,
-    });
-    let ip = Some(String::from("172.20.0.5"));
-    let endpoint = EndpointSettings {
-        ipam_config: Some(EndpointIpamConfig{
-                ipv4_address: ip.clone(),
-                ..Default::default()
-            }),
-        //network_id: Some(String::from("672821882d72")),
-        //ip_address: ip.clone(),
-        ..Default::default()
-    };
-    let mut hash = HashMap::new();
-    hash.insert("customnetwork", endpoint);
-    let net = NetworkingConfig {
-        endpoints_config: hash
-    };
-    let env = vec!["EULA=TRUE"];
-    let config = Config {
-        image: Some("itzg/minecraft-server:latest"),
-        env: Some(env),
-        networking_config: Some(net),
-        ..Default::default()
+    let net_name = String::from("customnetwork");
+    let net_range = String::from("172.20.0.0/24");
+
+    match network_docker::Network::create_network(docker.clone(), net_name, net_range).await {
+        Ok(_n)=> println!("va"),
+        Err(e)=> println!("err: {}", e),
     };
 
-    match docker.create_container(options, config).await{
-        Ok(r) => println!("va1"),
-        Err(e) => println!("error1:{}",e.to_string()),
-    }
-    match docker.start_container("my-new-container", None::<StartContainerOptions<String>>).await {
-        Ok(r) => println!("va2"),
-        Err(e) => println!("error2:{}",e.to_string()),
+    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),
     };
-    /*let docker = match docker_api::Docker::new("unix:///var/run/docker.sock") {
-        Ok(d) => d,
-        Err(e) => {print!("{}",e.to_string()); panic!("{}", e.to_string())},
-    };
-    block_on(create_container::list(docker.clone()));*/
-    //block_on(create_container::create(docker.clone()));
-    //block_on(create_container::list_c(docker));
-    //server::start().await;
 }

src/network_docker.rs

@@ -0,0 +1,48 @@
+use bollard::Docker;
+use bollard::errors::Error;
+use bollard::models::{IpamConfig,Ipam};
+use bollard::network::CreateNetworkOptions;
+
+pub struct Network {
+    name: String,
+    range: String,
+
+}
+
+impl Network {
+    async fn check_network(docker: bollard::Docker, name) -> bool {
+        let mut list_networks_filters = HashMap::new();
+        list_networks_filters.insert("name", name);
+        match docker.list_networks(Some(ListNetworksOptions {
+            filters: list_networks_filters,
+        })).await {
+            Ok(l)=> l.len()>0,
+            Err(e)=> false
+        }
+    }
+
+    pub async fn create_network(docker: bollard::Docker, name: String, range: String) -> Result<Self, Error>{
+        let ipam_config = IpamConfig {
+            subnet: Some(range.clone()),
+            ..Default::default()
+        };
+
+        let create_network_options = CreateNetworkOptions {
+            name: name.as_str(),
+            driver: "bridge",
+            ipam: Ipam {
+                config: Some(vec![ipam_config]),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        match docker.create_network(create_network_options).await {
+            Ok(n)=> Ok(Network {
+                name: name,
+                range: range,
+            }),
+            Err(e)=> Err(e),
+        }
+    }
+}
+