ydb 0.10.3

Crate contains generated low-level grpc code from YDB API protobuf, used as base for ydb crate
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::client::TimeoutSettings;
use crate::grpc_connection_manager::GrpcConnectionManager;
use crate::grpc_wrapper::raw_coordination_service::alter_node::RawAlterNodeRequest;
use crate::grpc_wrapper::raw_coordination_service::config::RawCoordinationNodeConfig;
use crate::grpc_wrapper::raw_coordination_service::create_node::RawCreateNodeRequest;
use crate::grpc_wrapper::raw_coordination_service::describe_node::RawDescribeNodeRequest;
use crate::grpc_wrapper::raw_coordination_service::drop_node::RawDropNodeRequest;
use crate::{grpc_wrapper, CoordinationSession, SessionOptions, YdbResult};

use super::list_types::{NodeConfig, NodeDescription};

#[derive(Clone)]
pub struct CoordinationClient {
    timeouts: TimeoutSettings,

    session_seq_no: u64,

    connection_manager: GrpcConnectionManager,
}

impl CoordinationClient {
    pub(crate) fn new(
        timeouts: TimeoutSettings,
        connection_manager: GrpcConnectionManager,
    ) -> Self {
        Self {
            timeouts,
            session_seq_no: 0,
            connection_manager,
        }
    }

    pub async fn create_session(
        &mut self,
        path: String,
        options: SessionOptions,
    ) -> YdbResult<CoordinationSession> {
        let seq_no = self.session_seq_no;
        self.session_seq_no += 1;

        CoordinationSession::new(path, seq_no, options, self.connection_manager.clone()).await
    }

    pub async fn create_node(&mut self, path: String, config: NodeConfig) -> YdbResult<()> {
        let req = RawCreateNodeRequest {
            config: RawCoordinationNodeConfig::from(config),
            operation_params: self.timeouts.operation_params(),
            path,
        };

        let mut service = self.raw_client_connection().await?;
        service.create_node(req).await?;

        Ok(())
    }

    pub async fn alter_node(&mut self, path: String, config: NodeConfig) -> YdbResult<()> {
        let req = RawAlterNodeRequest {
            config: RawCoordinationNodeConfig::from(config),
            operation_params: self.timeouts.operation_params(),
            path,
        };

        let mut service = self.raw_client_connection().await?;
        service.alter_node(req).await?;

        Ok(())
    }

    pub async fn describe_node(&mut self, path: String) -> YdbResult<NodeDescription> {
        let req = RawDescribeNodeRequest {
            operation_params: self.timeouts.operation_params(),
            path,
        };

        let mut service = self.raw_client_connection().await?;
        let result = service.describe_node(req).await?;
        let description = NodeDescription::from(result);

        Ok(description)
    }

    pub async fn drop_node(&mut self, path: String) -> YdbResult<()> {
        let req = RawDropNodeRequest {
            operation_params: self.timeouts.operation_params(),
            path,
        };

        let mut service = self.raw_client_connection().await?;
        service.drop_node(req).await?;

        Ok(())
    }

    pub(crate) async fn raw_client_connection(
        &self,
    ) -> YdbResult<grpc_wrapper::raw_coordination_service::client::RawCoordinationClient> {
        self.connection_manager
            .get_auth_service(
                grpc_wrapper::raw_coordination_service::client::RawCoordinationClient::new,
            )
            .await
    }
}