1#[derive(Clone, Copy, PartialEq, ::prost::Message)]
3pub struct SyncExtractorCatalogRequest {}
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct SyncExtractorCatalogResponse {
6 #[prost(int32, tag = "1")]
7 pub changed_rows: i32,
8 #[prost(int32, tag = "2")]
9 pub removed_rows: i32,
10 #[prost(string, repeated, tag = "3")]
11 pub moved_catalog_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
12}
13#[derive(Clone, PartialEq, ::prost::Message)]
14pub struct ListNativeExtractorInstallationsRequest {
15 #[prost(string, repeated, tag = "1")]
16 pub catalog_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
17 #[prost(int32, tag = "2")]
18 pub page_size: i32,
19 #[prost(string, tag = "3")]
20 pub page_token: ::prost::alloc::string::String,
21}
22#[derive(Clone, PartialEq, ::prost::Message)]
23pub struct ListNativeExtractorInstallationsResponse {
24 #[prost(message, repeated, tag = "1")]
25 pub installations: ::prost::alloc::vec::Vec<super::ContainerizedExtractor>,
26 #[prost(string, tag = "2")]
27 pub next_page_token: ::prost::alloc::string::String,
28}
29#[derive(Clone, PartialEq, ::prost::Message)]
30pub struct UpgradeNativeExtractorInstallationRequest {
31 #[prost(string, tag = "1")]
32 pub workspace_rid: ::prost::alloc::string::String,
33 #[prost(string, tag = "2")]
34 pub catalog_id: ::prost::alloc::string::String,
35}
36#[derive(Clone, Copy, PartialEq, ::prost::Message)]
37pub struct UpgradeNativeExtractorInstallationResponse {
38 #[prost(bool, tag = "1")]
39 pub upgraded: bool,
40}
41pub mod internal_extractor_catalog_service_client {
43 #![allow(
44 unused_variables,
45 dead_code,
46 missing_docs,
47 clippy::wildcard_imports,
48 clippy::let_unit_value,
49 )]
50 use tonic::codegen::*;
51 use tonic::codegen::http::Uri;
52 #[derive(Debug, Clone)]
53 pub struct InternalExtractorCatalogServiceClient<T> {
54 inner: tonic::client::Grpc<T>,
55 }
56 impl InternalExtractorCatalogServiceClient<tonic::transport::Channel> {
57 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
59 where
60 D: TryInto<tonic::transport::Endpoint>,
61 D::Error: Into<StdError>,
62 {
63 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
64 Ok(Self::new(conn))
65 }
66 }
67 impl<T> InternalExtractorCatalogServiceClient<T>
68 where
69 T: tonic::client::GrpcService<tonic::body::Body>,
70 T::Error: Into<StdError>,
71 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
72 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
73 {
74 pub fn new(inner: T) -> Self {
75 let inner = tonic::client::Grpc::new(inner);
76 Self { inner }
77 }
78 pub fn with_origin(inner: T, origin: Uri) -> Self {
79 let inner = tonic::client::Grpc::with_origin(inner, origin);
80 Self { inner }
81 }
82 pub fn with_interceptor<F>(
83 inner: T,
84 interceptor: F,
85 ) -> InternalExtractorCatalogServiceClient<InterceptedService<T, F>>
86 where
87 F: tonic::service::Interceptor,
88 T::ResponseBody: Default,
89 T: tonic::codegen::Service<
90 http::Request<tonic::body::Body>,
91 Response = http::Response<
92 <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
93 >,
94 >,
95 <T as tonic::codegen::Service<
96 http::Request<tonic::body::Body>,
97 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
98 {
99 InternalExtractorCatalogServiceClient::new(
100 InterceptedService::new(inner, interceptor),
101 )
102 }
103 #[must_use]
108 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
109 self.inner = self.inner.send_compressed(encoding);
110 self
111 }
112 #[must_use]
114 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
115 self.inner = self.inner.accept_compressed(encoding);
116 self
117 }
118 #[must_use]
122 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
123 self.inner = self.inner.max_decoding_message_size(limit);
124 self
125 }
126 #[must_use]
130 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
131 self.inner = self.inner.max_encoding_message_size(limit);
132 self
133 }
134 pub async fn sync_extractor_catalog(
135 &mut self,
136 request: impl tonic::IntoRequest<super::SyncExtractorCatalogRequest>,
137 ) -> std::result::Result<
138 tonic::Response<super::SyncExtractorCatalogResponse>,
139 tonic::Status,
140 > {
141 self.inner
142 .ready()
143 .await
144 .map_err(|e| {
145 tonic::Status::unknown(
146 format!("Service was not ready: {}", e.into()),
147 )
148 })?;
149 let codec = tonic::codec::ProstCodec::default();
150 let path = http::uri::PathAndQuery::from_static(
151 "/nominal.ingest.v2.internal.InternalExtractorCatalogService/SyncExtractorCatalog",
152 );
153 let mut req = request.into_request();
154 req.extensions_mut()
155 .insert(
156 GrpcMethod::new(
157 "nominal.ingest.v2.internal.InternalExtractorCatalogService",
158 "SyncExtractorCatalog",
159 ),
160 );
161 self.inner.unary(req, path, codec).await
162 }
163 pub async fn list_native_extractor_installations(
164 &mut self,
165 request: impl tonic::IntoRequest<
166 super::ListNativeExtractorInstallationsRequest,
167 >,
168 ) -> std::result::Result<
169 tonic::Response<super::ListNativeExtractorInstallationsResponse>,
170 tonic::Status,
171 > {
172 self.inner
173 .ready()
174 .await
175 .map_err(|e| {
176 tonic::Status::unknown(
177 format!("Service was not ready: {}", e.into()),
178 )
179 })?;
180 let codec = tonic::codec::ProstCodec::default();
181 let path = http::uri::PathAndQuery::from_static(
182 "/nominal.ingest.v2.internal.InternalExtractorCatalogService/ListNativeExtractorInstallations",
183 );
184 let mut req = request.into_request();
185 req.extensions_mut()
186 .insert(
187 GrpcMethod::new(
188 "nominal.ingest.v2.internal.InternalExtractorCatalogService",
189 "ListNativeExtractorInstallations",
190 ),
191 );
192 self.inner.unary(req, path, codec).await
193 }
194 pub async fn upgrade_native_extractor_installation(
195 &mut self,
196 request: impl tonic::IntoRequest<
197 super::UpgradeNativeExtractorInstallationRequest,
198 >,
199 ) -> std::result::Result<
200 tonic::Response<super::UpgradeNativeExtractorInstallationResponse>,
201 tonic::Status,
202 > {
203 self.inner
204 .ready()
205 .await
206 .map_err(|e| {
207 tonic::Status::unknown(
208 format!("Service was not ready: {}", e.into()),
209 )
210 })?;
211 let codec = tonic::codec::ProstCodec::default();
212 let path = http::uri::PathAndQuery::from_static(
213 "/nominal.ingest.v2.internal.InternalExtractorCatalogService/UpgradeNativeExtractorInstallation",
214 );
215 let mut req = request.into_request();
216 req.extensions_mut()
217 .insert(
218 GrpcMethod::new(
219 "nominal.ingest.v2.internal.InternalExtractorCatalogService",
220 "UpgradeNativeExtractorInstallation",
221 ),
222 );
223 self.inner.unary(req, path, codec).await
224 }
225 }
226}
227#[derive(Clone, PartialEq, ::prost::Message)]
228pub struct IngestInternalRequest {
229 #[prost(message, optional, tag = "1")]
230 pub ingest_request: ::core::option::Option<super::IngestRequest>,
231 #[prost(message, optional, tag = "2")]
232 pub overrides: ::core::option::Option<InternalIngestOverrides>,
233 #[prost(message, optional, tag = "4")]
234 pub triggerer: ::core::option::Option<IngestTriggerer>,
235 #[prost(string, optional, tag = "5")]
236 pub idempotency_key: ::core::option::Option<::prost::alloc::string::String>,
237}
238#[derive(Clone, PartialEq, ::prost::Message)]
239pub struct IngestTriggerer {
240 #[prost(oneof = "ingest_triggerer::Triggerer", tags = "1")]
241 pub triggerer: ::core::option::Option<ingest_triggerer::Triggerer>,
242}
243pub mod ingest_triggerer {
245 #[derive(Clone, PartialEq, ::prost::Oneof)]
246 pub enum Triggerer {
247 #[prost(message, tag = "1")]
248 IngestRule(super::IngestRuleTriggerer),
249 }
250}
251#[derive(Clone, PartialEq, ::prost::Message)]
252pub struct IngestRuleTriggerer {
253 #[prost(string, tag = "1")]
254 pub ingest_rule_rid: ::prost::alloc::string::String,
255}
256#[derive(Clone, PartialEq, ::prost::Message)]
257pub struct InternalIngestOverrides {
258 #[prost(string, optional, tag = "1")]
259 pub containerized_image_tag: ::core::option::Option<::prost::alloc::string::String>,
260 #[deprecated]
261 #[prost(int32, repeated, packed = "false", tag = "3")]
262 pub mcap_channel_ids: ::prost::alloc::vec::Vec<i32>,
263}
264#[derive(Clone, PartialEq, ::prost::Message)]
265pub struct IngestInternalResponse {
266 #[prost(message, optional, tag = "1")]
267 pub ingest_response: ::core::option::Option<super::IngestResponse>,
268 #[prost(string, optional, tag = "2")]
269 pub dataset_file_id: ::core::option::Option<::prost::alloc::string::String>,
270}
271pub mod internal_ingest_service_client {
273 #![allow(
274 unused_variables,
275 dead_code,
276 missing_docs,
277 clippy::wildcard_imports,
278 clippy::let_unit_value,
279 )]
280 use tonic::codegen::*;
281 use tonic::codegen::http::Uri;
282 #[derive(Debug, Clone)]
283 pub struct InternalIngestServiceClient<T> {
284 inner: tonic::client::Grpc<T>,
285 }
286 impl InternalIngestServiceClient<tonic::transport::Channel> {
287 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
289 where
290 D: TryInto<tonic::transport::Endpoint>,
291 D::Error: Into<StdError>,
292 {
293 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
294 Ok(Self::new(conn))
295 }
296 }
297 impl<T> InternalIngestServiceClient<T>
298 where
299 T: tonic::client::GrpcService<tonic::body::Body>,
300 T::Error: Into<StdError>,
301 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
302 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
303 {
304 pub fn new(inner: T) -> Self {
305 let inner = tonic::client::Grpc::new(inner);
306 Self { inner }
307 }
308 pub fn with_origin(inner: T, origin: Uri) -> Self {
309 let inner = tonic::client::Grpc::with_origin(inner, origin);
310 Self { inner }
311 }
312 pub fn with_interceptor<F>(
313 inner: T,
314 interceptor: F,
315 ) -> InternalIngestServiceClient<InterceptedService<T, F>>
316 where
317 F: tonic::service::Interceptor,
318 T::ResponseBody: Default,
319 T: tonic::codegen::Service<
320 http::Request<tonic::body::Body>,
321 Response = http::Response<
322 <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
323 >,
324 >,
325 <T as tonic::codegen::Service<
326 http::Request<tonic::body::Body>,
327 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
328 {
329 InternalIngestServiceClient::new(InterceptedService::new(inner, interceptor))
330 }
331 #[must_use]
336 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
337 self.inner = self.inner.send_compressed(encoding);
338 self
339 }
340 #[must_use]
342 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
343 self.inner = self.inner.accept_compressed(encoding);
344 self
345 }
346 #[must_use]
350 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
351 self.inner = self.inner.max_decoding_message_size(limit);
352 self
353 }
354 #[must_use]
358 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
359 self.inner = self.inner.max_encoding_message_size(limit);
360 self
361 }
362 pub async fn ingest_internal(
363 &mut self,
364 request: impl tonic::IntoRequest<super::IngestInternalRequest>,
365 ) -> std::result::Result<
366 tonic::Response<super::IngestInternalResponse>,
367 tonic::Status,
368 > {
369 self.inner
370 .ready()
371 .await
372 .map_err(|e| {
373 tonic::Status::unknown(
374 format!("Service was not ready: {}", e.into()),
375 )
376 })?;
377 let codec = tonic::codec::ProstCodec::default();
378 let path = http::uri::PathAndQuery::from_static(
379 "/nominal.ingest.v2.internal.InternalIngestService/IngestInternal",
380 );
381 let mut req = request.into_request();
382 req.extensions_mut()
383 .insert(
384 GrpcMethod::new(
385 "nominal.ingest.v2.internal.InternalIngestService",
386 "IngestInternal",
387 ),
388 );
389 self.inner.unary(req, path, codec).await
390 }
391 }
392}