Struct EggShell 

pub struct EggShell { /* private fields */ }

EggShell is basically a container for containers. When provided a docker client, it funnels all container create operations through it, allowing it to track what needs to be cleaned up. At drop() time (or when teardown() is called), these containers are cleaned up.

Implementations

impl EggShell

pub async fn new(docker: Arc<Mutex<Docker>>) -> Result<Self, Error>

Construct a new EggShell. When dropped or when teardown() is called, all containers launched through it will be reaped.

Examples found in repository

examples/basic.rs (line 9)

async fn main() -> Result<(), eggshell::Error> {
    let docker = Arc::new(tokio::sync::Mutex::new(
        bollard::Docker::connect_with_unix_defaults().unwrap(),
    ));

    let mut gs = eggshell::EggShell::new(docker.clone()).await?;

    let count = docker
        .lock()
        .await
        .list_containers::<String>(None)
        .await
        .unwrap()
        .len();

    println!(
        "before: {} containers -- starting 10 postgres containers",
        count
    );

    for num in 0..10 {
        gs.launch(
            &format!("test-{}", num),
            bollard::container::Config {
                image: Some("postgres:latest".to_string()),
                env: Some(vec!["POSTGRES_HOST_AUTH_METHOD=trust".to_string()]),
                ..Default::default()
            },
            None,
        )
        .await?;
    }

    let newcount = docker
        .lock()
        .await
        .list_containers::<String>(None)
        .await
        .unwrap()
        .len();

    println!(
        "before: {} containers, after: {} containers -- now dropping",
        count, newcount
    );

    drop(gs);

    let newcount = docker
        .lock()
        .await
        .list_containers::<String>(None)
        .await
        .unwrap()
        .len();

    println!(
        "after dropping: orig: {} containers, after: {} containers",
        count, newcount
    );

    Ok(())
}

pub fn set_debug(&mut self, debug: bool)

set_debug turns off the teardown functionality for this EggShell, allowing you to debug its behavior. This disables the teardown() call which drop() relies on, so you must be ready to clean up your own containers before enabling this.

pub async fn launch( &mut self, name: &str, container: Config<String>, start_options: Option<StartContainerOptions<String>>, ) -> Result<(), Error>

launch is the meat of EggShell and is how most of the work gets done. When provided with a name and container options, it will create and start that container, adding it to a registry of containers it is tracking. When drop() happens on the EggShell this container will be removed.

Examples found in repository

examples/basic.rs (lines 25-33)

async fn main() -> Result<(), eggshell::Error> {
    let docker = Arc::new(tokio::sync::Mutex::new(
        bollard::Docker::connect_with_unix_defaults().unwrap(),
    ));

    let mut gs = eggshell::EggShell::new(docker.clone()).await?;

    let count = docker
        .lock()
        .await
        .list_containers::<String>(None)
        .await
        .unwrap()
        .len();

    println!(
        "before: {} containers -- starting 10 postgres containers",
        count
    );

    for num in 0..10 {
        gs.launch(
            &format!("test-{}", num),
            bollard::container::Config {
                image: Some("postgres:latest".to_string()),
                env: Some(vec!["POSTGRES_HOST_AUTH_METHOD=trust".to_string()]),
                ..Default::default()
            },
            None,
        )
        .await?;
    }

    let newcount = docker
        .lock()
        .await
        .list_containers::<String>(None)
        .await
        .unwrap()
        .len();

    println!(
        "before: {} containers, after: {} containers -- now dropping",
        count, newcount
    );

    drop(gs);

    let newcount = docker
        .lock()
        .await
        .list_containers::<String>(None)
        .await
        .unwrap()
        .len();

    println!(
        "after dropping: orig: {} containers, after: {} containers",
        count, newcount
    );

    Ok(())
}

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

teardown is what reaps the launch()’d containers. It is called as a part of drop() as well.

Trait Implementations

impl Clone for EggShell

fn clone(&self) -> EggShell

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EggShell

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

Formats the value using the given formatter.

impl Drop for EggShell

fn drop(&mut self)

Reaps all containers registered with launch().