Skip to main content

nominal_api/conjure/endpoints/timeseries/seriescache/
series_cache_service.rs

1use conjure_http::endpoint;
2/// The Series Cache service manages internal chunks of data cached by Nominal's backend.
3#[conjure_http::conjure_endpoints(
4    name = "SeriesCacheService",
5    use_legacy_error_serialization
6)]
7pub trait SeriesCacheService {
8    /// Fetches "chunks" of series that are stored as Arrow files in S3.
9    /// This endpoint is being deprecated for new series in favor of batchGetCachedSeries
10    #[endpoint(
11        method = POST,
12        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/get-chunks",
13        name = "getChunks",
14        produces = conjure_http::server::StdResponseSerializer
15    )]
16    fn get_chunks(
17        &self,
18        #[auth]
19        auth_: conjure_object::BearerToken,
20        #[path(
21            name = "logicalSeriesRid",
22            decoder = conjure_http::server::conjure::FromPlainDecoder,
23            log_as = "logicalSeriesRid",
24            safe
25        )]
26        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
27        #[body(
28            deserializer = conjure_http::server::StdRequestDeserializer,
29            log_as = "getChunksParameters"
30        )]
31        get_chunks_parameters: super::super::super::super::objects::timeseries::seriescache::api::GetChunksParameters,
32    ) -> Result<
33        super::super::super::super::objects::timeseries::seriescache::api::GetChunksResponse,
34        conjure_http::private::Error,
35    >;
36    #[endpoint(
37        method = POST,
38        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/create-chunks",
39        name = "createChunks",
40        produces = conjure_http::server::StdResponseSerializer
41    )]
42    fn create_chunks(
43        &self,
44        #[auth]
45        auth_: conjure_object::BearerToken,
46        #[path(
47            name = "logicalSeriesRid",
48            decoder = conjure_http::server::conjure::FromPlainDecoder,
49            log_as = "logicalSeriesRid",
50            safe
51        )]
52        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
53        #[body(
54            deserializer = conjure_http::server::StdRequestDeserializer,
55            log_as = "createChunksParameters"
56        )]
57        create_chunks_parameters: super::super::super::super::objects::timeseries::seriescache::api::CreateChunksParameters,
58    ) -> Result<
59        super::super::super::super::objects::timeseries::seriescache::api::CreateChunksResponse,
60        conjure_http::private::Error,
61    >;
62    #[endpoint(
63        method = POST,
64        path = "/timeseries/series-cache/v1/batch-create-chunks",
65        name = "batchCreateChunks",
66        produces = conjure_http::server::StdResponseSerializer
67    )]
68    fn batch_create_chunks(
69        &self,
70        #[auth]
71        auth_: conjure_object::BearerToken,
72        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
73        request: super::super::super::super::objects::timeseries::seriescache::api::CreateChunksParameters,
74    ) -> Result<
75        super::super::super::super::objects::timeseries::seriescache::api::CreateChunksResponse,
76        conjure_http::private::Error,
77    >;
78    /// Deletes the chunks that intersect the given time range. Does not delete the corresponding files from S3.
79    #[endpoint(
80        method = POST,
81        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/delete-chunks",
82        name = "deleteChunks",
83        produces = conjure_http::server::StdResponseSerializer
84    )]
85    fn delete_chunks(
86        &self,
87        #[auth]
88        auth_: conjure_object::BearerToken,
89        #[path(
90            name = "logicalSeriesRid",
91            decoder = conjure_http::server::conjure::FromPlainDecoder,
92            log_as = "logicalSeriesRid",
93            safe
94        )]
95        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
96        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
97        request: super::super::super::super::objects::timeseries::seriescache::api::DeleteChunksParameters,
98    ) -> Result<
99        super::super::super::super::objects::timeseries::seriescache::api::DeleteChunksResponse,
100        conjure_http::private::Error,
101    >;
102}
103/// The Series Cache service manages internal chunks of data cached by Nominal's backend.
104#[conjure_http::conjure_endpoints(
105    name = "SeriesCacheService",
106    use_legacy_error_serialization
107)]
108pub trait AsyncSeriesCacheService {
109    /// Fetches "chunks" of series that are stored as Arrow files in S3.
110    /// This endpoint is being deprecated for new series in favor of batchGetCachedSeries
111    #[endpoint(
112        method = POST,
113        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/get-chunks",
114        name = "getChunks",
115        produces = conjure_http::server::StdResponseSerializer
116    )]
117    async fn get_chunks(
118        &self,
119        #[auth]
120        auth_: conjure_object::BearerToken,
121        #[path(
122            name = "logicalSeriesRid",
123            decoder = conjure_http::server::conjure::FromPlainDecoder,
124            log_as = "logicalSeriesRid",
125            safe
126        )]
127        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
128        #[body(
129            deserializer = conjure_http::server::StdRequestDeserializer,
130            log_as = "getChunksParameters"
131        )]
132        get_chunks_parameters: super::super::super::super::objects::timeseries::seriescache::api::GetChunksParameters,
133    ) -> Result<
134        super::super::super::super::objects::timeseries::seriescache::api::GetChunksResponse,
135        conjure_http::private::Error,
136    >;
137    #[endpoint(
138        method = POST,
139        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/create-chunks",
140        name = "createChunks",
141        produces = conjure_http::server::StdResponseSerializer
142    )]
143    async fn create_chunks(
144        &self,
145        #[auth]
146        auth_: conjure_object::BearerToken,
147        #[path(
148            name = "logicalSeriesRid",
149            decoder = conjure_http::server::conjure::FromPlainDecoder,
150            log_as = "logicalSeriesRid",
151            safe
152        )]
153        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
154        #[body(
155            deserializer = conjure_http::server::StdRequestDeserializer,
156            log_as = "createChunksParameters"
157        )]
158        create_chunks_parameters: super::super::super::super::objects::timeseries::seriescache::api::CreateChunksParameters,
159    ) -> Result<
160        super::super::super::super::objects::timeseries::seriescache::api::CreateChunksResponse,
161        conjure_http::private::Error,
162    >;
163    #[endpoint(
164        method = POST,
165        path = "/timeseries/series-cache/v1/batch-create-chunks",
166        name = "batchCreateChunks",
167        produces = conjure_http::server::StdResponseSerializer
168    )]
169    async fn batch_create_chunks(
170        &self,
171        #[auth]
172        auth_: conjure_object::BearerToken,
173        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
174        request: super::super::super::super::objects::timeseries::seriescache::api::CreateChunksParameters,
175    ) -> Result<
176        super::super::super::super::objects::timeseries::seriescache::api::CreateChunksResponse,
177        conjure_http::private::Error,
178    >;
179    /// Deletes the chunks that intersect the given time range. Does not delete the corresponding files from S3.
180    #[endpoint(
181        method = POST,
182        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/delete-chunks",
183        name = "deleteChunks",
184        produces = conjure_http::server::StdResponseSerializer
185    )]
186    async fn delete_chunks(
187        &self,
188        #[auth]
189        auth_: conjure_object::BearerToken,
190        #[path(
191            name = "logicalSeriesRid",
192            decoder = conjure_http::server::conjure::FromPlainDecoder,
193            log_as = "logicalSeriesRid",
194            safe
195        )]
196        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
197        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
198        request: super::super::super::super::objects::timeseries::seriescache::api::DeleteChunksParameters,
199    ) -> Result<
200        super::super::super::super::objects::timeseries::seriescache::api::DeleteChunksResponse,
201        conjure_http::private::Error,
202    >;
203}
204/// The Series Cache service manages internal chunks of data cached by Nominal's backend.
205#[conjure_http::conjure_endpoints(
206    name = "SeriesCacheService",
207    use_legacy_error_serialization,
208    local
209)]
210pub trait LocalAsyncSeriesCacheService {
211    /// Fetches "chunks" of series that are stored as Arrow files in S3.
212    /// This endpoint is being deprecated for new series in favor of batchGetCachedSeries
213    #[endpoint(
214        method = POST,
215        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/get-chunks",
216        name = "getChunks",
217        produces = conjure_http::server::StdResponseSerializer
218    )]
219    async fn get_chunks(
220        &self,
221        #[auth]
222        auth_: conjure_object::BearerToken,
223        #[path(
224            name = "logicalSeriesRid",
225            decoder = conjure_http::server::conjure::FromPlainDecoder,
226            log_as = "logicalSeriesRid",
227            safe
228        )]
229        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
230        #[body(
231            deserializer = conjure_http::server::StdRequestDeserializer,
232            log_as = "getChunksParameters"
233        )]
234        get_chunks_parameters: super::super::super::super::objects::timeseries::seriescache::api::GetChunksParameters,
235    ) -> Result<
236        super::super::super::super::objects::timeseries::seriescache::api::GetChunksResponse,
237        conjure_http::private::Error,
238    >;
239    #[endpoint(
240        method = POST,
241        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/create-chunks",
242        name = "createChunks",
243        produces = conjure_http::server::StdResponseSerializer
244    )]
245    async fn create_chunks(
246        &self,
247        #[auth]
248        auth_: conjure_object::BearerToken,
249        #[path(
250            name = "logicalSeriesRid",
251            decoder = conjure_http::server::conjure::FromPlainDecoder,
252            log_as = "logicalSeriesRid",
253            safe
254        )]
255        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
256        #[body(
257            deserializer = conjure_http::server::StdRequestDeserializer,
258            log_as = "createChunksParameters"
259        )]
260        create_chunks_parameters: super::super::super::super::objects::timeseries::seriescache::api::CreateChunksParameters,
261    ) -> Result<
262        super::super::super::super::objects::timeseries::seriescache::api::CreateChunksResponse,
263        conjure_http::private::Error,
264    >;
265    #[endpoint(
266        method = POST,
267        path = "/timeseries/series-cache/v1/batch-create-chunks",
268        name = "batchCreateChunks",
269        produces = conjure_http::server::StdResponseSerializer
270    )]
271    async fn batch_create_chunks(
272        &self,
273        #[auth]
274        auth_: conjure_object::BearerToken,
275        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
276        request: super::super::super::super::objects::timeseries::seriescache::api::CreateChunksParameters,
277    ) -> Result<
278        super::super::super::super::objects::timeseries::seriescache::api::CreateChunksResponse,
279        conjure_http::private::Error,
280    >;
281    /// Deletes the chunks that intersect the given time range. Does not delete the corresponding files from S3.
282    #[endpoint(
283        method = POST,
284        path = "/timeseries/series-cache/v1/logical-series/{logicalSeriesRid}/delete-chunks",
285        name = "deleteChunks",
286        produces = conjure_http::server::StdResponseSerializer
287    )]
288    async fn delete_chunks(
289        &self,
290        #[auth]
291        auth_: conjure_object::BearerToken,
292        #[path(
293            name = "logicalSeriesRid",
294            decoder = conjure_http::server::conjure::FromPlainDecoder,
295            log_as = "logicalSeriesRid",
296            safe
297        )]
298        logical_series_rid: super::super::super::super::objects::api::LogicalSeriesRid,
299        #[body(deserializer = conjure_http::server::StdRequestDeserializer, safe)]
300        request: super::super::super::super::objects::timeseries::seriescache::api::DeleteChunksParameters,
301    ) -> Result<
302        super::super::super::super::objects::timeseries::seriescache::api::DeleteChunksResponse,
303        conjure_http::private::Error,
304    >;
305}