testing bollard

src/create_container.rs

@@ -27,6 +27,7 @@ pub async fn create(docker: docker_api::Docker){
     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) => {
@@ -43,3 +44,7 @@ pub async fn create(docker: docker_api::Docker){
 
     };
 }
+
+/*async fn get_network(docker: docker_api::Docker) -> Network {
+
+}*/

src/main.rs

@@ -2,17 +2,62 @@ 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 server;
 mod conf;
 
 #[tokio::main]
 async fn main() {
-    let docker = match docker_api::Docker::new("unix:///var/run/docker.sock") {
+    let docker = match Docker::connect_with_local_defaults() {
+        Ok(d) => d,
+        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()
+    };
+
+    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()),
+    };
+    /*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::list(docker.clone()));*/
     //block_on(create_container::create(docker.clone()));
     //block_on(create_container::list_c(docker));
     //server::start().await;