Struct Docker

Source

pub struct Docker { /* private fields */ }

Expand description

§Docker

The main interface for calling the Docker API. Construct a new Docker instance using one of the connect methods:

Implementations§

Source §

impl Docker

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

Source

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

Source

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

Source §

impl Docker

Source

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

Set the request timeout.

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

By default, 2 minutes.

Source

pub fn timeout(&self) -> Duration

Get the current timeout.

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

Source

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.

Source §

impl Docker

Source

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);

Source

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

§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

Source

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");

Source

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);

Source

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");

Source

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);

Source

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);

Source

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);

Source

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);

Source

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);

Source

pub fn build_image<T>( &self, options: BuildImageOptions<T>, credentials: Option<HashMap<String, DockerCredentials>>, tar: Option<Body>, ) -> 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.

§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()));

Source

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 “mainifest.json”. If the export is of an image repository, rather than a signle 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 can refer to an individual image and tag (e.g. alpine:latest), an individual image by I

§Returns

An uncompressed TAR archive

Source

pub fn import_image( &self, options: ImportImageOptions, root_fs: Body, 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;
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 byte_stream = codec::FramedRead::new(file, codec::BytesCodec::new()).map(|r| {
        let bytes = r.unwrap().freeze();
        Ok::<_, Error>(bytes)
    });
    let body = hyper::Body::wrap_stream(byte_stream);
    let mut stream = docker
        .import_image(
            ImportImageOptions {
                ..Default::default()
            },
            body,
            None,
        );

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

Source §

impl Docker

Source

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);

Source

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");

Source

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));

Source

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));

Source

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);

Source

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);

Source

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));

Source §

impl Docker

Source

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);

Source

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);

Source

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);

Source

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");

Source

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
};

Source §

impl Docker

Source

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();

Source

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();

Source

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();

Source

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

System Events Response, wrapped in a Stream.

§Examples

use bollard::system::EventsOptions;
use chrono::{Duration, Utc};
use std::collections::HashMap;


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

Source

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();

Source §

impl Docker

Source

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));

Source

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);

Source

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");

Source

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));

Source

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§

Source §

impl Clone for Docker

Source §

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

Source §

impl Debug for Docker

Source §

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl !UnwindSafe for Docker

Blanket Implementations§

Source §

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

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

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

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

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

Source §

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

Mutably borrows from an owned value. Read more

Source §

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

Source §

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T> Instrument for T

Source §

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

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

Source §

fn in_current_span(self) -> Instrumented<Self>

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

Source §

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

Source §

fn into(self) -> U

Calls U::from(self).

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

Source §

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

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

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

Source §

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

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

Source §

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

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

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

Performs the conversion.

Source §

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

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

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

Performs the conversion.

Source §

impl<T> WithSubscriber for T

Source §

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

Source §

fn with_current_subscriber(self) -> WithDispatch<Self>

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

Source §

Struct DockerCopy item path

§Docker

Implementations§

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

§Arguments

§Returns

§Examples

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

§Arguments

§Returns

§Examples

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

§Start Container

§Arguments

§Returns

§Examples

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

§Stop Container

§Arguments

§Returns

§Examples

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

§Remove Container

§Arguments

§Returns

§Examples

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

§Arguments

§Returns

§Examples

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

§Arguments

§Returns

§Examples

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

§Resize container tty

§Arguments

§Examples

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

§Restart Container

§Arguments

§Returns

§Examples

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

§Inspect Container

§Arguments

§Returns

§Examples

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

§Top Processes

§Arguments

§Returns

§Examples

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

§Logs

§Arguments

§Returns

§Examples

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

§Container Changes

§Arguments

§Returns

§Examples

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

§Stats

§Arguments

§Returns

§Examples

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

§Kill Container

§Arguments

§Returns

§Examples

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

§Update Container

Struct Docker

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

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,

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

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

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

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

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

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

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

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

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

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

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,