Struct S2Config 

#[non_exhaustive]
pub struct S2Config { /* private fields */ }

Configuration for S2.

Implementations

impl S2Config

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

Create a new S2Config with the given access token and default settings.

Examples found in repository

examples/docs_overview.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // ANCHOR: create-client
    use s2_sdk::{S2, types::S2Config};

    let client = S2::new(S2Config::new(std::env::var("S2_ACCESS_TOKEN")?))?;

    let basin = client.basin("my-basin".parse()?);
    let stream = basin.stream("my-stream".parse()?);
    // ANCHOR_END: create-client

    println!("Created client for stream: {:?}", stream);
    Ok(())
}

examples/list_all_basins.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let access_token =
        std::env::var("S2_ACCESS_TOKEN").map_err(|_| "S2_ACCESS_TOKEN env var not set")?;

    let config = S2Config::new(access_token);
    let s2 = S2::new(config)?;

    let input = ListAllBasinsInput::new();

    let basins: Vec<_> = s2.list_all_basins(input).take(10).try_collect().await?;

    println!("{basins:#?}");

    Ok(())
}

examples/delete_basin.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let access_token =
        std::env::var("S2_ACCESS_TOKEN").map_err(|_| "S2_ACCESS_TOKEN env var not set")?;
    let basin_name: BasinName = std::env::var("S2_BASIN")
        .map_err(|_| "S2_BASIN env var not set")?
        .parse()?;

    let config = S2Config::new(access_token);
    let s2 = S2::new(config)?;

    let input = DeleteBasinInput::new(basin_name).with_ignore_not_found(true);
    s2.delete_basin(input).await?;
    println!("Deletion requested");

    Ok(())
}

examples/list_streams.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let access_token =
        std::env::var("S2_ACCESS_TOKEN").map_err(|_| "S2_ACCESS_TOKEN env var not set")?;
    let basin_name: BasinName = std::env::var("S2_BASIN")
        .map_err(|_| "S2_BASIN env var not set")?
        .parse()?;

    let s2 = S2::new(S2Config::new(access_token))?;
    let basin = s2.basin(basin_name);

    let input = ListStreamsInput::new().with_prefix("my-".parse()?);
    let page = basin.list_streams(input).await?;
    println!("{page:#?}");

    Ok(())
}

examples/delete_stream.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let access_token =
        std::env::var("S2_ACCESS_TOKEN").map_err(|_| "S2_ACCESS_TOKEN env var not set")?;
    let basin_name: BasinName = std::env::var("S2_BASIN")
        .map_err(|_| "S2_BASIN env var not set")?
        .parse()?;
    let stream_name: StreamName = std::env::var("S2_STREAM")
        .map_err(|_| "S2_STREAM env var not set")?
        .parse()?;

    let s2 = S2::new(S2Config::new(access_token))?;
    let basin = s2.basin(basin_name);

    let input = DeleteStreamInput::new(stream_name);
    basin.delete_stream(input).await?;
    println!("Deletion requested");

    Ok(())
}

examples/consumer.rs (line 14)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let access_token = std::env::var("S2_ACCESS_TOKEN")?;
    let basin_name: BasinName = std::env::var("S2_BASIN")?.parse()?;
    let stream_name: StreamName = std::env::var("S2_STREAM")?.parse()?;

    let s2 = S2::new(S2Config::new(access_token))?;
    let stream = s2.basin(basin_name).stream(stream_name);

    let input = ReadInput::new();
    let mut batches = stream.read_session(input).await?;
    loop {
        select! {
            batch = batches.next() => {
                let Some(batch) = batch else { break };
                let batch = batch?;
                println!("{batch:?}");
            }
            _ = tokio::signal::ctrl_c() => break,
        }
    }

    Ok(())
}

Additional examples can be found in:

• examples/reconfigure_stream.rs
• examples/create_basin.rs
• examples/get_latest_record.rs
• examples/reconfigure_basin.rs
• examples/explicit_trim.rs
• examples/issue_access_token.rs
• examples/create_stream.rs
• examples/producer.rs
• examples/docs_metrics.rs
• examples/docs_configuration.rs
• examples/docs_account_and_basins.rs
• examples/docs_streams.rs

pub fn with_endpoints(self, endpoints: S2Endpoints) -> Self

Set the S2 endpoints to connect to.

Examples found in repository

examples/docs_configuration.rs (lines 17-20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example: Custom endpoints (e.g., for s2-lite local dev)
    {
        // ANCHOR: custom-endpoints
        let client = S2::new(
            S2Config::new("local-token").with_endpoints(S2Endpoints::new(
                AccountEndpoint::new("http://localhost:8080")?,
                BasinEndpoint::new("http://localhost:8080")?,
            )?),
        )?;
        // ANCHOR_END: custom-endpoints
        println!("Created client with custom endpoints: {:?}", client);
    }

    // Example: Custom retry configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: retry-config
        let client = S2::new(
            S2Config::new(access_token).with_retry(
                RetryConfig::new()
                    .with_max_attempts(NonZeroU32::new(5).unwrap())
                    .with_min_base_delay(Duration::from_millis(100))
                    .with_max_base_delay(Duration::from_secs(2)),
            ),
        )?;
        // ANCHOR_END: retry-config
        println!("Created client with retry config: {:?}", client);
    }

    // Example: Custom timeout configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: timeout-config
        let client = S2::new(
            S2Config::new(access_token)
                .with_connection_timeout(Duration::from_secs(5))
                .with_request_timeout(Duration::from_secs(10)),
        )?;
        // ANCHOR_END: timeout-config
        println!("Created client with timeout config: {:?}", client);
    }

    Ok(())
}

pub fn with_connection_timeout(self, connection_timeout: Duration) -> Self

Set the timeout for establishing a connection to the server.

Defaults to 3s.

Examples found in repository

examples/docs_configuration.rs (line 48)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example: Custom endpoints (e.g., for s2-lite local dev)
    {
        // ANCHOR: custom-endpoints
        let client = S2::new(
            S2Config::new("local-token").with_endpoints(S2Endpoints::new(
                AccountEndpoint::new("http://localhost:8080")?,
                BasinEndpoint::new("http://localhost:8080")?,
            )?),
        )?;
        // ANCHOR_END: custom-endpoints
        println!("Created client with custom endpoints: {:?}", client);
    }

    // Example: Custom retry configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: retry-config
        let client = S2::new(
            S2Config::new(access_token).with_retry(
                RetryConfig::new()
                    .with_max_attempts(NonZeroU32::new(5).unwrap())
                    .with_min_base_delay(Duration::from_millis(100))
                    .with_max_base_delay(Duration::from_secs(2)),
            ),
        )?;
        // ANCHOR_END: retry-config
        println!("Created client with retry config: {:?}", client);
    }

    // Example: Custom timeout configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: timeout-config
        let client = S2::new(
            S2Config::new(access_token)
                .with_connection_timeout(Duration::from_secs(5))
                .with_request_timeout(Duration::from_secs(10)),
        )?;
        // ANCHOR_END: timeout-config
        println!("Created client with timeout config: {:?}", client);
    }

    Ok(())
}

pub fn with_request_timeout(self, request_timeout: Duration) -> Self

Set the timeout for requests.

Defaults to 5s.

Examples found in repository

examples/docs_configuration.rs (line 49)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example: Custom endpoints (e.g., for s2-lite local dev)
    {
        // ANCHOR: custom-endpoints
        let client = S2::new(
            S2Config::new("local-token").with_endpoints(S2Endpoints::new(
                AccountEndpoint::new("http://localhost:8080")?,
                BasinEndpoint::new("http://localhost:8080")?,
            )?),
        )?;
        // ANCHOR_END: custom-endpoints
        println!("Created client with custom endpoints: {:?}", client);
    }

    // Example: Custom retry configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: retry-config
        let client = S2::new(
            S2Config::new(access_token).with_retry(
                RetryConfig::new()
                    .with_max_attempts(NonZeroU32::new(5).unwrap())
                    .with_min_base_delay(Duration::from_millis(100))
                    .with_max_base_delay(Duration::from_secs(2)),
            ),
        )?;
        // ANCHOR_END: retry-config
        println!("Created client with retry config: {:?}", client);
    }

    // Example: Custom timeout configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: timeout-config
        let client = S2::new(
            S2Config::new(access_token)
                .with_connection_timeout(Duration::from_secs(5))
                .with_request_timeout(Duration::from_secs(10)),
        )?;
        // ANCHOR_END: timeout-config
        println!("Created client with timeout config: {:?}", client);
    }

    Ok(())
}

pub fn with_retry(self, retry: RetryConfig) -> Self

Set the retry configuration for requests.

See RetryConfig for defaults.

Examples found in repository

examples/docs_configuration.rs (lines 31-36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Example: Custom endpoints (e.g., for s2-lite local dev)
    {
        // ANCHOR: custom-endpoints
        let client = S2::new(
            S2Config::new("local-token").with_endpoints(S2Endpoints::new(
                AccountEndpoint::new("http://localhost:8080")?,
                BasinEndpoint::new("http://localhost:8080")?,
            )?),
        )?;
        // ANCHOR_END: custom-endpoints
        println!("Created client with custom endpoints: {:?}", client);
    }

    // Example: Custom retry configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: retry-config
        let client = S2::new(
            S2Config::new(access_token).with_retry(
                RetryConfig::new()
                    .with_max_attempts(NonZeroU32::new(5).unwrap())
                    .with_min_base_delay(Duration::from_millis(100))
                    .with_max_base_delay(Duration::from_secs(2)),
            ),
        )?;
        // ANCHOR_END: retry-config
        println!("Created client with retry config: {:?}", client);
    }

    // Example: Custom timeout configuration
    {
        let access_token = std::env::var("S2_ACCESS_TOKEN").unwrap_or_else(|_| "demo".into());
        // ANCHOR: timeout-config
        let client = S2::new(
            S2Config::new(access_token)
                .with_connection_timeout(Duration::from_secs(5))
                .with_request_timeout(Duration::from_secs(10)),
        )?;
        // ANCHOR_END: timeout-config
        println!("Created client with timeout config: {:?}", client);
    }

    Ok(())
}

pub fn with_compression(self, compression: Compression) -> Self

Set the compression algorithm for requests and responses.

Defaults to no compression.

pub fn with_insecure_skip_cert_verification(self, skip: bool) -> Self

Skip TLS certificate verification (insecure).

This is useful for connecting to endpoints with self-signed certificates or certificates that don’t match the hostname (similar to curl -k).

Warning

This disables certificate verification and should only be used for testing or development purposes. Never use this in production.

Defaults to false.

pub fn with_rustls_crypto_provider( self, provider: impl Into<Arc<CryptoProvider>>, ) -> Self

Use a specific rustls crypto provider for SDK TLS connections.

With default features enabled, the SDK uses the aws-lc-rs provider. With default features disabled, the SDK uses rustls’s process-global provider if one has been installed, or returns an error otherwise.

Use this when your application needs a specific rustls provider, such as ring or a custom rustls::crypto::CryptoProvider. The corresponding rustls provider feature must be enabled in the dependency graph.

pub fn with_rustls_aws_lc_rs_crypto_provider(self) -> Self

Use rustls’s aws-lc-rs crypto provider.

Requires the rustls-aws-lc-rs crate feature.

pub fn with_rustls_ring_crypto_provider(self) -> Self

Use rustls’s ring crypto provider.

Requires the rustls-ring crate feature.

Trait Implementations

impl Clone for S2Config

fn clone(&self) -> S2Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for S2Config

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

Formats the value using the given formatter.