Struct docktape::Docker

pub struct Docker { /* fields omitted */ }

Struct representing a Docker object with its socket

Methods

impl Docker

pub fn new(socket: Socket) -> Self

pub fn get_info(&mut self) -> Option<Value>

Returns Docker informations

Example

 match docker.get_info(){
      Some(info) =>{
          println!("Dock info: {}", info);
      },
      None =>{
          println!("No info! (Docker is offline?)");
      }
  }

pub fn create_image_from_image(     &mut self,     name: &str,     repo: &str,     platform: &str ) -> Option<Value>

Creates a Docker image from a public image

Example

 match docker.create_image_from_image("fedora:latest", ""){
       Some(msg) =>{
           println!("Error message: {:?}", msg["message"]);
       }
       None =>{
           println!("Image created.");
       }
   }

pub fn get_images(&mut self) -> Option<Vec<Image>>

Returns a vec of Docker images

Example

 match docker.get_images(){
      Some(images) =>{
          println!("There are {} image(s).", images.len());
      },
      None =>{
          println!("There are no images.");
      }
  }

pub fn inspect_image(&mut self, image: &str) -> Option<Image>

Inspects a Docker image

Example

 match docker.inspect_image("fedora:latest"){
      Some(img) => {
          println!("Image id: {}.", img.id());
      }
      None => {
          println!("Cannot get image.");
      }
  }

pub fn delete_image(&mut self, name: &str) -> Option<Value>

Deletes a Docker image

Example

 match docker.delete_image("fedora:latest"){
      Some(_) =>{
          println!("Image deleted.");
      }
      None =>{
          println!("Error while deleting image.");
      }
  }

pub fn create_container(&mut self, body: &str, name: &str) -> Option<Container>

Creates a Docker container

Example

 let body = json!({
      "Image": "fedora:latest",
      "Cmd": ["echo"]
  });

  match docker.create_container(&body.to_string(), "my_container"){
      Some(_) =>{
          println!("Container created.");
      },
      None =>{
          println!("Error while creating container.");
      }
  }

pub fn get_containers(&mut self) -> Option<Vec<Container>>

Returns a vec of Docker containers

Example

match docker.get_containers(){
      Some(containers) =>{
          println!("There are {} container(s).", containers.len());
      },
      None =>{
          println!("There are no containers.");
      }
  }

pub fn inspect_container(&mut self, container: &str) -> Option<Container>

Inspects a Docker container

Example

 match docker.inspect_container("my_container"){
      Some(container) =>{
          println!("Container id: {}.", container.id());
      }
      None =>{
          println!("Container can't be found.");
      }
  }

pub fn start_container(&mut self, container: &str) -> Option<Value>

Starts a Docker container

Example

 match docker.start_container("my_container"){
      Some(msg) =>{
          println!("Error message: {:?}.", msg["message"]);
      }
      None =>{
          println!("Container started.");
      }
  }

pub fn stop_container(&mut self, container: &str) -> Option<Value>

Stops a Docker container

Example

 match docker.stop_container("my_container"){
      Some(msg) =>{
          println!("Error message: {:?}.", msg["message"]);
      }
      None =>{
          println!("Container stopped.");
      }
  }

pub fn restart_container(&mut self, container: &str) -> Option<Value>

Restarts a Docker container

Example

 match docker.restart_container("my_container"){
      Some(msg) =>{
          println!("Error message: {:?}.", msg["message"]);
      }
      None =>{
          println!("Container restarted.");
      }
  }

pub fn delete_container(&mut self, container: &str) -> Option<Value>

Deletes a Docker container

Example

 match docker.delete_container("my_container"){
      Some(msg) =>{
          println!("Error message: {:?}", msg["message"]);
      }
      None =>{
          println!("Container deleted.");
      }
  }

pub fn create_network(&mut self, body: &str) -> Option<Network>

Creates a Docker network

Example

 let body = json!({
      "Name": "my_network",
      "CheckDuplicate": true
  });

  match docker.create_network(&body.to_string()) {
      Some(_) =>{
          println!("Network created.");
      }
      None =>{
          println!("Error while creating network.");
      }
  }

pub fn get_networks(&mut self) -> Option<Vec<Network>>

Returns a vec of Docker networks

Example

 match docker.get_networks(){
      Some(networks) =>{
          println!("There are {} network(s).", networks.len());
      },
      None =>{
          println!("There are no networks.");
      }
  }

pub fn inspect_network(&mut self, name: &str) -> Option<Network>

Inspects a Docker network

Example

 match docker.inspect_network("my_network"){
      Some(network) => {
          println!("Network id: {}.", network.id());
      }
      None => {
          println!("Cannot get network.");
      }
  }

pub fn delete_network(&mut self, name: &str) -> Option<Value>

Deletes a Docker network

Example

  match docker.delete_network("my_network"){
      Some(msg) =>{
          println!("Error message: {:?}.", msg["message"]);
      }
      None =>{
          println!("Network deleted.");
      }
  }

pub fn create_volume(&mut self, body: &str) -> Option<Volume>

Creates a Docker volume

Example

   let body = json!({
      "Name": "my_volume"
  });

  match docker.create_volume(&body.to_string()){
      Some(_) =>{
          println!("Volume created.");
      }
      None =>{
          println!("Error while creating volume.");
      }
  }

pub fn get_volumes(&mut self) -> Option<Vec<Volume>>

Returns a vec of Docker volumes

Example

  match docker.get_volumes(){
      Some(volumes) =>{
          println!("There are {} volume(s).", volumes.len());
      },
      None =>{
          println!("There are no volumes.");
      }
  }

pub fn inspect_volume(&mut self, name: &str) -> Option<Volume>

Inspects a Docker volume

Example

 match docker.inspect_volume("my_volume"){
      Some(volume) =>{
          println!("Volume mountpoint: {}.", volume.mountpoint());
      }
      None =>{
          println!("Volume can't be found.");
      }
  }

pub fn delete_volume(&mut self, name: &str) -> Option<Value>

Deletes a Docker volume

Example

 match docker.delete_volume("my_volume"){
      Some(msg) =>{
          println!("Error message: {:?}", msg["message"]);
      }
      None =>{
          println!("Volume deleted.");
      }
  }