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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
/// The request message for the PublishChannelConnectionEvents method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishChannelConnectionEventsRequest {
/// The channel_connection that the events are published from. For example:
/// `projects/{partner_project_id}/locations/{location}/channelConnections/{channel_connection_id}`.
#[prost(string, tag = "1")]
pub channel_connection: ::prost::alloc::string::String,
/// The CloudEvents v1.0 events to publish. No other types are allowed.
/// If this field is set, then the `text_events` fields must not be set.
#[prost(message, repeated, tag = "2")]
pub events: ::prost::alloc::vec::Vec<::prost_types::Any>,
/// The text representation of events to publish.
/// CloudEvent v1.0 in JSON format is the only allowed type. Refer to
/// <https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/formats/json-format.md>
/// for specification.
/// If this field is set, then the `events` fields must not be set.
#[prost(string, repeated, tag = "3")]
pub text_events: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The response message for the PublishChannelConnectionEvents method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishChannelConnectionEventsResponse {}
/// The request message for the PublishEvents method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishEventsRequest {
/// The full name of the channel to publish to. For example:
/// `projects/{project}/locations/{location}/channels/{channel-id}`.
#[prost(string, tag = "1")]
pub channel: ::prost::alloc::string::String,
/// The CloudEvents v1.0 events to publish. No other types are allowed.
/// If this field is set, then the `text_events` fields must not be set.
#[prost(message, repeated, tag = "2")]
pub events: ::prost::alloc::vec::Vec<::prost_types::Any>,
/// The text representation of events to publish.
/// CloudEvent v1.0 in JSON format is the only allowed type. Refer to
/// <https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/formats/json-format.md>
/// for specification.
/// If this field is set, then the `events` fields must not be set.
#[prost(string, repeated, tag = "3")]
pub text_events: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// The response message for the PublishEvents method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PublishEventsResponse {}
/// Generated client implementations.
pub mod publisher_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
use tonic::codegen::http::Uri;
/// Eventarc processes events generated by an event provider and delivers them to
/// a subscriber.
///
/// An event provider is a software-as-a-service (SaaS) system or
/// product that can generate and deliver events through Eventarc.
///
/// A third-party event provider is an event provider from outside of Google.
///
/// A partner is a third-party event provider that is integrated with Eventarc.
///
/// A subscriber is a GCP customer interested in receiving events.
///
/// Channel is a first-class Eventarc resource that is created and managed
/// by the subscriber in their GCP project. A Channel represents a subscriber's
/// intent to receive events from an event provider. A Channel is associated with
/// exactly one event provider.
///
/// ChannelConnection is a first-class Eventarc resource that
/// is created and managed by the partner in their GCP project. A
/// ChannelConnection represents a connection between a partner and a
/// subscriber's Channel. A ChannelConnection has a one-to-one mapping with a
/// Channel.
///
/// Publisher allows an event provider to publish events to Eventarc.
#[derive(Debug, Clone)]
pub struct PublisherClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> PublisherClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + 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,
) -> PublisherClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
>>::Error: Into<StdError> + Send + Sync,
{
PublisherClient::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
}
/// Publish events to a ChannelConnection in a partner's project.
pub async fn publish_channel_connection_events(
&mut self,
request: impl tonic::IntoRequest<
super::PublishChannelConnectionEventsRequest,
>,
) -> std::result::Result<
tonic::Response<super::PublishChannelConnectionEventsResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.eventarc.publishing.v1.Publisher/PublishChannelConnectionEvents",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new(
"google.cloud.eventarc.publishing.v1.Publisher",
"PublishChannelConnectionEvents",
),
);
self.inner.unary(req, path, codec).await
}
/// Publish events to a subscriber's channel.
pub async fn publish_events(
&mut self,
request: impl tonic::IntoRequest<super::PublishEventsRequest>,
) -> std::result::Result<
tonic::Response<super::PublishEventsResponse>,
tonic::Status,
> {
self.inner
.ready()
.await
.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.cloud.eventarc.publishing.v1.Publisher/PublishEvents",
);
let mut req = request.into_request();
req.extensions_mut()
.insert(
GrpcMethod::new(
"google.cloud.eventarc.publishing.v1.Publisher",
"PublishEvents",
),
);
self.inner.unary(req, path, codec).await
}
}
}