Struct ClientConfig

Source

pub struct ClientConfig { /* private fields */ }

Expand description

Client configuration.

Implementations§

Source §

impl ClientConfig

Source

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

Initialize a default client configuration with the specified authentication token.

Examples found in repository ?

examples/delete_stream.rs (line 9)

7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    let token = std::env::var("S2_ACCESS_TOKEN")?;
9    let config = ClientConfig::new(token);
10    let basin: BasinName = "my-favorite-basin".parse()?;
11    let basin_client = BasinClient::new(config, basin);
12
13    let stream = "my-favorite-stream";
14
15    let delete_stream_request = DeleteStreamRequest::new(stream);
16
17    basin_client.delete_stream(delete_stream_request).await?;
18
19    Ok(())
20}

More examples

Hide additional examples

examples/delete_basin.rs (line 9)

7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    let token = std::env::var("S2_ACCESS_TOKEN")?;
9    let config = ClientConfig::new(token);
10    let client = Client::new(config);
11
12    let basin: BasinName = "my-favorite-basin".parse()?;
13
14    let delete_basin_request = DeleteBasinRequest::new(basin)
15        // Don't error if the basin doesn't exist.
16        .with_if_exists(true);
17
18    client.delete_basin(delete_basin_request).await?;
19
20    Ok(())
21}

examples/list_streams.rs (line 9)

7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    let token = std::env::var("S2_ACCESS_TOKEN")?;
9    let config = ClientConfig::new(token);
10    let basin: BasinName = "my-favorite-basin".parse()?;
11    let basin_client = BasinClient::new(config, basin);
12
13    let prefix = "my-";
14    let list_streams_request = ListStreamsRequest::new().with_prefix(prefix);
15
16    let list_streams_response = basin_client.list_streams(list_streams_request).await?;
17
18    println!("{list_streams_response:#?}");
19
20    Ok(())
21}

examples/get_latest_record.rs (line 9)

7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    let token = std::env::var("S2_ACCESS_TOKEN")?;
9    let config = ClientConfig::new(token);
10    let basin: BasinName = "my-favorite-basin".parse()?;
11    let stream = "my-favorite-stream";
12    let stream_client = StreamClient::new(config, basin, stream);
13
14    let read_limit = ReadLimit::new().with_count(1);
15    let read_request = ReadRequest::new(ReadStart::TailOffset(1)).with_limit(read_limit);
16    let latest_record = stream_client.read(read_request).await?;
17
18    println!("{latest_record:#?}");
19
20    Ok(())
21}

examples/create_stream.rs (line 9)

7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    let token = std::env::var("S2_ACCESS_TOKEN")?;
9    let config = ClientConfig::new(token);
10    let client = Client::new(config);
11
12    let basin: BasinName = "my-favorite-basin".parse()?;
13    let basin_client = client.basin_client(basin);
14
15    let stream = "my-favorite-stream";
16
17    let stream_config = StreamConfig::new().with_storage_class(StorageClass::Express);
18
19    let create_stream_request = CreateStreamRequest::new(stream).with_config(stream_config);
20
21    let created_stream = basin_client.create_stream(create_stream_request).await?;
22    println!("{created_stream:#?}");
23
24    let stream_config = basin_client.get_stream_config(stream).await?;
25    println!("{stream_config:#?}");
26
27    Ok(())
28}

examples/consumer.rs (line 11)

9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10    let token = std::env::var("S2_ACCESS_TOKEN")?;
11    let config = ClientConfig::new(token);
12    let basin: BasinName = "my-favorite-basin".parse()?;
13    let stream = "my-favorite-stream";
14    let stream_client = StreamClient::new(config, basin, stream);
15
16    let start_seq_num = 0;
17    let read_session_request = ReadSessionRequest::new(ReadStart::SeqNum(start_seq_num));
18    let mut read_stream = stream_client.read_session(read_session_request).await?;
19
20    loop {
21        select! {
22            next_batch = read_stream.next() => {
23                let Some(next_batch) = next_batch else { break };
24                let next_batch = next_batch?;
25                println!("{next_batch:?}");
26            }
27            _ = tokio::signal::ctrl_c() => break,
28        }
29    }
30
31    Ok(())
32}