Struct bollard::Docker

impl Docker

pub async fn list_containers<'de, T>( &self, options: Option<ListContainersOptions<T>> ) -> Result<Vec<ContainerSummary>, Error>
where T: Into<String> + Eq + Hash + Serialize,

§List Containers

Returns a list of containers.

§Arguments

Optional ListContainersOptions struct.

§Returns

Vector of ContainerSummary, wrapped in a Future.

§Examples

use bollard::container::ListContainersOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("health", vec!["unhealthy"]);

let options = Some(ListContainersOptions{
    all: true,
    filters,
    ..Default::default()
});

docker.list_containers(options);

pub async fn create_container<T, Z>( &self, options: Option<CreateContainerOptions<T>>, config: Config<Z> ) -> Result<ContainerCreateResponse, Error>
where T: Into<String> + Serialize, Z: Into<String> + Hash + Eq + Serialize,

§Create Container

Prepares a container for a subsequent start operation.

§Arguments

Optional Create Container Options struct.
Container Config struct.

§Returns

ContainerCreateResponse, wrapped in a Future.

§Examples

use bollard::container::{CreateContainerOptions, Config};

use std::default::Default;

let options = Some(CreateContainerOptions{
    name: "my-new-container",
    platform: None,
});

let config = Config {
    image: Some("hello-world"),
    cmd: Some(vec!["/hello"]),
    ..Default::default()
};

docker.create_container(options, config);

pub async fn start_container<T>( &self, container_name: &str, options: Option<StartContainerOptions<T>> ) -> Result<(), Error>
where T: Into<String> + Serialize,

§Start Container

Starts a container, after preparing it with the Create Container API.

§Arguments

Container name as a string slice.
Optional Start Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples

use bollard::container::StartContainerOptions;

docker.start_container("hello-world", None::<StartContainerOptions<String>>);

pub async fn stop_container( &self, container_name: &str, options: Option<StopContainerOptions> ) -> Result<(), Error>

§Stop Container

Stops a container.

§Arguments

Container name as string slice.
Optional Stop Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples

use bollard::container::StopContainerOptions;

let options = Some(StopContainerOptions{
    t: 30,
});

docker.stop_container("hello-world", options);

pub async fn remove_container( &self, container_name: &str, options: Option<RemoveContainerOptions> ) -> Result<(), Error>

§Remove Container

Remove a container.

§Arguments

Container name as a string slice.
Optional Remove Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::container::RemoveContainerOptions;

use std::default::Default;

let options = Some(RemoveContainerOptions{
    force: true,
    ..Default::default()
});

docker.remove_container("hello-world", options);

pub fn wait_container<T>( &self, container_name: &str, options: Option<WaitContainerOptions<T>> ) -> impl Stream<Item = Result<ContainerWaitResponse, Error>>
where T: Into<String> + Serialize,

§Wait Container

Wait for a container to stop. This is a non-blocking operation, the resulting stream will end when the container stops.

§Arguments

Container name as string slice.
Optional Wait Container Options struct.

§Returns

ContainerWaitResponse, wrapped in a Stream.

§Examples


use bollard::container::WaitContainerOptions;

let options = Some(WaitContainerOptions{
    condition: "not-running",
});

docker.wait_container("hello-world", options);

pub async fn attach_container<T>( &self, container_name: &str, options: Option<AttachContainerOptions<T>> ) -> Result<AttachContainerResults, Error>
where T: Into<String> + Serialize + Default,

§Attach Container

Attach to a container to read its output or send it input. You can attach to the same container multiple times and you can reattach to containers that have been detached.

§Arguments

Container name as string slice.
Optional Attach Container Options struct.

§Returns

AttachContainerResults wrapped in a Future.

§Examples


use bollard::container::AttachContainerOptions;

let options = Some(AttachContainerOptions::<String>{
    stdin: Some(true),
    stdout: Some(true),
    stderr: Some(true),
    stream: Some(true),
    logs: Some(true),
    detach_keys: Some("ctrl-c".to_string()),
});

docker.attach_container("hello-world", options);

pub async fn resize_container_tty( &self, container_name: &str, options: ResizeContainerTtyOptions ) -> Result<(), Error>

§Resize container tty

Resize the container’s TTY.

§Arguments

Container name as string slice.
Resize Container Tty Options struct.

§Examples


use bollard::container::ResizeContainerTtyOptions;

let options = ResizeContainerTtyOptions {
    width: 50,
    height: 20,
};

docker.resize_container_tty("hello-world", options);

pub async fn restart_container( &self, container_name: &str, options: Option<RestartContainerOptions> ) -> Result<(), Error>

§Restart Container

Restart a container.

§Arguments

Container name as string slice.
Optional Restart Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::container::RestartContainerOptions;

let options = Some(RestartContainerOptions{
    t: 30,
});

docker.restart_container("postgres", options);

pub async fn inspect_container( &self, container_name: &str, options: Option<InspectContainerOptions> ) -> Result<ContainerInspectResponse, Error>

§Inspect Container

Inspect a container.

§Arguments

Container name as a string slice.
Optional Inspect Container Options struct.

§Returns

ContainerInspectResponse, wrapped in a Future.

§Examples

use bollard::container::InspectContainerOptions;

let options = Some(InspectContainerOptions{
    size: false,
});

docker.inspect_container("hello-world", options);

pub async fn top_processes<T>( &self, container_name: &str, options: Option<TopOptions<T>> ) -> Result<ContainerTopResponse, Error>
where T: Into<String> + Serialize,

§Top Processes

List processes running inside a container.

§Arguments

Container name as string slice.
Optional Top Options struct.

§Returns

ContainerTopResponse, wrapped in a Future.

§Examples

use bollard::container::TopOptions;

let options = Some(TopOptions{
    ps_args: "aux",
});

docker.top_processes("fussybeaver/uhttpd", options);

pub fn logs<T>( &self, container_name: &str, options: Option<LogsOptions<T>> ) -> impl Stream<Item = Result<LogOutput, Error>>
where T: Into<String> + Serialize,

§Logs

Get container logs.

§Arguments

Container name as string slice.
Optional Logs Options struct.

§Returns

Log Output enum, wrapped in a Stream.

§Examples


use bollard::container::LogsOptions;

use std::default::Default;

let options = Some(LogsOptions::<String>{
    stdout: true,
    ..Default::default()
});

docker.logs("hello-world", options);

pub async fn container_changes( &self, container_name: &str ) -> Result<Option<Vec<FilesystemChange>>, Error>

§Container Changes

Get changes on a container’s filesystem.

§Arguments

Container name as string slice.

§Returns

An Option of Vector of File System Change structs, wrapped in a Future.

§Examples


docker.container_changes("hello-world");

pub fn stats( &self, container_name: &str, options: Option<StatsOptions> ) -> impl Stream<Item = Result<Stats, Error>>

§Stats

Get container stats based on resource usage.

§Arguments

Container name as string slice.
Optional Stats Options struct.

§Returns

Stats struct, wrapped in a Stream.

§Examples


use bollard::container::StatsOptions;

let options = Some(StatsOptions{
    stream: false,
    one_shot: true,
});

docker.stats("hello-world", options);

pub async fn kill_container<T>( &self, container_name: &str, options: Option<KillContainerOptions<T>> ) -> Result<(), Error>
where T: Into<String> + Serialize,

§Kill Container

Kill a container.

§Arguments

Container name as string slice.
Optional Kill Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::container::KillContainerOptions;

let options = Some(KillContainerOptions{
    signal: "SIGINT",
});

docker.kill_container("postgres", options);

pub async fn update_container<T>( &self, container_name: &str, config: UpdateContainerOptions<T> ) -> Result<(), Error>
where T: Into<String> + Eq + Hash + Serialize,

§Update Container

Update a container.

§Arguments

Container name as string slice.
Update Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::container::UpdateContainerOptions;
use std::default::Default;

let config = UpdateContainerOptions::<String> {
    memory: Some(314572800),
    memory_swap: Some(314572800),
    ..Default::default()
};

docker.update_container("postgres", config);

pub async fn rename_container<T>( &self, container_name: &str, options: RenameContainerOptions<T> ) -> Result<(), Error>
where T: Into<String> + Serialize,

§Rename Container

Rename a container.

§Arguments

Container name as string slice.
Rename Container Options struct

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::container::RenameContainerOptions;

let required = RenameContainerOptions {
    name: "my_new_container_name"
};

docker.rename_container("hello-world", required);

pub async fn pause_container(&self, container_name: &str) -> Result<(), Error>

§Pause Container

Use the cgroups freezer to suspend all processes in a container.

§Arguments

Container name as a string slice.

§Returns

unit type (), wrapped in a Future.

§Examples


docker.pause_container("postgres");

pub async fn unpause_container(&self, container_name: &str) -> Result<(), Error>

§Unpause Container

Resume a container which has been paused.

§Arguments

Container name as a string slice.

§Returns

unit type (), wrapped in a Future.

§Examples


docker.unpause_container("postgres");

pub async fn prune_containers<T>( &self, options: Option<PruneContainersOptions<T>> ) -> Result<ContainerPruneResponse, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Prune Containers

Delete stopped containers.

§Arguments

Optional Prune Containers Options struct.

§Returns

Container Prune Response struct, wrapped in a Future.

§Examples

use bollard::container::PruneContainersOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("until", vec!["10m"]);

let options = Some(PruneContainersOptions{
    filters
});

docker.prune_containers(options);

pub async fn upload_to_container<T>( &self, container_name: &str, options: Option<UploadToContainerOptions<T>>, tar: Bytes ) -> Result<(), Error>
where T: Into<String> + Serialize,

§Upload To Container

Upload a tar archive to be extracted to a path in the filesystem of container id.

§Arguments

Optional Upload To Container Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples

use bollard::container::UploadToContainerOptions;

use std::default::Default;
use std::fs::File;
use std::io::Read;

let options = Some(UploadToContainerOptions{
    path: "/opt",
    ..Default::default()
});

let mut file = File::open("tarball.tar.gz").unwrap();
let mut contents = Vec::new();
file.read_to_end(&mut contents).unwrap();

docker.upload_to_container("my-container", options, contents.into());

pub fn download_from_container<T>( &self, container_name: &str, options: Option<DownloadFromContainerOptions<T>> ) -> impl Stream<Item = Result<Bytes, Error>>
where T: Into<String> + Serialize,

§Download From Container

Get a tar archive of a resource in the filesystem of container id.

§Arguments

Download From Container Options struct.

§Returns

Tar archive compressed with one of the following algorithms: identity (no compression), gzip, bzip2, xz. Hyper Body.

§Examples

use bollard::container::DownloadFromContainerOptions;

let options = Some(DownloadFromContainerOptions{
    path: "/opt",
});

docker.download_from_container("my-container", options);

pub fn export_container( &self, container_name: &str ) -> impl Stream<Item = Result<Bytes, Error>>

§Export Container

Get a tarball containing the filesystem contents of a container.

See the Docker API documentation for more information.

§Arguments

The container_name string referring to an individual container

§Returns

An uncompressed TAR archive

impl Docker

A Docker implementation that wraps away which local implementation we are calling.

pub fn connect_with_local_defaults() -> Result<Docker, Error>

Connect using the local machine connection method with default arguments.

This is a simple wrapper over the OS specific handlers:

Unix: Docker::connect_with_unix_defaults
Windows: Docker::connect_with_named_pipe_defaults

pub fn connect_with_local( addr: &str, timeout: u64, client_version: &ClientVersion ) -> Result<Docker, Error>

Connect using the local machine connection method with supplied arguments.

This is a simple wrapper over the OS specific handlers:

Unix: Docker::connect_with_unix
Windows: Docker::connect_with_named_pipe

impl Docker

pub fn with_timeout(self, timeout: Duration) -> Self

Set the request timeout.

This timeout is shared by all requests to the Docker Engine API.

By default, 2 minutes.

pub fn timeout(&self) -> Duration

Get the current timeout.

This timeout is shared by all requests to the Docker Engine API.

pub fn set_timeout(&mut self, timeout: Duration)

Set the request timeout.

This timeout is shared by all requests to the Docker Engine API.

By default, 2 minutes.

impl Docker

pub async fn list_images<T>( &self, options: Option<ListImagesOptions<T>> ) -> Result<Vec<ImageSummary>, Error>
where T: Into<String> + Eq + Hash + Serialize,

§List Images

Returns a list of images on the server. Note that it uses a different, smaller representation of an image than inspecting a single image

§Arguments

An optional List Images Options struct.

§Returns

Vector of API Images, wrapped in a Future.

§Examples

use bollard::image::ListImagesOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("dangling", vec!["true"]);

let options = Some(ListImagesOptions{
  all: true,
  filters,
  ..Default::default()
});

docker.list_images(options);

pub fn create_image<T>( &self, options: Option<CreateImageOptions<'_, T>>, root_fs: Option<Bytes>, credentials: Option<DockerCredentials> ) -> impl Stream<Item = Result<CreateImageInfo, Error>>
where T: Into<String> + Serialize + Debug + Clone,

§Create Image

Create an image by either pulling it from a registry or importing it.

§Arguments

An optional Create Image Options struct.
An optional request body consisting of a tar or tar.gz archive with the root file system for the image. If this argument is used, the value of the from_src option must be “-”.

§Returns

Create Image Info, wrapped in an asynchronous Stream.

§Examples

use bollard::image::CreateImageOptions;

use std::default::Default;

let options = Some(CreateImageOptions{
  from_image: "hello-world",
  ..Default::default()
});

docker.create_image(options, None, None);

// do some other work while the image is pulled from the docker hub...

§Unsupported

Import from tarball

pub async fn inspect_image( &self, image_name: &str ) -> Result<ImageInspect, Error>

§Inspect Image

Return low-level information about an image.

§Arguments

Image name as a string slice.

§Returns

ImageInspect, wrapped in a Future.

§Examples


use std::default::Default;

docker.inspect_image("hello-world");

pub async fn inspect_registry_image( &self, image_name: &str, credentials: Option<DockerCredentials> ) -> Result<DistributionInspect, Error>

§Inspect an Image by contacting the registry

Return image digest and platform information by contacting the registry

§Arguments

Image name as a string slice.

§Returns

DistributionInspect, wrapped in a Future

§Examples

use bollard::Docker;
let docker = Docker::connect_with_http_defaults().unwrap();
docker.inspect_registry_image("ubuntu:jammy", None);

pub async fn prune_images<T>( &self, options: Option<PruneImagesOptions<T>> ) -> Result<ImagePruneResponse, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Prune Images

Delete unused images.

§Arguments

An optional Prune Images Options struct.

§Returns

a Prune Image Response, wrapped in a Future.

§Examples

use bollard::image::PruneImagesOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("until", vec!["10m"]);

let options = Some(PruneImagesOptions {
  filters
});

docker.prune_images(options);

pub async fn image_history( &self, image_name: &str ) -> Result<Vec<HistoryResponseItem>, Error>

§Image History

Return parent layers of an image.

§Arguments

Image name as a string slice.

§Returns

Vector of History Response Item, wrapped in a Future.

§Examples


docker.image_history("hello-world");

pub async fn search_images<T>( &self, options: SearchImagesOptions<T> ) -> Result<Vec<ImageSearchResponseItem>, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Search Images

Search for an image on Docker Hub.

§Arguments

Search Image Options struct.

§Returns

Vector of Image Search Response Item results, wrapped in a Future.

§Examples


use bollard::image::SearchImagesOptions;
use std::default::Default;
use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("until", vec!["10m"]);

let search_options = SearchImagesOptions {
    term: "hello-world",
    filters,
    ..Default::default()
};

docker.search_images(search_options);

pub async fn remove_image( &self, image_name: &str, options: Option<RemoveImageOptions>, credentials: Option<DockerCredentials> ) -> Result<Vec<ImageDeleteResponseItem>, Error>

§Remove Image

Remove an image, along with any untagged parent images that were referenced by that image.

§Arguments

Image name as a string slice.
An optional Remove Image Options struct.

§Returns

Vector of Image Delete Response Item, wrapped in a Future.

§Examples


use bollard::image::RemoveImageOptions;
use std::default::Default;

let remove_options = Some(RemoveImageOptions {
    force: true,
    ..Default::default()
});

docker.remove_image("hello-world", remove_options, None);

pub async fn tag_image<T>( &self, image_name: &str, options: Option<TagImageOptions<T>> ) -> Result<(), Error>
where T: Into<String> + Serialize,

§Tag Image

Tag an image so that it becomes part of a repository.

§Arguments

Image name as a string slice.
Optional Tag Image Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::image::TagImageOptions;
use std::default::Default;

let tag_options = Some(TagImageOptions {
    tag: "v1.0.1",
    ..Default::default()
});

docker.tag_image("hello-world", tag_options);

pub fn push_image<T>( &self, image_name: &str, options: Option<PushImageOptions<T>>, credentials: Option<DockerCredentials> ) -> impl Stream<Item = Result<PushImageInfo, Error>>
where T: Into<String> + Serialize,

§Push Image

Push an image to a registry.

§Arguments

Image name as a string slice.
Optional Push Image Options struct.
Optional Docker Credentials struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::auth::DockerCredentials;
use bollard::image::PushImageOptions;

use std::default::Default;

let push_options = Some(PushImageOptions {
    tag: "v1.0.1",
});

let credentials = Some(DockerCredentials {
    username: Some("Jack".to_string()),
    password: Some("myverysecretpassword".to_string()),
    ..Default::default()
});

docker.push_image("hello-world", push_options, credentials);

pub async fn commit_container<T, Z>( &self, options: CommitContainerOptions<T>, config: Config<Z> ) -> Result<Commit, Error>
where T: Into<String> + Serialize, Z: Into<String> + Eq + Hash + Serialize,

§Commit Container

Create a new image from a container.

§Arguments

Commit Container Options struct.
Container Config struct.

§Returns

Commit, wrapped in a Future.

§Examples

use bollard::image::CommitContainerOptions;
use bollard::container::Config;

use std::default::Default;

let options = CommitContainerOptions{
    container: "my-running-container",
    pause: true,
    ..Default::default()
};

let config = Config::<String> {
    ..Default::default()
};

docker.commit_container(options, config);

pub fn build_image<T>( &self, options: BuildImageOptions<T>, credentials: Option<HashMap<String, DockerCredentials>>, tar: Option<Bytes> ) -> impl Stream<Item = Result<BuildInfo, Error>> + '_
where T: Into<String> + Eq + Hash + Serialize,

§Build Image

Build an image from a tar archive with a Dockerfile in it.

The Dockerfile specifies how the image is built from the tar archive. It is typically in the archive’s root, but can be at a different path or have a different name by specifying the dockerfile parameter.

By default, the call to build specifies using BuilderV1, the first generation builder in docker daemon.

§Arguments

Build Image Options struct.
Optional Docker Credentials struct.
Tar archive compressed with one of the following algorithms: identity (no compression), gzip, bzip2, xz. Optional Hyper Body.

§Returns

Create Image Info, wrapped in an asynchronous Stream.

§Examples

use bollard::image::BuildImageOptions;
use bollard::container::Config;

use std::default::Default;
use std::fs::File;
use std::io::Read;

let options = BuildImageOptions{
    dockerfile: "Dockerfile",
    t: "my-image",
    rm: true,
    ..Default::default()
};

let mut file = File::open("tarball.tar.gz").unwrap();
let mut contents = Vec::new();
file.read_to_end(&mut contents).unwrap();

docker.build_image(options, None, Some(contents.into()));

pub fn export_image( &self, image_name: &str ) -> impl Stream<Item = Result<Bytes, Error>>

§Export Image

Get a tarball containing all images and metadata for a repository.

The root of the resulting tar file will contain the file “manifest.json”. If the export is of an image repository, rather than a single image, there will also be a repositories file with a JSON description of the exported image repositories. Additionally, each layer of all exported images will have a sub directory in the archive containing the filesystem of the layer.

See the Docker API documentation for more information.

§Arguments

The image_name string referring to an individual image and tag (e.g. alpine:latest)

§Returns

An uncompressed TAR archive

pub fn export_images( &self, image_names: &[&str] ) -> impl Stream<Item = Result<Bytes, Error>>

§Export Images

Get a tarball containing all images and metadata for several image repositories. Shared layers will be deduplicated.

See the Docker API documentation for more information.

§Arguments

The image_names Vec of image names.

§Returns

An uncompressed TAR archive

pub fn import_image( &self, options: ImportImageOptions, root_fs: Bytes, credentials: Option<HashMap<String, DockerCredentials>> ) -> impl Stream<Item = Result<BuildInfo, Error>>

§Import Image

Load a set of images and tags into a repository.

For details on the format, see the export image endpoint.

§Arguments

Image Import Options struct.

§Returns

Build Info, wrapped in an asynchronous Stream.

§Examples

use bollard::image::ImportImageOptions;
use bollard::errors::Error;

use std::default::Default;
use futures_util::stream::{StreamExt, TryStreamExt};
use tokio::fs::File;
use tokio::io::AsyncWriteExt;
use tokio_util::codec;

let options = ImportImageOptions{
    ..Default::default()
};

async move {
    let mut file = File::open("tarball.tar.gz").await.unwrap();

    let mut byte_stream = codec::FramedRead::new(file, codec::BytesCodec::new()).map(|r| {
        let bytes = r.unwrap().freeze();
        Ok::<_, Error>(bytes)
    });

    let bytes = byte_stream.next().await.unwrap().unwrap();

    let mut stream = docker
        .import_image(
            ImportImageOptions {
                ..Default::default()
            },
            bytes,
            None,
        );

    while let Some(response) = stream.next().await {
        // ...
    }
};

impl Docker

pub async fn create_network<T>( &self, config: CreateNetworkOptions<T> ) -> Result<NetworkCreateResponse, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Create Network

Create a new network.

§Arguments

Create Network Options struct.

§Returns

A Network Create Response struct, wrapped in a Future.

§Examples


use bollard::network::CreateNetworkOptions;

use std::default::Default;

let config = CreateNetworkOptions {
    name: "certs",
    ..Default::default()
};

docker.create_network(config);

pub async fn remove_network(&self, network_name: &str) -> Result<(), Error>

§Remove a Network

§Arguments

Network name as a string slice.

§Returns

unit type (), wrapped in a Future.

§Examples


docker.remove_network("my_network_name");

pub async fn inspect_network<T>( &self, network_name: &str, options: Option<InspectNetworkOptions<T>> ) -> Result<Network, Error>
where T: Into<String> + Serialize,

§Inspect a Network

§Arguments

Network name as a string slice.

§Returns

A Models struct, wrapped in a Future.

§Examples


use bollard::network::InspectNetworkOptions;

use std::default::Default;

let config = InspectNetworkOptions {
    verbose: true,
    scope: "global"
};

docker.inspect_network("my_network_name", Some(config));

pub async fn list_networks<T>( &self, options: Option<ListNetworksOptions<T>> ) -> Result<Vec<Network>, Error>
where T: Into<String> + Eq + Hash + Serialize,

§List Networks

§Arguments

Optional List Network Options struct.

§Returns

A vector of Network struct, wrapped in a Future.

§Examples


use bollard::network::ListNetworksOptions;

use std::collections::HashMap;

let mut list_networks_filters = HashMap::new();
list_networks_filters.insert("label", vec!["maintainer=some_maintainer"]);

let config = ListNetworksOptions {
    filters: list_networks_filters,
};

docker.list_networks(Some(config));

pub async fn connect_network<T>( &self, network_name: &str, config: ConnectNetworkOptions<T> ) -> Result<(), Error>
where T: Into<String> + Eq + Hash + Serialize,

§Connect Network

§Arguments

A Connect Network Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::network::ConnectNetworkOptions;
use bollard::models::{EndpointSettings, EndpointIpamConfig};

use std::default::Default;

let config = ConnectNetworkOptions {
    container: "3613f73ba0e4",
    endpoint_config: EndpointSettings {
        ipam_config: Some(EndpointIpamConfig {
            ipv4_address: Some(String::from("172.24.56.89")),
            ipv6_address: Some(String::from("2001:db8::5689")),
            ..Default::default()
        }),
        ..Default::default()
    }
};

docker.connect_network("my_network_name", config);

pub async fn disconnect_network<T>( &self, network_name: &str, config: DisconnectNetworkOptions<T> ) -> Result<(), Error>
where T: Into<String> + Serialize,

§Disconnect Network

§Arguments

A Disconnect Network Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::network::DisconnectNetworkOptions;

use std::default::Default;

let config = DisconnectNetworkOptions {
    container: "3613f73ba0e4",
    force: true
};

docker.disconnect_network("my_network_name", config);

pub async fn prune_networks<T>( &self, options: Option<PruneNetworksOptions<T>> ) -> Result<NetworkPruneResponse, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Prune Networks

Deletes networks which are unused.

§Arguments

A Prune Networks Options struct.

§Returns

A Network Prune Response struct.

§Examples


use bollard::network::PruneNetworksOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("label", vec!["maintainer=some_maintainer"]);

let options = PruneNetworksOptions {
    filters,
};

docker.prune_networks(Some(options));

impl Docker

pub async fn list_secrets<T>( &self, options: Option<ListSecretsOptions<T>> ) -> Result<Vec<Secret>, Error>
where T: Into<String> + Eq + Hash + Serialize,

§List Secrets

Returns a list of secrets.

§Arguments

Optional ListSecretsOptions struct.

§Returns

Vector of Secret, wrapped in a Future.

§Examples

use bollard::secret::ListSecretsOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("label", vec!["secret-label=label-value"]);

let options = Some(ListSecretsOptions{
    filters,
    ..Default::default()
});

docker.list_secrets(options);

pub async fn create_secret( &self, secret_spec: SecretSpec ) -> Result<IdResponse, Error>

§Create Secret

Create new secret on the docker swarm.

§Arguments

SecretSpec struct.

§Returns

A IdResponse wrapped in a Future.

§Examples

use bollard::secret::SecretSpec;

use base64;

let secret_spec = SecretSpec {
    name: Some(String::from("secret-name")),
    data: Some(base64::engine::general_purpose::STANDARD.encode("secret-data")),
    ..Default::default()
};

docker.create_secret(secret_spec);

pub async fn inspect_secret(&self, secret_id: &str) -> Result<Secret, Error>

§Inspect Secret

Inspect a secret.

§Arguments

Secret id or name as a string slice.

§Returns

Secret, wrapped in a Future.

§Examples


docker.inspect_secret("secret-id");
docker.inspect_secret("secret-name");

pub async fn delete_secret(&self, secret_id: &str) -> Result<(), Error>

§Delete Secret

Delete a secret, fails when more than one service use that secret..

§Arguments

Secret id or name as a string slice.

§Returns

unit type (), wrapped in a Future.

§Examples


docker.delete_secret("secret-id");
docker.delete_secret("secret-name");

pub async fn update_secret( &self, secret_id: &str, secret_spec: SecretSpec, options: UpdateSecretOptions ) -> Result<(), Error>

§Update Secret

Update an existing secret, fails when more than one service use that secret or trying update data.

§Arguments

Secret id or name as a string slice.
SecretSpec struct.
UpdateSecretOptions struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use std::collections::HashMap;
use bollard::secret::UpdateSecretOptions;

let result = async move {
    let existing = docker.inspect_secret("my-secret").await?;
    let version = existing.version.unwrap().index.unwrap();
    let mut spec = existing.spec.unwrap().clone();

    let mut labels = HashMap::new();
    labels.insert(String::from("secret-label"), String::from("label-value"));
    spec.labels = Some(labels.clone());

    let options = UpdateSecretOptions { version };

    docker.update_secret("my-secret", spec, options).await
};

impl Docker

pub async fn list_services<T>( &self, options: Option<ListServicesOptions<T>> ) -> Result<Vec<Service>, Error>
where T: Into<String> + Eq + Hash + Serialize,

§List Services

Returns a list of services.

§Arguments

Optional ListServicesOptions struct.

§Returns

Vector of Services, wrapped in a Future.

§Examples

use bollard::service::ListServicesOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("mode", vec!["global"]);

let options = Some(ListServicesOptions{
    filters,
    ..Default::default()
});

docker.list_services(options);

pub async fn create_service( &self, service_spec: ServiceSpec, credentials: Option<DockerCredentials> ) -> Result<ServiceCreateResponse, Error>

§Create Service

Dispatch a new service on the docker swarm

§Arguments

ServiceSpec struct.
Optional Docker Credentials struct.

§Returns

A Service Create Response struct, wrapped in a Future.

§Examples

use bollard::service::{
    ServiceSpec,
    ServiceSpecMode,
    ServiceSpecModeReplicated,
    TaskSpec,
    TaskSpecContainerSpec
};

let service = ServiceSpec {
    name: Some(String::from("my-service")),
    mode: Some(ServiceSpecMode {
        replicated: Some(ServiceSpecModeReplicated {
            replicas: Some(2)
        }),
        ..Default::default()
    }),
    task_template: Some(TaskSpec {
        container_spec: Some(TaskSpecContainerSpec {
            image: Some(String::from("hello-world")),
            ..Default::default()
        }),
        ..Default::default()
    }),
    ..Default::default()
};
let credentials = None;

docker.create_service(service, credentials);

pub async fn inspect_service( &self, service_name: &str, options: Option<InspectServiceOptions> ) -> Result<Service, Error>

§Inspect Service

Inspect a service.

§Arguments

Service name or id as a string slice.
Optional Inspect Service Options struct.

§Returns

Service, wrapped in a Future.

§Examples

use bollard::service::InspectServiceOptions;

let options = Some(InspectServiceOptions{
    insert_defaults: true,
});

docker.inspect_service("my-service", options);

pub async fn delete_service(&self, service_name: &str) -> Result<(), Error>

§Delete Service

Delete a service.

§Arguments

Service name or id as a string slice.

§Returns

unit type (), wrapped in a Future.

§Examples


docker.delete_service("my-service");

pub async fn update_service( &self, service_name: &str, service_spec: ServiceSpec, options: UpdateServiceOptions, credentials: Option<DockerCredentials> ) -> Result<ServiceUpdateResponse, Error>

§Update Service

Update an existing service

§Arguments

Service name or id as a string slice.
ServiceSpec struct.
UpdateServiceOptions struct.
Optional Docker Credentials struct.

§Returns

A Service Update Response struct, wrapped in a Future.

§Examples

use bollard::service::{
    InspectServiceOptions,
    ServiceSpec,
    ServiceSpecMode,
    ServiceSpecModeReplicated,
    TaskSpec,
    TaskSpecContainerSpec,
    UpdateServiceOptions,
};

use std::collections::HashMap;
use std::default::Default;

let result = async move {
    let service_name = "my-service";
    let current_version = docker.inspect_service(
        service_name,
        None::<InspectServiceOptions>
    ).await?.version.unwrap().index.unwrap();
    let service = ServiceSpec {
        mode: Some(ServiceSpecMode {
            replicated: Some(ServiceSpecModeReplicated {
                replicas: Some(0)
            }),
            ..Default::default()
        }),
        ..Default::default()
    };
    let options = UpdateServiceOptions {
        version: current_version,
        ..Default::default()
    };
    let credentials = None;

    docker.update_service("my-service", service, options, credentials).await
};

impl Docker

pub async fn version(&self) -> Result<Version, Error>

§Version

Returns the version of Docker that is running and various information about the system that Docker is running on.

§Returns

Version, wrapped in a Future.

§Examples

docker.version();

pub async fn info(&self) -> Result<SystemInfo, Error>

§Info

Returns Docker client and server information that is running.

§Returns

Info, wrapped in a Future.

§Examples

docker.info();

pub async fn ping(&self) -> Result<String, Error>

§Ping

This is a dummy endpoint you can use to test if the server is accessible.

§Returns - A String, wrapped in a Future. # Examples


docker.ping();

pub fn events<T>( &self, options: Option<EventsOptions<T>> ) -> impl Stream<Item = Result<EventMessage, Error>>
where T: Into<String> + Eq + Hash + Serialize,

§Events

Stream real-time events from the server.

§Returns

EventMessage, wrapped in a Stream.

§Examples

use bollard::system::EventsOptions;
use time::{Duration, OffsetDateTime};
use std::collections::HashMap;


docker.events(Some(EventsOptions::<String> {
    since: Some(OffsetDateTime::now_utc() - Duration::minutes(20)),
    until: Some(OffsetDateTime::now_utc()),
    filters: HashMap::new(),
}));

pub async fn df(&self) -> Result<SystemDataUsageResponse, Error>

§Get data usage information

Show docker disk usage

§Returns

System Data Usage Response, wrapped in a Future.

§Examples

docker.df();

impl Docker

pub async fn list_volumes<T>( &self, options: Option<ListVolumesOptions<T>> ) -> Result<VolumeListResponse, Error>
where T: Into<String> + Eq + Hash + Serialize,

§List volumes

§Arguments

List Volumes Options struct.

§Returns

A [Volume List Response]VolumeListResponse) struct, wrapped in a Future.

§Examples


use bollard::volume::ListVolumesOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("dangling", vec!("1"));

let options = ListVolumesOptions {
    filters,
};

docker.list_volumes(Some(options));

pub async fn create_volume<T>( &self, config: CreateVolumeOptions<T> ) -> Result<Volume, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Create Volume

Create a new volume.

§Arguments

Create Volume Options struct.

§Returns

A Volume struct, wrapped in a Future.

§Examples


use bollard::volume::CreateVolumeOptions;

use std::default::Default;

let config = CreateVolumeOptions {
    name: "certs",
    ..Default::default()
};

docker.create_volume(config);

pub async fn inspect_volume(&self, volume_name: &str) -> Result<Volume, Error>

§Inspect a Volume

§Arguments

Volume name as a string slice.

§Returns

A Volume struct, wrapped in a Future.

§Examples


docker.inspect_volume("my_volume_name");

pub async fn remove_volume( &self, volume_name: &str, options: Option<RemoveVolumeOptions> ) -> Result<(), Error>

§Remove a Volume

§Arguments

Volume name as a string slice.

§Arguments

Remove Volume Options struct.

§Returns

unit type (), wrapped in a Future.

§Examples


use bollard::volume::RemoveVolumeOptions;

let options = RemoveVolumeOptions {
    force: true,
};

docker.remove_volume("my_volume_name", Some(options));

pub async fn prune_volumes<T>( &self, options: Option<PruneVolumesOptions<T>> ) -> Result<VolumePruneResponse, Error>
where T: Into<String> + Eq + Hash + Serialize,

§Prune Volumes

Delete unused volumes.

§Arguments

A Prune Volumes Options struct.

§Returns

A Volume Prune Response struct.

§Examples


use bollard::volume::PruneVolumesOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("label", vec!["maintainer=some_maintainer"]);

let options = PruneVolumesOptions {
    filters,
};

docker.prune_volumes(Some(options));

Trait Implementations§

impl Clone for Docker

fn clone(&self) -> Docker

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl Debug for Docker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

impl !UnwindSafe for Docker

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more