-
Notifications
You must be signed in to change notification settings - Fork 0
/
pubsub_api_pb2_grpc.py
301 lines (260 loc) · 13.7 KB
/
pubsub_api_pb2_grpc.py
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
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import pubsub_api_pb2 as pubsub__api__pb2
class PubSubStub(object):
"""
The Pub/Sub API provides a single interface for publishing and subscribing to platform events, including real-time
event monitoring events, and change data capture events. The Pub/Sub API is a gRPC API that is based on HTTP/2.
A session token is needed to authenticate. Any of the Salesforce supported
OAuth flows can be used to obtain a session token:
https://help.salesforce.com/articleView?id=sf.remoteaccess_oauth_flows.htm&type=5
For each RPC, a client needs to pass authentication information
as metadata headers (https://www.grpc.io/docs/guides/concepts/#metadata) with their method call.
For Salesforce session token authentication, use:
accesstoken : access token
instanceurl : Salesforce instance URL
tenantid : tenant/org id of the client
StatusException is thrown in case of response failure for any request.
"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.Subscribe = channel.stream_stream(
'/eventbus.v1.PubSub/Subscribe',
request_serializer=pubsub__api__pb2.FetchRequest.SerializeToString,
response_deserializer=pubsub__api__pb2.FetchResponse.FromString,
)
self.GetSchema = channel.unary_unary(
'/eventbus.v1.PubSub/GetSchema',
request_serializer=pubsub__api__pb2.SchemaRequest.SerializeToString,
response_deserializer=pubsub__api__pb2.SchemaInfo.FromString,
)
self.GetTopic = channel.unary_unary(
'/eventbus.v1.PubSub/GetTopic',
request_serializer=pubsub__api__pb2.TopicRequest.SerializeToString,
response_deserializer=pubsub__api__pb2.TopicInfo.FromString,
)
self.Publish = channel.unary_unary(
'/eventbus.v1.PubSub/Publish',
request_serializer=pubsub__api__pb2.PublishRequest.SerializeToString,
response_deserializer=pubsub__api__pb2.PublishResponse.FromString,
)
self.PublishStream = channel.stream_stream(
'/eventbus.v1.PubSub/PublishStream',
request_serializer=pubsub__api__pb2.PublishRequest.SerializeToString,
response_deserializer=pubsub__api__pb2.PublishResponse.FromString,
)
class PubSubServicer(object):
"""
The Pub/Sub API provides a single interface for publishing and subscribing to platform events, including real-time
event monitoring events, and change data capture events. The Pub/Sub API is a gRPC API that is based on HTTP/2.
A session token is needed to authenticate. Any of the Salesforce supported
OAuth flows can be used to obtain a session token:
https://help.salesforce.com/articleView?id=sf.remoteaccess_oauth_flows.htm&type=5
For each RPC, a client needs to pass authentication information
as metadata headers (https://www.grpc.io/docs/guides/concepts/#metadata) with their method call.
For Salesforce session token authentication, use:
accesstoken : access token
instanceurl : Salesforce instance URL
tenantid : tenant/org id of the client
StatusException is thrown in case of response failure for any request.
"""
def Subscribe(self, request_iterator, context):
"""
Bidirectional streaming RPC to subscribe to a Topic. The subscription is pull-based. A client can request
for more events as it consumes events. This enables a client to handle flow control based on the client's processing speed.
Typical flow:
1. Client requests for X number of events via FetchRequest.
2. Server receives request and delivers events until X events are delivered to the client via one or more FetchResponse messages.
3. Client consumes the FetchResponse messages as they come.
4. Client issues new FetchRequest for Y more number of events. This request can
come before the server has delivered the earlier requested X number of events
so the client gets a continuous stream of events if any.
If a client requests more events before the server finishes the last
requested amount, the server appends the new amount to the current amount of
events it still needs to fetch and deliver.
A client can subscribe at any point in the stream by providing a replay option in the first FetchRequest.
The replay option is honored for the first FetchRequest received from a client. Any subsequent FetchRequests with a
new replay option are ignored. A client needs to call the Subscribe RPC again to restart the subscription
at a new point in the stream.
The first FetchRequest of the stream identifies the topic to subscribe to.
If any subsequent FetchRequest provides topic_name, it must match what
was provided in the first FetchRequest; otherwise, the RPC returns an error
with INVALID_ARGUMENT status.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GetSchema(self, request, context):
"""Get the event schema for a topic based on a schema ID.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GetTopic(self, request, context):
"""
Get the topic Information related to the specified topic.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Publish(self, request, context):
"""
Send a publish request to synchronously publish events to a topic.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def PublishStream(self, request_iterator, context):
"""
Bidirectional Streaming RPC to publish events to the event bus.
PublishRequest contains the batch of events to publish.
The first PublishRequest of the stream identifies the topic to publish on.
If any subsequent PublishRequest provides topic_name, it must match what
was provided in the first PublishRequest; otherwise, the RPC returns an error
with INVALID_ARGUMENT status.
The server returns a PublishResponse for each PublishRequest when publish is
complete for the batch. A client does not have to wait for a PublishResponse
before sending a new PublishRequest, i.e. multiple publish batches can be queued
up, which allows for higher publish rate as a client can asynchronously
publish more events while publishes are still in flight on the server side.
PublishResponse holds a PublishResult for each event published that indicates success
or failure of the publish. A client can then retry the publish as needed before sending
more PublishRequests for new events to publish.
A client must send a valid publish request with one or more events every 70 seconds to hold on to the stream.
Otherwise, the server closes the stream and notifies the client. Once the client is notified of the stream closure,
it must make a new PublishStream call to resume publishing.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_PubSubServicer_to_server(servicer, server):
rpc_method_handlers = {
'Subscribe': grpc.stream_stream_rpc_method_handler(
servicer.Subscribe,
request_deserializer=pubsub__api__pb2.FetchRequest.FromString,
response_serializer=pubsub__api__pb2.FetchResponse.SerializeToString,
),
'GetSchema': grpc.unary_unary_rpc_method_handler(
servicer.GetSchema,
request_deserializer=pubsub__api__pb2.SchemaRequest.FromString,
response_serializer=pubsub__api__pb2.SchemaInfo.SerializeToString,
),
'GetTopic': grpc.unary_unary_rpc_method_handler(
servicer.GetTopic,
request_deserializer=pubsub__api__pb2.TopicRequest.FromString,
response_serializer=pubsub__api__pb2.TopicInfo.SerializeToString,
),
'Publish': grpc.unary_unary_rpc_method_handler(
servicer.Publish,
request_deserializer=pubsub__api__pb2.PublishRequest.FromString,
response_serializer=pubsub__api__pb2.PublishResponse.SerializeToString,
),
'PublishStream': grpc.stream_stream_rpc_method_handler(
servicer.PublishStream,
request_deserializer=pubsub__api__pb2.PublishRequest.FromString,
response_serializer=pubsub__api__pb2.PublishResponse.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'eventbus.v1.PubSub', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
# This class is part of an EXPERIMENTAL API.
class PubSub(object):
"""
The Pub/Sub API provides a single interface for publishing and subscribing to platform events, including real-time
event monitoring events, and change data capture events. The Pub/Sub API is a gRPC API that is based on HTTP/2.
A session token is needed to authenticate. Any of the Salesforce supported
OAuth flows can be used to obtain a session token:
https://help.salesforce.com/articleView?id=sf.remoteaccess_oauth_flows.htm&type=5
For each RPC, a client needs to pass authentication information
as metadata headers (https://www.grpc.io/docs/guides/concepts/#metadata) with their method call.
For Salesforce session token authentication, use:
accesstoken : access token
instanceurl : Salesforce instance URL
tenantid : tenant/org id of the client
StatusException is thrown in case of response failure for any request.
"""
@staticmethod
def Subscribe(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_stream(request_iterator, target, '/eventbus.v1.PubSub/Subscribe',
pubsub__api__pb2.FetchRequest.SerializeToString,
pubsub__api__pb2.FetchResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def GetSchema(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(request, target, '/eventbus.v1.PubSub/GetSchema',
pubsub__api__pb2.SchemaRequest.SerializeToString,
pubsub__api__pb2.SchemaInfo.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def GetTopic(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(request, target, '/eventbus.v1.PubSub/GetTopic',
pubsub__api__pb2.TopicRequest.SerializeToString,
pubsub__api__pb2.TopicInfo.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def Publish(request,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.unary_unary(request, target, '/eventbus.v1.PubSub/Publish',
pubsub__api__pb2.PublishRequest.SerializeToString,
pubsub__api__pb2.PublishResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
@staticmethod
def PublishStream(request_iterator,
target,
options=(),
channel_credentials=None,
call_credentials=None,
insecure=False,
compression=None,
wait_for_ready=None,
timeout=None,
metadata=None):
return grpc.experimental.stream_stream(request_iterator, target, '/eventbus.v1.PubSub/PublishStream',
pubsub__api__pb2.PublishRequest.SerializeToString,
pubsub__api__pb2.PublishResponse.FromString,
options, channel_credentials,
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)