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
// This file is @generated by prost-build.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MarkBatchesCompletedRequest {
#[prost(string, tag = "1")]
pub ingest_job_rid: ::prost::alloc::string::String,
#[prost(string, tag = "2")]
pub dataset_file_id: ::prost::alloc::string::String,
#[prost(int32, repeated, tag = "3")]
pub batch_ids: ::prost::alloc::vec::Vec<i32>,
/// True when the batches belong to a primary (production) ingest run: the
/// cascade updates dataset_files.ingest_status and rolls up to
/// ingest_jobs.job_status. False (the default on the wire) selects the
/// refinery shadow path — the cascade writes dataset_files.shadow_ingest_status
/// and stops at the file level so business state is untouched. Defaulting to
/// shadow keeps unset callers on the safe path during the rollout.
#[prost(bool, tag = "4")]
pub is_primary: bool,
}
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct MarkBatchesCompletedResponse {}
/// Generated client implementations.
pub mod internal_ingest_batch_service_client {
#![allow(
unused_variables,
dead_code,
missing_docs,
clippy::wildcard_imports,
clippy::let_unit_value,
)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
/// Internal service for inter-service RPCs. Uses a separate package so that
/// the gRPC path (nominal.ingest.v1.internal.*) is excluded from public ingress.
#[derive(Debug, Clone)]
pub struct InternalIngestBatchServiceClient<T> {
inner: tonic::client::Grpc<T>,
}
impl InternalIngestBatchServiceClient<tonic::transport::Channel> {
/// Attempt to create a new client by connecting to a given endpoint.
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: TryInto<tonic::transport::Endpoint>,
D::Error: Into<StdError>,
{
let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
Ok(Self::new(conn))
}
}
impl<T> InternalIngestBatchServiceClient<T>
where
T: tonic::client::GrpcService<tonic::body::Body>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_origin(inner: T, origin: Uri) -> Self {
let inner = tonic::client::Grpc::with_origin(inner, origin);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> InternalIngestBatchServiceClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::Body>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::Body>,
>>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
{
InternalIngestBatchServiceClient::new(
InterceptedService::new(inner, interceptor),
)
}
/// Compress requests with the given encoding.
///
/// This requires the server to support it otherwise it might respond with an
/// error.
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
/// Enable decompressing responses.
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
/// Limits the maximum size of a decoded message.
///
/// Default: `4MB`
#[must_use]
pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_decoding_message_size(limit);
self
}
/// Limits the maximum size of an encoded message.
///
/// Default: `usize::MAX`
#[must_use]
pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
self.inner = self.inner.max_encoding_message_size(limit);
self
}
/// Mark the supplied batches for {@code dataset_file_id} as COMPLETED. Within the same
/// transaction, if all batches for the file are now complete, mark the file's ingest
/// status as COMPLETED; if all files for {@code ingest_job_rid} are then in a terminal
/// ingest status (COMPLETED or FAILED), mark the ingest job COMPLETED. Internal-only
/// (service-token auth).
///
/// Idempotent: re-issuing the same request after success is a no-op. Already-COMPLETED
/// batches/files/jobs are left in place and the cascade short-circuits at each step.
pub async fn mark_batches_completed(
&mut self,
request: impl tonic::IntoRequest<super::MarkBatchesCompletedRequest>,
) -> std::result::Result<
tonic::Response<super::MarkBatchesCompletedResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::unknown(
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/nominal.ingest.v1.internal.InternalIngestBatchService/MarkBatchesCompleted",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new(
"nominal.ingest.v1.internal.InternalIngestBatchService",
"MarkBatchesCompleted",
),
);
self.inner.unary(req, path, codec).await
}
}
}