Struct S2Endpoints 

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

Endpoints for the S2 environment.

Implementations

impl S2Endpoints

pub fn new( account_endpoint: AccountEndpoint, basin_endpoint: BasinEndpoint, ) -> Result<Self, ValidationError>

Create a new S2Endpoints with the given account and basin endpoints.

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 for_endpoint(endpoint: &str) -> Result<Self, ValidationError>

Create endpoints for a single account and basin endpoint.

This is useful for S2-compatible services that expose both APIs at one endpoint.

pub fn from_env() -> Result<Self, ValidationError>

Create a new S2Endpoints from environment variables.

The following environment variables are expected to be set:

• S2_ACCOUNT_ENDPOINT - Account-level endpoint.
• S2_BASIN_ENDPOINT - Basin-level endpoint.

Examples found in repository

examples/caught_up.rs (line 28)

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 mut config = S2Config::new(access_token);
    if std::env::var_os("S2_ACCOUNT_ENDPOINT").is_some()
        || std::env::var_os("S2_BASIN_ENDPOINT").is_some()
    {
        config = config.with_endpoints(S2Endpoints::from_env()?);
    }

    let suffix = &uuid::Uuid::new_v4().simple().to_string()[..8];
    let basin_name: BasinName = format!("caught-up-{suffix}").parse()?;
    let stream_name: StreamName = "example".parse()?;
    let s2 = S2::new(config)?;
    let basin = s2.basin(basin_name.clone());

    s2.create_basin(CreateBasinInput::new(basin_name.clone()))
        .await?;
    basin
        .create_stream(CreateStreamInput::new(stream_name.clone()))
        .await?;
    let stream = basin.stream(stream_name.clone());

    stream
        .append(AppendInput::new(AppendRecordBatch::try_from_iter([
            AppendRecord::new("first")?,
            AppendRecord::new("second")?,
        ])?))
        .await?;

    let mut session = stream
        .read_session(
            ReadInput::new().with_start(ReadStart::new().with_from(ReadFrom::TailOffset(2))),
            ReadSessionConfig::default(),
        )
        .await?;
    let mut caught_up = session.caught_up();

    loop {
        tokio::select! {
            tail = &mut caught_up => {
                println!("Caught up through sequence number {}", tail?.seq_num);
                break;
            }
            Some(batch) = session.next() => {
                print_batch("Read before catching up", &batch?);
            }
        }
    }

    let ack = stream
        .append(AppendInput::new(AppendRecordBatch::try_from_iter([
            AppendRecord::new("third")?,
        ])?))
        .await?;
    println!(
        "Appended another record at sequence number {}",
        ack.start.seq_num
    );

    while let Some(batch) = session.next().await {
        let batch = batch?;
        print_batch("Read after catching up", &batch);
        if batch
            .records
            .iter()
            .any(|record| record.seq_num == ack.start.seq_num)
        {
            break;
        }
    }
    println!("Session is caught up again: {}", session.is_caught_up());

    drop(session);
    basin
        .delete_stream(DeleteStreamInput::new(stream_name))
        .await?;
    s2.delete_basin(DeleteBasinInput::new(basin_name)).await?;

    Ok(())
}

pub fn for_cloud() -> Self

Return the default S2 Cloud endpoints.

Trait Implementations

impl Clone for S2Endpoints

fn clone(&self) -> S2Endpoints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for S2Endpoints

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

Formats the value using the given formatter.