Struct Client 

pub struct Client<D = Docker> { /* private fields */ }

The main entry point for interacting with local Atlas deployments.

Client provides a high-level interface for managing MongoDB Atlas local deployments through Docker. It serves as the primary abstraction layer between your application and the underlying Docker containers running Atlas services.

Examples

See the module-level documentation for a complete example of creating a new client instance.

Implementations

impl<D: DockerPullImage + DockerCreateContainer + DockerStartContainer + DockerInspectContainer + Send + Sync + 'static> Client<D>

pub fn create_deployment( &self, deployment_options: CreateDeploymentOptions, ) -> CreateDeploymentProgress

Creates a local Atlas deployment.

impl<D: DockerStopContainer + DockerRemoveContainer + DockerInspectContainer> Client<D>

pub async fn delete_deployment( &self, name: &str, ) -> Result<(), DeleteDeploymentError>

Deletes a local Atlas deployment.

impl<D: DockerInspectContainer + RunCommandInContainer> Client<D>

pub async fn get_connection_string( &self, container_id_or_name: String, ) -> Result<String, GetConnectionStringError>

impl<D: DockerInspectContainer> Client<D>

pub async fn get_deployment( &self, container_id_or_name: &str, ) -> Result<Deployment, GetDeploymentError>

Inspects a container.

Arguments

• container_id_or_name - The ID or name of the container to inspect.

impl<D: DockerInspectContainer + RunCommandInContainer> Client<D>

pub async fn get_deployment_id( &self, cluster_id_or_name: &str, ) -> Result<String, GetDeploymentIdError>

Gets the Atlas deployment ID for a local Atlas deployment.

impl<D: DockerLogContainer> Client<D>

pub async fn get_logs( &self, container_id_or_name: &str, options: Option<LogsOptions>, ) -> Result<Vec<LogOutput>, GetLogsError>

Gets the logs from a container.

Arguments

• container_id_or_name - The ID or name of the container to get logs from.
• options - Optional logging options (e.g., tail, timestamps, etc.)

Returns

A Result containing a vector of log entries from the container, or an error if the logs could not be retrieved.

Examples

See the complete working example:

cargo run --example get_logs

Example code:

use anyhow::{Context, Result};
use atlas_local::{
    Client,
    models::{CreateDeploymentOptions, LogsOptions, Tail},
};
use bollard::Docker;

#[tokio::main]
async fn main() -> Result<()> {
    let docker = Docker::connect_with_defaults().context("connecting to docker")?;
    let client = Client::new(docker.clone());

    let deployment_options = CreateDeploymentOptions::default();
    let deployment = client
        .create_deployment(deployment_options)
        .await
        .context("creating deployment")?;

    // Configure log options
    let log_options = LogsOptions::builder()
        .stdout(true) // Include stdout
        .stderr(true) // Include stderr
        .tail(Tail::Number(100)) // Get last 100 lines
        .timestamps(true) // Include timestamps
        .build();

    // Get logs from the deployment
    let logs = client
        .get_logs(&deployment.container_id, Some(log_options))
        .await
        .context("getting logs")?;

    println!("Container logs:");
    for log in logs {
        // Use print! instead of println! because logs contain new line characters
        print!("{}", log);
    }

    Ok(())
}

impl<D: DockerListContainers + DockerInspectContainer> Client<D>

pub async fn list_deployments( &self, ) -> Result<Vec<Deployment>, GetDeploymentError>

Lists all local Atlas deployments.

impl<D: DockerPauseContainer + DockerInspectContainer> Client<D>

pub async fn pause_deployment( &self, name: &str, ) -> Result<(), PauseDeploymentError>

Pauses a local Atlas deployment.

impl<D: DockerPullImage> Client<D>

pub async fn pull_image( &self, image: &str, tag: &str, ) -> Result<(), PullImageError>

Pulls the Atlas Local image.

Arguments

• image - The image to pull.
• tag - The tag to pull.

impl<D: DockerStartContainer + DockerInspectContainer> Client<D>

pub async fn start_deployment( &self, name: &str, ) -> Result<(), StartDeploymentError>

Starts a local Atlas deployment.

impl<D: DockerStopContainer + DockerInspectContainer> Client<D>

pub async fn stop_deployment( &self, name: &str, ) -> Result<(), StopDeploymentError>

Stops a local Atlas deployment.

impl<D: DockerUnpauseContainer + DockerInspectContainer> Client<D>

pub async fn unpause_deployment( &self, name: &str, ) -> Result<(), UnpauseDeploymentError>

Unpauses a local Atlas deployment.

impl<D: DockerInspectContainer> Client<D>

pub async fn wait_for_healthy_deployment( &self, deployment_name: &str, options: WatchOptions, ) -> Result<(), WatchDeploymentError>

Waits for a deployment to become healthy.

This method polls the container’s health status until it becomes healthy, or until the timeout specified in the options is reached.

Arguments

• cluster_name - The name or ID of the container to watch
• options - Configuration options including timeout duration

Returns

Returns Ok(()) when the container becomes healthy, or an error if:

• The container inspection fails
• The container becomes unhealthy
• The timeout is reached

Examples

use atlas_local::models::WatchOptions;
use std::time::Duration;

let options = WatchOptions::builder()
    .timeout_duration(Duration::from_secs(300))
    .build();

client.wait_for_healthy_deployment("my-deployment", options).await?;

impl<D> Client<D>

pub fn new(docker: D) -> Client<D>

Creates a new Atlas Local client with the default MongoDB adapter.

Arguments

• docker - A connected Docker client instance from the bollard crate

Returns

A new Client instance ready to manage Atlas Local deployments.

Examples

See the module-level documentation for usage examples.

Trait Implementations

impl<D> Clone for Client<D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.