laser-wire 0.8.1

LaserData SDK over Apache Iggy: typed streaming, operational and lakehouse query, materialization destinations, key-value state, copy-on-write forks, and an optional agent runtime with the Agent Data Exchange Protocol (AGDX).
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

// One trait pairing each managed command code with its request and reply wire
// types. Not a multi-implementor abstraction (there is one wire contract and one established
// band): a compile-time assertion that the code/type pairings match, giving
// the SDK one generic send path and LaserData Cloud's dispatch table a fixture test
// against the same pairings.

use crate::authz::{
    AuthzReply, BindRolesReq, DefineRoleReq, DeleteRoleReq, GetBindingsReq, GetRoleReq,
    ListRolesReq, WhoamiReq,
};
use crate::browse::{
    BrowseReply, DecodeRecord, GetProjection, GetSchema, ListProjections, ListSchemas,
    RegisterSchema,
};
use crate::checkpoint::{
    CheckpointReadReply, CheckpointReply, CheckpointRequestEnvelope, DestinationGetRequest,
    DestinationListRequest, QueryRouteListRequest,
};
use crate::codes::*;
use crate::fork::{ForkCreate, ForkDelete, ForkList, ForkPromote, ForkPut, ForkReply};
use crate::http::{DestinationHttpReply, DestinationHttpRequest};
use crate::kv::{KvDelete, KvDeleteMany, KvGet, KvNamespaces, KvReply, KvScan, KvSet};
use crate::query::{
    QueryCancelEnvelope, QueryCancelReply, QueryEnvelope, QueryPageEnvelope, QueryReply,
    QueryStatusEnvelope, QueryStatusReply,
};
use crate::session::{SessionReply, request as session};

/// A managed command: the request type, its wire code, and the reply type the
/// other end answers with.
pub trait Command {
    /// The managed command code this request rides.
    const CODE: u32;
    /// The reply wire type.
    type Reply;
}

macro_rules! command {
    ($request:ty, $code:expr, $reply:ty) => {
        impl Command for $request {
            const CODE: u32 = $code;
            type Reply = $reply;
        }
    };
}

command!(WhoamiReq, AGDX_AUTHZ_WHOAMI_CODE, AuthzReply);
command!(ListRolesReq, AGDX_AUTHZ_LIST_ROLES_CODE, AuthzReply);
command!(GetRoleReq, AGDX_AUTHZ_GET_ROLE_CODE, AuthzReply);
command!(GetBindingsReq, AGDX_AUTHZ_GET_BINDINGS_CODE, AuthzReply);
command!(DefineRoleReq, AGDX_AUTHZ_DEFINE_ROLE_CODE, AuthzReply);
command!(DeleteRoleReq, AGDX_AUTHZ_DELETE_ROLE_CODE, AuthzReply);
command!(BindRolesReq, AGDX_AUTHZ_BIND_ROLES_CODE, AuthzReply);
command!(QueryEnvelope, AGDX_QUERY_CODE, QueryReply);
command!(QueryPageEnvelope, AGDX_QUERY_PAGE_CODE, QueryReply);
command!(
    QueryCancelEnvelope,
    AGDX_QUERY_CANCEL_CODE,
    QueryCancelReply
);
command!(
    QueryStatusEnvelope,
    AGDX_QUERY_STATUS_CODE,
    QueryStatusReply
);
command!(
    CheckpointRequestEnvelope,
    AGDX_CHECKPOINT_CODE,
    CheckpointReply
);
command!(
    DestinationGetRequest,
    AGDX_DESTINATION_GET_CODE,
    CheckpointReadReply
);
command!(
    DestinationListRequest,
    AGDX_DESTINATION_LIST_CODE,
    CheckpointReadReply
);
command!(
    QueryRouteListRequest,
    AGDX_QUERY_ROUTE_LIST_CODE,
    CheckpointReadReply
);
command!(
    DestinationHttpRequest,
    AGDX_DESTINATION_HTTP_CODE,
    DestinationHttpReply
);
command!(GetProjection, AGDX_GET_PROJECTION_CODE, BrowseReply);
command!(ListProjections, AGDX_LIST_PROJECTIONS_CODE, BrowseReply);
command!(GetSchema, AGDX_GET_SCHEMA_CODE, BrowseReply);
command!(ListSchemas, AGDX_LIST_SCHEMAS_CODE, BrowseReply);
command!(RegisterSchema, AGDX_REGISTER_SCHEMA_CODE, BrowseReply);
command!(DecodeRecord, AGDX_DECODE_RECORD_CODE, BrowseReply);
command!(KvGet, AGDX_KV_GET_CODE, KvReply);
command!(KvSet, AGDX_KV_SET_CODE, KvReply);
command!(KvScan, AGDX_KV_SCAN_CODE, KvReply);
command!(KvDelete, AGDX_KV_DELETE_CODE, KvReply);
command!(KvDeleteMany, AGDX_KV_DELETE_MANY_CODE, KvReply);
command!(KvNamespaces, AGDX_KV_NAMESPACES_CODE, KvReply);
command!(ForkCreate, AGDX_FORK_CREATE_CODE, ForkReply);
command!(ForkDelete, AGDX_FORK_DELETE_CODE, ForkReply);
command!(ForkPromote, AGDX_FORK_PROMOTE_CODE, ForkReply);
command!(ForkList, AGDX_FORK_LIST_CODE, ForkReply);
command!(ForkPut, AGDX_FORK_PUT_CODE, ForkReply);
command!(session::SessionGet, AGDX_SESSION_GET_CODE, SessionReply);
command!(session::SessionList, AGDX_SESSION_LIST_CODE, SessionReply);
command!(
    session::SessionEvents,
    AGDX_SESSION_EVENTS_CODE,
    SessionReply
);
command!(session::SessionState, AGDX_SESSION_STATE_CODE, SessionReply);
command!(session::SessionLinks, AGDX_SESSION_LINKS_CODE, SessionReply);
command!(
    session::SessionSources,
    AGDX_SESSION_SOURCES_CODE,
    SessionReply
);
command!(
    session::SessionChanges,
    AGDX_SESSION_CHANGES_CODE,
    SessionReply
);

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn given_command_impls_when_compared_then_codes_should_match_the_dictionary() {
        assert_eq!(<WhoamiReq as Command>::CODE, 1_000_100);
        assert_eq!(<ListRolesReq as Command>::CODE, 1_000_101);
        assert_eq!(<GetRoleReq as Command>::CODE, 1_000_102);
        assert_eq!(<GetBindingsReq as Command>::CODE, 1_000_103);
        assert_eq!(<DefineRoleReq as Command>::CODE, 1_000_104);
        assert_eq!(<DeleteRoleReq as Command>::CODE, 1_000_105);
        assert_eq!(<BindRolesReq as Command>::CODE, 1_000_106);
        assert_eq!(<QueryEnvelope as Command>::CODE, 1_000_200);
        assert_eq!(<QueryPageEnvelope as Command>::CODE, 1_000_201);
        assert_eq!(<QueryCancelEnvelope as Command>::CODE, 1_000_202);
        assert_eq!(<QueryStatusEnvelope as Command>::CODE, 1_000_203);
        assert_eq!(<CheckpointRequestEnvelope as Command>::CODE, 1_000_021);
        assert_eq!(<DestinationGetRequest as Command>::CODE, 1_000_022);
        assert_eq!(<DestinationListRequest as Command>::CODE, 1_000_023);
        assert_eq!(<QueryRouteListRequest as Command>::CODE, 1_000_024);
        assert_eq!(<DestinationHttpRequest as Command>::CODE, 1_000_025);
        assert_eq!(<GetProjection as Command>::CODE, 1_000_210);
        assert_eq!(<ListProjections as Command>::CODE, 1_000_211);
        assert_eq!(<GetSchema as Command>::CODE, 1_000_220);
        assert_eq!(<ListSchemas as Command>::CODE, 1_000_221);
        assert_eq!(<RegisterSchema as Command>::CODE, 1_000_222);
        assert_eq!(<DecodeRecord as Command>::CODE, 1_000_223);
        assert_eq!(<KvGet as Command>::CODE, 1_000_300);
        assert_eq!(<KvSet as Command>::CODE, 1_000_301);
        assert_eq!(<KvScan as Command>::CODE, 1_000_302);
        assert_eq!(<KvDelete as Command>::CODE, 1_000_303);
        assert_eq!(<KvDeleteMany as Command>::CODE, 1_000_304);
        assert_eq!(<KvNamespaces as Command>::CODE, 1_000_305);
        assert_eq!(<ForkCreate as Command>::CODE, 1_000_400);
        assert_eq!(<ForkDelete as Command>::CODE, 1_000_401);
        assert_eq!(<ForkPromote as Command>::CODE, 1_000_402);
        assert_eq!(<ForkList as Command>::CODE, 1_000_403);
        assert_eq!(<ForkPut as Command>::CODE, 1_000_404);
        assert_eq!(<session::SessionGet as Command>::CODE, 1_000_710);
        assert_eq!(<session::SessionList as Command>::CODE, 1_000_711);
        assert_eq!(<session::SessionEvents as Command>::CODE, 1_000_712);
        assert_eq!(<session::SessionState as Command>::CODE, 1_000_713);
        assert_eq!(<session::SessionLinks as Command>::CODE, 1_000_714);
        assert_eq!(<session::SessionSources as Command>::CODE, 1_000_715);
        assert_eq!(<session::SessionChanges as Command>::CODE, 1_000_716);
    }
}