Struct ToxiproxyTemplate 

pub struct ToxiproxyTemplate { /* private fields */ }

Toxiproxy template for TCP fault injection.

Runs the ghcr.io/shopify/toxiproxy container and exposes a typed client over its :8474 control API. Register proxies with create_proxy and add toxics with add_toxic.

Proxies should listen on 0.0.0.0:<port> and that port must be published (via proxy_port) so host clients can connect through the proxy.

Implementations

impl ToxiproxyTemplate

pub fn new(name: impl Into<String>) -> Self

Create a new Toxiproxy template.

The control API is published on port 8474 by default. Use proxy_port to also publish the ports your proxies listen on so host clients can reach them.

pub fn control_port(self, port: u16) -> Self

Set the host port for the control API (default: 8474).

This maps the host port to the container’s 8474 control port.

pub fn proxy_port(self, port: u16) -> Self

Publish a proxy port so host clients can connect through a proxy.

A proxy that listens on 0.0.0.0:<port> inside the container is only reachable from the host if that port is published. Call this once per port you intend to proxy on. The same port is used on both the host and container sides so the published address matches the proxy’s listen address.

Example

use docker_wrapper::template::toxiproxy::ToxiproxyTemplate;

let toxiproxy = ToxiproxyTemplate::new("chaos")
    .proxy_port(16379)
    .proxy_port(15432);

pub fn network(self, network: impl Into<String>) -> Self

Connect to a specific Docker network.

Use this to place Toxiproxy on the same network as the upstream containers it proxies, so it can reach them by container name.

pub fn auto_remove(self) -> Self

Enable auto-remove when the container stops.

pub fn custom_image( self, image: impl Into<String>, tag: impl Into<String>, ) -> Self

Use a custom image and tag.

pub fn platform(self, platform: impl Into<String>) -> Self

Set the platform for the container (e.g., “linux/arm64”, “linux/amd64”).

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

Set how long to wait for the control API to become ready (default: 30s).

pub async fn wait_for_control_api(&self) -> Result<()>

Wait for the Toxiproxy control API to start responding.

Polls GET /version on the control port until it returns success or the configured timeout elapses. Call this after start (or start_and_wait) before registering proxies.

Errors

Returns an error if the control API does not respond within the timeout.

pub async fn create_proxy( &self, name: impl Into<String>, listen: impl Into<String>, upstream: impl Into<String>, ) -> Result<ProxyInfo>

Register a new proxy.

• name identifies the proxy in subsequent calls.
• listen is the address the proxy listens on inside the container. Use 0.0.0.0:<port> with a published proxy_port so host clients can connect through it.
• upstream is the address the proxy forwards to (e.g. redis:6379 when on a shared network).

Errors

Returns an error if the control API request fails or returns a non-success status (for example, if a proxy with the same name already exists).

pub async fn add_toxic( &self, proxy: &str, name: impl Into<String>, stream: ToxicStream, toxic: Toxic, ) -> Result<()>

Add a toxic to an existing proxy.

• proxy is the proxy name passed to create_proxy.
• name identifies the toxic for later removal.
• stream selects the direction the toxic applies to.
• toxic is the typed fault to inject.

The toxic is applied with full toxicity (1.0), so it affects every connection.

Errors

Returns an error if the control API request fails or returns a non-success status.

pub async fn remove_toxic(&self, proxy: &str, toxic: &str) -> Result<()>

Remove a toxic from a proxy.

Errors

Returns an error if the control API request fails or returns a non-success status.

pub async fn list_proxies(&self) -> Result<Vec<ProxyInfo>>

List all registered proxies.

Errors

Returns an error if the control API request fails or the response cannot be parsed.

pub async fn reset(&self) -> Result<()>

Reset all proxies and remove all toxics.

This re-enables every proxy and clears all toxics, returning Toxiproxy to a clean state without restarting the container.

Errors

Returns an error if the control API request fails or returns a non-success status.

Trait Implementations

impl Template for ToxiproxyTemplate

fn name(&self) -> &str

Get the template name

fn config(&self) -> &TemplateConfig

Get the template configuration

fn config_mut(&mut self) -> &mut TemplateConfig

Get a mutable reference to the configuration

fn build_command(&self) -> RunCommand

Build the RunCommand for this template

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Start the container with this template

fn start_and_wait<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Start the container and wait for it to be ready

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stop the container

fn remove<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Remove the container

fn is_running<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Check if the container is running

fn logs<'life0, 'life1, 'async_trait>( &'life0 self, follow: bool, tail: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<CommandOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get container logs

fn exec<'life0, 'life1, 'async_trait>( &'life0 self, command: Vec<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<ExecOutput>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a command in the running container

fn wait_for_ready<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Wait for the container to be ready