Struct docker_api::api::container::opts::ContainerOptsBuilder

pub struct ContainerOptsBuilder { /* fields omitted */ }

Implementations

impl ContainerOptsBuilder

pub fn name<N>(&mut self, name: N) -> &mut Self where
    N: Into<String>, 

Set the name of the container.

pub fn publish_all_ports(&mut self) -> &mut Self

enable all exposed ports on the container to be mapped to random, available, ports on the host

pub fn expose(&mut self, srcport: PublishPort, hostport: u32) -> &mut Self

pub fn publish(&mut self, port: PublishPort) -> &mut Self

Publish a port in the container without assigning a port on the host

pub fn working_dir<W>(&mut self, working_dir: W) -> &mut Self where
    W: AsRef<str> + Serialize, 

Specify the working dir (corresponds to the -w docker cli argument)

pub fn volumes<V, S>(&mut self, volumes: V) -> &mut Self where
    V: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

Specify any bind mounts, taking the form of /some/host/path:/some/container/path

pub fn links<L, S>(&mut self, links: L) -> &mut Self where
    L: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn memory(&mut self, memory: u64) -> &mut Self

pub fn memory_swap(&mut self, memory_swap: i64) -> &mut Self

Total memory limit (memory + swap) in bytes. Set to -1 (default) to enable unlimited swap.

pub fn nano_cpus(&mut self, nano_cpus: u64) -> &mut Self

CPU quota in units of 10^-9 CPUs. Set to 0 (default) for there to be no limit.

For example, setting nano_cpus to 500_000_000 results in the container being allocated 50% of a single CPU, while 2_000_000_000 results in the container being allocated 2 CPUs.

pub fn cpus(&mut self, cpus: f64) -> &mut Self

CPU quota in units of CPUs. This is a wrapper around nano_cpus to do the unit conversion.

See nano_cpus.

pub fn cpu_shares(&mut self, cpu_shares: u32) -> &mut Self

Sets an integer value representing the container’s relative CPU weight versus other containers.

pub fn labels<L, K, V>(&mut self, labels: L) -> &mut Self where
    L: IntoIterator<Item = (K, V)>,
    K: AsRef<str> + Serialize + Eq + Hash,
    V: AsRef<str> + Serialize, 

pub fn attach_stdin(&mut self, attach: bool) -> &mut Self

Whether to attach to stdin.

pub fn attach_stdout(&mut self, attach_stdout: bool) -> &mut Self

Whether to attach to stdout.

pub fn attach_stderr(&mut self, attach_stderr: bool) -> &mut Self

Whether to attach to stderr.

pub fn tty(&mut self, tty: bool) -> &mut Self

Whether standard streams should be attached to a TTY.

pub fn extra_hosts<H, S>(&mut self, extra_hosts: H) -> &mut Self where
    H: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn volumes_from<V, S>(&mut self, volumes_from: V) -> &mut Self where
    V: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn network_mode<M>(&mut self, network_mode: M) -> &mut Self where
    M: AsRef<str> + Serialize, 

pub fn env<E, S>(&mut self, env: E) -> &mut Self where
    E: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn cmd<C, S>(&mut self, cmd: C) -> &mut Self where
    C: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn entrypoint<E, S>(&mut self, entrypoint: E) -> &mut Self where
    E: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn capabilities<C, S>(&mut self, capabilities: C) -> &mut Self where
    C: IntoIterator<Item = S>,
    S: AsRef<str> + Serialize, 

pub fn devices(&mut self, devices: Vec<Labels>) -> &mut Self

pub fn log_driver<L>(&mut self, log_driver: L) -> &mut Self where
    L: AsRef<str> + Serialize, 

pub fn restart_policy(
    &mut self,
    name: &str,
    maximum_retry_count: u64
) -> &mut Self

pub fn auto_remove(&mut self, auto_remove: bool) -> &mut Self

pub fn stop_signal<S>(&mut self, stop_signal: S) -> &mut Self where
    S: AsRef<str> + Serialize, 

Signal to stop a container as a string. Default is "SIGTERM"

pub fn stop_signal_num(&mut self, stop_signal_num: u64) -> &mut Self

Signal to stop a container as an integer. Default is 15 (SIGTERM).

pub fn stop_timeout(&mut self, stop_timeout: Duration) -> &mut Self

Timeout to stop a container. Only seconds are counted. Default is 10s

pub fn userns_mode<M>(&mut self, userns_mode: M) -> &mut Self where
    M: AsRef<str> + Serialize, 

pub fn privileged(&mut self, privileged: bool) -> &mut Self

pub fn user<U>(&mut self, user: U) -> &mut Self where
    U: AsRef<str> + Serialize, 

pub fn build(&self) -> ContainerCreateOpts

Trait Implementations

impl Default for ContainerOptsBuilder

fn default() -> ContainerOptsBuilder

Returns the “default value” for a type.