rice-sdk 0.1.2

Rust sdk for interacting with Rice
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use rice_core::config::RiceConfig;
use rice_core::error::RiceError;
use rice_state::client::StateClient;
use rice_storage::client::StorageClient;

pub struct Client {
    pub storage: Option<StorageClient>,
    pub state: Option<StateClient>,
}

impl Client {
    pub async fn new(config: RiceConfig) -> Result<Self, RiceError> {
        let storage = if let Some(storage_config) = config.storage {
            if storage_config.enabled {
                let url = storage_config
                    .base_url
                    .unwrap_or_else(|| "http://localhost:50051".to_string());
                let token = storage_config.auth_token;

                // Heuristic: If URL contains "grpc", treat as gRPC. Otherwise HTTP.
                // Or if it matches typical REST ports?
                // For now, let's assume if it doesn't say "grpc", it might be HTTP if it fails?
                // Better: Explicitly check scheme or keyword.
                // The provided URLs: `grpc...` vs `api...`.

                if url.contains("grpc") {
                    if let Some(t) = token {
                        Some(StorageClient::connect_with_token(url, t).await?)
                    } else {
                        Some(StorageClient::connect(url).await?)
                    }
                } else {
                    // Assume HTTP
                    let valid_url = if url.starts_with("http://") || url.starts_with("https://") {
                        url
                    } else {
                        format!("http://{}", url)
                    };
                    let mut client = StorageClient::connect_http_url(valid_url, token.clone())?;

                    // Auto-login mirroring Node SDK behavior:
                    // If username is present and auth_token (used as password) is present, attempt login.
                    if let Some(user) = &storage_config.username {
                        if let Some(pwd) = &token {
                            // We ignore errors here to allow partial functionality if auth fails/is not needed for some ops
                            let _ = client.login(user.clone(), pwd.clone()).await;
                        }
                    }
                    Some(client)
                }
            } else {
                None
            }
        } else {
            None
        };

        let state = if let Some(state_config) = config.state {
            if state_config.enabled {
                let url = state_config
                    .base_url
                    .unwrap_or_else(|| "http://localhost:50051".to_string());
                if let Some(token) = state_config.auth_token {
                    Some(StateClient::connect_with_token(url, token).await?)
                } else {
                    Some(StateClient::connect(url).await?)
                }
            } else {
                None
            }
        } else {
            None
        };

        Ok(Self { storage, state })
    }
}