changed
hex_metadata.config
|
|
@@ -3,10 3,12 @@
|
|
3
3
|
{<<"description">>,<<"Spawn is the core lib for Spawn Actors System">>}.
|
|
4
4
|
{<<"elixir">>,<<"~> 1.15">>}.
|
|
5
5
|
{<<"files">>,
|
|
6
|
- [<<"lib">>,<<"lib/spawn.ex">>,<<"lib/spawn">>,<<"lib/spawn/cache">>,
|
|
7
|
- <<"lib/spawn/cache/lookup_cache.ex">>,<<"lib/spawn/cloudevents">>,
|
|
8
|
- <<"lib/spawn/cloudevents/spec.pb.ex">>,<<"lib/spawn/cluster">>,
|
|
9
|
- <<"lib/spawn/cluster/state_handoff">>,
|
|
6
|
[<<"lib">>,<<"lib/spawn.ex">>,<<"lib/spawn">>,<<"lib/spawn/grpc">>,
|
|
7
|
<<"lib/spawn/grpc/reflection">>,<<"lib/spawn/grpc/reflection/v1alpha">>,
|
|
8
|
<<"lib/spawn/grpc/reflection/v1alpha/reflection.pb.ex">>,
|
|
9
|
<<"lib/spawn/cache">>,<<"lib/spawn/cache/lookup_cache.ex">>,
|
|
10
|
<<"lib/spawn/cloudevents">>,<<"lib/spawn/cloudevents/spec.pb.ex">>,
|
|
11
|
<<"lib/spawn/cluster">>,<<"lib/spawn/cluster/state_handoff">>,
|
|
10
12
|
<<"lib/spawn/cluster/state_handoff/controllers">>,
|
|
11
13
|
<<"lib/spawn/cluster/state_handoff/controllers/persistent_controller.ex">>,
|
|
12
14
|
<<"lib/spawn/cluster/state_handoff/controllers/crdt_controller.ex">>,
|
|
|
@@ -21,14 23,38 @@
|
|
21
23
|
<<"lib/spawn/cluster/node/client.ex">>,
|
|
22
24
|
<<"lib/spawn/cluster/node/connection_supervisor.ex">>,
|
|
23
25
|
<<"lib/spawn/google">>,<<"lib/spawn/google/protobuf">>,
|
|
24
|
- <<"lib/spawn/google/protobuf/any.pb.ex">>,<<"lib/spawn/supervisor.ex">>,
|
|
25
|
- <<"lib/spawn/actors">>,<<"lib/spawn/actors/actor.pb.ex">>,
|
|
26
|
- <<"lib/spawn/actors/protocol.pb.ex">>,<<"lib/spawn/actors/state.pb.ex">>,
|
|
26
|
<<"lib/spawn/google/protobuf/struct.pb.ex">>,
|
|
27
|
<<"lib/spawn/google/protobuf/empty.pb.ex">>,
|
|
28
|
<<"lib/spawn/google/protobuf/timestamp.pb.ex">>,
|
|
29
|
<<"lib/spawn/google/protobuf/any.pb.ex">>,
|
|
30
|
<<"lib/spawn/google/protobuf/wrappers.pb.ex">>,
|
|
31
|
<<"lib/spawn/google/protobuf/source_context.pb.ex">>,
|
|
32
|
<<"lib/spawn/google/protobuf/descriptor.pb.ex">>,
|
|
33
|
<<"lib/spawn/google/protobuf/field_mask.pb.ex">>,
|
|
34
|
<<"lib/spawn/google/protobuf/duration.pb.ex">>,
|
|
35
|
<<"lib/spawn/supervisor.ex">>,<<"lib/spawn/actors">>,
|
|
36
|
<<"lib/spawn/actors/eigr">>,<<"lib/spawn/actors/eigr/functions">>,
|
|
37
|
<<"lib/spawn/actors/eigr/functions/protocol">>,
|
|
38
|
<<"lib/spawn/actors/eigr/functions/protocol/actors">>,
|
|
39
|
<<"lib/spawn/actors/eigr/functions/protocol/actors/extensions.pb.ex">>,
|
|
40
|
<<"lib/spawn/actors/eigr/functions/protocol/actors/actor.pb.ex">>,
|
|
41
|
<<"lib/spawn/actors/eigr/functions/protocol/actors/healthcheck.pb.ex">>,
|
|
42
|
<<"lib/spawn/actors/eigr/functions/protocol/actors/protocol.pb.ex">>,
|
|
43
|
<<"lib/spawn/actors/eigr/functions/protocol/actors/state.pb.ex">>,
|
|
27
44
|
<<"lib/spawn/utils">>,<<"lib/spawn/utils/any_serializer.ex">>,
|
|
28
45
|
<<"lib/spawn/utils/nats.ex">>,<<"lib/spawn/utils/common.ex">>,
|
|
29
46
|
<<"lib/_exceptions">>,<<"lib/_exceptions/network_partition_exception.ex">>,
|
|
30
47
|
<<"lib/_exceptions/not_authorized_exception.ex">>,<<"lib/sidecar.ex">>,
|
|
31
48
|
<<"lib/sidecar">>,<<"lib/sidecar/graceful_shutdown.ex">>,
|
|
49
|
<<"lib/sidecar/grpc">>,<<"lib/sidecar/grpc/code_generator.ex">>,
|
|
50
|
<<"lib/sidecar/grpc/generators">>,
|
|
51
|
<<"lib/sidecar/grpc/generators/service_generator.ex">>,
|
|
52
|
<<"lib/sidecar/grpc/generators/handler_generator.ex">>,
|
|
53
|
<<"lib/sidecar/grpc/generators/reflection_server_generator.ex">>,
|
|
54
|
<<"lib/sidecar/grpc/generators/handler_transcoding_generator.ex">>,
|
|
55
|
<<"lib/sidecar/grpc/healthcheck">>,
|
|
56
|
<<"lib/sidecar/grpc/healthcheck/healthcheck_handler_actordispatcher.ex">>,
|
|
57
|
<<"lib/sidecar/grpc/supervisor.ex">>,<<"lib/sidecar/grpc/dispatcher.ex">>,
|
|
32
58
|
<<"lib/sidecar/metrics_supervisor.ex">>,<<"lib/sidecar/measurements.ex">>,
|
|
33
59
|
<<"lib/sidecar/supervisor.ex">>,<<"lib/sidecar/process_supervisor.ex">>,
|
|
34
60
|
<<"lib/actors">>,<<"lib/actors/config">>,
|
|
|
@@ -68,14 94,33 @@
|
|
68
94
|
<<"lib/actors/supervisors/protocol_supervisor.ex">>,<<"lib/actors/node">>,
|
|
69
95
|
<<"lib/actors/node/client.ex">>,
|
|
70
96
|
<<"lib/actors/node/default_split_brain_detector.ex">>,<<"mix.exs">>,
|
|
71
|
- <<"priv">>,<<"priv/protos">>,<<"priv/protos/eigr">>,
|
|
72
|
- <<"priv/protos/eigr/functions">>,<<"priv/protos/eigr/functions/protocol">>,
|
|
97
|
<<"priv">>,<<"priv/protos">>,<<"priv/protos/grpc">>,
|
|
98
|
<<"priv/protos/grpc/reflection">>,<<"priv/protos/grpc/reflection/v1alpha">>,
|
|
99
|
<<"priv/protos/grpc/reflection/v1alpha/reflection.proto">>,
|
|
100
|
<<"priv/protos/eigr">>,<<"priv/protos/eigr/functions">>,
|
|
101
|
<<"priv/protos/eigr/functions/protocol">>,
|
|
73
102
|
<<"priv/protos/eigr/functions/protocol/actors">>,
|
|
74
103
|
<<"priv/protos/eigr/functions/protocol/actors/actor.proto">>,
|
|
104
|
<<"priv/protos/eigr/functions/protocol/actors/extensions.proto">>,
|
|
75
105
|
<<"priv/protos/eigr/functions/protocol/actors/protocol.proto">>,
|
|
76
106
|
<<"priv/protos/eigr/functions/protocol/actors/state.proto">>,
|
|
77
|
- <<"priv/protos/google">>,<<"priv/protos/google/protobuf">>,
|
|
78
|
- <<"priv/protos/google/protobuf/any.proto">>,<<"priv/protos/io">>,
|
|
107
|
<<"priv/protos/eigr/functions/protocol/actors/healthcheck.proto">>,
|
|
108
|
<<"priv/protos/modules">>,<<"priv/protos/modules/README.md">>,
|
|
109
|
<<"priv/protos/google">>,<<"priv/protos/google/api">>,
|
|
110
|
<<"priv/protos/google/api/http.proto">>,
|
|
111
|
<<"priv/protos/google/api/annotations.proto">>,
|
|
112
|
<<"priv/protos/google/protobuf">>,
|
|
113
|
<<"priv/protos/google/protobuf/source_context.proto">>,
|
|
114
|
<<"priv/protos/google/protobuf/any.proto">>,
|
|
115
|
<<"priv/protos/google/protobuf/wrappers.proto">>,
|
|
116
|
<<"priv/protos/google/protobuf/timestamp.proto">>,
|
|
117
|
<<"priv/protos/google/protobuf/empty.proto">>,
|
|
118
|
<<"priv/protos/google/protobuf/type.proto">>,
|
|
119
|
<<"priv/protos/google/protobuf/field_mask.proto">>,
|
|
120
|
<<"priv/protos/google/protobuf/api.proto">>,
|
|
121
|
<<"priv/protos/google/protobuf/descriptor.proto">>,
|
|
122
|
<<"priv/protos/google/protobuf/duration.proto">>,
|
|
123
|
<<"priv/protos/google/protobuf/struct.proto">>,<<"priv/protos/io">>,
|
|
79
124
|
<<"priv/protos/io/cloudevents">>,<<"priv/protos/io/cloudevents/v1">>,
|
|
80
125
|
<<"priv/protos/io/cloudevents/v1/spec.proto">>,<<"priv/certs">>,
|
|
81
126
|
<<"priv/certs/tls.crt">>,<<"priv/certs/ca.crt">>,<<"priv/certs/ca.key">>,
|
|
|
@@ -126,12 171,27 @@
|
|
126
171
|
{<<"name">>,<<"protobuf">>},
|
|
127
172
|
{<<"optional">>,false},
|
|
128
173
|
{<<"repository">>,<<"hexpm">>},
|
|
129
|
- {<<"requirement">>,<<"~> 0.11">>}],
|
|
174
|
{<<"requirement">>,<<"~> 0.12">>}],
|
|
175
|
[{<<"app">>,<<"protobuf_generate">>},
|
|
176
|
{<<"name">>,<<"protobuf_generate">>},
|
|
177
|
{<<"optional">>,false},
|
|
178
|
{<<"repository">>,<<"hexpm">>},
|
|
179
|
{<<"requirement">>,<<"~> 0.1">>}],
|
|
180
|
[{<<"app">>,<<"grpc">>},
|
|
181
|
{<<"name">>,<<"grpc">>},
|
|
182
|
{<<"optional">>,false},
|
|
183
|
{<<"repository">>,<<"hexpm">>},
|
|
184
|
{<<"requirement">>,<<"~> 0.8">>}],
|
|
185
|
[{<<"app">>,<<"grpc_reflection">>},
|
|
186
|
{<<"name">>,<<"grpc_reflection">>},
|
|
187
|
{<<"optional">>,false},
|
|
188
|
{<<"repository">>,<<"hexpm">>},
|
|
189
|
{<<"requirement">>,<<"~> 0.1">>}],
|
|
130
190
|
[{<<"app">>,<<"finch">>},
|
|
131
191
|
{<<"name">>,<<"finch">>},
|
|
132
192
|
{<<"optional">>,false},
|
|
133
193
|
{<<"repository">>,<<"hexpm">>},
|
|
134
|
- {<<"requirement">>,<<"~> 0.16">>}],
|
|
194
|
{<<"requirement">>,<<"~> 0.18">>}],
|
|
135
195
|
[{<<"app">>,<<"retry">>},
|
|
136
196
|
{<<"name">>,<<"retry">>},
|
|
137
197
|
{<<"optional">>,false},
|
|
|
@@ -187,6 247,11 @@
|
|
187
247
|
{<<"optional">>,false},
|
|
188
248
|
{<<"repository">>,<<"hexpm">>},
|
|
189
249
|
{<<"requirement">>,<<"~> 0.2">>}],
|
|
250
|
[{<<"app">>,<<"hpax">>},
|
|
251
|
{<<"name">>,<<"hpax">>},
|
|
252
|
{<<"optional">>,false},
|
|
253
|
{<<"repository">>,<<"hexpm">>},
|
|
254
|
{<<"requirement">>,<<"~> 0.1.1">>}],
|
|
190
255
|
[{<<"app">>,<<"telemetry_poller">>},
|
|
191
256
|
{<<"name">>,<<"telemetry_poller">>},
|
|
192
257
|
{<<"optional">>,false},
|
|
|
@@ -221,40 286,40 @@
|
|
221
286
|
{<<"name">>,<<"spawn_statestores_mssql">>},
|
|
222
287
|
{<<"optional">>,true},
|
|
223
288
|
{<<"repository">>,<<"hexpm">>},
|
|
224
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
289
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
225
290
|
[{<<"app">>,<<"spawn_statestores_mariadb">>},
|
|
226
291
|
{<<"name">>,<<"spawn_statestores_mariadb">>},
|
|
227
292
|
{<<"optional">>,true},
|
|
228
293
|
{<<"repository">>,<<"hexpm">>},
|
|
229
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
294
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
230
295
|
[{<<"app">>,<<"spawn_statestores_mysql">>},
|
|
231
296
|
{<<"name">>,<<"spawn_statestores_mysql">>},
|
|
232
297
|
{<<"optional">>,true},
|
|
233
298
|
{<<"repository">>,<<"hexpm">>},
|
|
234
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
299
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
235
300
|
[{<<"app">>,<<"spawn_statestores_postgres">>},
|
|
236
301
|
{<<"name">>,<<"spawn_statestores_postgres">>},
|
|
237
302
|
{<<"optional">>,true},
|
|
238
303
|
{<<"repository">>,<<"hexpm">>},
|
|
239
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
304
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
240
305
|
[{<<"app">>,<<"spawn_statestores_sqlite">>},
|
|
241
306
|
{<<"name">>,<<"spawn_statestores_sqlite">>},
|
|
242
307
|
{<<"optional">>,true},
|
|
243
308
|
{<<"repository">>,<<"hexpm">>},
|
|
244
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
309
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
245
310
|
[{<<"app">>,<<"spawn_statestores_cockroachdb">>},
|
|
246
311
|
{<<"name">>,<<"spawn_statestores_cockroachdb">>},
|
|
247
312
|
{<<"optional">>,true},
|
|
248
313
|
{<<"repository">>,<<"hexpm">>},
|
|
249
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
314
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
250
315
|
[{<<"app">>,<<"spawn_statestores_native">>},
|
|
251
316
|
{<<"name">>,<<"spawn_statestores_native">>},
|
|
252
317
|
{<<"optional">>,true},
|
|
253
318
|
{<<"repository">>,<<"hexpm">>},
|
|
254
|
- {<<"requirement">>,<<"1.3.3">>}],
|
|
319
|
{<<"requirement">>,<<"1.4.0">>}],
|
|
255
320
|
[{<<"app">>,<<"pluggable">>},
|
|
256
321
|
{<<"name">>,<<"pluggable">>},
|
|
257
322
|
{<<"optional">>,false},
|
|
258
323
|
{<<"repository">>,<<"hexpm">>},
|
|
259
324
|
{<<"requirement">>,<<"~> 1.0">>}]]}.
|
|
260
|
- {<<"version">>,<<"1.3.3">>}.
|
|
325
|
{<<"version">>,<<"1.4.0">>}.
|
changed
lib/actors/actor/caller_consumer.ex
|
|
@@ -106,6 106,14 @@ defmodule Actors.Actor.CallerConsumer do
|
|
106
106
|
reply_to_producer(from, get_state(event))
|
|
107
107
|
end
|
|
108
108
|
|
|
109
|
defp dispatch_to_actor({from, {:readiness, event, _opts}} = _producer_event) do
|
|
110
|
reply_to_producer(from, readiness(event))
|
|
111
|
end
|
|
112
|
|
|
113
|
defp dispatch_to_actor({from, {:liveness, event, _opts}} = _producer_event) do
|
|
114
|
reply_to_producer(from, liveness(event))
|
|
115
|
end
|
|
116
|
|
|
109
117
|
defp dispatch_to_actor({from, {:spawn_actor, event, opts}} = _producer_event) do
|
|
110
118
|
reply_to_producer(from, spawn_actor(event, opts))
|
|
111
119
|
end
|
|
|
@@ -143,6 151,7 @@ defmodule Actors.Actor.CallerConsumer do
|
|
143
151
|
opts
|
|
144
152
|
) do
|
|
145
153
|
if Sidecar.GracefulShutdown.running?() do
|
|
154
|
# actors [�tor{id: �torId{} = id, settings: �torSettings{} = settings}]
|
|
146
155
|
actors
|
|
147
156
|
|> Map.values()
|
|
148
157
|
|> Enum.map(fn actor -> ActorPool.create_actor_host_pool(actor, opts) end)
|
|
|
@@ -178,7 187,7 @@ defmodule Actors.Actor.CallerConsumer do
|
|
178
187
|
protocol_major_version: 1,
|
|
179
188
|
protocol_minor_version: 2,
|
|
180
189
|
proxy_name: "spawn",
|
|
181
|
- proxy_version: "1.3.3"
|
|
190
|
proxy_version: "1.4.0"
|
|
182
191
|
}
|
|
183
192
|
end
|
|
184
193
|
|
|
|
@@ -235,6 244,148 @@ defmodule Actors.Actor.CallerConsumer do
|
|
235
244
|
end
|
|
236
245
|
end
|
|
237
246
|
|
|
247
|
@doc """
|
|
248
|
Performs a readiness check for a given actor identified by `�torId{}`.
|
|
249
|
|
|
250
|
This function uses a retry mechanism with exponential backoff, randomization, and a 30-second expiry to handle errors and failures gracefully.
|
|
251
|
It attempts to check the readiness of the specified actor, logging any errors encountered during the process.
|
|
252
|
|
|
253
|
## Parameters
|
|
254
|
|
|
255
|
- `id`: An `�torId{}` struct that contains:
|
|
256
|
- `name`: The name of the actor.
|
|
257
|
- `system`: The name of the system the actor belongs to.
|
|
258
|
|
|
259
|
## Returns
|
|
260
|
|
|
261
|
- `{:ok, %HealthCheckReply{}}` if the readiness check is successful. The `HealthCheckReply` struct contains:
|
|
262
|
- `status`: A `HealthcheckStatus` struct with:
|
|
263
|
- `status`: A string indicating the status, e.g., "OK".
|
|
264
|
- `details`: A string providing additional details, e.g., "I'm alive!".
|
|
265
|
- `updated_at`: A `Google.Protobuf.Timestamp` indicating the last update time.
|
|
266
|
- An error tuple (e.g., `{:error, :noproc}`) if the readiness check fails after all retry attempts.
|
|
267
|
|
|
268
|
## Examples
|
|
269
|
|
|
270
|
iex> readiness(�torId{name: "actor1", system: "system1"})
|
|
271
|
{:ok,
|
|
272
|
%HealthCheckReply{
|
|
273
|
status: %HealthcheckStatus{
|
|
274
|
status: "OK",
|
|
275
|
details: "I'm alive!",
|
|
276
|
updated_at: %Google.Protobuf.Timestamp{seconds: 1717606730}
|
|
277
|
}
|
|
278
|
}}
|
|
279
|
|
|
280
|
iex> readiness(�torId{name: "nonexistent_actor", system: "system1"})
|
|
281
|
{:error, :noproc}
|
|
282
|
|
|
283
|
## Notes
|
|
284
|
|
|
285
|
The retry mechanism handles the following cases: `:error`, `:exit`, `:noproc`, `:erpc`, `:noconnection`, and `:timeout`. It rescues only `ErlangError`.
|
|
286
|
|
|
287
|
The readiness check is performed by calling `ActorEntity.readiness/2` on the actor reference obtained through `do_lookup_action/4`.
|
|
288
|
|
|
289
|
Any errors during the readiness check are logged with a message indicating the actor's name and the error encountered.
|
|
290
|
"""
|
|
291
|
@spec readiness(ActorId.t()) :: {:ok, HealthCheckReply.t()} | {:error, any()}
|
|
292
|
def readiness(�torId{name: actor_name, system: system_name} = id) do
|
|
293
|
retry with: exponential_backoff() |> randomize |> expiry(30_000),
|
|
294
|
atoms: [:error, :exit, :noproc, :erpc, :noconnection, :timeout],
|
|
295
|
rescue_only: [ErlangError] do
|
|
296
|
try do
|
|
297
|
do_lookup_action(
|
|
298
|
system_name,
|
|
299
|
{false, system_name, actor_name, id},
|
|
300
|
nil,
|
|
301
|
fn actor_ref, _actor_ref_id ->
|
|
302
|
ActorEntity.readiness(actor_ref)
|
|
303
|
end
|
|
304
|
)
|
|
305
|
rescue
|
|
306
|
e ->
|
|
307
|
Logger.error("Failure to make a call to actor #{inspect(actor_name)} #{inspect(e)}")
|
|
308
|
|
|
309
|
reraise e, __STACKTRACE__
|
|
310
|
end
|
|
311
|
after
|
|
312
|
result -> result
|
|
313
|
else
|
|
314
|
error -> error
|
|
315
|
end
|
|
316
|
end
|
|
317
|
|
|
318
|
@doc """
|
|
319
|
Performs a liveness check for a given actor identified by `�torId{}`.
|
|
320
|
|
|
321
|
This function uses a retry mechanism with exponential backoff, randomization, and a 30-second expiry to handle errors and failures gracefully.
|
|
322
|
It attempts to check the liveness of the specified actor, logging any errors encountered during the process.
|
|
323
|
|
|
324
|
## Parameters
|
|
325
|
|
|
326
|
- `id`: An `�torId{}` struct that contains:
|
|
327
|
- `name`: The name of the actor.
|
|
328
|
- `system`: The name of the system the actor belongs to.
|
|
329
|
|
|
330
|
## Returns
|
|
331
|
|
|
332
|
- `{:ok, %HealthCheckReply{}}` if the liveness check is successful. The `HealthCheckReply` struct contains:
|
|
333
|
- `status`: A `HealthcheckStatus` struct with:
|
|
334
|
- `status`: A string indicating the status, e.g., "OK".
|
|
335
|
- `details`: A string providing additional details, e.g., "I'm alive!".
|
|
336
|
- `updated_at`: A `Google.Protobuf.Timestamp` indicating the last update time.
|
|
337
|
- An error tuple (e.g., `{:error, :noproc}`) if the liveness check fails after all retry attempts.
|
|
338
|
|
|
339
|
## Examples
|
|
340
|
|
|
341
|
iex> liveness(�torId{name: "actor1", system: "system1"})
|
|
342
|
{:ok,
|
|
343
|
%HealthCheckReply{
|
|
344
|
status: %HealthcheckStatus{
|
|
345
|
status: "OK",
|
|
346
|
details: "I'm still alive!",
|
|
347
|
updated_at: %Google.Protobuf.Timestamp{seconds: 1717606837}
|
|
348
|
}
|
|
349
|
}}
|
|
350
|
|
|
351
|
iex> liveness(�torId{name: "nonexistent_actor", system: "system1"})
|
|
352
|
{:error, :noproc}
|
|
353
|
|
|
354
|
## Notes
|
|
355
|
|
|
356
|
The retry mechanism handles the following cases: `:error`, `:exit`, `:noproc`, `:erpc`, `:noconnection`, and `:timeout`. It rescues only `ErlangError`.
|
|
357
|
|
|
358
|
The liveness check is performed by calling `ActorEntity.liveness/2` on the actor reference obtained through `do_lookup_action/4`.
|
|
359
|
|
|
360
|
Any errors during the liveness check are logged with a message indicating the actor's name and the error encountered.
|
|
361
|
"""
|
|
362
|
@spec liveness(ActorId.t()) :: {:ok, HealthCheckReply.t()} | {:error, any()}
|
|
363
|
def liveness(�torId{name: actor_name, system: system_name} = id) do
|
|
364
|
retry with: exponential_backoff() |> randomize |> expiry(30_000),
|
|
365
|
atoms: [:error, :exit, :noproc, :erpc, :noconnection, :timeout],
|
|
366
|
rescue_only: [ErlangError] do
|
|
367
|
try do
|
|
368
|
do_lookup_action(
|
|
369
|
system_name,
|
|
370
|
{false, system_name, actor_name, id},
|
|
371
|
nil,
|
|
372
|
fn actor_ref, _actor_ref_id ->
|
|
373
|
ActorEntity.liveness(actor_ref)
|
|
374
|
end
|
|
375
|
)
|
|
376
|
rescue
|
|
377
|
e ->
|
|
378
|
Logger.error("Failure to make a call to actor #{inspect(actor_name)} #{inspect(e)}")
|
|
379
|
|
|
380
|
reraise e, __STACKTRACE__
|
|
381
|
end
|
|
382
|
after
|
|
383
|
result -> result
|
|
384
|
else
|
|
385
|
error -> error
|
|
386
|
end
|
|
387
|
end
|
|
388
|
|
|
238
389
|
@doc """
|
|
239
390
|
Spawns an actor or a group of actors based on the provided `SpawnRequest`.
|
changed
lib/actors/actor/caller_producer.ex
|
|
@@ -95,6 95,52 @@ defmodule Actors.Actor.CallerProducer do
|
|
95
95
|
end
|
|
96
96
|
end
|
|
97
97
|
|
|
98
|
@doc """
|
|
99
|
Performs a readiness check for a given actor.
|
|
100
|
|
|
101
|
## Parameters
|
|
102
|
|
|
103
|
- `actor_id` (ActorId.t()): The ID of the actor.
|
|
104
|
- `opts` (any): Additional options.
|
|
105
|
|
|
106
|
## Returns
|
|
107
|
|
|
108
|
- `{:ok, response}`: If the response is successfully.
|
|
109
|
- `{:error, reason}`: If an error occurs during the operation.
|
|
110
|
|
|
111
|
"""
|
|
112
|
@spec readiness(ActorId.t()) :: {:ok, term()} | {:error, term()}
|
|
113
|
def readiness(actor_id, opts \\ []) do
|
|
114
|
if Config.get(:actors_global_backpressure_enabled) do
|
|
115
|
GenStage.call(__MODULE__, {:enqueue, {:readiness, actor_id, opts}}, :infinity)
|
|
116
|
else
|
|
117
|
CallerConsumer.readiness(actor_id)
|
|
118
|
end
|
|
119
|
end
|
|
120
|
|
|
121
|
@doc """
|
|
122
|
Performs a liveness check for a given actor.
|
|
123
|
|
|
124
|
## Parameters
|
|
125
|
|
|
126
|
- `actor_id` (ActorId.t()): The ID of the actor.
|
|
127
|
- `opts` (any): Additional options.
|
|
128
|
|
|
129
|
## Returns
|
|
130
|
|
|
131
|
- `{:ok, response}`: If the response is successfully.
|
|
132
|
- `{:error, reason}`: If an error occurs during the operation.
|
|
133
|
|
|
134
|
"""
|
|
135
|
@spec liveness(ActorId.t()) :: {:ok, term()} | {:error, term()}
|
|
136
|
def liveness(actor_id, opts \\ []) do
|
|
137
|
if Config.get(:actors_global_backpressure_enabled) do
|
|
138
|
GenStage.call(__MODULE__, {:enqueue, {:liveness, actor_id, opts}}, :infinity)
|
|
139
|
else
|
|
140
|
CallerConsumer.liveness(actor_id)
|
|
141
|
end
|
|
142
|
end
|
|
143
|
|
|
98
144
|
@doc """
|
|
99
145
|
Registers an actor with the specified registration request.
|
changed
lib/actors/actor/entity/entity.ex
|
|
@@ -66,13 66,15 @@ defmodule Actors.Actor.Entity do
|
|
66
66
|
require Logger
|
|
67
67
|
|
|
68
68
|
alias Actors.Actor.StateManager
|
|
69
|
- alias Actors.Actor.Entity.{EntityState, Lifecycle, Invocation}
|
|
69
|
alias Actors.Actor.Entity.EntityState
|
|
70
|
alias Actors.Actor.Entity.Lifecycle
|
|
71
|
alias Actors.Actor.Entity.Invocation
|
|
70
72
|
|
|
71
|
- alias Eigr.Functions.Protocol.Actors.{
|
|
72
|
- Actor,
|
|
73
|
- ActorId,
|
|
74
|
- ActorState
|
|
75
|
- }
|
|
73
|
alias Eigr.Functions.Protocol.Actors.Actor
|
|
74
|
alias Eigr.Functions.Protocol.Actors.ActorId
|
|
75
|
alias Eigr.Functions.Protocol.Actors.ActorState
|
|
76
|
alias Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckReply
|
|
77
|
alias Eigr.Functions.Protocol.Actors.Healthcheck.Status, as: HealthcheckStatus
|
|
76
78
|
|
|
77
79
|
alias Eigr.Functions.Protocol.State.Checkpoint
|
|
78
80
|
alias Eigr.Functions.Protocol.State.Revision
|
|
|
@@ -141,6 143,12 @@ defmodule Actors.Actor.Entity do
|
|
141
143
|
:get_state ->
|
|
142
144
|
do_handle_get_state(action, from, state)
|
|
143
145
|
|
|
146
|
:readiness ->
|
|
147
|
do_handle_readiness(action, from, state)
|
|
148
|
|
|
149
|
:liveness ->
|
|
150
|
do_handle_liveness(action, from, state)
|
|
151
|
|
|
144
152
|
:checkpoint ->
|
|
145
153
|
do_handle_checkpoint(action, from, state)
|
|
146
154
|
|
|
|
@@ -149,6 157,48 @@ defmodule Actors.Actor.Entity do
|
|
149
157
|
end
|
|
150
158
|
end
|
|
151
159
|
|
|
160
|
defp do_handle_readiness(
|
|
161
|
_action,
|
|
162
|
_from,
|
|
163
|
%EntityState{
|
|
164
|
actor: �tor{} = _actor
|
|
165
|
} = state
|
|
166
|
) do
|
|
167
|
{:reply,
|
|
168
|
{:ok,
|
|
169
|
%HealthCheckReply{
|
|
170
|
status: %HealthcheckStatus{
|
|
171
|
status: "OK",
|
|
172
|
details: "I'm alive!",
|
|
173
|
updated_at: %Google.Protobuf.Timestamp{
|
|
174
|
seconds: DateTime.to_unix(DateTime.utc_now(:second))
|
|
175
|
}
|
|
176
|
}
|
|
177
|
}}, state}
|
|
178
|
|> return_and_maybe_hibernate()
|
|
179
|
end
|
|
180
|
|
|
181
|
defp do_handle_liveness(
|
|
182
|
_action,
|
|
183
|
_from,
|
|
184
|
%EntityState{
|
|
185
|
actor: �tor{} = _actor
|
|
186
|
} = state
|
|
187
|
) do
|
|
188
|
{:reply,
|
|
189
|
{:ok,
|
|
190
|
%HealthCheckReply{
|
|
191
|
status: %HealthcheckStatus{
|
|
192
|
status: "OK",
|
|
193
|
details: "I'm still alive!",
|
|
194
|
updated_at: %Google.Protobuf.Timestamp{
|
|
195
|
seconds: DateTime.to_unix(DateTime.utc_now(:second))
|
|
196
|
}
|
|
197
|
}
|
|
198
|
}}, state}
|
|
199
|
|> return_and_maybe_hibernate()
|
|
200
|
end
|
|
201
|
|
|
152
202
|
defp do_handle_checkpoint(
|
|
153
203
|
_action,
|
|
154
204
|
_from,
|
|
|
@@ -360,6 410,38 @@ defmodule Actors.Actor.Entity do
|
|
360
410
|
GenServer.call(via(ref), :get_state, timeout)
|
|
361
411
|
end
|
|
362
412
|
|
|
413
|
@doc """
|
|
414
|
Retrieve the health check readiness status.
|
|
415
|
"""
|
|
416
|
@spec readiness(any, any) :: {:error, term()} | {:ok, term()}
|
|
417
|
def readiness(ref, opts \\ [])
|
|
418
|
|
|
419
|
def readiness(ref, opts) when is_pid(ref) do
|
|
420
|
timeout = Keyword.get(opts, :timeout, @default_call_timeout)
|
|
421
|
GenServer.call(ref, :readiness, timeout)
|
|
422
|
end
|
|
423
|
|
|
424
|
def readiness(ref, opts) do
|
|
425
|
timeout = Keyword.get(opts, :timeout, @default_call_timeout)
|
|
426
|
GenServer.call(via(ref), :readiness, timeout)
|
|
427
|
end
|
|
428
|
|
|
429
|
@doc """
|
|
430
|
Retrieve the health check liveness status.
|
|
431
|
"""
|
|
432
|
@spec readiness(any, any) :: {:error, term()} | {:ok, term()}
|
|
433
|
def liveness(ref, opts \\ [])
|
|
434
|
|
|
435
|
def liveness(ref, opts) when is_pid(ref) do
|
|
436
|
timeout = Keyword.get(opts, :timeout, @default_call_timeout)
|
|
437
|
GenServer.call(ref, :liveness, timeout)
|
|
438
|
end
|
|
439
|
|
|
440
|
def liveness(ref, opts) do
|
|
441
|
timeout = Keyword.get(opts, :timeout, @default_call_timeout)
|
|
442
|
GenServer.call(via(ref), :liveness, timeout)
|
|
443
|
end
|
|
444
|
|
|
363
445
|
@doc """
|
|
364
446
|
Synchronously invokes an Action on an Actor.
|
|
365
447
|
"""
|
changed
lib/actors/actor/entity/lifecycle.ex
|
|
@@ -117,7 117,9 @@ defmodule Actors.Actor.Entity.Lifecycle do
|
|
117
117
|
|
|
118
118
|
{:not_found, %{}, _current_revision} ->
|
|
119
119
|
Logger.debug("Not found state on statestore for Actor #{inspect(actor.id)}.")
|
|
120
|
- {:noreply, updated_state(state, state.actor.state, revision), {:continue, :call_init_action}}
|
|
120
|
|
|
121
|
{:noreply, updated_state(state, state.actor.state, revision),
|
|
122
|
{:continue, :call_init_action}}
|
|
121
123
|
|
|
122
124
|
error ->
|
|
123
125
|
handle_load_state_error(actor.name, state, error)
|
changed
lib/actors/actors.ex
|
|
@@ -40,6 40,40 @@ defmodule Actors do
|
|
40
40
|
@spec get_state(ActorId.t()) :: {:ok, term()} | {:error, term()}
|
|
41
41
|
defdelegate get_state(id), to: CallerProducer
|
|
42
42
|
|
|
43
|
@doc """
|
|
44
|
Performs a readiness check for a given actor.
|
|
45
|
|
|
46
|
## Parameters
|
|
47
|
|
|
48
|
- `actor_id` (ActorId.t()): The ID of the actor.
|
|
49
|
- `opts` (any): Additional options.
|
|
50
|
|
|
51
|
## Returns
|
|
52
|
|
|
53
|
- `{:ok, response}`: If the response is successfully.
|
|
54
|
- `{:error, reason}`: If an error occurs during the operation.
|
|
55
|
|
|
56
|
"""
|
|
57
|
@spec readiness(ActorId.t()) :: {:ok, term()} | {:error, term()}
|
|
58
|
defdelegate readiness(id), to: CallerProducer
|
|
59
|
|
|
60
|
@doc """
|
|
61
|
Performs a liveness check for a given actor.
|
|
62
|
|
|
63
|
## Parameters
|
|
64
|
|
|
65
|
- `actor_id` (ActorId.t()): The ID of the actor.
|
|
66
|
- `opts` (any): Additional options.
|
|
67
|
|
|
68
|
## Returns
|
|
69
|
|
|
70
|
- `{:ok, response}`: If the response is successfully.
|
|
71
|
- `{:error, reason}`: If an error occurs during the operation.
|
|
72
|
|
|
73
|
"""
|
|
74
|
@spec liveness(ActorId.t()) :: {:ok, term()} | {:error, term()}
|
|
75
|
defdelegate liveness(id), to: CallerProducer
|
|
76
|
|
|
43
77
|
@doc """
|
|
44
78
|
Spawn actors defined in HostActor.
|
changed
lib/actors/config/persistent_term_config.ex
|
|
@@ -26,6 26,15 @@ if Code.ensure_loaded?(:persistent_term) do
|
|
26
26
|
{:delayed_invokes, "true"},
|
|
27
27
|
{:deployment_mode, "sidecar"},
|
|
28
28
|
{:http_port, "9001"},
|
|
29
|
{:http_num_acceptors, "150"},
|
|
30
|
{:grpc_port, "9980"},
|
|
31
|
{:grpc_server_enabled, "true"},
|
|
32
|
{:grpc_reflection_enabled, "true"},
|
|
33
|
{:grpc_http_transcoding_enabled, "true"},
|
|
34
|
# default values are evaluated at runtime.
|
|
35
|
{:grpc_compiled_modules_path, :runtime},
|
|
36
|
{:grpc_actors_protos_path, :runtime},
|
|
37
|
{:grpc_include_protos_path, :runtime},
|
|
29
38
|
{:internal_nats_hosts, "nats://127.0.0.1:4222"},
|
|
30
39
|
{:internal_nats_tls, "false"},
|
|
31
40
|
{:internal_nats_auth, "false"},
|
|
|
@@ -49,6 58,7 @@ if Code.ensure_loaded?(:persistent_term) do
|
|
49
58
|
{:proxy_http_client_adapter_pool_schedulers, "0"},
|
|
50
59
|
{:proxy_http_client_adapter_pool_size, "30"},
|
|
51
60
|
{:proxy_http_client_adapter_pool_max_idle_timeout, "1000"},
|
|
61
|
{:proxy_proto_descriptor_path, "/app/protos/user-function.desc"},
|
|
52
62
|
{:proxy_cluster_strategy, "gossip"},
|
|
53
63
|
{:proxy_headless_service, "proxy-headless"},
|
|
54
64
|
{:proxy_cluster_polling_interval, "3000"},
|
|
|
@@ -221,6 231,83 @@ if Code.ensure_loaded?(:persistent_term) do
|
|
221
231
|
value
|
|
222
232
|
end
|
|
223
233
|
|
|
234
|
defp load_env({:grpc_port, default}) do
|
|
235
|
value =
|
|
236
|
env("PROXY_GRPC_PORT", default)
|
|
237
|
|> String.to_integer()
|
|
238
|
|
|
239
|
:persistent_term.put({__MODULE__, :grpc_port}, value)
|
|
240
|
|
|
241
|
value
|
|
242
|
end
|
|
243
|
|
|
244
|
defp load_env({:grpc_server_enabled, default}) do
|
|
245
|
value =
|
|
246
|
env("PROXY_GRPC_SERVER_ENABLED", default)
|
|
247
|
|> to_bool()
|
|
248
|
|
|
249
|
:persistent_term.put({__MODULE__, :grpc_server_enabled}, value)
|
|
250
|
|
|
251
|
value
|
|
252
|
end
|
|
253
|
|
|
254
|
defp load_env({:grpc_reflection_enabled, default}) do
|
|
255
|
value =
|
|
256
|
env("PROXY_GRPC_REFLECTION_ENABLED", default)
|
|
257
|
|> to_bool()
|
|
258
|
|
|
259
|
:persistent_term.put({__MODULE__, :grpc_reflection_enabled}, value)
|
|
260
|
|
|
261
|
value
|
|
262
|
end
|
|
263
|
|
|
264
|
defp load_env({:grpc_http_transcoding_enabled, default}) do
|
|
265
|
value =
|
|
266
|
env("PROXY_GRPC_HTTP_TRANSCODING_ENABLED", default)
|
|
267
|
|> to_bool()
|
|
268
|
|
|
269
|
:persistent_term.put({__MODULE__, :grpc_http_transcoding_enabled}, value)
|
|
270
|
|
|
271
|
value
|
|
272
|
end
|
|
273
|
|
|
274
|
defp load_env({:grpc_actors_protos_path, :runtime}) do
|
|
275
|
default_value = "#{File.cwd!()}/priv/protos/actors"
|
|
276
|
|
|
277
|
value = env("PROXY_GRPC_ACTORS_PROTOS_PATH", default_value)
|
|
278
|
:persistent_term.put({__MODULE__, :grpc_actors_protos_path}, value)
|
|
279
|
|
|
280
|
value
|
|
281
|
end
|
|
282
|
|
|
283
|
defp load_env({:grpc_include_protos_path, :runtime}) do
|
|
284
|
default_value = "#{File.cwd!()}/priv/protos"
|
|
285
|
|
|
286
|
value = env("PROXY_GRPC_INCLUDE_PROTOS_PATH", default_value)
|
|
287
|
:persistent_term.put({__MODULE__, :grpc_include_protos_path}, value)
|
|
288
|
|
|
289
|
value
|
|
290
|
end
|
|
291
|
|
|
292
|
defp load_env({:grpc_compiled_modules_path, :runtime}) do
|
|
293
|
default_value = "#{File.cwd!()}/priv/protos/modules"
|
|
294
|
|
|
295
|
value = env("PROXY_GRPC_COMPILED_MODULES_PATH", default_value)
|
|
296
|
:persistent_term.put({__MODULE__, :grpc_compiled_modules_path}, value)
|
|
297
|
|
|
298
|
value
|
|
299
|
end
|
|
300
|
|
|
301
|
defp load_env({:http_num_acceptors, default}) do
|
|
302
|
value =
|
|
303
|
env("PROXY_HTTP_NUM_ACCEPTORS", default)
|
|
304
|
|> String.to_integer()
|
|
305
|
|
|
306
|
:persistent_term.put({__MODULE__, :http_num_acceptors}, value)
|
|
307
|
|
|
308
|
value
|
|
309
|
end
|
|
310
|
|
|
224
311
|
defp load_env({:internal_nats_hosts, default}) do
|
|
225
312
|
value = env("SPAWN_INTERNAL_NATS_HOSTS", default)
|
|
226
313
|
:persistent_term.put({__MODULE__, :internal_nats_hosts}, value)
|
|
|
@@ -414,6 501,14 @@ if Code.ensure_loaded?(:persistent_term) do
|
|
414
501
|
value
|
|
415
502
|
end
|
|
416
503
|
|
|
504
|
defp load_env({:proxy_proto_descriptor_path, default}) do
|
|
505
|
value = env("PROXY_PROTO_DESCRIPTOR_PATH", default)
|
|
506
|
|
|
507
|
:persistent_term.put({__MODULE__, :proxy_proto_descriptor_path}, value)
|
|
508
|
|
|
509
|
value
|
|
510
|
end
|
|
511
|
|
|
417
512
|
defp load_env({:proxy_cluster_strategy, default}) do
|
|
418
513
|
value = env("PROXY_CLUSTER_STRATEGY", default)
|
|
419
514
|
:persistent_term.put({__MODULE__, :proxy_cluster_strategy}, value)
|
changed
lib/actors/security/tls/initializer.ex
|
|
@@ -7,7 7,7 @@ defmodule Actors.Security.Tls.Initializer do
|
|
7
7
|
- args:
|
|
8
8
|
- eval
|
|
9
9
|
- Kompost.Webhooks.bootstrap_tls(:prod, "tls-certs")
|
|
10
|
- image: docker.io/eigr/spawn-proxy:1.3.3
|
|
10
|
image: docker.io/eigr/spawn-proxy:1.4.0
|
|
11
11
|
name: init-certificates
|
|
12
12
|
serviceAccountName: kompost
|
|
13
13
|
volumes:
|
added
lib/sidecar/grpc/code_generator.ex
|
|
@@ -0,0 1,181 @@
|
|
1
|
defmodule Sidecar.GRPC.CodeGenerator do
|
|
2
|
@moduledoc """
|
|
3
|
Module for generating gRPC code from Protobuf files.
|
|
4
|
|
|
5
|
This module provides functionality to compile Protobuf files and generate gRPC-related code.
|
|
6
|
It supports both gRPC and HTTP transcoding code generation.
|
|
7
|
|
|
8
|
## Usage
|
|
9
|
|
|
10
|
1. Call `compile_protos/1` to generate gRPC code from Protobuf files.
|
|
11
|
2. Ensure that Protobuf files are placed in the specified directory (`priv/protos` by default).
|
|
12
|
|
|
13
|
"""
|
|
14
|
require Logger
|
|
15
|
|
|
16
|
alias Actors.Config.PersistentTermConfig, as: Config
|
|
17
|
alias Mix.Tasks.Protobuf.Generate
|
|
18
|
|
|
19
|
@doc """
|
|
20
|
Compiles Protobuf files and generates gRPC-related code.
|
|
21
|
|
|
22
|
### Options:
|
|
23
|
|
|
24
|
- `:protos_path` - Include path of protobufs to generate (default: "priv/protos").
|
|
25
|
- `:output_path` - Output path for generated code (default: "priv/protos/modules").
|
|
26
|
- `:http_transcoding_enabled` - Enable HTTP transcoding (default: true).
|
|
27
|
|
|
28
|
### Example:
|
|
29
|
|
|
30
|
```elixir
|
|
31
|
Sidecar.Grpc.CodeGenerator.compile_protos(output_path: "custom_output", http_transcoding_enabled: false)
|
|
32
|
|
|
33
|
"""
|
|
34
|
def compile_protos(opts \\ []) do
|
|
35
|
Logger.debug("Compiling ActorHost Protocol Buffers...")
|
|
36
|
|
|
37
|
actors_path = Keyword.get(opts, :protos_path, Config.get(:grpc_actors_protos_path))
|
|
38
|
include_path = Keyword.get(opts, :protos_path, Config.get(:grpc_include_protos_path))
|
|
39
|
output_path = Keyword.get(opts, :output_path, Config.get(:grpc_compiled_modules_path))
|
|
40
|
|
|
41
|
transcoding_enabled? =
|
|
42
|
Keyword.get(opts, :http_transcoding_enabled, Config.get(:grpc_http_transcoding_enabled))
|
|
43
|
|
|
44
|
{grpc_generator_plugin, handler_generator_plugin} =
|
|
45
|
if transcoding_enabled? do
|
|
46
|
{ProtobufGenerate.Plugins.GRPCWithOptions,
|
|
47
|
Sidecar.GRPC.Generators.HandlerTranscodingGenerator}
|
|
48
|
else
|
|
49
|
{ProtobufGenerate.Plugins.GRPC, Sidecar.GRPC.Generators.HandlerGenerator}
|
|
50
|
end
|
|
51
|
|
|
52
|
user_defined_proto_files_list = list_files_with_full_path_by_extensions(actors_path, ".proto")
|
|
53
|
|
|
54
|
Logger.info(
|
|
55
|
"Found #{length(user_defined_proto_files_list)} ActorHost Protocol Buffers to compile... (#{inspect(user_defined_proto_files_list)})"
|
|
56
|
)
|
|
57
|
|
|
58
|
if length(user_defined_proto_files_list) > 0 do
|
|
59
|
protoc_options =
|
|
60
|
[
|
|
61
|
"--include-path=#{include_path}",
|
|
62
|
"--include-path=#{File.cwd!()}/priv/protos/google/protobuf",
|
|
63
|
"--include-path=#{File.cwd!()}/priv/protos/google/api",
|
|
64
|
"--generate-descriptors=true",
|
|
65
|
"--output-path=#{output_path}",
|
|
66
|
"--plugins=#{grpc_generator_plugin}",
|
|
67
|
"--plugins=#{handler_generator_plugin}",
|
|
68
|
"--plugins=Sidecar.GRPC.Generators.ServiceGenerator",
|
|
69
|
"--plugins=Sidecar.Grpc.Generators.ReflectionServerGenerator"
|
|
70
|
]
|
|
71
|
user_defined_proto_files_list
|
|
72
|
|
|
73
|
_ = Generate.run(protoc_options)
|
|
74
|
|
|
75
|
:ok
|
|
76
|
else
|
|
77
|
{:ok, :nothing_to_compile}
|
|
78
|
end
|
|
79
|
end
|
|
80
|
|
|
81
|
@doc """
|
|
82
|
Loads Elixir modules from the specified directory with a '.pb.ex' file extension.
|
|
83
|
|
|
84
|
## Parameters
|
|
85
|
|
|
86
|
- `opts` (KeywordList): Options for loading modules.
|
|
87
|
- `:output_path` (String): Path to the directory containing the modules. Default is "#{File.cwd!()}/priv/protos/modules".
|
|
88
|
|
|
89
|
## Returns
|
|
90
|
|
|
91
|
A list of strings, where each string represents the content of an Elixir module file.
|
|
92
|
|
|
93
|
## Examples
|
|
94
|
|
|
95
|
```elixir
|
|
96
|
opts = [output_path: "/path/to/modules"]
|
|
97
|
modules = load_modules(opts)
|
|
98
|
IO.inspect(modules)
|
|
99
|
|
|
100
|
This example loads Elixir modules from the specified directory "/path/to/modules" and prints the content of each module.
|
|
101
|
|
|
102
|
"""
|
|
103
|
def load_modules(opts \\ []) do
|
|
104
|
path = Keyword.get(opts, :output_path, Config.get(:grpc_compiled_modules_path))
|
|
105
|
|
|
106
|
user_defined_modules_files = list_files_with_full_path_by_extensions(path, ".pb.ex")
|
|
107
|
|
|
108
|
modules = Enum.map(user_defined_modules_files, fn full_path -> File.read!(full_path) end)
|
|
109
|
|
|
110
|
Logger.info("Found #{length(modules)} ActorHost Contract Modules to compile...")
|
|
111
|
|
|
112
|
{:ok, modules}
|
|
113
|
end
|
|
114
|
|
|
115
|
@doc """
|
|
116
|
Compiles an Elixir module generated from Protobuf files and returns the compiled code.
|
|
117
|
|
|
118
|
### Parameters:
|
|
119
|
|
|
120
|
- `module` - The String of Elixir module code generated from Protobuf files.
|
|
121
|
|
|
122
|
### Returns:
|
|
123
|
|
|
124
|
The compiled Elixir code.
|
|
125
|
|
|
126
|
### Example:
|
|
127
|
|
|
128
|
```elixir
|
|
129
|
module_code = Sidecar.Grpc.CodeGenerator.compile_modules(generated_code)
|
|
130
|
|
|
131
|
Raises:
|
|
132
|
|
|
133
|
Raises an error if there are issues during the compilation process.
|
|
134
|
|
|
135
|
"""
|
|
136
|
def compile_modules(modules) when is_list(modules) do
|
|
137
|
Logger.debug("Compiling ActorHost contract modules...")
|
|
138
|
Enum.each(modules, &compile_modules/1)
|
|
139
|
end
|
|
140
|
|
|
141
|
def compile_modules(module), do: do_compile(module)
|
|
142
|
|
|
143
|
defp do_compile(module) do
|
|
144
|
Code.compile_string(module)
|
|
145
|
rescue
|
|
146
|
error in UndefinedFunctionError ->
|
|
147
|
Logger.error("Error in Module definition. Make sure the service name is correct")
|
|
148
|
raise error
|
|
149
|
|
|
150
|
error ->
|
|
151
|
Logger.error("Error during Service compilation phase #{inspect(error)}")
|
|
152
|
end
|
|
153
|
|
|
154
|
defp list_files_with_full_path_by_extensions(directory, extension) do
|
|
155
|
case ls_r(directory) do
|
|
156
|
[] ->
|
|
157
|
Logger.warning("Not found any protos on #{inspect(directory)}")
|
|
158
|
[]
|
|
159
|
|
|
160
|
files ->
|
|
161
|
files
|
|
162
|
|> Enum.filter(&String.ends_with?(&1, extension))
|
|
163
|
end
|
|
164
|
end
|
|
165
|
|
|
166
|
def ls_r(path \\ ".") do
|
|
167
|
cond do
|
|
168
|
File.regular?(path) ->
|
|
169
|
[path]
|
|
170
|
|
|
171
|
File.dir?(path) ->
|
|
172
|
File.ls!(path)
|
|
173
|
|> Enum.map(&Path.join(path, &1))
|
|
174
|
|> Enum.map(&ls_r/1)
|
|
175
|
|> Enum.concat()
|
|
176
|
|
|
177
|
true ->
|
|
178
|
[]
|
|
179
|
end
|
|
180
|
end
|
|
181
|
end
|
added
lib/sidecar/grpc/dispatcher.ex
|
|
@@ -0,0 1,378 @@
|
|
1
|
defmodule Sidecar.GRPC.Dispatcher do
|
|
2
|
@moduledoc """
|
|
3
|
Module for dispatching gRPC messages to Actors.
|
|
4
|
|
|
5
|
This module handles the dispatching of gRPC messages to Actors based on the provided parameters.
|
|
6
|
It logs relevant information and raises an error if the service descriptor is not found.
|
|
7
|
"""
|
|
8
|
require Logger
|
|
9
|
|
|
10
|
alias Actors.Actor.CallerProducer
|
|
11
|
alias Actors.Registry.ActorRegistry
|
|
12
|
alias Actors.Registry.HostActor
|
|
13
|
|
|
14
|
alias Eigr.Functions.Protocol.ActorInvocationResponse
|
|
15
|
alias Eigr.Functions.Protocol.Actors.Actor
|
|
16
|
alias Eigr.Functions.Protocol.Actors.ActorId
|
|
17
|
alias Eigr.Functions.Protocol.Actors.ActorSettings
|
|
18
|
alias Eigr.Functions.Protocol.Actors.ActorSystem
|
|
19
|
alias Eigr.Functions.Protocol.InvocationRequest
|
|
20
|
|
|
21
|
alias GRPC.Server
|
|
22
|
alias GRPC.Server.Stream, as: GRPCStream
|
|
23
|
|
|
24
|
import Spawn.Utils.AnySerializer, only: [any_pack!: 1, unpack_unknown: 1]
|
|
25
|
|
|
26
|
@doc """
|
|
27
|
Dispatches a gRPC message to the specified actor.
|
|
28
|
|
|
29
|
### Parameters:
|
|
30
|
|
|
31
|
- `request` - A map containing the following parameters:
|
|
32
|
- `system: system_name` - The name of the actor system.
|
|
33
|
- `actor_name: actor_name` - The name of the actor.
|
|
34
|
- `action_name: action_name` - The name of action to call.
|
|
35
|
- `input: message` - The input message.
|
|
36
|
- `stream: stream` - The stream (optional).
|
|
37
|
- `descriptor: descriptor` - The service descriptor.
|
|
38
|
|
|
39
|
### Example:
|
|
40
|
|
|
41
|
```elixir
|
|
42
|
request = %{
|
|
43
|
system: "spawn-system",
|
|
44
|
actor_name: "GreeterActor",
|
|
45
|
action_name: "SayHello",
|
|
46
|
input: %{data: "some_data"},
|
|
47
|
stream: %GRPC.Server.Stream{},
|
|
48
|
descriptor: %Google.Protobuf.FileDescriptorProto{
|
|
49
|
name: "helloworld.proto",
|
|
50
|
package: "helloworld"},
|
|
51
|
service: [
|
|
52
|
%Google.Protobuf.ServiceDescriptorProto{
|
|
53
|
name: "GreeterActor",
|
|
54
|
method: [
|
|
55
|
%Google.Protobuf.MethodDescriptorProto{
|
|
56
|
name: "SayHello",
|
|
57
|
input_type: ".helloworld.HelloRequest",
|
|
58
|
output_type: ".helloworld.HelloReply",
|
|
59
|
}
|
|
60
|
]
|
|
61
|
}
|
|
62
|
]
|
|
63
|
}
|
|
64
|
}
|
|
65
|
|
|
66
|
Sidecar.GRPC.Dispatcher.dispatch(request)
|
|
67
|
"""
|
|
68
|
def dispatch(%{system: system_name, actor_name: actor_name, descriptor: nil} = _request) do
|
|
69
|
handle_error(
|
|
70
|
"Service descriptor not found. Impossible to call Actor #{system_name}:#{actor_name}",
|
|
71
|
GRPC.Status.failed_precondition()
|
|
72
|
)
|
|
73
|
end
|
|
74
|
|
|
75
|
def dispatch(
|
|
76
|
%{
|
|
77
|
system: system_name,
|
|
78
|
actor_name: actor_name,
|
|
79
|
action_name: action_name,
|
|
80
|
input: message,
|
|
81
|
stream: %GRPCStream{grpc_type: grpc_type} = stream,
|
|
82
|
descriptor: _descriptor
|
|
83
|
} = _request
|
|
84
|
) do
|
|
85
|
Logger.info(
|
|
86
|
"Dispatching gRPC message to Actor #{system_name}:#{actor_name}. with grpc_type: #{grpc_type}"
|
|
87
|
)
|
|
88
|
|
|
89
|
handle_dispatch(system_name, actor_name, action_name, message, stream, grpc_type)
|
|
90
|
end
|
|
91
|
|
|
92
|
defp handle_dispatch(system_name, actor_name, action_name, message, stream, :client_stream),
|
|
93
|
do: handle_client_stream(system_name, actor_name, action_name, message, stream)
|
|
94
|
|
|
95
|
defp handle_dispatch(system_name, actor_name, action_name, message, stream, :server_stream),
|
|
96
|
do: handle_server_stream(system_name, actor_name, action_name, message, stream)
|
|
97
|
|
|
98
|
defp handle_dispatch(
|
|
99
|
system_name,
|
|
100
|
actor_name,
|
|
101
|
action_name,
|
|
102
|
message,
|
|
103
|
stream,
|
|
104
|
:bidirectional_stream
|
|
105
|
),
|
|
106
|
do: handle_bidirectional_stream(system_name, actor_name, action_name, message, stream)
|
|
107
|
|
|
108
|
defp handle_dispatch(system_name, actor_name, action_name, message, stream, :unary),
|
|
109
|
do: handle_unary(system_name, actor_name, action_name, message, stream)
|
|
110
|
|
|
111
|
defp handle_client_stream(system_name, actor_name, action_name, message, stream) do
|
|
112
|
Stream.each(message, fn msg ->
|
|
113
|
dispatch_async(system_name, actor_name, action_name, msg, stream)
|
|
114
|
end)
|
|
115
|
|> Stream.run()
|
|
116
|
end
|
|
117
|
|
|
118
|
defp handle_server_stream(system_name, actor_name, action_name, message, stream) do
|
|
119
|
dispatch_async(system_name, actor_name, action_name, message, stream)
|
|
120
|
end
|
|
121
|
|
|
122
|
defp handle_bidirectional_stream(system_name, actor_name, action_name, message, stream) do
|
|
123
|
Stream.each(message, fn msg ->
|
|
124
|
dispatch_sync(system_name, actor_name, action_name, msg, stream)
|
|
125
|
end)
|
|
126
|
|> Stream.run()
|
|
127
|
end
|
|
128
|
|
|
129
|
defp handle_unary(system_name, actor_name, action_name, message, stream) do
|
|
130
|
dispatch_sync(system_name, actor_name, action_name, message, stream)
|
|
131
|
end
|
|
132
|
|
|
133
|
defp dispatch_sync(system_name, actor_name, "Readiness", message, stream) do
|
|
134
|
with {:actor_id, actor_id} <- {:actor_id, build_actor_id(system_name, actor_name, message)},
|
|
135
|
{:response, {:ok, response}} <- {:response, invoke_readiness(actor_id)} do
|
|
136
|
server_send_reply(stream, response)
|
|
137
|
else
|
|
138
|
{:actor_id, {:not_found, _}} ->
|
|
139
|
log_and_raise_error(
|
|
140
|
:warning,
|
|
141
|
"Actor Not Found. The Actor probably does not exist or not implemented or the request params are incorrect!",
|
|
142
|
GRPC.Status.not_found()
|
|
143
|
)
|
|
144
|
|
|
145
|
{:actor_id, error} ->
|
|
146
|
log_and_raise_error(
|
|
147
|
:error,
|
|
148
|
"Failed to build actor ID for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
149
|
GRPC.Status.unknown()
|
|
150
|
)
|
|
151
|
|
|
152
|
{:response, error} ->
|
|
153
|
log_and_raise_error(
|
|
154
|
:error,
|
|
155
|
"Failed to invoke request for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
156
|
GRPC.Status.unknown()
|
|
157
|
)
|
|
158
|
end
|
|
159
|
end
|
|
160
|
|
|
161
|
defp dispatch_sync(system_name, actor_name, "Liveness", message, stream) do
|
|
162
|
with {:actor_id, actor_id} <- {:actor_id, build_actor_id(system_name, actor_name, message)},
|
|
163
|
{:response, {:ok, response}} <- {:response, invoke_liveness(actor_id)} do
|
|
164
|
server_send_reply(stream, response)
|
|
165
|
else
|
|
166
|
{:actor_id, {:not_found, _}} ->
|
|
167
|
log_and_raise_error(
|
|
168
|
:warning,
|
|
169
|
"Actor Not Found. The Actor probably does not exist or not implemented or the request params are incorrect!",
|
|
170
|
GRPC.Status.not_found()
|
|
171
|
)
|
|
172
|
|
|
173
|
{:actor_id, error} ->
|
|
174
|
log_and_raise_error(
|
|
175
|
:error,
|
|
176
|
"Failed to build actor ID for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
177
|
GRPC.Status.unknown()
|
|
178
|
)
|
|
179
|
|
|
180
|
{:response, error} ->
|
|
181
|
log_and_raise_error(
|
|
182
|
:error,
|
|
183
|
"Failed to invoke request for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
184
|
GRPC.Status.unknown()
|
|
185
|
)
|
|
186
|
end
|
|
187
|
end
|
|
188
|
|
|
189
|
defp dispatch_sync(system_name, actor_name, action_name, message, stream) do
|
|
190
|
with {:actor_id, actor_id} <- {:actor_id, build_actor_id(system_name, actor_name, message)},
|
|
191
|
{:request, {:ok, request}} <-
|
|
192
|
{:request, build_request(actor_id, system_name, action_name, message, async: false)},
|
|
193
|
{:response, {:ok, response}} <- {:response, invoke_request(request)} do
|
|
194
|
server_send_reply(stream, response)
|
|
195
|
else
|
|
196
|
{:actor_id, {:not_found, _}} ->
|
|
197
|
log_and_raise_error(
|
|
198
|
:warning,
|
|
199
|
"Actor Not Found. The Actor probably does not exist or not implemented or the request params are incorrect!",
|
|
200
|
GRPC.Status.not_found()
|
|
201
|
)
|
|
202
|
|
|
203
|
{:actor_id, error} ->
|
|
204
|
log_and_raise_error(
|
|
205
|
:error,
|
|
206
|
"Failed to build actor ID for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
207
|
GRPC.Status.unknown()
|
|
208
|
)
|
|
209
|
|
|
210
|
{:request, error} ->
|
|
211
|
log_and_raise_error(
|
|
212
|
:error,
|
|
213
|
"Failed to build request for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
214
|
GRPC.Status.failed_precondition()
|
|
215
|
)
|
|
216
|
|
|
217
|
{:response, error} ->
|
|
218
|
log_and_raise_error(
|
|
219
|
:error,
|
|
220
|
"Failed to invoke request for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
221
|
GRPC.Status.unknown()
|
|
222
|
)
|
|
223
|
end
|
|
224
|
end
|
|
225
|
|
|
226
|
defp dispatch_async(system_name, actor_name, action_name, message, stream) do
|
|
227
|
with {:actor_id, actor_id} <- {:actor_id, build_actor_id(system_name, actor_name, message)},
|
|
228
|
{:request, {:ok, request}} <-
|
|
229
|
{:request, build_request(actor_id, system_name, action_name, message, async: true)},
|
|
230
|
{:response, {:ok, :async}} <- {:response, invoke_request(request)} do
|
|
231
|
server_send_reply(stream, %{})
|
|
232
|
else
|
|
233
|
{:actor_id, {:not_found, _}} ->
|
|
234
|
log_and_raise_error(
|
|
235
|
:warning,
|
|
236
|
"Actor Not Found. The Actor probably does not exist or not implemented or the request params are incorrect!",
|
|
237
|
GRPC.Status.not_found()
|
|
238
|
)
|
|
239
|
|
|
240
|
{:actor_id, error} ->
|
|
241
|
log_and_raise_error(
|
|
242
|
:error,
|
|
243
|
"Failed to build actor ID for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
244
|
GRPC.Status.unknown()
|
|
245
|
)
|
|
246
|
|
|
247
|
{:request, error} ->
|
|
248
|
log_and_raise_error(
|
|
249
|
:error,
|
|
250
|
"Failed to build request for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
251
|
GRPC.Status.unknown()
|
|
252
|
)
|
|
253
|
|
|
254
|
{:response, error} ->
|
|
255
|
log_and_raise_error(
|
|
256
|
:error,
|
|
257
|
"Failed to invoke request for Actor #{system_name}:#{actor_name}. Details: #{inspect(error)}",
|
|
258
|
GRPC.Status.unknown()
|
|
259
|
)
|
|
260
|
end
|
|
261
|
end
|
|
262
|
|
|
263
|
defp server_send_reply(stream, response) do
|
|
264
|
if stream.grpc_type == :unary do
|
|
265
|
response
|
|
266
|
else
|
|
267
|
Server.send_reply(stream, response)
|
|
268
|
end
|
|
269
|
end
|
|
270
|
|
|
271
|
defp build_actor_id(system_name, actor_name, message) do
|
|
272
|
with {:ok, %HostActor{actor: �tor{settings: �torSettings{} = actor_settings}}} <-
|
|
273
|
ActorRegistry.lookup(�torId{system: system_name, name: actor_name}) do
|
|
274
|
build_actor_id_from_settings(system_name, actor_name, actor_settings, message)
|
|
275
|
else
|
|
276
|
{:not_found, _} ->
|
|
277
|
log_and_raise_error(
|
|
278
|
:warning,
|
|
279
|
"Actor Not Found. The Actor probably does not exist or not implemented or the request params are incorrect!",
|
|
280
|
GRPC.Status.not_found()
|
|
281
|
)
|
|
282
|
end
|
|
283
|
end
|
|
284
|
|
|
285
|
defp build_actor_id_from_settings(
|
|
286
|
system_name,
|
|
287
|
actor_name,
|
|
288
|
�torSettings{kind: :NAMED} = _settings,
|
|
289
|
_message
|
|
290
|
) do
|
|
291
|
�torId{system: system_name, name: actor_name}
|
|
292
|
end
|
|
293
|
|
|
294
|
defp build_actor_id_from_settings(
|
|
295
|
system_name,
|
|
296
|
actor_name,
|
|
297
|
�torSettings{kind: :UNNAMED} = _settings,
|
|
298
|
message
|
|
299
|
) do
|
|
300
|
{ctype, name} = find_actor_name_and_ctype(message)
|
|
301
|
actor_id_name = get_actor_id_name(ctype, message, name)
|
|
302
|
�torId{system: system_name, name: actor_id_name, parent: actor_name}
|
|
303
|
end
|
|
304
|
|
|
305
|
defp build_actor_id_from_settings(_, _, _, _), do: nil
|
|
306
|
|
|
307
|
defp find_actor_name_and_ctype(message) do
|
|
308
|
Enum.find_value(message.descriptor().field, fn %Google.Protobuf.FieldDescriptorProto{
|
|
309
|
name: name,
|
|
310
|
options: %Google.Protobuf.FieldOptions{
|
|
311
|
ctype: ctype,
|
|
312
|
__pb_extensions__: ext
|
|
313
|
}
|
|
314
|
} ->
|
|
315
|
Map.get(ext, {Eigr.Functions.Protocol.Actors.PbExtension, :actor_id}, false) &&
|
|
316
|
{ctype, name}
|
|
317
|
end)
|
|
318
|
end
|
|
319
|
|
|
320
|
defp get_actor_id_name(:STRING, message, attribute), do: Map.get(message, attribute)
|
|
321
|
|
|
322
|
defp get_actor_id_name(_ctype, message, attribute),
|
|
323
|
do: "#{inspect(Map.get(message, attribute))}"
|
|
324
|
|
|
325
|
defp build_request(nil, _, _, _, _), do: {:error, nil}
|
|
326
|
|
|
327
|
defp build_request(actor_id, actor_system, action_name, message, opts) do
|
|
328
|
async = Keyword.get(opts, :async, false)
|
|
329
|
|
|
330
|
{:ok,
|
|
331
|
%InvocationRequest{
|
|
332
|
async: async,
|
|
333
|
system: �torSystem{name: actor_system},
|
|
334
|
actor: �tor{id: actor_id},
|
|
335
|
action_name: action_name,
|
|
336
|
payload: {:value, any_pack!(message)}
|
|
337
|
}}
|
|
338
|
end
|
|
339
|
|
|
340
|
defp invoke_readiness(nil), do: {:error, :invalid_payload}
|
|
341
|
|
|
342
|
defp invoke_readiness(request), do: CallerProducer.readiness(request)
|
|
343
|
|
|
344
|
defp invoke_liveness(nil), do: {:error, :invalid_payload}
|
|
345
|
|
|
346
|
defp invoke_liveness(request), do: CallerProducer.liveness(request)
|
|
347
|
|
|
348
|
defp invoke_request(nil), do: {:error, :invalid_payload}
|
|
349
|
|
|
350
|
defp invoke_request(request) do
|
|
351
|
case CallerProducer.invoke(request) do
|
|
352
|
{:ok, �torInvocationResponse{payload: {:value, %Google.Protobuf.Any{} = response}}} ->
|
|
353
|
{:ok, unpack_unknown(response)}
|
|
354
|
|
|
355
|
{:ok, �torInvocationResponse{payload: %Google.Protobuf.Any{} = response}} ->
|
|
356
|
{:ok, unpack_unknown(response)}
|
|
357
|
|
|
358
|
{:ok, �torInvocationResponse{payload: {:noop, %Eigr.Functions.Protocol.Noop{}}}} ->
|
|
359
|
{:ok, %Google.Protobuf.Empty{}}
|
|
360
|
|
|
361
|
:async ->
|
|
362
|
{:ok, %Google.Protobuf.Empty{}}
|
|
363
|
|
|
364
|
error ->
|
|
365
|
Logger.warning("Error during parse response. Details: #{inspect(error)}")
|
|
366
|
{:error, error}
|
|
367
|
end
|
|
368
|
end
|
|
369
|
|
|
370
|
defp log_and_raise_error(level, message, status) do
|
|
371
|
Logger.log(level, message)
|
|
372
|
raise GRPC.RPCError, status: status, message: message
|
|
373
|
end
|
|
374
|
|
|
375
|
defp handle_error(message, status) do
|
|
376
|
log_and_raise_error(:error, message, status)
|
|
377
|
end
|
|
378
|
end
|
added
lib/sidecar/grpc/generators/handler_generator.ex
|
|
@@ -0,0 1,87 @@
|
|
1
|
defmodule Sidecar.GRPC.Generators.HandlerGenerator do
|
|
2
|
@moduledoc """
|
|
3
|
Module for generating an actor dispatcher with transcoding capabilities for gRPC methods.
|
|
4
|
|
|
5
|
This module implements the `ProtobufGenerate.Plugin` behaviour to generate an actor dispatcher
|
|
6
|
with transcoding capabilities for each gRPC method defined in the Protobuf service.
|
|
7
|
|
|
8
|
"""
|
|
9
|
@behaviour ProtobufGenerate.Plugin
|
|
10
|
|
|
11
|
alias Actors.Config.PersistentTermConfig, as: Config
|
|
12
|
alias Protobuf.Protoc.Generator.Util
|
|
13
|
|
|
14
|
@impl true
|
|
15
|
def template do
|
|
16
|
"""
|
|
17
|
defmodule <%= @module %>.ActorDispatcher do
|
|
18
|
@moduledoc since: "1.2.1"
|
|
19
|
use GRPC.Server, service: <%= @service_name %>
|
|
20
|
|
|
21
|
alias Sidecar.GRPC.Dispatcher
|
|
22
|
|
|
23
|
<%= for {method_name, input, output} <- @methods do %>
|
|
24
|
@spec <%= Macro.underscore(method_name) %>(<%= input %>.t(), GRPC.Server.Stream.t()) :: <%= output %>.t()
|
|
25
|
def <%= method_name %>(message, stream) do
|
|
26
|
request = %{
|
|
27
|
system: <%= inspect(@actor_system) %>,
|
|
28
|
actor_name: <%= inspect(@actor_name) %>,
|
|
29
|
action_name: <%= inspect(method_name) %>,
|
|
30
|
input: message,
|
|
31
|
stream: stream
|
|
32
|
}
|
|
33
|
|
|
34
|
Dispatcher.dispatch(request)
|
|
35
|
end
|
|
36
|
<% end %>
|
|
37
|
|
|
38
|
end
|
|
39
|
"""
|
|
40
|
end
|
|
41
|
|
|
42
|
@impl true
|
|
43
|
def generate(ctx, %Google.Protobuf.FileDescriptorProto{service: svcs} = _desc) do
|
|
44
|
for svc <- svcs do
|
|
45
|
mod_name = Util.mod_name(ctx, [Macro.camelize(svc.name)])
|
|
46
|
actor_name = Macro.camelize(svc.name)
|
|
47
|
actor_system = Config.get(:actor_system_name)
|
|
48
|
|
|
49
|
methods =
|
|
50
|
for m <- svc.method do
|
|
51
|
input = service_arg(Util.type_from_type_name(ctx, m.input_type), m.client_streaming)
|
|
52
|
output = service_arg(Util.type_from_type_name(ctx, m.output_type), m.server_streaming)
|
|
53
|
|
|
54
|
options =
|
|
55
|
m.options
|
|
56
|
|> opts()
|
|
57
|
|> inspect(limit: :infinity)
|
|
58
|
|
|
59
|
{m.name, input, output, options}
|
|
60
|
end
|
|
61
|
|
|
62
|
{mod_name,
|
|
63
|
[
|
|
64
|
module: mod_name,
|
|
65
|
actor_system: actor_system,
|
|
66
|
actor_name: actor_name,
|
|
67
|
service_name: mod_name,
|
|
68
|
methods: methods,
|
|
69
|
version: Util.version()
|
|
70
|
]}
|
|
71
|
end
|
|
72
|
end
|
|
73
|
|
|
74
|
defp service_arg(type, _streaming? = true), do: "stream(#{type})"
|
|
75
|
defp service_arg(type, _streaming?), do: type
|
|
76
|
|
|
77
|
defp opts(%Google.Protobuf.MethodOptions{__pb_extensions__: extensions})
|
|
78
|
when extensions == %{} do
|
|
79
|
%{}
|
|
80
|
end
|
|
81
|
|
|
82
|
defp opts(%Google.Protobuf.MethodOptions{__pb_extensions__: extensions}) do
|
|
83
|
for {{type, field}, value} <- extensions, into: %{} do
|
|
84
|
{field, %{type: type, value: value}}
|
|
85
|
end
|
|
86
|
end
|
|
87
|
end
|
added
lib/sidecar/grpc/generators/handler_transcoding_generator.ex
|
|
@@ -0,0 1,88 @@
|
|
1
|
defmodule Sidecar.GRPC.Generators.HandlerTranscodingGenerator do
|
|
2
|
@moduledoc """
|
|
3
|
Module for generating an actor dispatcher with transcoding capabilities for gRPC methods.
|
|
4
|
|
|
5
|
This module implements the `ProtobufGenerate.Plugin` behaviour to generate an actor dispatcher
|
|
6
|
with transcoding capabilities for each gRPC method defined in the Protobuf service.
|
|
7
|
|
|
8
|
"""
|
|
9
|
@behaviour ProtobufGenerate.Plugin
|
|
10
|
|
|
11
|
alias Actors.Config.PersistentTermConfig, as: Config
|
|
12
|
alias Protobuf.Protoc.Generator.Util
|
|
13
|
|
|
14
|
@impl true
|
|
15
|
def template do
|
|
16
|
"""
|
|
17
|
defmodule <%= @module %>.ActorDispatcher do
|
|
18
|
@moduledoc since: "1.2.1"
|
|
19
|
use GRPC.Server, service: <%= @service_name %>.Service, http_transcode: true
|
|
20
|
|
|
21
|
alias Sidecar.GRPC.Dispatcher
|
|
22
|
|
|
23
|
<%= for {method_name, input, output, _options} <- @methods do %>
|
|
24
|
@spec <%= Macro.underscore(method_name) %>(<%= input %>.t(), GRPC.Server.Stream.t()) :: <%= output %>.t()
|
|
25
|
def <%= Macro.underscore(method_name) %>(message, stream) do
|
|
26
|
request = %{
|
|
27
|
system: <%= inspect(@actor_system) %>,
|
|
28
|
actor_name: <%= inspect(@actor_name) %>,
|
|
29
|
action_name: <%= inspect(method_name) %>,
|
|
30
|
input: message,
|
|
31
|
stream: stream,
|
|
32
|
descriptor: <%= @service_name %>.Service.descriptor()
|
|
33
|
}
|
|
34
|
|
|
35
|
Dispatcher.dispatch(request)
|
|
36
|
end
|
|
37
|
<% end %>
|
|
38
|
|
|
39
|
end
|
|
40
|
"""
|
|
41
|
end
|
|
42
|
|
|
43
|
@impl true
|
|
44
|
def generate(ctx, %Google.Protobuf.FileDescriptorProto{service: svcs} = _desc) do
|
|
45
|
for svc <- svcs do
|
|
46
|
mod_name = Util.mod_name(ctx, [Macro.camelize(svc.name)])
|
|
47
|
actor_name = Macro.camelize(svc.name)
|
|
48
|
actor_system = Config.get(:actor_system_name)
|
|
49
|
|
|
50
|
methods =
|
|
51
|
for m <- svc.method do
|
|
52
|
input = service_arg(Util.type_from_type_name(ctx, m.input_type), m.client_streaming)
|
|
53
|
output = service_arg(Util.type_from_type_name(ctx, m.output_type), m.server_streaming)
|
|
54
|
|
|
55
|
options =
|
|
56
|
m.options
|
|
57
|
|> opts()
|
|
58
|
|> inspect(limit: :infinity)
|
|
59
|
|
|
60
|
{m.name, input, output, options}
|
|
61
|
end
|
|
62
|
|
|
63
|
{mod_name,
|
|
64
|
[
|
|
65
|
module: mod_name,
|
|
66
|
actor_system: actor_system,
|
|
67
|
actor_name: actor_name,
|
|
68
|
service_name: mod_name,
|
|
69
|
methods: methods,
|
|
70
|
version: Util.version()
|
|
71
|
]}
|
|
72
|
end
|
|
73
|
end
|
|
74
|
|
|
75
|
defp service_arg(type, _streaming? = true), do: "stream(#{type})"
|
|
76
|
defp service_arg(type, _streaming?), do: type
|
|
77
|
|
|
78
|
defp opts(%Google.Protobuf.MethodOptions{__pb_extensions__: extensions})
|
|
79
|
when extensions == %{} do
|
|
80
|
%{}
|
|
81
|
end
|
|
82
|
|
|
83
|
defp opts(%Google.Protobuf.MethodOptions{__pb_extensions__: extensions}) do
|
|
84
|
for {{type, field}, value} <- extensions, into: %{} do
|
|
85
|
{field, %{type: type, value: value}}
|
|
86
|
end
|
|
87
|
end
|
|
88
|
end
|
added
lib/sidecar/grpc/generators/reflection_server_generator.ex
|
|
@@ -0,0 1,54 @@
|
|
1
|
defmodule Sidecar.Grpc.Generators.ReflectionServerGenerator do
|
|
2
|
@moduledoc """
|
|
3
|
Module for generating a gRPC reflection server module.
|
|
4
|
|
|
5
|
This module implements the `ProtobufGenerate.Plugin` behaviour to generate a gRPC reflection server
|
|
6
|
module that includes specified gRPC services for reflection purposes.
|
|
7
|
|
|
8
|
"""
|
|
9
|
@behaviour ProtobufGenerate.Plugin
|
|
10
|
|
|
11
|
alias Protobuf.Protoc.Generator.Util
|
|
12
|
|
|
13
|
@impl true
|
|
14
|
def template do
|
|
15
|
"""
|
|
16
|
defmodule Sidecar.GRPC.Reflection.Server do
|
|
17
|
@moduledoc since: "1.2.1"
|
|
18
|
|
|
19
|
defmodule V1 do
|
|
20
|
use GrpcReflection.Server, version: :v1, services: [
|
|
21
|
<%= for service_name <- @services do %>
|
|
22
|
<%= service_name %>.Service,
|
|
23
|
<% end %>
|
|
24
|
]
|
|
25
|
end
|
|
26
|
|
|
27
|
defmodule V1Alpha do
|
|
28
|
use GrpcReflection.Server, version: :v1alpha, services: [
|
|
29
|
<%= for service_name <- @services do %>
|
|
30
|
<%= service_name %>.Service,
|
|
31
|
<% end %>
|
|
32
|
]
|
|
33
|
end
|
|
34
|
end
|
|
35
|
"""
|
|
36
|
end
|
|
37
|
|
|
38
|
@impl true
|
|
39
|
def generate(ctx, %Google.Protobuf.FileDescriptorProto{service: svcs} = _desc) do
|
|
40
|
current_services = :persistent_term.get(:grpc_reflection_services, [])
|
|
41
|
|
|
42
|
services =
|
|
43
|
svcs
|
|
44
|
|> Enum.map(fn svc -> Util.mod_name(ctx, [Macro.camelize(svc.name)]) end)
|
|
45
|
|> Kernel. (current_services)
|
|
46
|
|
|
47
|
:persistent_term.put(:grpc_reflection_services, services)
|
|
48
|
|
|
49
|
{List.first(services),
|
|
50
|
[
|
|
51
|
services: services
|
|
52
|
]}
|
|
53
|
end
|
|
54
|
end
|
added
lib/sidecar/grpc/generators/service_generator.ex
|
|
@@ -0,0 1,57 @@
|
|
1
|
defmodule Sidecar.GRPC.Generators.ServiceGenerator do
|
|
2
|
@moduledoc """
|
|
3
|
Module for generating a gRPC proxy endpoint module.
|
|
4
|
|
|
5
|
This module implements the `ProtobufGenerate.Plugin` behaviour to generate a gRPC proxy endpoint
|
|
6
|
module that includes specified gRPC services.
|
|
7
|
|
|
8
|
"""
|
|
9
|
@behaviour ProtobufGenerate.Plugin
|
|
10
|
|
|
11
|
alias Protobuf.Protoc.Generator.Util
|
|
12
|
require Logger
|
|
13
|
|
|
14
|
@impl true
|
|
15
|
def template do
|
|
16
|
"""
|
|
17
|
defmodule Sidecar.GRPC.ProxyEndpoint do
|
|
18
|
@moduledoc false
|
|
19
|
use GRPC.Endpoint
|
|
20
|
|
|
21
|
intercept(GRPC.Server.Interceptors.Logger)
|
|
22
|
|
|
23
|
services = [
|
|
24
|
<%= for service_name <- @services do %>
|
|
25
|
<%= service_name %>.ActorDispatcher,
|
|
26
|
<% end %>
|
|
27
|
]
|
|
28
|
|
|
29
|
services =
|
|
30
|
[
|
|
31
|
Sidecar.GRPC.Reflection.Server.V1,
|
|
32
|
Sidecar.GRPC.Reflection.Server.V1Alpha,
|
|
33
|
Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckActor.ActorDispatcher
|
|
34
|
] services
|
|
35
|
|
|
36
|
run(services)
|
|
37
|
end
|
|
38
|
"""
|
|
39
|
end
|
|
40
|
|
|
41
|
@impl true
|
|
42
|
def generate(ctx, %Google.Protobuf.FileDescriptorProto{service: svcs} = _desc) do
|
|
43
|
current_services = :persistent_term.get(:grpc_services, [])
|
|
44
|
|
|
45
|
services =
|
|
46
|
svcs
|
|
47
|
|> Enum.map(fn svc -> Util.mod_name(ctx, [Macro.camelize(svc.name)]) end)
|
|
48
|
|> Kernel. (current_services)
|
|
49
|
|
|
50
|
:persistent_term.put(:grpc_services, services)
|
|
51
|
|
|
52
|
{List.first(services),
|
|
53
|
[
|
|
54
|
services: services
|
|
55
|
]}
|
|
56
|
end
|
|
57
|
end
|
added
lib/sidecar/grpc/healthcheck/healthcheck_handler_actordispatcher.ex
|
|
@@ -0,0 1,40 @@
|
|
1
|
defmodule Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckActor.ActorDispatcher do
|
|
2
|
@moduledoc since: "1.2.1"
|
|
3
|
use GRPC.Server,
|
|
4
|
service: Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckActor.Service,
|
|
5
|
http_transcode: true
|
|
6
|
|
|
7
|
alias Actors.Config.PersistentTermConfig, as: Config
|
|
8
|
|
|
9
|
alias Sidecar.GRPC.Dispatcher
|
|
10
|
|
|
11
|
@spec liveness(Google.Protobuf.Empty.t(), GRPC.Server.Stream.t()) ::
|
|
12
|
Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckReply.t()
|
|
13
|
def liveness(message, stream) do
|
|
14
|
request = %{
|
|
15
|
system: "#{Config.get(:actor_system_name)}-internal",
|
|
16
|
actor_name: "HealthCheckActor",
|
|
17
|
action_name: "Liveness",
|
|
18
|
input: message,
|
|
19
|
stream: stream,
|
|
20
|
descriptor: Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckActor.Service.descriptor()
|
|
21
|
}
|
|
22
|
|
|
23
|
Dispatcher.dispatch(request)
|
|
24
|
end
|
|
25
|
|
|
26
|
@spec readiness(Google.Protobuf.Empty.t(), GRPC.Server.Stream.t()) ::
|
|
27
|
Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckReply.t()
|
|
28
|
def readiness(message, stream) do
|
|
29
|
request = %{
|
|
30
|
system: "#{Config.get(:actor_system_name)}-internal",
|
|
31
|
actor_name: "HealthCheckActor",
|
|
32
|
action_name: "Readiness",
|
|
33
|
input: message,
|
|
34
|
stream: stream,
|
|
35
|
descriptor: Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckActor.Service.descriptor()
|
|
36
|
}
|
|
37
|
|
|
38
|
Dispatcher.dispatch(request)
|
|
39
|
end
|
|
40
|
end
|
added
lib/sidecar/grpc/supervisor.ex
|
|
@@ -0,0 1,73 @@
|
|
1
|
defmodule Sidecar.GRPC.Supervisor do
|
|
2
|
@moduledoc false
|
|
3
|
use Supervisor
|
|
4
|
require Logger
|
|
5
|
|
|
6
|
alias Actors.Config.PersistentTermConfig, as: Config
|
|
7
|
alias Sidecar.GRPC.CodeGenerator, as: Generator
|
|
8
|
|
|
9
|
def init(opts) do
|
|
10
|
Logger.debug("Parser and compiling Protocol Buffers...")
|
|
11
|
|
|
12
|
children =
|
|
13
|
with {:compiling_protos, :ok} <-
|
|
14
|
{:compiling_protos, Generator.compile_protos()},
|
|
15
|
{:load_modules, {:ok, modules}} <- {:load_modules, Generator.load_modules(opts)},
|
|
16
|
{:compiling_modules, :ok} <- {:compiling_modules, Generator.compile_modules(modules)} do
|
|
17
|
[]
|
|
18
|
|> maybe_start_reflection(Config.get(:grpc_reflection_enabled))
|
|
19
|
|> maybe_start_grpc_server(Config.get(:grpc_server_enabled))
|
|
20
|
else
|
|
21
|
{:compiling_protos, {:ok, :nothing_to_compile}} ->
|
|
22
|
[]
|
|
23
|
|
|
24
|
{:compiling_protos, error} ->
|
|
25
|
raise ArgumentError,
|
|
26
|
"Failed during compilation of ActorHost Protobufs files. Details: #{inspect(error)}"
|
|
27
|
|
|
28
|
{:load_modules, error} ->
|
|
29
|
raise ArgumentError,
|
|
30
|
"Failed on load of ActorHost Protobufs modules. Details: #{inspect(error)}"
|
|
31
|
|
|
32
|
{:compiling_modules, error} ->
|
|
33
|
raise ArgumentError,
|
|
34
|
"Failed during compilation of ActorHost protobufs modules. Details: #{inspect(error)}"
|
|
35
|
|
|
36
|
error ->
|
|
37
|
raise ArgumentError,
|
|
38
|
"Failed to load ActorHost Protobufs modules. Details: #{inspect(error)}"
|
|
39
|
end
|
|
40
|
|
|
41
|
Supervisor.init(children, strategy: :one_for_one)
|
|
42
|
end
|
|
43
|
|
|
44
|
defp maybe_start_reflection(children, false), do: children
|
|
45
|
|
|
46
|
defp maybe_start_reflection(children, true) do
|
|
47
|
Logger.info("Starting gRPC Reflection...")
|
|
48
|
(children [{GrpcReflection, []}]) |> List.flatten()
|
|
49
|
end
|
|
50
|
|
|
51
|
defp maybe_start_grpc_server(children, false), do: children
|
|
52
|
|
|
53
|
defp maybe_start_grpc_server(children, true) do
|
|
54
|
port = Config.get(:grpc_port)
|
|
55
|
Logger.debug("Starting gRPC Server on port #{inspect(port)}...")
|
|
56
|
|
|
57
|
(children
|
|
58
|
[
|
|
59
|
{GRPC.Server.Supervisor,
|
|
60
|
endpoint: Sidecar.GRPC.ProxyEndpoint, port: port, start_server: true}
|
|
61
|
])
|
|
62
|
|> List.flatten()
|
|
63
|
end
|
|
64
|
|
|
65
|
def start_link(opts) do
|
|
66
|
Supervisor.start_link(
|
|
67
|
__MODULE__,
|
|
68
|
opts,
|
|
69
|
name: __MODULE__,
|
|
70
|
strategy: :one_for_one
|
|
71
|
)
|
|
72
|
end
|
|
73
|
end
|
changed
lib/sidecar/process_supervisor.ex
|
|
@@ -3,6 3,20 @@ defmodule Sidecar.ProcessSupervisor do
|
|
3
3
|
use Supervisor
|
|
4
4
|
require Logger
|
|
5
5
|
|
|
6
|
alias Actors.Config.PersistentTermConfig, as: Config
|
|
7
|
|
|
8
|
alias Eigr.Functions.Protocol.Actors.Actor
|
|
9
|
alias Eigr.Functions.Protocol.Actors.ActorId
|
|
10
|
alias Eigr.Functions.Protocol.Actors.ActorDeactivationStrategy
|
|
11
|
alias Eigr.Functions.Protocol.Actors.ActorSettings
|
|
12
|
alias Eigr.Functions.Protocol.Actors.ActorSystem
|
|
13
|
alias Eigr.Functions.Protocol.Actors.Metadata
|
|
14
|
alias Eigr.Functions.Protocol.Actors.Registry
|
|
15
|
alias Eigr.Functions.Protocol.Actors.TimeoutStrategy
|
|
16
|
|
|
17
|
alias Eigr.Functions.Protocol.RegistrationRequest
|
|
18
|
alias Eigr.Functions.Protocol.ServiceInfo
|
|
19
|
|
|
6
20
|
import Spawn.Utils.Common, only: [supervisor_process_logger: 1]
|
|
7
21
|
|
|
8
22
|
@impl true
|
|
|
@@ -14,7 28,61 @@ defmodule Sidecar.ProcessSupervisor do
|
|
14
28
|
Spawn.Supervisor.child_spec(opts),
|
|
15
29
|
statestores(),
|
|
16
30
|
Actors.Supervisors.ActorSupervisor.child_spec(opts),
|
|
17
|
- Actors.Supervisors.ProtocolSupervisor.child_spec(opts)
|
|
31
|
Actors.Supervisors.ProtocolSupervisor.child_spec(opts),
|
|
32
|
%{
|
|
33
|
id: :healthcheck_actor_init,
|
|
34
|
start:
|
|
35
|
{Task, :start,
|
|
36
|
[
|
|
37
|
fn ->
|
|
38
|
Process.flag(:trap_exit, true)
|
|
39
|
|
|
40
|
Logger.info("[SUPERVISOR] HealthCheckActor is up")
|
|
41
|
|
|
42
|
registration_internal_system = %RegistrationRequest{
|
|
43
|
service_info: %ServiceInfo{
|
|
44
|
service_name: "",
|
|
45
|
service_version: "",
|
|
46
|
service_runtime: "",
|
|
47
|
support_library_name: "",
|
|
48
|
support_library_version: ""
|
|
49
|
},
|
|
50
|
actor_system: �torSystem{
|
|
51
|
name: "#{Config.get(:actor_system_name)}-internal",
|
|
52
|
registry: %Registry{
|
|
53
|
actors: %{
|
|
54
|
"HealthCheckActor" => �tor{
|
|
55
|
id: �torId{
|
|
56
|
system: "#{Config.get(:actor_system_name)}-internal",
|
|
57
|
name: "HealthCheckActor"
|
|
58
|
},
|
|
59
|
metadata: %Metadata{},
|
|
60
|
settings: �torSettings{
|
|
61
|
kind: :NAMED,
|
|
62
|
stateful: false,
|
|
63
|
deactivation_strategy: �torDeactivationStrategy{
|
|
64
|
strategy: {:timeout, %TimeoutStrategy{timeout: 120_000}}
|
|
65
|
}
|
|
66
|
}
|
|
67
|
}
|
|
68
|
}
|
|
69
|
}
|
|
70
|
}
|
|
71
|
}
|
|
72
|
|
|
73
|
Actors.register(registration_internal_system)
|
|
74
|
|
|
75
|
receive do
|
|
76
|
{:EXIT, _pid, reason} ->
|
|
77
|
Logger.info(
|
|
78
|
"[SUPERVISOR] HealthCheckActor:#{inspect(self())} is successfully down with reason #{inspect(reason)}"
|
|
79
|
)
|
|
80
|
|
|
81
|
:ok
|
|
82
|
end
|
|
83
|
end
|
|
84
|
]}
|
|
85
|
}
|
|
18
86
|
]
|
|
19
87
|
|> Enum.reject(&is_nil/1)
|
changed
lib/sidecar/supervisor.ex
|
|
@@ -17,7 17,8 @@ defmodule Sidecar.Supervisor do
|
|
17
17
|
[
|
|
18
18
|
supervisor_process_logger(__MODULE__),
|
|
19
19
|
{Sidecar.GracefulShutdown, opts},
|
|
20
|
- {Sidecar.ProcessSupervisor, opts}
|
|
20
|
{Sidecar.ProcessSupervisor, opts},
|
|
21
|
{Sidecar.GRPC.Supervisor, opts}
|
|
21
22
|
]
|
|
22
23
|
|> Enum.reject(&is_nil/1)
|
removed
lib/spawn/actors/actor.pb.ex
|
|
@@ -1,1202 0,0 @@
|
|
1
|
- defmodule Eigr.Functions.Protocol.Actors.Kind do
|
|
2
|
- @moduledoc false
|
|
3
|
- use Protobuf, enum: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
4
|
-
|
|
5
|
- def descriptor do
|
|
6
|
- # credo:disable-for-next-line
|
|
7
|
- %Google.Protobuf.EnumDescriptorProto{
|
|
8
|
- name: "Kind",
|
|
9
|
- value: [
|
|
10
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
11
|
- name: "UNKNOW_KIND",
|
|
12
|
- number: 0,
|
|
13
|
- options: nil,
|
|
14
|
- __unknown_fields__: []
|
|
15
|
- },
|
|
16
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
17
|
- name: "NAMED",
|
|
18
|
- number: 1,
|
|
19
|
- options: nil,
|
|
20
|
- __unknown_fields__: []
|
|
21
|
- },
|
|
22
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
23
|
- name: "UNNAMED",
|
|
24
|
- number: 2,
|
|
25
|
- options: nil,
|
|
26
|
- __unknown_fields__: []
|
|
27
|
- },
|
|
28
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
29
|
- name: "POOLED",
|
|
30
|
- number: 3,
|
|
31
|
- options: nil,
|
|
32
|
- __unknown_fields__: []
|
|
33
|
- },
|
|
34
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
35
|
- name: "PROXY",
|
|
36
|
- number: 4,
|
|
37
|
- options: nil,
|
|
38
|
- __unknown_fields__: []
|
|
39
|
- }
|
|
40
|
- ],
|
|
41
|
- options: nil,
|
|
42
|
- reserved_range: [],
|
|
43
|
- reserved_name: [],
|
|
44
|
- __unknown_fields__: []
|
|
45
|
- }
|
|
46
|
- end
|
|
47
|
-
|
|
48
|
- field(:UNKNOW_KIND, 0)
|
|
49
|
- field(:NAMED, 1)
|
|
50
|
- field(:UNNAMED, 2)
|
|
51
|
- field(:POOLED, 3)
|
|
52
|
- field(:PROXY, 4)
|
|
53
|
- end
|
|
54
|
-
|
|
55
|
- defmodule Eigr.Functions.Protocol.Actors.Registry.ActorsEntry do
|
|
56
|
- @moduledoc false
|
|
57
|
- use Protobuf, map: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
58
|
-
|
|
59
|
- def descriptor do
|
|
60
|
- # credo:disable-for-next-line
|
|
61
|
- %Google.Protobuf.DescriptorProto{
|
|
62
|
- name: "ActorsEntry",
|
|
63
|
- field: [
|
|
64
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
65
|
- name: "key",
|
|
66
|
- extendee: nil,
|
|
67
|
- number: 1,
|
|
68
|
- label: :LABEL_OPTIONAL,
|
|
69
|
- type: :TYPE_STRING,
|
|
70
|
- type_name: nil,
|
|
71
|
- default_value: nil,
|
|
72
|
- options: nil,
|
|
73
|
- oneof_index: nil,
|
|
74
|
- json_name: "key",
|
|
75
|
- proto3_optional: nil,
|
|
76
|
- __unknown_fields__: []
|
|
77
|
- },
|
|
78
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
79
|
- name: "value",
|
|
80
|
- extendee: nil,
|
|
81
|
- number: 2,
|
|
82
|
- label: :LABEL_OPTIONAL,
|
|
83
|
- type: :TYPE_MESSAGE,
|
|
84
|
- type_name: ".eigr.functions.protocol.actors.Actor",
|
|
85
|
- default_value: nil,
|
|
86
|
- options: nil,
|
|
87
|
- oneof_index: nil,
|
|
88
|
- json_name: "value",
|
|
89
|
- proto3_optional: nil,
|
|
90
|
- __unknown_fields__: []
|
|
91
|
- }
|
|
92
|
- ],
|
|
93
|
- nested_type: [],
|
|
94
|
- enum_type: [],
|
|
95
|
- extension_range: [],
|
|
96
|
- extension: [],
|
|
97
|
- options: %Google.Protobuf.MessageOptions{
|
|
98
|
- message_set_wire_format: false,
|
|
99
|
- no_standard_descriptor_accessor: false,
|
|
100
|
- deprecated: false,
|
|
101
|
- map_entry: true,
|
|
102
|
- uninterpreted_option: [],
|
|
103
|
- __pb_extensions__: %{},
|
|
104
|
- __unknown_fields__: []
|
|
105
|
- },
|
|
106
|
- oneof_decl: [],
|
|
107
|
- reserved_range: [],
|
|
108
|
- reserved_name: [],
|
|
109
|
- __unknown_fields__: []
|
|
110
|
- }
|
|
111
|
- end
|
|
112
|
-
|
|
113
|
- field(:key, 1, type: :string)
|
|
114
|
- field(:value, 2, type: Eigr.Functions.Protocol.Actors.Actor)
|
|
115
|
- end
|
|
116
|
-
|
|
117
|
- defmodule Eigr.Functions.Protocol.Actors.Registry do
|
|
118
|
- @moduledoc false
|
|
119
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
120
|
-
|
|
121
|
- def descriptor do
|
|
122
|
- # credo:disable-for-next-line
|
|
123
|
- %Google.Protobuf.DescriptorProto{
|
|
124
|
- name: "Registry",
|
|
125
|
- field: [
|
|
126
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
127
|
- name: "actors",
|
|
128
|
- extendee: nil,
|
|
129
|
- number: 1,
|
|
130
|
- label: :LABEL_REPEATED,
|
|
131
|
- type: :TYPE_MESSAGE,
|
|
132
|
- type_name: ".eigr.functions.protocol.actors.Registry.ActorsEntry",
|
|
133
|
- default_value: nil,
|
|
134
|
- options: nil,
|
|
135
|
- oneof_index: nil,
|
|
136
|
- json_name: "actors",
|
|
137
|
- proto3_optional: nil,
|
|
138
|
- __unknown_fields__: []
|
|
139
|
- }
|
|
140
|
- ],
|
|
141
|
- nested_type: [
|
|
142
|
- %Google.Protobuf.DescriptorProto{
|
|
143
|
- name: "ActorsEntry",
|
|
144
|
- field: [
|
|
145
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
146
|
- name: "key",
|
|
147
|
- extendee: nil,
|
|
148
|
- number: 1,
|
|
149
|
- label: :LABEL_OPTIONAL,
|
|
150
|
- type: :TYPE_STRING,
|
|
151
|
- type_name: nil,
|
|
152
|
- default_value: nil,
|
|
153
|
- options: nil,
|
|
154
|
- oneof_index: nil,
|
|
155
|
- json_name: "key",
|
|
156
|
- proto3_optional: nil,
|
|
157
|
- __unknown_fields__: []
|
|
158
|
- },
|
|
159
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
160
|
- name: "value",
|
|
161
|
- extendee: nil,
|
|
162
|
- number: 2,
|
|
163
|
- label: :LABEL_OPTIONAL,
|
|
164
|
- type: :TYPE_MESSAGE,
|
|
165
|
- type_name: ".eigr.functions.protocol.actors.Actor",
|
|
166
|
- default_value: nil,
|
|
167
|
- options: nil,
|
|
168
|
- oneof_index: nil,
|
|
169
|
- json_name: "value",
|
|
170
|
- proto3_optional: nil,
|
|
171
|
- __unknown_fields__: []
|
|
172
|
- }
|
|
173
|
- ],
|
|
174
|
- nested_type: [],
|
|
175
|
- enum_type: [],
|
|
176
|
- extension_range: [],
|
|
177
|
- extension: [],
|
|
178
|
- options: %Google.Protobuf.MessageOptions{
|
|
179
|
- message_set_wire_format: false,
|
|
180
|
- no_standard_descriptor_accessor: false,
|
|
181
|
- deprecated: false,
|
|
182
|
- map_entry: true,
|
|
183
|
- uninterpreted_option: [],
|
|
184
|
- __pb_extensions__: %{},
|
|
185
|
- __unknown_fields__: []
|
|
186
|
- },
|
|
187
|
- oneof_decl: [],
|
|
188
|
- reserved_range: [],
|
|
189
|
- reserved_name: [],
|
|
190
|
- __unknown_fields__: []
|
|
191
|
- }
|
|
192
|
- ],
|
|
193
|
- enum_type: [],
|
|
194
|
- extension_range: [],
|
|
195
|
- extension: [],
|
|
196
|
- options: nil,
|
|
197
|
- oneof_decl: [],
|
|
198
|
- reserved_range: [],
|
|
199
|
- reserved_name: [],
|
|
200
|
- __unknown_fields__: []
|
|
201
|
- }
|
|
202
|
- end
|
|
203
|
-
|
|
204
|
- field(:actors, 1,
|
|
205
|
- repeated: true,
|
|
206
|
- type: Eigr.Functions.Protocol.Actors.Registry.ActorsEntry,
|
|
207
|
- map: true
|
|
208
|
- )
|
|
209
|
- end
|
|
210
|
-
|
|
211
|
- defmodule Eigr.Functions.Protocol.Actors.ActorSystem do
|
|
212
|
- @moduledoc false
|
|
213
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
214
|
-
|
|
215
|
- def descriptor do
|
|
216
|
- # credo:disable-for-next-line
|
|
217
|
- %Google.Protobuf.DescriptorProto{
|
|
218
|
- name: "ActorSystem",
|
|
219
|
- field: [
|
|
220
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
221
|
- name: "name",
|
|
222
|
- extendee: nil,
|
|
223
|
- number: 1,
|
|
224
|
- label: :LABEL_OPTIONAL,
|
|
225
|
- type: :TYPE_STRING,
|
|
226
|
- type_name: nil,
|
|
227
|
- default_value: nil,
|
|
228
|
- options: nil,
|
|
229
|
- oneof_index: nil,
|
|
230
|
- json_name: "name",
|
|
231
|
- proto3_optional: nil,
|
|
232
|
- __unknown_fields__: []
|
|
233
|
- },
|
|
234
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
235
|
- name: "registry",
|
|
236
|
- extendee: nil,
|
|
237
|
- number: 2,
|
|
238
|
- label: :LABEL_OPTIONAL,
|
|
239
|
- type: :TYPE_MESSAGE,
|
|
240
|
- type_name: ".eigr.functions.protocol.actors.Registry",
|
|
241
|
- default_value: nil,
|
|
242
|
- options: nil,
|
|
243
|
- oneof_index: nil,
|
|
244
|
- json_name: "registry",
|
|
245
|
- proto3_optional: nil,
|
|
246
|
- __unknown_fields__: []
|
|
247
|
- }
|
|
248
|
- ],
|
|
249
|
- nested_type: [],
|
|
250
|
- enum_type: [],
|
|
251
|
- extension_range: [],
|
|
252
|
- extension: [],
|
|
253
|
- options: nil,
|
|
254
|
- oneof_decl: [],
|
|
255
|
- reserved_range: [],
|
|
256
|
- reserved_name: [],
|
|
257
|
- __unknown_fields__: []
|
|
258
|
- }
|
|
259
|
- end
|
|
260
|
-
|
|
261
|
- field(:name, 1, type: :string)
|
|
262
|
- field(:registry, 2, type: Eigr.Functions.Protocol.Actors.Registry)
|
|
263
|
- end
|
|
264
|
-
|
|
265
|
- defmodule Eigr.Functions.Protocol.Actors.ActorSnapshotStrategy do
|
|
266
|
- @moduledoc false
|
|
267
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
268
|
-
|
|
269
|
- def descriptor do
|
|
270
|
- # credo:disable-for-next-line
|
|
271
|
- %Google.Protobuf.DescriptorProto{
|
|
272
|
- name: "ActorSnapshotStrategy",
|
|
273
|
- field: [
|
|
274
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
275
|
- name: "timeout",
|
|
276
|
- extendee: nil,
|
|
277
|
- number: 1,
|
|
278
|
- label: :LABEL_OPTIONAL,
|
|
279
|
- type: :TYPE_MESSAGE,
|
|
280
|
- type_name: ".eigr.functions.protocol.actors.TimeoutStrategy",
|
|
281
|
- default_value: nil,
|
|
282
|
- options: nil,
|
|
283
|
- oneof_index: 0,
|
|
284
|
- json_name: "timeout",
|
|
285
|
- proto3_optional: nil,
|
|
286
|
- __unknown_fields__: []
|
|
287
|
- }
|
|
288
|
- ],
|
|
289
|
- nested_type: [],
|
|
290
|
- enum_type: [],
|
|
291
|
- extension_range: [],
|
|
292
|
- extension: [],
|
|
293
|
- options: nil,
|
|
294
|
- oneof_decl: [
|
|
295
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
296
|
- name: "strategy",
|
|
297
|
- options: nil,
|
|
298
|
- __unknown_fields__: []
|
|
299
|
- }
|
|
300
|
- ],
|
|
301
|
- reserved_range: [],
|
|
302
|
- reserved_name: [],
|
|
303
|
- __unknown_fields__: []
|
|
304
|
- }
|
|
305
|
- end
|
|
306
|
-
|
|
307
|
- oneof(:strategy, 0)
|
|
308
|
-
|
|
309
|
- field(:timeout, 1, type: Eigr.Functions.Protocol.Actors.TimeoutStrategy, oneof: 0)
|
|
310
|
- end
|
|
311
|
-
|
|
312
|
- defmodule Eigr.Functions.Protocol.Actors.ActorDeactivationStrategy do
|
|
313
|
- @moduledoc false
|
|
314
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
315
|
-
|
|
316
|
- def descriptor do
|
|
317
|
- # credo:disable-for-next-line
|
|
318
|
- %Google.Protobuf.DescriptorProto{
|
|
319
|
- name: "ActorDeactivationStrategy",
|
|
320
|
- field: [
|
|
321
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
322
|
- name: "timeout",
|
|
323
|
- extendee: nil,
|
|
324
|
- number: 1,
|
|
325
|
- label: :LABEL_OPTIONAL,
|
|
326
|
- type: :TYPE_MESSAGE,
|
|
327
|
- type_name: ".eigr.functions.protocol.actors.TimeoutStrategy",
|
|
328
|
- default_value: nil,
|
|
329
|
- options: nil,
|
|
330
|
- oneof_index: 0,
|
|
331
|
- json_name: "timeout",
|
|
332
|
- proto3_optional: nil,
|
|
333
|
- __unknown_fields__: []
|
|
334
|
- }
|
|
335
|
- ],
|
|
336
|
- nested_type: [],
|
|
337
|
- enum_type: [],
|
|
338
|
- extension_range: [],
|
|
339
|
- extension: [],
|
|
340
|
- options: nil,
|
|
341
|
- oneof_decl: [
|
|
342
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
343
|
- name: "strategy",
|
|
344
|
- options: nil,
|
|
345
|
- __unknown_fields__: []
|
|
346
|
- }
|
|
347
|
- ],
|
|
348
|
- reserved_range: [],
|
|
349
|
- reserved_name: [],
|
|
350
|
- __unknown_fields__: []
|
|
351
|
- }
|
|
352
|
- end
|
|
353
|
-
|
|
354
|
- oneof(:strategy, 0)
|
|
355
|
-
|
|
356
|
- field(:timeout, 1, type: Eigr.Functions.Protocol.Actors.TimeoutStrategy, oneof: 0)
|
|
357
|
- end
|
|
358
|
-
|
|
359
|
- defmodule Eigr.Functions.Protocol.Actors.TimeoutStrategy do
|
|
360
|
- @moduledoc false
|
|
361
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
362
|
-
|
|
363
|
- def descriptor do
|
|
364
|
- # credo:disable-for-next-line
|
|
365
|
- %Google.Protobuf.DescriptorProto{
|
|
366
|
- name: "TimeoutStrategy",
|
|
367
|
- field: [
|
|
368
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
369
|
- name: "timeout",
|
|
370
|
- extendee: nil,
|
|
371
|
- number: 1,
|
|
372
|
- label: :LABEL_OPTIONAL,
|
|
373
|
- type: :TYPE_INT64,
|
|
374
|
- type_name: nil,
|
|
375
|
- default_value: nil,
|
|
376
|
- options: nil,
|
|
377
|
- oneof_index: nil,
|
|
378
|
- json_name: "timeout",
|
|
379
|
- proto3_optional: nil,
|
|
380
|
- __unknown_fields__: []
|
|
381
|
- }
|
|
382
|
- ],
|
|
383
|
- nested_type: [],
|
|
384
|
- enum_type: [],
|
|
385
|
- extension_range: [],
|
|
386
|
- extension: [],
|
|
387
|
- options: nil,
|
|
388
|
- oneof_decl: [],
|
|
389
|
- reserved_range: [],
|
|
390
|
- reserved_name: [],
|
|
391
|
- __unknown_fields__: []
|
|
392
|
- }
|
|
393
|
- end
|
|
394
|
-
|
|
395
|
- field(:timeout, 1, type: :int64)
|
|
396
|
- end
|
|
397
|
-
|
|
398
|
- defmodule Eigr.Functions.Protocol.Actors.Action do
|
|
399
|
- @moduledoc false
|
|
400
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
401
|
-
|
|
402
|
- def descriptor do
|
|
403
|
- # credo:disable-for-next-line
|
|
404
|
- %Google.Protobuf.DescriptorProto{
|
|
405
|
- name: "Action",
|
|
406
|
- field: [
|
|
407
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
408
|
- name: "name",
|
|
409
|
- extendee: nil,
|
|
410
|
- number: 1,
|
|
411
|
- label: :LABEL_OPTIONAL,
|
|
412
|
- type: :TYPE_STRING,
|
|
413
|
- type_name: nil,
|
|
414
|
- default_value: nil,
|
|
415
|
- options: nil,
|
|
416
|
- oneof_index: nil,
|
|
417
|
- json_name: "name",
|
|
418
|
- proto3_optional: nil,
|
|
419
|
- __unknown_fields__: []
|
|
420
|
- }
|
|
421
|
- ],
|
|
422
|
- nested_type: [],
|
|
423
|
- enum_type: [],
|
|
424
|
- extension_range: [],
|
|
425
|
- extension: [],
|
|
426
|
- options: nil,
|
|
427
|
- oneof_decl: [],
|
|
428
|
- reserved_range: [],
|
|
429
|
- reserved_name: [],
|
|
430
|
- __unknown_fields__: []
|
|
431
|
- }
|
|
432
|
- end
|
|
433
|
-
|
|
434
|
- field(:name, 1, type: :string)
|
|
435
|
- end
|
|
436
|
-
|
|
437
|
- defmodule Eigr.Functions.Protocol.Actors.FixedTimerAction do
|
|
438
|
- @moduledoc false
|
|
439
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
440
|
-
|
|
441
|
- def descriptor do
|
|
442
|
- # credo:disable-for-next-line
|
|
443
|
- %Google.Protobuf.DescriptorProto{
|
|
444
|
- name: "FixedTimerAction",
|
|
445
|
- field: [
|
|
446
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
447
|
- name: "seconds",
|
|
448
|
- extendee: nil,
|
|
449
|
- number: 1,
|
|
450
|
- label: :LABEL_OPTIONAL,
|
|
451
|
- type: :TYPE_INT32,
|
|
452
|
- type_name: nil,
|
|
453
|
- default_value: nil,
|
|
454
|
- options: nil,
|
|
455
|
- oneof_index: nil,
|
|
456
|
- json_name: "seconds",
|
|
457
|
- proto3_optional: nil,
|
|
458
|
- __unknown_fields__: []
|
|
459
|
- },
|
|
460
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
461
|
- name: "action",
|
|
462
|
- extendee: nil,
|
|
463
|
- number: 2,
|
|
464
|
- label: :LABEL_OPTIONAL,
|
|
465
|
- type: :TYPE_MESSAGE,
|
|
466
|
- type_name: ".eigr.functions.protocol.actors.Action",
|
|
467
|
- default_value: nil,
|
|
468
|
- options: nil,
|
|
469
|
- oneof_index: nil,
|
|
470
|
- json_name: "action",
|
|
471
|
- proto3_optional: nil,
|
|
472
|
- __unknown_fields__: []
|
|
473
|
- }
|
|
474
|
- ],
|
|
475
|
- nested_type: [],
|
|
476
|
- enum_type: [],
|
|
477
|
- extension_range: [],
|
|
478
|
- extension: [],
|
|
479
|
- options: nil,
|
|
480
|
- oneof_decl: [],
|
|
481
|
- reserved_range: [],
|
|
482
|
- reserved_name: [],
|
|
483
|
- __unknown_fields__: []
|
|
484
|
- }
|
|
485
|
- end
|
|
486
|
-
|
|
487
|
- field(:seconds, 1, type: :int32)
|
|
488
|
- field(:action, 2, type: Eigr.Functions.Protocol.Actors.Action)
|
|
489
|
- end
|
|
490
|
-
|
|
491
|
- defmodule Eigr.Functions.Protocol.Actors.ActorState.TagsEntry do
|
|
492
|
- @moduledoc false
|
|
493
|
- use Protobuf, map: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
494
|
-
|
|
495
|
- def descriptor do
|
|
496
|
- # credo:disable-for-next-line
|
|
497
|
- %Google.Protobuf.DescriptorProto{
|
|
498
|
- name: "TagsEntry",
|
|
499
|
- field: [
|
|
500
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
501
|
- name: "key",
|
|
502
|
- extendee: nil,
|
|
503
|
- number: 1,
|
|
504
|
- label: :LABEL_OPTIONAL,
|
|
505
|
- type: :TYPE_STRING,
|
|
506
|
- type_name: nil,
|
|
507
|
- default_value: nil,
|
|
508
|
- options: nil,
|
|
509
|
- oneof_index: nil,
|
|
510
|
- json_name: "key",
|
|
511
|
- proto3_optional: nil,
|
|
512
|
- __unknown_fields__: []
|
|
513
|
- },
|
|
514
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
515
|
- name: "value",
|
|
516
|
- extendee: nil,
|
|
517
|
- number: 2,
|
|
518
|
- label: :LABEL_OPTIONAL,
|
|
519
|
- type: :TYPE_STRING,
|
|
520
|
- type_name: nil,
|
|
521
|
- default_value: nil,
|
|
522
|
- options: nil,
|
|
523
|
- oneof_index: nil,
|
|
524
|
- json_name: "value",
|
|
525
|
- proto3_optional: nil,
|
|
526
|
- __unknown_fields__: []
|
|
527
|
- }
|
|
528
|
- ],
|
|
529
|
- nested_type: [],
|
|
530
|
- enum_type: [],
|
|
531
|
- extension_range: [],
|
|
532
|
- extension: [],
|
|
533
|
- options: %Google.Protobuf.MessageOptions{
|
|
534
|
- message_set_wire_format: false,
|
|
535
|
- no_standard_descriptor_accessor: false,
|
|
536
|
- deprecated: false,
|
|
537
|
- map_entry: true,
|
|
538
|
- uninterpreted_option: [],
|
|
539
|
- __pb_extensions__: %{},
|
|
540
|
- __unknown_fields__: []
|
|
541
|
- },
|
|
542
|
- oneof_decl: [],
|
|
543
|
- reserved_range: [],
|
|
544
|
- reserved_name: [],
|
|
545
|
- __unknown_fields__: []
|
|
546
|
- }
|
|
547
|
- end
|
|
548
|
-
|
|
549
|
- field(:key, 1, type: :string)
|
|
550
|
- field(:value, 2, type: :string)
|
|
551
|
- end
|
|
552
|
-
|
|
553
|
- defmodule Eigr.Functions.Protocol.Actors.ActorState do
|
|
554
|
- @moduledoc false
|
|
555
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
556
|
-
|
|
557
|
- def descriptor do
|
|
558
|
- # credo:disable-for-next-line
|
|
559
|
- %Google.Protobuf.DescriptorProto{
|
|
560
|
- name: "ActorState",
|
|
561
|
- field: [
|
|
562
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
563
|
- name: "tags",
|
|
564
|
- extendee: nil,
|
|
565
|
- number: 1,
|
|
566
|
- label: :LABEL_REPEATED,
|
|
567
|
- type: :TYPE_MESSAGE,
|
|
568
|
- type_name: ".eigr.functions.protocol.actors.ActorState.TagsEntry",
|
|
569
|
- default_value: nil,
|
|
570
|
- options: nil,
|
|
571
|
- oneof_index: nil,
|
|
572
|
- json_name: "tags",
|
|
573
|
- proto3_optional: nil,
|
|
574
|
- __unknown_fields__: []
|
|
575
|
- },
|
|
576
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
577
|
- name: "state",
|
|
578
|
- extendee: nil,
|
|
579
|
- number: 2,
|
|
580
|
- label: :LABEL_OPTIONAL,
|
|
581
|
- type: :TYPE_MESSAGE,
|
|
582
|
- type_name: ".google.protobuf.Any",
|
|
583
|
- default_value: nil,
|
|
584
|
- options: nil,
|
|
585
|
- oneof_index: nil,
|
|
586
|
- json_name: "state",
|
|
587
|
- proto3_optional: nil,
|
|
588
|
- __unknown_fields__: []
|
|
589
|
- }
|
|
590
|
- ],
|
|
591
|
- nested_type: [
|
|
592
|
- %Google.Protobuf.DescriptorProto{
|
|
593
|
- name: "TagsEntry",
|
|
863
|
- field: [
|
|
595
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
596
|
- name: "key",
|
|
597
|
- extendee: nil,
|
|
598
|
- number: 1,
|
|
599
|
- label: :LABEL_OPTIONAL,
|
|
600
|
- type: :TYPE_STRING,
|
|
601
|
- type_name: nil,
|
|
602
|
- default_value: nil,
|
|
603
|
- options: nil,
|
|
604
|
- oneof_index: nil,
|
|
605
|
- json_name: "key",
|
|
606
|
- proto3_optional: nil,
|
|
607
|
- __unknown_fields__: []
|
|
608
|
- },
|
|
609
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
610
|
- name: "value",
|
|
611
|
- extendee: nil,
|
|
612
|
- number: 2,
|
|
613
|
- label: :LABEL_OPTIONAL,
|
|
614
|
- type: :TYPE_STRING,
|
|
615
|
- type_name: nil,
|
|
616
|
- default_value: nil,
|
|
617
|
- options: nil,
|
|
618
|
- oneof_index: nil,
|
|
619
|
- json_name: "value",
|
|
620
|
- proto3_optional: nil,
|
|
621
|
- __unknown_fields__: []
|
|
622
|
- }
|
|
623
|
- ],
|
|
624
|
- nested_type: [],
|
|
625
|
- enum_type: [],
|
|
626
|
- extension_range: [],
|
|
627
|
- extension: [],
|
|
628
|
- options: %Google.Protobuf.MessageOptions{
|
|
629
|
- message_set_wire_format: false,
|
|
630
|
- no_standard_descriptor_accessor: false,
|
|
631
|
- deprecated: false,
|
|
632
|
- map_entry: true,
|
|
633
|
- uninterpreted_option: [],
|
|
634
|
- __pb_extensions__: %{},
|
|
635
|
- __unknown_fields__: []
|
|
636
|
- },
|
|
637
|
- oneof_decl: [],
|
|
638
|
- reserved_range: [],
|
|
639
|
- reserved_name: [],
|
|
640
|
- __unknown_fields__: []
|
|
641
|
- }
|
|
642
|
- ],
|
|
643
|
- enum_type: [],
|
|
644
|
- extension_range: [],
|
|
645
|
- extension: [],
|
|
646
|
- options: nil,
|
|
647
|
- oneof_decl: [],
|
|
648
|
- reserved_range: [],
|
|
649
|
- reserved_name: [],
|
|
650
|
- __unknown_fields__: []
|
|
651
|
- }
|
|
652
|
- end
|
|
653
|
-
|
|
654
|
- field(:tags, 1,
|
|
655
|
- repeated: true,
|
|
656
|
- type: Eigr.Functions.Protocol.Actors.ActorState.TagsEntry,
|
|
657
|
- map: true
|
|
658
|
- )
|
|
659
|
-
|
|
660
|
- field(:state, 2, type: Google.Protobuf.Any)
|
|
661
|
- end
|
|
662
|
-
|
|
663
|
- defmodule Eigr.Functions.Protocol.Actors.Metadata.TagsEntry do
|
|
664
|
- @moduledoc false
|
|
665
|
- use Protobuf, map: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
666
|
-
|
|
667
|
- def descriptor do
|
|
668
|
- # credo:disable-for-next-line
|
|
669
|
- %Google.Protobuf.DescriptorProto{
|
|
670
|
- name: "TagsEntry",
|
|
671
|
- field: [
|
|
672
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
673
|
- name: "key",
|
|
674
|
- extendee: nil,
|
|
675
|
- number: 1,
|
|
676
|
- label: :LABEL_OPTIONAL,
|
|
677
|
- type: :TYPE_STRING,
|
|
678
|
- type_name: nil,
|
|
679
|
- default_value: nil,
|
|
680
|
- options: nil,
|
|
681
|
- oneof_index: nil,
|
|
682
|
- json_name: "key",
|
|
683
|
- proto3_optional: nil,
|
|
684
|
- __unknown_fields__: []
|
|
685
|
- },
|
|
686
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
687
|
- name: "value",
|
|
688
|
- extendee: nil,
|
|
689
|
- number: 2,
|
|
690
|
- label: :LABEL_OPTIONAL,
|
|
691
|
- type: :TYPE_STRING,
|
|
692
|
- type_name: nil,
|
|
693
|
- default_value: nil,
|
|
694
|
- options: nil,
|
|
695
|
- oneof_index: nil,
|
|
696
|
- json_name: "value",
|
|
697
|
- proto3_optional: nil,
|
|
698
|
- __unknown_fields__: []
|
|
699
|
- }
|
|
700
|
- ],
|
|
701
|
- nested_type: [],
|
|
702
|
- enum_type: [],
|
|
703
|
- extension_range: [],
|
|
704
|
- extension: [],
|
|
705
|
- options: %Google.Protobuf.MessageOptions{
|
|
706
|
- message_set_wire_format: false,
|
|
707
|
- no_standard_descriptor_accessor: false,
|
|
708
|
- deprecated: false,
|
|
709
|
- map_entry: true,
|
|
710
|
- uninterpreted_option: [],
|
|
711
|
- __pb_extensions__: %{},
|
|
712
|
- __unknown_fields__: []
|
|
713
|
- },
|
|
714
|
- oneof_decl: [],
|
|
715
|
- reserved_range: [],
|
|
716
|
- reserved_name: [],
|
|
717
|
- __unknown_fields__: []
|
|
718
|
- }
|
|
719
|
- end
|
|
720
|
-
|
|
721
|
- field(:key, 1, type: :string)
|
|
722
|
- field(:value, 2, type: :string)
|
|
723
|
- end
|
|
724
|
-
|
|
725
|
- defmodule Eigr.Functions.Protocol.Actors.Metadata do
|
|
726
|
- @moduledoc false
|
|
727
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
728
|
-
|
|
729
|
- def descriptor do
|
|
730
|
- # credo:disable-for-next-line
|
|
731
|
- %Google.Protobuf.DescriptorProto{
|
|
732
|
- name: "Metadata",
|
|
733
|
- field: [
|
|
734
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
735
|
- name: "channel_group",
|
|
736
|
- extendee: nil,
|
|
737
|
- number: 1,
|
|
738
|
- label: :LABEL_REPEATED,
|
|
739
|
- type: :TYPE_MESSAGE,
|
|
740
|
- type_name: ".eigr.functions.protocol.actors.Channel",
|
|
741
|
- default_value: nil,
|
|
742
|
- options: nil,
|
|
743
|
- oneof_index: nil,
|
|
744
|
- json_name: "channelGroup",
|
|
745
|
- proto3_optional: nil,
|
|
746
|
- __unknown_fields__: []
|
|
747
|
- },
|
|
748
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
749
|
- name: "tags",
|
|
750
|
- extendee: nil,
|
|
751
|
- number: 2,
|
|
752
|
- label: :LABEL_REPEATED,
|
|
753
|
- type: :TYPE_MESSAGE,
|
|
754
|
- type_name: ".eigr.functions.protocol.actors.Metadata.TagsEntry",
|
|
755
|
- default_value: nil,
|
|
756
|
- options: nil,
|
|
757
|
- oneof_index: nil,
|
|
758
|
- json_name: "tags",
|
|
759
|
- proto3_optional: nil,
|
|
760
|
- __unknown_fields__: []
|
|
761
|
- }
|
|
762
|
- ],
|
|
763
|
- nested_type: [
|
|
764
|
- %Google.Protobuf.DescriptorProto{
|
|
765
|
- name: "TagsEntry",
|
|
766
|
- field: [
|
|
767
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
768
|
- name: "key",
|
|
769
|
- extendee: nil,
|
|
770
|
- number: 1,
|
|
771
|
- label: :LABEL_OPTIONAL,
|
|
772
|
- type: :TYPE_STRING,
|
|
773
|
- type_name: nil,
|
|
774
|
- default_value: nil,
|
|
775
|
- options: nil,
|
|
776
|
- oneof_index: nil,
|
|
777
|
- json_name: "key",
|
|
778
|
- proto3_optional: nil,
|
|
779
|
- __unknown_fields__: []
|
|
780
|
- },
|
|
781
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
782
|
- name: "value",
|
|
783
|
- extendee: nil,
|
|
784
|
- number: 2,
|
|
785
|
- label: :LABEL_OPTIONAL,
|
|
786
|
- type: :TYPE_STRING,
|
|
787
|
- type_name: nil,
|
|
788
|
- default_value: nil,
|
|
789
|
- options: nil,
|
|
790
|
- oneof_index: nil,
|
|
791
|
- json_name: "value",
|
|
792
|
- proto3_optional: nil,
|
|
793
|
- __unknown_fields__: []
|
|
794
|
- }
|
|
795
|
- ],
|
|
796
|
- nested_type: [],
|
|
797
|
- enum_type: [],
|
|
798
|
- extension_range: [],
|
|
799
|
- extension: [],
|
|
800
|
- options: %Google.Protobuf.MessageOptions{
|
|
801
|
- message_set_wire_format: false,
|
|
802
|
- no_standard_descriptor_accessor: false,
|
|
803
|
- deprecated: false,
|
|
804
|
- map_entry: true,
|
|
805
|
- uninterpreted_option: [],
|
|
806
|
- __pb_extensions__: %{},
|
|
807
|
- __unknown_fields__: []
|
|
808
|
- },
|
|
809
|
- oneof_decl: [],
|
|
810
|
- reserved_range: [],
|
|
811
|
- reserved_name: [],
|
|
812
|
- __unknown_fields__: []
|
|
813
|
- }
|
|
814
|
- ],
|
|
815
|
- enum_type: [],
|
|
816
|
- extension_range: [],
|
|
817
|
- extension: [],
|
|
818
|
- options: nil,
|
|
819
|
- oneof_decl: [],
|
|
820
|
- reserved_range: [],
|
|
821
|
- reserved_name: [],
|
|
822
|
- __unknown_fields__: []
|
|
823
|
- }
|
|
824
|
- end
|
|
825
|
-
|
|
826
|
- field(:channel_group, 1,
|
|
827
|
- repeated: true,
|
|
828
|
- type: Eigr.Functions.Protocol.Actors.Channel,
|
|
829
|
- json_name: "channelGroup"
|
|
830
|
- )
|
|
831
|
-
|
|
832
|
- field(:tags, 2,
|
|
833
|
- repeated: true,
|
|
834
|
- type: Eigr.Functions.Protocol.Actors.Metadata.TagsEntry,
|
|
835
|
- map: true
|
|
836
|
- )
|
|
837
|
- end
|
|
838
|
-
|
|
839
|
- defmodule Eigr.Functions.Protocol.Actors.Channel do
|
|
840
|
- @moduledoc false
|
|
841
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
842
|
-
|
|
843
|
- def descriptor do
|
|
844
|
- # credo:disable-for-next-line
|
|
845
|
- %Google.Protobuf.DescriptorProto{
|
|
846
|
- name: "Channel",
|
|
847
|
- field: [
|
|
848
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
849
|
- name: "topic",
|
|
850
|
- extendee: nil,
|
|
851
|
- number: 1,
|
|
852
|
- label: :LABEL_OPTIONAL,
|
|
853
|
- type: :TYPE_STRING,
|
|
854
|
- type_name: nil,
|
|
855
|
- default_value: nil,
|
|
856
|
- options: nil,
|
|
857
|
- oneof_index: nil,
|
|
858
|
- json_name: "topic",
|
|
859
|
- proto3_optional: nil,
|
|
860
|
- __unknown_fields__: []
|
|
861
|
- },
|
|
862
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
863
|
- name: "action",
|
|
864
|
- extendee: nil,
|
|
865
|
- number: 2,
|
|
866
|
- label: :LABEL_OPTIONAL,
|
|
867
|
- type: :TYPE_STRING,
|
|
868
|
- type_name: nil,
|
|
869
|
- default_value: nil,
|
|
870
|
- options: nil,
|
|
871
|
- oneof_index: nil,
|
|
872
|
- json_name: "action",
|
|
873
|
- proto3_optional: nil,
|
|
874
|
- __unknown_fields__: []
|
|
875
|
- }
|
|
876
|
- ],
|
|
877
|
- nested_type: [],
|
|
878
|
- enum_type: [],
|
|
879
|
- extension_range: [],
|
|
880
|
- extension: [],
|
|
881
|
- options: nil,
|
|
882
|
- oneof_decl: [],
|
|
883
|
- reserved_range: [],
|
|
884
|
- reserved_name: [],
|
|
885
|
- __unknown_fields__: []
|
|
886
|
- }
|
|
887
|
- end
|
|
888
|
-
|
|
889
|
- field(:topic, 1, type: :string)
|
|
890
|
- field(:action, 2, type: :string)
|
|
891
|
- end
|
|
892
|
-
|
|
893
|
- defmodule Eigr.Functions.Protocol.Actors.ActorSettings do
|
|
894
|
- @moduledoc false
|
|
895
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
896
|
-
|
|
897
|
- def descriptor do
|
|
898
|
- # credo:disable-for-next-line
|
|
899
|
- %Google.Protobuf.DescriptorProto{
|
|
900
|
- name: "ActorSettings",
|
|
901
|
- field: [
|
|
902
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
903
|
- name: "kind",
|
|
904
|
- extendee: nil,
|
|
905
|
- number: 1,
|
|
906
|
- label: :LABEL_OPTIONAL,
|
|
907
|
- type: :TYPE_ENUM,
|
|
908
|
- type_name: ".eigr.functions.protocol.actors.Kind",
|
|
909
|
- default_value: nil,
|
|
910
|
- options: nil,
|
|
911
|
- oneof_index: nil,
|
|
912
|
- json_name: "kind",
|
|
913
|
- proto3_optional: nil,
|
|
914
|
- __unknown_fields__: []
|
|
915
|
- },
|
|
916
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
917
|
- name: "stateful",
|
|
918
|
- extendee: nil,
|
|
919
|
- number: 2,
|
|
920
|
- label: :LABEL_OPTIONAL,
|
|
921
|
- type: :TYPE_BOOL,
|
|
922
|
- type_name: nil,
|
|
923
|
- default_value: nil,
|
|
924
|
- options: nil,
|
|
925
|
- oneof_index: nil,
|
|
926
|
- json_name: "stateful",
|
|
927
|
- proto3_optional: nil,
|
|
928
|
- __unknown_fields__: []
|
|
929
|
- },
|
|
930
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
931
|
- name: "snapshot_strategy",
|
|
932
|
- extendee: nil,
|
|
933
|
- number: 3,
|
|
934
|
- label: :LABEL_OPTIONAL,
|
|
935
|
- type: :TYPE_MESSAGE,
|
|
936
|
- type_name: ".eigr.functions.protocol.actors.ActorSnapshotStrategy",
|
|
937
|
- default_value: nil,
|
|
938
|
- options: nil,
|
|
939
|
- oneof_index: nil,
|
|
940
|
- json_name: "snapshotStrategy",
|
|
941
|
- proto3_optional: nil,
|
|
942
|
- __unknown_fields__: []
|
|
943
|
- },
|
|
944
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
945
|
- name: "deactivation_strategy",
|
|
946
|
- extendee: nil,
|
|
947
|
- number: 4,
|
|
948
|
- label: :LABEL_OPTIONAL,
|
|
949
|
- type: :TYPE_MESSAGE,
|
|
950
|
- type_name: ".eigr.functions.protocol.actors.ActorDeactivationStrategy",
|
|
951
|
- default_value: nil,
|
|
952
|
- options: nil,
|
|
953
|
- oneof_index: nil,
|
|
954
|
- json_name: "deactivationStrategy",
|
|
955
|
- proto3_optional: nil,
|
|
956
|
- __unknown_fields__: []
|
|
957
|
- },
|
|
958
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
959
|
- name: "min_pool_size",
|
|
960
|
- extendee: nil,
|
|
961
|
- number: 5,
|
|
962
|
- label: :LABEL_OPTIONAL,
|
|
963
|
- type: :TYPE_INT32,
|
|
964
|
- type_name: nil,
|
|
965
|
- default_value: nil,
|
|
966
|
- options: nil,
|
|
967
|
- oneof_index: nil,
|
|
968
|
- json_name: "minPoolSize",
|
|
969
|
- proto3_optional: nil,
|
|
970
|
- __unknown_fields__: []
|
|
971
|
- },
|
|
972
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
973
|
- name: "max_pool_size",
|
|
974
|
- extendee: nil,
|
|
975
|
- number: 6,
|
|
976
|
- label: :LABEL_OPTIONAL,
|
|
977
|
- type: :TYPE_INT32,
|
|
978
|
- type_name: nil,
|
|
979
|
- default_value: nil,
|
|
980
|
- options: nil,
|
|
981
|
- oneof_index: nil,
|
|
982
|
- json_name: "maxPoolSize",
|
|
983
|
- proto3_optional: nil,
|
|
984
|
- __unknown_fields__: []
|
|
985
|
- }
|
|
986
|
- ],
|
|
987
|
- nested_type: [],
|
|
988
|
- enum_type: [],
|
|
989
|
- extension_range: [],
|
|
990
|
- extension: [],
|
|
991
|
- options: nil,
|
|
992
|
- oneof_decl: [],
|
|
993
|
- reserved_range: [],
|
|
994
|
- reserved_name: [],
|
|
995
|
- __unknown_fields__: []
|
|
996
|
- }
|
|
997
|
- end
|
|
998
|
-
|
|
999
|
- field(:kind, 1, type: Eigr.Functions.Protocol.Actors.Kind, enum: true)
|
|
1000
|
- field(:stateful, 2, type: :bool)
|
|
1001
|
-
|
|
1002
|
- field(:snapshot_strategy, 3,
|
|
1003
|
- type: Eigr.Functions.Protocol.Actors.ActorSnapshotStrategy,
|
|
1004
|
- json_name: "snapshotStrategy"
|
|
1005
|
- )
|
|
1006
|
-
|
|
1007
|
- field(:deactivation_strategy, 4,
|
|
1008
|
- type: Eigr.Functions.Protocol.Actors.ActorDeactivationStrategy,
|
|
1009
|
- json_name: "deactivationStrategy"
|
|
1010
|
- )
|
|
1011
|
-
|
|
1012
|
- field(:min_pool_size, 5, type: :int32, json_name: "minPoolSize")
|
|
1013
|
- field(:max_pool_size, 6, type: :int32, json_name: "maxPoolSize")
|
|
1014
|
- end
|
|
1015
|
-
|
|
1016
|
- defmodule Eigr.Functions.Protocol.Actors.ActorId do
|
|
1017
|
- @moduledoc false
|
|
1018
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1019
|
-
|
|
1020
|
- def descriptor do
|
|
1021
|
- # credo:disable-for-next-line
|
|
1022
|
- %Google.Protobuf.DescriptorProto{
|
|
1023
|
- name: "ActorId",
|
|
1024
|
- field: [
|
|
1025
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1026
|
- name: "name",
|
|
1027
|
- extendee: nil,
|
|
1028
|
- number: 1,
|
|
1029
|
- label: :LABEL_OPTIONAL,
|
|
1030
|
- type: :TYPE_STRING,
|
|
1031
|
- type_name: nil,
|
|
1032
|
- default_value: nil,
|
|
1033
|
- options: nil,
|
|
1034
|
- oneof_index: nil,
|
|
1035
|
- json_name: "name",
|
|
1036
|
- proto3_optional: nil,
|
|
1037
|
- __unknown_fields__: []
|
|
1038
|
- },
|
|
1039
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1040
|
- name: "system",
|
|
1041
|
- extendee: nil,
|
|
1042
|
- number: 2,
|
|
1043
|
- label: :LABEL_OPTIONAL,
|
|
1044
|
- type: :TYPE_STRING,
|
|
1045
|
- type_name: nil,
|
|
1046
|
- default_value: nil,
|
|
1047
|
- options: nil,
|
|
1048
|
- oneof_index: nil,
|
|
1049
|
- json_name: "system",
|
|
1050
|
- proto3_optional: nil,
|
|
1051
|
- __unknown_fields__: []
|
|
1052
|
- },
|
|
1053
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1054
|
- name: "parent",
|
|
1055
|
- extendee: nil,
|
|
1056
|
- number: 3,
|
|
1057
|
- label: :LABEL_OPTIONAL,
|
|
1058
|
- type: :TYPE_STRING,
|
|
1059
|
- type_name: nil,
|
|
1060
|
- default_value: nil,
|
|
1061
|
- options: nil,
|
|
1062
|
- oneof_index: nil,
|
|
1063
|
- json_name: "parent",
|
|
1064
|
- proto3_optional: nil,
|
|
1065
|
- __unknown_fields__: []
|
|
1066
|
- }
|
|
1067
|
- ],
|
|
1068
|
- nested_type: [],
|
|
1069
|
- enum_type: [],
|
|
1070
|
- extension_range: [],
|
|
1071
|
- extension: [],
|
|
1072
|
- options: nil,
|
|
1073
|
- oneof_decl: [],
|
|
1074
|
- reserved_range: [],
|
|
1075
|
- reserved_name: [],
|
|
1076
|
- __unknown_fields__: []
|
|
1077
|
- }
|
|
1078
|
- end
|
|
1079
|
-
|
|
1080
|
- field(:name, 1, type: :string)
|
|
1081
|
- field(:system, 2, type: :string)
|
|
1082
|
- field(:parent, 3, type: :string)
|
|
1083
|
- end
|
|
1084
|
-
|
|
1085
|
- defmodule Eigr.Functions.Protocol.Actors.Actor do
|
|
1086
|
- @moduledoc false
|
|
1087
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1088
|
-
|
|
1089
|
- def descriptor do
|
|
1090
|
- # credo:disable-for-next-line
|
|
1091
|
- %Google.Protobuf.DescriptorProto{
|
|
1092
|
- name: "Actor",
|
|
1093
|
- field: [
|
|
1094
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1095
|
- name: "id",
|
|
1096
|
- extendee: nil,
|
|
1097
|
- number: 1,
|
|
1098
|
- label: :LABEL_OPTIONAL,
|
|
1099
|
- type: :TYPE_MESSAGE,
|
|
1100
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1101
|
- default_value: nil,
|
|
1102
|
- options: nil,
|
|
1103
|
- oneof_index: nil,
|
|
1104
|
- json_name: "id",
|
|
1105
|
- proto3_optional: nil,
|
|
1106
|
- __unknown_fields__: []
|
|
1107
|
- },
|
|
1108
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1109
|
- name: "state",
|
|
1110
|
- extendee: nil,
|
|
1111
|
- number: 2,
|
|
1112
|
- label: :LABEL_OPTIONAL,
|
|
1113
|
- type: :TYPE_MESSAGE,
|
|
1114
|
- type_name: ".eigr.functions.protocol.actors.ActorState",
|
|
1115
|
- default_value: nil,
|
|
1116
|
- options: nil,
|
|
1117
|
- oneof_index: nil,
|
|
1118
|
- json_name: "state",
|
|
1119
|
- proto3_optional: nil,
|
|
1120
|
- __unknown_fields__: []
|
|
1121
|
- },
|
|
1122
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1123
|
- name: "metadata",
|
|
1124
|
- extendee: nil,
|
|
1125
|
- number: 6,
|
|
1126
|
- label: :LABEL_OPTIONAL,
|
|
1127
|
- type: :TYPE_MESSAGE,
|
|
1128
|
- type_name: ".eigr.functions.protocol.actors.Metadata",
|
|
1129
|
- default_value: nil,
|
|
1130
|
- options: nil,
|
|
1131
|
- oneof_index: nil,
|
|
1132
|
- json_name: "metadata",
|
|
1133
|
- proto3_optional: nil,
|
|
1134
|
- __unknown_fields__: []
|
|
1135
|
- },
|
|
1136
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1137
|
- name: "settings",
|
|
1138
|
- extendee: nil,
|
|
1139
|
- number: 3,
|
|
1140
|
- label: :LABEL_OPTIONAL,
|
|
1141
|
- type: :TYPE_MESSAGE,
|
|
1142
|
- type_name: ".eigr.functions.protocol.actors.ActorSettings",
|
|
1143
|
- default_value: nil,
|
|
1144
|
- options: nil,
|
|
1145
|
- oneof_index: nil,
|
|
1146
|
- json_name: "settings",
|
|
1147
|
- proto3_optional: nil,
|
|
1148
|
- __unknown_fields__: []
|
|
1149
|
- },
|
|
1150
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1151
|
- name: "actions",
|
|
1152
|
- extendee: nil,
|
|
1153
|
- number: 4,
|
|
1154
|
- label: :LABEL_REPEATED,
|
|
1155
|
- type: :TYPE_MESSAGE,
|
|
1156
|
- type_name: ".eigr.functions.protocol.actors.Action",
|
|
1157
|
- default_value: nil,
|
|
1158
|
- options: nil,
|
|
1159
|
- oneof_index: nil,
|
|
1160
|
- json_name: "actions",
|
|
1161
|
- proto3_optional: nil,
|
|
1162
|
- __unknown_fields__: []
|
|
1163
|
- },
|
|
1164
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1165
|
- name: "timer_actions",
|
|
1166
|
- extendee: nil,
|
|
1167
|
- number: 5,
|
|
1168
|
- label: :LABEL_REPEATED,
|
|
1169
|
- type: :TYPE_MESSAGE,
|
|
1170
|
- type_name: ".eigr.functions.protocol.actors.FixedTimerAction",
|
|
1171
|
- default_value: nil,
|
|
1172
|
- options: nil,
|
|
1173
|
- oneof_index: nil,
|
|
1174
|
- json_name: "timerActions",
|
|
1175
|
- proto3_optional: nil,
|
|
1176
|
- __unknown_fields__: []
|
|
1177
|
- }
|
|
1178
|
- ],
|
|
1179
|
- nested_type: [],
|
|
1180
|
- enum_type: [],
|
|
1181
|
- extension_range: [],
|
|
1182
|
- extension: [],
|
|
1183
|
- options: nil,
|
|
1184
|
- oneof_decl: [],
|
|
1185
|
- reserved_range: [],
|
|
1186
|
- reserved_name: [],
|
|
1187
|
- __unknown_fields__: []
|
|
1188
|
- }
|
|
1189
|
- end
|
|
1190
|
-
|
|
1191
|
- field(:id, 1, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1192
|
- field(:state, 2, type: Eigr.Functions.Protocol.Actors.ActorState)
|
|
1193
|
- field(:metadata, 6, type: Eigr.Functions.Protocol.Actors.Metadata)
|
|
1194
|
- field(:settings, 3, type: Eigr.Functions.Protocol.Actors.ActorSettings)
|
|
1195
|
- field(:actions, 4, repeated: true, type: Eigr.Functions.Protocol.Actors.Action)
|
|
1196
|
-
|
|
1197
|
- field(:timer_actions, 5,
|
|
1198
|
- repeated: true,
|
|
1199
|
- type: Eigr.Functions.Protocol.Actors.FixedTimerAction,
|
|
1200
|
- json_name: "timerActions"
|
|
1201
|
- )
|
|
1202
|
- end
|
added
lib/spawn/actors/eigr/functions/protocol/actors/actor.pb.ex
|
|
@@ -0,0 1,1214 @@
|
|
1
|
defmodule Eigr.Functions.Protocol.Actors.Kind do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.EnumDescriptorProto{
|
|
8
|
name: "Kind",
|
|
9
|
value: [
|
|
10
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
11
|
name: "UNKNOW_KIND",
|
|
12
|
number: 0,
|
|
13
|
options: nil,
|
|
14
|
__unknown_fields__: []
|
|
15
|
},
|
|
16
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
17
|
name: "NAMED",
|
|
18
|
number: 1,
|
|
19
|
options: nil,
|
|
20
|
__unknown_fields__: []
|
|
21
|
},
|
|
22
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
23
|
name: "UNNAMED",
|
|
24
|
number: 2,
|
|
25
|
options: nil,
|
|
26
|
__unknown_fields__: []
|
|
27
|
},
|
|
28
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
29
|
name: "POOLED",
|
|
30
|
number: 3,
|
|
31
|
options: nil,
|
|
32
|
__unknown_fields__: []
|
|
33
|
},
|
|
34
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
35
|
name: "PROXY",
|
|
36
|
number: 4,
|
|
37
|
options: nil,
|
|
38
|
__unknown_fields__: []
|
|
39
|
}
|
|
40
|
],
|
|
41
|
options: nil,
|
|
42
|
reserved_range: [],
|
|
43
|
reserved_name: [],
|
|
44
|
__unknown_fields__: []
|
|
45
|
}
|
|
46
|
end
|
|
47
|
|
|
48
|
field(:UNKNOW_KIND, 0)
|
|
49
|
field(:NAMED, 1)
|
|
50
|
field(:UNNAMED, 2)
|
|
51
|
field(:POOLED, 3)
|
|
52
|
field(:PROXY, 4)
|
|
53
|
end
|
|
54
|
|
|
55
|
defmodule Eigr.Functions.Protocol.Actors.Registry.ActorsEntry do
|
|
56
|
@moduledoc false
|
|
57
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
58
|
|
|
59
|
def descriptor do
|
|
60
|
# credo:disable-for-next-line
|
|
61
|
%Google.Protobuf.DescriptorProto{
|
|
62
|
name: "ActorsEntry",
|
|
63
|
field: [
|
|
64
|
%Google.Protobuf.FieldDescriptorProto{
|
|
65
|
name: "key",
|
|
66
|
extendee: nil,
|
|
67
|
number: 1,
|
|
68
|
label: :LABEL_OPTIONAL,
|
|
69
|
type: :TYPE_STRING,
|
|
70
|
type_name: nil,
|
|
71
|
default_value: nil,
|
|
72
|
options: nil,
|
|
73
|
oneof_index: nil,
|
|
74
|
json_name: "key",
|
|
75
|
proto3_optional: nil,
|
|
76
|
__unknown_fields__: []
|
|
77
|
},
|
|
78
|
%Google.Protobuf.FieldDescriptorProto{
|
|
79
|
name: "value",
|
|
80
|
extendee: nil,
|
|
81
|
number: 2,
|
|
82
|
label: :LABEL_OPTIONAL,
|
|
83
|
type: :TYPE_MESSAGE,
|
|
84
|
type_name: ".eigr.functions.protocol.actors.Actor",
|
|
85
|
default_value: nil,
|
|
86
|
options: nil,
|
|
87
|
oneof_index: nil,
|
|
88
|
json_name: "value",
|
|
89
|
proto3_optional: nil,
|
|
90
|
__unknown_fields__: []
|
|
91
|
}
|
|
92
|
],
|
|
93
|
nested_type: [],
|
|
94
|
enum_type: [],
|
|
95
|
extension_range: [],
|
|
96
|
extension: [],
|
|
97
|
options: %Google.Protobuf.MessageOptions{
|
|
98
|
message_set_wire_format: false,
|
|
99
|
no_standard_descriptor_accessor: false,
|
|
100
|
deprecated: false,
|
|
101
|
map_entry: true,
|
|
102
|
deprecated_legacy_json_field_conflicts: nil,
|
|
103
|
# features: nil,
|
|
104
|
uninterpreted_option: [],
|
|
105
|
__pb_extensions__: %{},
|
|
106
|
__unknown_fields__: []
|
|
107
|
},
|
|
108
|
oneof_decl: [],
|
|
109
|
reserved_range: [],
|
|
110
|
reserved_name: [],
|
|
111
|
__unknown_fields__: []
|
|
112
|
}
|
|
113
|
end
|
|
114
|
|
|
115
|
field(:key, 1, type: :string)
|
|
116
|
field(:value, 2, type: Eigr.Functions.Protocol.Actors.Actor)
|
|
117
|
end
|
|
118
|
|
|
119
|
defmodule Eigr.Functions.Protocol.Actors.Registry do
|
|
120
|
@moduledoc false
|
|
121
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
122
|
|
|
123
|
def descriptor do
|
|
124
|
# credo:disable-for-next-line
|
|
125
|
%Google.Protobuf.DescriptorProto{
|
|
126
|
name: "Registry",
|
|
127
|
field: [
|
|
128
|
%Google.Protobuf.FieldDescriptorProto{
|
|
129
|
name: "actors",
|
|
130
|
extendee: nil,
|
|
131
|
number: 1,
|
|
132
|
label: :LABEL_REPEATED,
|
|
133
|
type: :TYPE_MESSAGE,
|
|
134
|
type_name: ".eigr.functions.protocol.actors.Registry.ActorsEntry",
|
|
135
|
default_value: nil,
|
|
136
|
options: nil,
|
|
137
|
oneof_index: nil,
|
|
138
|
json_name: "actors",
|
|
139
|
proto3_optional: nil,
|
|
140
|
__unknown_fields__: []
|
|
141
|
}
|
|
142
|
],
|
|
143
|
nested_type: [
|
|
144
|
%Google.Protobuf.DescriptorProto{
|
|
145
|
name: "ActorsEntry",
|
|
146
|
field: [
|
|
147
|
%Google.Protobuf.FieldDescriptorProto{
|
|
148
|
name: "key",
|
|
149
|
extendee: nil,
|
|
150
|
number: 1,
|
|
151
|
label: :LABEL_OPTIONAL,
|
|
152
|
type: :TYPE_STRING,
|
|
153
|
type_name: nil,
|
|
154
|
default_value: nil,
|
|
155
|
options: nil,
|
|
156
|
oneof_index: nil,
|
|
157
|
json_name: "key",
|
|
158
|
proto3_optional: nil,
|
|
159
|
__unknown_fields__: []
|
|
160
|
},
|
|
161
|
%Google.Protobuf.FieldDescriptorProto{
|
|
162
|
name: "value",
|
|
163
|
extendee: nil,
|
|
164
|
number: 2,
|
|
165
|
label: :LABEL_OPTIONAL,
|
|
166
|
type: :TYPE_MESSAGE,
|
|
167
|
type_name: ".eigr.functions.protocol.actors.Actor",
|
|
168
|
default_value: nil,
|
|
169
|
options: nil,
|
|
170
|
oneof_index: nil,
|
|
171
|
json_name: "value",
|
|
172
|
proto3_optional: nil,
|
|
173
|
__unknown_fields__: []
|
|
174
|
}
|
|
175
|
],
|
|
176
|
nested_type: [],
|
|
177
|
enum_type: [],
|
|
178
|
extension_range: [],
|
|
179
|
extension: [],
|
|
180
|
options: %Google.Protobuf.MessageOptions{
|
|
181
|
message_set_wire_format: false,
|
|
182
|
no_standard_descriptor_accessor: false,
|
|
183
|
deprecated: false,
|
|
184
|
map_entry: true,
|
|
185
|
deprecated_legacy_json_field_conflicts: nil,
|
|
186
|
# features: nil,
|
|
187
|
uninterpreted_option: [],
|
|
188
|
__pb_extensions__: %{},
|
|
189
|
__unknown_fields__: []
|
|
190
|
},
|
|
191
|
oneof_decl: [],
|
|
192
|
reserved_range: [],
|
|
193
|
reserved_name: [],
|
|
194
|
__unknown_fields__: []
|
|
195
|
}
|
|
196
|
],
|
|
197
|
enum_type: [],
|
|
198
|
extension_range: [],
|
|
199
|
extension: [],
|
|
200
|
options: nil,
|
|
201
|
oneof_decl: [],
|
|
202
|
reserved_range: [],
|
|
203
|
reserved_name: [],
|
|
204
|
__unknown_fields__: []
|
|
205
|
}
|
|
206
|
end
|
|
207
|
|
|
208
|
field(:actors, 1,
|
|
209
|
repeated: true,
|
|
210
|
type: Eigr.Functions.Protocol.Actors.Registry.ActorsEntry,
|
|
211
|
map: true
|
|
212
|
)
|
|
213
|
end
|
|
214
|
|
|
215
|
defmodule Eigr.Functions.Protocol.Actors.ActorSystem do
|
|
216
|
@moduledoc false
|
|
217
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
218
|
|
|
219
|
def descriptor do
|
|
220
|
# credo:disable-for-next-line
|
|
221
|
%Google.Protobuf.DescriptorProto{
|
|
222
|
name: "ActorSystem",
|
|
223
|
field: [
|
|
224
|
%Google.Protobuf.FieldDescriptorProto{
|
|
225
|
name: "name",
|
|
226
|
extendee: nil,
|
|
227
|
number: 1,
|
|
228
|
label: :LABEL_OPTIONAL,
|
|
229
|
type: :TYPE_STRING,
|
|
230
|
type_name: nil,
|
|
231
|
default_value: nil,
|
|
232
|
options: nil,
|
|
233
|
oneof_index: nil,
|
|
234
|
json_name: "name",
|
|
235
|
proto3_optional: nil,
|
|
236
|
__unknown_fields__: []
|
|
237
|
},
|
|
238
|
%Google.Protobuf.FieldDescriptorProto{
|
|
239
|
name: "registry",
|
|
240
|
extendee: nil,
|
|
241
|
number: 2,
|
|
242
|
label: :LABEL_OPTIONAL,
|
|
243
|
type: :TYPE_MESSAGE,
|
|
244
|
type_name: ".eigr.functions.protocol.actors.Registry",
|
|
245
|
default_value: nil,
|
|
246
|
options: nil,
|
|
247
|
oneof_index: nil,
|
|
248
|
json_name: "registry",
|
|
249
|
proto3_optional: nil,
|
|
250
|
__unknown_fields__: []
|
|
251
|
}
|
|
252
|
],
|
|
253
|
nested_type: [],
|
|
254
|
enum_type: [],
|
|
255
|
extension_range: [],
|
|
256
|
extension: [],
|
|
257
|
options: nil,
|
|
258
|
oneof_decl: [],
|
|
259
|
reserved_range: [],
|
|
260
|
reserved_name: [],
|
|
261
|
__unknown_fields__: []
|
|
262
|
}
|
|
263
|
end
|
|
264
|
|
|
265
|
field(:name, 1, type: :string)
|
|
266
|
field(:registry, 2, type: Eigr.Functions.Protocol.Actors.Registry)
|
|
267
|
end
|
|
268
|
|
|
269
|
defmodule Eigr.Functions.Protocol.Actors.ActorSnapshotStrategy do
|
|
270
|
@moduledoc false
|
|
271
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
272
|
|
|
273
|
def descriptor do
|
|
274
|
# credo:disable-for-next-line
|
|
275
|
%Google.Protobuf.DescriptorProto{
|
|
276
|
name: "ActorSnapshotStrategy",
|
|
277
|
field: [
|
|
278
|
%Google.Protobuf.FieldDescriptorProto{
|
|
279
|
name: "timeout",
|
|
280
|
extendee: nil,
|
|
281
|
number: 1,
|
|
282
|
label: :LABEL_OPTIONAL,
|
|
283
|
type: :TYPE_MESSAGE,
|
|
284
|
type_name: ".eigr.functions.protocol.actors.TimeoutStrategy",
|
|
285
|
default_value: nil,
|
|
286
|
options: nil,
|
|
287
|
oneof_index: 0,
|
|
288
|
json_name: "timeout",
|
|
289
|
proto3_optional: nil,
|
|
290
|
__unknown_fields__: []
|
|
291
|
}
|
|
292
|
],
|
|
293
|
nested_type: [],
|
|
294
|
enum_type: [],
|
|
295
|
extension_range: [],
|
|
296
|
extension: [],
|
|
297
|
options: nil,
|
|
298
|
oneof_decl: [
|
|
299
|
%Google.Protobuf.OneofDescriptorProto{
|
|
300
|
name: "strategy",
|
|
301
|
options: nil,
|
|
302
|
__unknown_fields__: []
|
|
303
|
}
|
|
304
|
],
|
|
305
|
reserved_range: [],
|
|
306
|
reserved_name: [],
|
|
307
|
__unknown_fields__: []
|
|
308
|
}
|
|
309
|
end
|
|
310
|
|
|
311
|
oneof(:strategy, 0)
|
|
312
|
|
|
313
|
field(:timeout, 1, type: Eigr.Functions.Protocol.Actors.TimeoutStrategy, oneof: 0)
|
|
314
|
end
|
|
315
|
|
|
316
|
defmodule Eigr.Functions.Protocol.Actors.ActorDeactivationStrategy do
|
|
317
|
@moduledoc false
|
|
318
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
319
|
|
|
320
|
def descriptor do
|
|
321
|
# credo:disable-for-next-line
|
|
322
|
%Google.Protobuf.DescriptorProto{
|
|
323
|
name: "ActorDeactivationStrategy",
|
|
324
|
field: [
|
|
325
|
%Google.Protobuf.FieldDescriptorProto{
|
|
326
|
name: "timeout",
|
|
327
|
extendee: nil,
|
|
328
|
number: 1,
|
|
329
|
label: :LABEL_OPTIONAL,
|
|
330
|
type: :TYPE_MESSAGE,
|
|
331
|
type_name: ".eigr.functions.protocol.actors.TimeoutStrategy",
|
|
332
|
default_value: nil,
|
|
333
|
options: nil,
|
|
334
|
oneof_index: 0,
|
|
335
|
json_name: "timeout",
|
|
336
|
proto3_optional: nil,
|
|
337
|
__unknown_fields__: []
|
|
338
|
}
|
|
339
|
],
|
|
340
|
nested_type: [],
|
|
341
|
enum_type: [],
|
|
342
|
extension_range: [],
|
|
343
|
extension: [],
|
|
344
|
options: nil,
|
|
345
|
oneof_decl: [
|
|
346
|
%Google.Protobuf.OneofDescriptorProto{
|
|
347
|
name: "strategy",
|
|
348
|
options: nil,
|
|
349
|
__unknown_fields__: []
|
|
350
|
}
|
|
351
|
],
|
|
352
|
reserved_range: [],
|
|
353
|
reserved_name: [],
|
|
354
|
__unknown_fields__: []
|
|
355
|
}
|
|
356
|
end
|
|
357
|
|
|
358
|
oneof(:strategy, 0)
|
|
359
|
|
|
360
|
field(:timeout, 1, type: Eigr.Functions.Protocol.Actors.TimeoutStrategy, oneof: 0)
|
|
361
|
end
|
|
362
|
|
|
363
|
defmodule Eigr.Functions.Protocol.Actors.TimeoutStrategy do
|
|
364
|
@moduledoc false
|
|
365
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
366
|
|
|
367
|
def descriptor do
|
|
368
|
# credo:disable-for-next-line
|
|
369
|
%Google.Protobuf.DescriptorProto{
|
|
370
|
name: "TimeoutStrategy",
|
|
371
|
field: [
|
|
372
|
%Google.Protobuf.FieldDescriptorProto{
|
|
373
|
name: "timeout",
|
|
374
|
extendee: nil,
|
|
375
|
number: 1,
|
|
376
|
label: :LABEL_OPTIONAL,
|
|
377
|
type: :TYPE_INT64,
|
|
378
|
type_name: nil,
|
|
379
|
default_value: nil,
|
|
380
|
options: nil,
|
|
381
|
oneof_index: nil,
|
|
382
|
json_name: "timeout",
|
|
383
|
proto3_optional: nil,
|
|
384
|
__unknown_fields__: []
|
|
385
|
}
|
|
386
|
],
|
|
387
|
nested_type: [],
|
|
388
|
enum_type: [],
|
|
389
|
extension_range: [],
|
|
390
|
extension: [],
|
|
391
|
options: nil,
|
|
392
|
oneof_decl: [],
|
|
393
|
reserved_range: [],
|
|
394
|
reserved_name: [],
|
|
395
|
__unknown_fields__: []
|
|
396
|
}
|
|
397
|
end
|
|
398
|
|
|
399
|
field(:timeout, 1, type: :int64)
|
|
400
|
end
|
|
401
|
|
|
402
|
defmodule Eigr.Functions.Protocol.Actors.Action do
|
|
403
|
@moduledoc false
|
|
404
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
405
|
|
|
406
|
def descriptor do
|
|
407
|
# credo:disable-for-next-line
|
|
408
|
%Google.Protobuf.DescriptorProto{
|
|
409
|
name: "Action",
|
|
410
|
field: [
|
|
411
|
%Google.Protobuf.FieldDescriptorProto{
|
|
412
|
name: "name",
|
|
413
|
extendee: nil,
|
|
414
|
number: 1,
|
|
415
|
label: :LABEL_OPTIONAL,
|
|
416
|
type: :TYPE_STRING,
|
|
417
|
type_name: nil,
|
|
418
|
default_value: nil,
|
|
419
|
options: nil,
|
|
420
|
oneof_index: nil,
|
|
421
|
json_name: "name",
|
|
422
|
proto3_optional: nil,
|
|
423
|
__unknown_fields__: []
|
|
424
|
}
|
|
425
|
],
|
|
426
|
nested_type: [],
|
|
427
|
enum_type: [],
|
|
428
|
extension_range: [],
|
|
429
|
extension: [],
|
|
430
|
options: nil,
|
|
431
|
oneof_decl: [],
|
|
432
|
reserved_range: [],
|
|
433
|
reserved_name: [],
|
|
434
|
__unknown_fields__: []
|
|
435
|
}
|
|
436
|
end
|
|
437
|
|
|
438
|
field(:name, 1, type: :string)
|
|
439
|
end
|
|
440
|
|
|
441
|
defmodule Eigr.Functions.Protocol.Actors.FixedTimerAction do
|
|
442
|
@moduledoc false
|
|
443
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
444
|
|
|
445
|
def descriptor do
|
|
446
|
# credo:disable-for-next-line
|
|
447
|
%Google.Protobuf.DescriptorProto{
|
|
448
|
name: "FixedTimerAction",
|
|
449
|
field: [
|
|
450
|
%Google.Protobuf.FieldDescriptorProto{
|
|
451
|
name: "seconds",
|
|
452
|
extendee: nil,
|
|
453
|
number: 1,
|
|
454
|
label: :LABEL_OPTIONAL,
|
|
455
|
type: :TYPE_INT32,
|
|
456
|
type_name: nil,
|
|
457
|
default_value: nil,
|
|
458
|
options: nil,
|
|
459
|
oneof_index: nil,
|
|
460
|
json_name: "seconds",
|
|
461
|
proto3_optional: nil,
|
|
462
|
__unknown_fields__: []
|
|
463
|
},
|
|
464
|
%Google.Protobuf.FieldDescriptorProto{
|
|
465
|
name: "action",
|
|
466
|
extendee: nil,
|
|
467
|
number: 2,
|
|
468
|
label: :LABEL_OPTIONAL,
|
|
469
|
type: :TYPE_MESSAGE,
|
|
470
|
type_name: ".eigr.functions.protocol.actors.Action",
|
|
471
|
default_value: nil,
|
|
472
|
options: nil,
|
|
473
|
oneof_index: nil,
|
|
474
|
json_name: "action",
|
|
475
|
proto3_optional: nil,
|
|
476
|
__unknown_fields__: []
|
|
477
|
}
|
|
478
|
],
|
|
479
|
nested_type: [],
|
|
480
|
enum_type: [],
|
|
481
|
extension_range: [],
|
|
482
|
extension: [],
|
|
483
|
options: nil,
|
|
484
|
oneof_decl: [],
|
|
485
|
reserved_range: [],
|
|
486
|
reserved_name: [],
|
|
487
|
__unknown_fields__: []
|
|
488
|
}
|
|
489
|
end
|
|
490
|
|
|
491
|
field(:seconds, 1, type: :int32)
|
|
492
|
field(:action, 2, type: Eigr.Functions.Protocol.Actors.Action)
|
|
493
|
end
|
|
494
|
|
|
495
|
defmodule Eigr.Functions.Protocol.Actors.ActorState.TagsEntry do
|
|
496
|
@moduledoc false
|
|
497
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
498
|
|
|
499
|
def descriptor do
|
|
500
|
# credo:disable-for-next-line
|
|
501
|
%Google.Protobuf.DescriptorProto{
|
|
502
|
name: "TagsEntry",
|
|
503
|
field: [
|
|
504
|
%Google.Protobuf.FieldDescriptorProto{
|
|
505
|
name: "key",
|
|
506
|
extendee: nil,
|
|
507
|
number: 1,
|
|
508
|
label: :LABEL_OPTIONAL,
|
|
509
|
type: :TYPE_STRING,
|
|
510
|
type_name: nil,
|
|
511
|
default_value: nil,
|
|
512
|
options: nil,
|
|
513
|
oneof_index: nil,
|
|
514
|
json_name: "key",
|
|
515
|
proto3_optional: nil,
|
|
516
|
__unknown_fields__: []
|
|
517
|
},
|
|
518
|
%Google.Protobuf.FieldDescriptorProto{
|
|
519
|
name: "value",
|
|
520
|
extendee: nil,
|
|
521
|
number: 2,
|
|
522
|
label: :LABEL_OPTIONAL,
|
|
523
|
type: :TYPE_STRING,
|
|
524
|
type_name: nil,
|
|
525
|
default_value: nil,
|
|
526
|
options: nil,
|
|
527
|
oneof_index: nil,
|
|
528
|
json_name: "value",
|
|
529
|
proto3_optional: nil,
|
|
530
|
__unknown_fields__: []
|
|
531
|
}
|
|
532
|
],
|
|
533
|
nested_type: [],
|
|
534
|
enum_type: [],
|
|
535
|
extension_range: [],
|
|
536
|
extension: [],
|
|
537
|
options: %Google.Protobuf.MessageOptions{
|
|
538
|
message_set_wire_format: false,
|
|
539
|
no_standard_descriptor_accessor: false,
|
|
540
|
deprecated: false,
|
|
541
|
map_entry: true,
|
|
542
|
deprecated_legacy_json_field_conflicts: nil,
|
|
543
|
# features: nil,
|
|
544
|
uninterpreted_option: [],
|
|
545
|
__pb_extensions__: %{},
|
|
546
|
__unknown_fields__: []
|
|
547
|
},
|
|
548
|
oneof_decl: [],
|
|
549
|
reserved_range: [],
|
|
550
|
reserved_name: [],
|
|
551
|
__unknown_fields__: []
|
|
552
|
}
|
|
553
|
end
|
|
554
|
|
|
555
|
field(:key, 1, type: :string)
|
|
556
|
field(:value, 2, type: :string)
|
|
557
|
end
|
|
558
|
|
|
559
|
defmodule Eigr.Functions.Protocol.Actors.ActorState do
|
|
560
|
@moduledoc false
|
|
561
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
562
|
|
|
563
|
def descriptor do
|
|
564
|
# credo:disable-for-next-line
|
|
565
|
%Google.Protobuf.DescriptorProto{
|
|
566
|
name: "ActorState",
|
|
567
|
field: [
|
|
568
|
%Google.Protobuf.FieldDescriptorProto{
|
|
569
|
name: "tags",
|
|
570
|
extendee: nil,
|
|
571
|
number: 1,
|
|
572
|
label: :LABEL_REPEATED,
|
|
573
|
type: :TYPE_MESSAGE,
|
|
574
|
type_name: ".eigr.functions.protocol.actors.ActorState.TagsEntry",
|
|
575
|
default_value: nil,
|
|
576
|
options: nil,
|
|
577
|
oneof_index: nil,
|
|
578
|
json_name: "tags",
|
|
579
|
proto3_optional: nil,
|
|
580
|
__unknown_fields__: []
|
|
581
|
},
|
|
582
|
%Google.Protobuf.FieldDescriptorProto{
|
|
583
|
name: "state",
|
|
584
|
extendee: nil,
|
|
585
|
number: 2,
|
|
586
|
label: :LABEL_OPTIONAL,
|
|
587
|
type: :TYPE_MESSAGE,
|
|
588
|
type_name: ".google.protobuf.Any",
|
|
589
|
default_value: nil,
|
|
590
|
options: nil,
|
|
591
|
oneof_index: nil,
|
|
592
|
json_name: "state",
|
|
593
|
proto3_optional: nil,
|
|
863
|
__unknown_fields__: []
|
|
595
|
}
|
|
596
|
],
|
|
597
|
nested_type: [
|
|
598
|
%Google.Protobuf.DescriptorProto{
|
|
599
|
name: "TagsEntry",
|
|
600
|
field: [
|
|
601
|
%Google.Protobuf.FieldDescriptorProto{
|
|
602
|
name: "key",
|
|
603
|
extendee: nil,
|
|
604
|
number: 1,
|
|
605
|
label: :LABEL_OPTIONAL,
|
|
606
|
type: :TYPE_STRING,
|
|
607
|
type_name: nil,
|
|
608
|
default_value: nil,
|
|
609
|
options: nil,
|
|
610
|
oneof_index: nil,
|
|
611
|
json_name: "key",
|
|
612
|
proto3_optional: nil,
|
|
613
|
__unknown_fields__: []
|
|
614
|
},
|
|
615
|
%Google.Protobuf.FieldDescriptorProto{
|
|
616
|
name: "value",
|
|
617
|
extendee: nil,
|
|
618
|
number: 2,
|
|
619
|
label: :LABEL_OPTIONAL,
|
|
620
|
type: :TYPE_STRING,
|
|
621
|
type_name: nil,
|
|
622
|
default_value: nil,
|
|
623
|
options: nil,
|
|
624
|
oneof_index: nil,
|
|
625
|
json_name: "value",
|
|
626
|
proto3_optional: nil,
|
|
627
|
__unknown_fields__: []
|
|
628
|
}
|
|
629
|
],
|
|
630
|
nested_type: [],
|
|
631
|
enum_type: [],
|
|
632
|
extension_range: [],
|
|
633
|
extension: [],
|
|
634
|
options: %Google.Protobuf.MessageOptions{
|
|
635
|
message_set_wire_format: false,
|
|
636
|
no_standard_descriptor_accessor: false,
|
|
637
|
deprecated: false,
|
|
638
|
map_entry: true,
|
|
639
|
deprecated_legacy_json_field_conflicts: nil,
|
|
640
|
# features: nil,
|
|
641
|
uninterpreted_option: [],
|
|
642
|
__pb_extensions__: %{},
|
|
643
|
__unknown_fields__: []
|
|
644
|
},
|
|
645
|
oneof_decl: [],
|
|
646
|
reserved_range: [],
|
|
647
|
reserved_name: [],
|
|
648
|
__unknown_fields__: []
|
|
649
|
}
|
|
650
|
],
|
|
651
|
enum_type: [],
|
|
652
|
extension_range: [],
|
|
653
|
extension: [],
|
|
654
|
options: nil,
|
|
655
|
oneof_decl: [],
|
|
656
|
reserved_range: [],
|
|
657
|
reserved_name: [],
|
|
658
|
__unknown_fields__: []
|
|
659
|
}
|
|
660
|
end
|
|
661
|
|
|
662
|
field(:tags, 1,
|
|
663
|
repeated: true,
|
|
664
|
type: Eigr.Functions.Protocol.Actors.ActorState.TagsEntry,
|
|
665
|
map: true
|
|
666
|
)
|
|
667
|
|
|
668
|
field(:state, 2, type: Google.Protobuf.Any)
|
|
669
|
end
|
|
670
|
|
|
671
|
defmodule Eigr.Functions.Protocol.Actors.Metadata.TagsEntry do
|
|
672
|
@moduledoc false
|
|
673
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
674
|
|
|
675
|
def descriptor do
|
|
676
|
# credo:disable-for-next-line
|
|
677
|
%Google.Protobuf.DescriptorProto{
|
|
678
|
name: "TagsEntry",
|
|
679
|
field: [
|
|
680
|
%Google.Protobuf.FieldDescriptorProto{
|
|
681
|
name: "key",
|
|
682
|
extendee: nil,
|
|
683
|
number: 1,
|
|
684
|
label: :LABEL_OPTIONAL,
|
|
685
|
type: :TYPE_STRING,
|
|
686
|
type_name: nil,
|
|
687
|
default_value: nil,
|
|
688
|
options: nil,
|
|
689
|
oneof_index: nil,
|
|
690
|
json_name: "key",
|
|
691
|
proto3_optional: nil,
|
|
692
|
__unknown_fields__: []
|
|
693
|
},
|
|
694
|
%Google.Protobuf.FieldDescriptorProto{
|
|
695
|
name: "value",
|
|
696
|
extendee: nil,
|
|
697
|
number: 2,
|
|
698
|
label: :LABEL_OPTIONAL,
|
|
699
|
type: :TYPE_STRING,
|
|
700
|
type_name: nil,
|
|
701
|
default_value: nil,
|
|
702
|
options: nil,
|
|
703
|
oneof_index: nil,
|
|
704
|
json_name: "value",
|
|
705
|
proto3_optional: nil,
|
|
706
|
__unknown_fields__: []
|
|
707
|
}
|
|
708
|
],
|
|
709
|
nested_type: [],
|
|
710
|
enum_type: [],
|
|
711
|
extension_range: [],
|
|
712
|
extension: [],
|
|
713
|
options: %Google.Protobuf.MessageOptions{
|
|
714
|
message_set_wire_format: false,
|
|
715
|
no_standard_descriptor_accessor: false,
|
|
716
|
deprecated: false,
|
|
717
|
map_entry: true,
|
|
718
|
deprecated_legacy_json_field_conflicts: nil,
|
|
719
|
# features: nil,
|
|
720
|
uninterpreted_option: [],
|
|
721
|
__pb_extensions__: %{},
|
|
722
|
__unknown_fields__: []
|
|
723
|
},
|
|
724
|
oneof_decl: [],
|
|
725
|
reserved_range: [],
|
|
726
|
reserved_name: [],
|
|
727
|
__unknown_fields__: []
|
|
728
|
}
|
|
729
|
end
|
|
730
|
|
|
731
|
field(:key, 1, type: :string)
|
|
732
|
field(:value, 2, type: :string)
|
|
733
|
end
|
|
734
|
|
|
735
|
defmodule Eigr.Functions.Protocol.Actors.Metadata do
|
|
736
|
@moduledoc false
|
|
737
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
738
|
|
|
739
|
def descriptor do
|
|
740
|
# credo:disable-for-next-line
|
|
741
|
%Google.Protobuf.DescriptorProto{
|
|
742
|
name: "Metadata",
|
|
743
|
field: [
|
|
744
|
%Google.Protobuf.FieldDescriptorProto{
|
|
745
|
name: "channel_group",
|
|
746
|
extendee: nil,
|
|
747
|
number: 1,
|
|
748
|
label: :LABEL_REPEATED,
|
|
749
|
type: :TYPE_MESSAGE,
|
|
750
|
type_name: ".eigr.functions.protocol.actors.Channel",
|
|
751
|
default_value: nil,
|
|
752
|
options: nil,
|
|
753
|
oneof_index: nil,
|
|
754
|
json_name: "channelGroup",
|
|
755
|
proto3_optional: nil,
|
|
756
|
__unknown_fields__: []
|
|
757
|
},
|
|
758
|
%Google.Protobuf.FieldDescriptorProto{
|
|
759
|
name: "tags",
|
|
760
|
extendee: nil,
|
|
761
|
number: 2,
|
|
762
|
label: :LABEL_REPEATED,
|
|
763
|
type: :TYPE_MESSAGE,
|
|
764
|
type_name: ".eigr.functions.protocol.actors.Metadata.TagsEntry",
|
|
765
|
default_value: nil,
|
|
766
|
options: nil,
|
|
767
|
oneof_index: nil,
|
|
768
|
json_name: "tags",
|
|
769
|
proto3_optional: nil,
|
|
770
|
__unknown_fields__: []
|
|
771
|
}
|
|
772
|
],
|
|
773
|
nested_type: [
|
|
774
|
%Google.Protobuf.DescriptorProto{
|
|
775
|
name: "TagsEntry",
|
|
776
|
field: [
|
|
777
|
%Google.Protobuf.FieldDescriptorProto{
|
|
778
|
name: "key",
|
|
779
|
extendee: nil,
|
|
780
|
number: 1,
|
|
781
|
label: :LABEL_OPTIONAL,
|
|
782
|
type: :TYPE_STRING,
|
|
783
|
type_name: nil,
|
|
784
|
default_value: nil,
|
|
785
|
options: nil,
|
|
786
|
oneof_index: nil,
|
|
787
|
json_name: "key",
|
|
788
|
proto3_optional: nil,
|
|
789
|
__unknown_fields__: []
|
|
790
|
},
|
|
791
|
%Google.Protobuf.FieldDescriptorProto{
|
|
792
|
name: "value",
|
|
793
|
extendee: nil,
|
|
794
|
number: 2,
|
|
795
|
label: :LABEL_OPTIONAL,
|
|
796
|
type: :TYPE_STRING,
|
|
797
|
type_name: nil,
|
|
798
|
default_value: nil,
|
|
799
|
options: nil,
|
|
800
|
oneof_index: nil,
|
|
801
|
json_name: "value",
|
|
802
|
proto3_optional: nil,
|
|
803
|
__unknown_fields__: []
|
|
804
|
}
|
|
805
|
],
|
|
806
|
nested_type: [],
|
|
807
|
enum_type: [],
|
|
808
|
extension_range: [],
|
|
809
|
extension: [],
|
|
810
|
options: %Google.Protobuf.MessageOptions{
|
|
811
|
message_set_wire_format: false,
|
|
812
|
no_standard_descriptor_accessor: false,
|
|
813
|
deprecated: false,
|
|
814
|
map_entry: true,
|
|
815
|
deprecated_legacy_json_field_conflicts: nil,
|
|
816
|
# features: nil,
|
|
817
|
uninterpreted_option: [],
|
|
818
|
__pb_extensions__: %{},
|
|
819
|
__unknown_fields__: []
|
|
820
|
},
|
|
821
|
oneof_decl: [],
|
|
822
|
reserved_range: [],
|
|
823
|
reserved_name: [],
|
|
824
|
__unknown_fields__: []
|
|
825
|
}
|
|
826
|
],
|
|
827
|
enum_type: [],
|
|
828
|
extension_range: [],
|
|
829
|
extension: [],
|
|
830
|
options: nil,
|
|
831
|
oneof_decl: [],
|
|
832
|
reserved_range: [],
|
|
833
|
reserved_name: [],
|
|
834
|
__unknown_fields__: []
|
|
835
|
}
|
|
836
|
end
|
|
837
|
|
|
838
|
field(:channel_group, 1,
|
|
839
|
repeated: true,
|
|
840
|
type: Eigr.Functions.Protocol.Actors.Channel,
|
|
841
|
json_name: "channelGroup"
|
|
842
|
)
|
|
843
|
|
|
844
|
field(:tags, 2,
|
|
845
|
repeated: true,
|
|
846
|
type: Eigr.Functions.Protocol.Actors.Metadata.TagsEntry,
|
|
847
|
map: true
|
|
848
|
)
|
|
849
|
end
|
|
850
|
|
|
851
|
defmodule Eigr.Functions.Protocol.Actors.Channel do
|
|
852
|
@moduledoc false
|
|
853
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
854
|
|
|
855
|
def descriptor do
|
|
856
|
# credo:disable-for-next-line
|
|
857
|
%Google.Protobuf.DescriptorProto{
|
|
858
|
name: "Channel",
|
|
859
|
field: [
|
|
860
|
%Google.Protobuf.FieldDescriptorProto{
|
|
861
|
name: "topic",
|
|
862
|
extendee: nil,
|
|
863
|
number: 1,
|
|
864
|
label: :LABEL_OPTIONAL,
|
|
865
|
type: :TYPE_STRING,
|
|
866
|
type_name: nil,
|
|
867
|
default_value: nil,
|
|
868
|
options: nil,
|
|
869
|
oneof_index: nil,
|
|
870
|
json_name: "topic",
|
|
871
|
proto3_optional: nil,
|
|
872
|
__unknown_fields__: []
|
|
873
|
},
|
|
874
|
%Google.Protobuf.FieldDescriptorProto{
|
|
875
|
name: "action",
|
|
876
|
extendee: nil,
|
|
877
|
number: 2,
|
|
878
|
label: :LABEL_OPTIONAL,
|
|
879
|
type: :TYPE_STRING,
|
|
880
|
type_name: nil,
|
|
881
|
default_value: nil,
|
|
882
|
options: nil,
|
|
883
|
oneof_index: nil,
|
|
884
|
json_name: "action",
|
|
885
|
proto3_optional: nil,
|
|
886
|
__unknown_fields__: []
|
|
887
|
}
|
|
888
|
],
|
|
889
|
nested_type: [],
|
|
890
|
enum_type: [],
|
|
891
|
extension_range: [],
|
|
892
|
extension: [],
|
|
893
|
options: nil,
|
|
894
|
oneof_decl: [],
|
|
895
|
reserved_range: [],
|
|
896
|
reserved_name: [],
|
|
897
|
__unknown_fields__: []
|
|
898
|
}
|
|
899
|
end
|
|
900
|
|
|
901
|
field(:topic, 1, type: :string)
|
|
902
|
field(:action, 2, type: :string)
|
|
903
|
end
|
|
904
|
|
|
905
|
defmodule Eigr.Functions.Protocol.Actors.ActorSettings do
|
|
906
|
@moduledoc false
|
|
907
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
908
|
|
|
909
|
def descriptor do
|
|
910
|
# credo:disable-for-next-line
|
|
911
|
%Google.Protobuf.DescriptorProto{
|
|
912
|
name: "ActorSettings",
|
|
913
|
field: [
|
|
914
|
%Google.Protobuf.FieldDescriptorProto{
|
|
915
|
name: "kind",
|
|
916
|
extendee: nil,
|
|
917
|
number: 1,
|
|
918
|
label: :LABEL_OPTIONAL,
|
|
919
|
type: :TYPE_ENUM,
|
|
920
|
type_name: ".eigr.functions.protocol.actors.Kind",
|
|
921
|
default_value: nil,
|
|
922
|
options: nil,
|
|
923
|
oneof_index: nil,
|
|
924
|
json_name: "kind",
|
|
925
|
proto3_optional: nil,
|
|
926
|
__unknown_fields__: []
|
|
927
|
},
|
|
928
|
%Google.Protobuf.FieldDescriptorProto{
|
|
929
|
name: "stateful",
|
|
930
|
extendee: nil,
|
|
931
|
number: 2,
|
|
932
|
label: :LABEL_OPTIONAL,
|
|
933
|
type: :TYPE_BOOL,
|
|
934
|
type_name: nil,
|
|
935
|
default_value: nil,
|
|
936
|
options: nil,
|
|
937
|
oneof_index: nil,
|
|
938
|
json_name: "stateful",
|
|
939
|
proto3_optional: nil,
|
|
940
|
__unknown_fields__: []
|
|
941
|
},
|
|
942
|
%Google.Protobuf.FieldDescriptorProto{
|
|
943
|
name: "snapshot_strategy",
|
|
944
|
extendee: nil,
|
|
945
|
number: 3,
|
|
946
|
label: :LABEL_OPTIONAL,
|
|
947
|
type: :TYPE_MESSAGE,
|
|
948
|
type_name: ".eigr.functions.protocol.actors.ActorSnapshotStrategy",
|
|
949
|
default_value: nil,
|
|
950
|
options: nil,
|
|
951
|
oneof_index: nil,
|
|
952
|
json_name: "snapshotStrategy",
|
|
953
|
proto3_optional: nil,
|
|
954
|
__unknown_fields__: []
|
|
955
|
},
|
|
956
|
%Google.Protobuf.FieldDescriptorProto{
|
|
957
|
name: "deactivation_strategy",
|
|
958
|
extendee: nil,
|
|
959
|
number: 4,
|
|
960
|
label: :LABEL_OPTIONAL,
|
|
961
|
type: :TYPE_MESSAGE,
|
|
962
|
type_name: ".eigr.functions.protocol.actors.ActorDeactivationStrategy",
|
|
963
|
default_value: nil,
|
|
964
|
options: nil,
|
|
965
|
oneof_index: nil,
|
|
966
|
json_name: "deactivationStrategy",
|
|
967
|
proto3_optional: nil,
|
|
968
|
__unknown_fields__: []
|
|
969
|
},
|
|
970
|
%Google.Protobuf.FieldDescriptorProto{
|
|
971
|
name: "min_pool_size",
|
|
972
|
extendee: nil,
|
|
973
|
number: 5,
|
|
974
|
label: :LABEL_OPTIONAL,
|
|
975
|
type: :TYPE_INT32,
|
|
976
|
type_name: nil,
|
|
977
|
default_value: nil,
|
|
978
|
options: nil,
|
|
979
|
oneof_index: nil,
|
|
980
|
json_name: "minPoolSize",
|
|
981
|
proto3_optional: nil,
|
|
982
|
__unknown_fields__: []
|
|
983
|
},
|
|
984
|
%Google.Protobuf.FieldDescriptorProto{
|
|
985
|
name: "max_pool_size",
|
|
986
|
extendee: nil,
|
|
987
|
number: 6,
|
|
988
|
label: :LABEL_OPTIONAL,
|
|
989
|
type: :TYPE_INT32,
|
|
990
|
type_name: nil,
|
|
991
|
default_value: nil,
|
|
992
|
options: nil,
|
|
993
|
oneof_index: nil,
|
|
994
|
json_name: "maxPoolSize",
|
|
995
|
proto3_optional: nil,
|
|
996
|
__unknown_fields__: []
|
|
997
|
}
|
|
998
|
],
|
|
999
|
nested_type: [],
|
|
1000
|
enum_type: [],
|
|
1001
|
extension_range: [],
|
|
1002
|
extension: [],
|
|
1003
|
options: nil,
|
|
1004
|
oneof_decl: [],
|
|
1005
|
reserved_range: [],
|
|
1006
|
reserved_name: [],
|
|
1007
|
__unknown_fields__: []
|
|
1008
|
}
|
|
1009
|
end
|
|
1010
|
|
|
1011
|
field(:kind, 1, type: Eigr.Functions.Protocol.Actors.Kind, enum: true)
|
|
1012
|
field(:stateful, 2, type: :bool)
|
|
1013
|
|
|
1014
|
field(:snapshot_strategy, 3,
|
|
1015
|
type: Eigr.Functions.Protocol.Actors.ActorSnapshotStrategy,
|
|
1016
|
json_name: "snapshotStrategy"
|
|
1017
|
)
|
|
1018
|
|
|
1019
|
field(:deactivation_strategy, 4,
|
|
1020
|
type: Eigr.Functions.Protocol.Actors.ActorDeactivationStrategy,
|
|
1021
|
json_name: "deactivationStrategy"
|
|
1022
|
)
|
|
1023
|
|
|
1024
|
field(:min_pool_size, 5, type: :int32, json_name: "minPoolSize")
|
|
1025
|
field(:max_pool_size, 6, type: :int32, json_name: "maxPoolSize")
|
|
1026
|
end
|
|
1027
|
|
|
1028
|
defmodule Eigr.Functions.Protocol.Actors.ActorId do
|
|
1029
|
@moduledoc false
|
|
1030
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1031
|
|
|
1032
|
def descriptor do
|
|
1033
|
# credo:disable-for-next-line
|
|
1034
|
%Google.Protobuf.DescriptorProto{
|
|
1035
|
name: "ActorId",
|
|
1036
|
field: [
|
|
1037
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1038
|
name: "name",
|
|
1039
|
extendee: nil,
|
|
1040
|
number: 1,
|
|
1041
|
label: :LABEL_OPTIONAL,
|
|
1042
|
type: :TYPE_STRING,
|
|
1043
|
type_name: nil,
|
|
1044
|
default_value: nil,
|
|
1045
|
options: nil,
|
|
1046
|
oneof_index: nil,
|
|
1047
|
json_name: "name",
|
|
1048
|
proto3_optional: nil,
|
|
1049
|
__unknown_fields__: []
|
|
1050
|
},
|
|
1051
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1052
|
name: "system",
|
|
1053
|
extendee: nil,
|
|
1054
|
number: 2,
|
|
1055
|
label: :LABEL_OPTIONAL,
|
|
1056
|
type: :TYPE_STRING,
|
|
1057
|
type_name: nil,
|
|
1058
|
default_value: nil,
|
|
1059
|
options: nil,
|
|
1060
|
oneof_index: nil,
|
|
1061
|
json_name: "system",
|
|
1062
|
proto3_optional: nil,
|
|
1063
|
__unknown_fields__: []
|
|
1064
|
},
|
|
1065
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1066
|
name: "parent",
|
|
1067
|
extendee: nil,
|
|
1068
|
number: 3,
|
|
1069
|
label: :LABEL_OPTIONAL,
|
|
1070
|
type: :TYPE_STRING,
|
|
1071
|
type_name: nil,
|
|
1072
|
default_value: nil,
|
|
1073
|
options: nil,
|
|
1074
|
oneof_index: nil,
|
|
1075
|
json_name: "parent",
|
|
1076
|
proto3_optional: nil,
|
|
1077
|
__unknown_fields__: []
|
|
1078
|
}
|
|
1079
|
],
|
|
1080
|
nested_type: [],
|
|
1081
|
enum_type: [],
|
|
1082
|
extension_range: [],
|
|
1083
|
extension: [],
|
|
1084
|
options: nil,
|
|
1085
|
oneof_decl: [],
|
|
1086
|
reserved_range: [],
|
|
1087
|
reserved_name: [],
|
|
1088
|
__unknown_fields__: []
|
|
1089
|
}
|
|
1090
|
end
|
|
1091
|
|
|
1092
|
field(:name, 1, type: :string)
|
|
1093
|
field(:system, 2, type: :string)
|
|
1094
|
field(:parent, 3, type: :string)
|
|
1095
|
end
|
|
1096
|
|
|
1097
|
defmodule Eigr.Functions.Protocol.Actors.Actor do
|
|
1098
|
@moduledoc false
|
|
1099
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1100
|
|
|
1101
|
def descriptor do
|
|
1102
|
# credo:disable-for-next-line
|
|
1103
|
%Google.Protobuf.DescriptorProto{
|
|
1104
|
name: "Actor",
|
|
1105
|
field: [
|
|
1106
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1107
|
name: "id",
|
|
1108
|
extendee: nil,
|
|
1109
|
number: 1,
|
|
1110
|
label: :LABEL_OPTIONAL,
|
|
1111
|
type: :TYPE_MESSAGE,
|
|
1112
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1113
|
default_value: nil,
|
|
1114
|
options: nil,
|
|
1115
|
oneof_index: nil,
|
|
1116
|
json_name: "id",
|
|
1117
|
proto3_optional: nil,
|
|
1118
|
__unknown_fields__: []
|
|
1119
|
},
|
|
1120
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1121
|
name: "state",
|
|
1122
|
extendee: nil,
|
|
1123
|
number: 2,
|
|
1124
|
label: :LABEL_OPTIONAL,
|
|
1125
|
type: :TYPE_MESSAGE,
|
|
1126
|
type_name: ".eigr.functions.protocol.actors.ActorState",
|
|
1127
|
default_value: nil,
|
|
1128
|
options: nil,
|
|
1129
|
oneof_index: nil,
|
|
1130
|
json_name: "state",
|
|
1131
|
proto3_optional: nil,
|
|
1132
|
__unknown_fields__: []
|
|
1133
|
},
|
|
1134
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1135
|
name: "metadata",
|
|
1136
|
extendee: nil,
|
|
1137
|
number: 6,
|
|
1138
|
label: :LABEL_OPTIONAL,
|
|
1139
|
type: :TYPE_MESSAGE,
|
|
1140
|
type_name: ".eigr.functions.protocol.actors.Metadata",
|
|
1141
|
default_value: nil,
|
|
1142
|
options: nil,
|
|
1143
|
oneof_index: nil,
|
|
1144
|
json_name: "metadata",
|
|
1145
|
proto3_optional: nil,
|
|
1146
|
__unknown_fields__: []
|
|
1147
|
},
|
|
1148
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1149
|
name: "settings",
|
|
1150
|
extendee: nil,
|
|
1151
|
number: 3,
|
|
1152
|
label: :LABEL_OPTIONAL,
|
|
1153
|
type: :TYPE_MESSAGE,
|
|
1154
|
type_name: ".eigr.functions.protocol.actors.ActorSettings",
|
|
1155
|
default_value: nil,
|
|
1156
|
options: nil,
|
|
1157
|
oneof_index: nil,
|
|
1158
|
json_name: "settings",
|
|
1159
|
proto3_optional: nil,
|
|
1160
|
__unknown_fields__: []
|
|
1161
|
},
|
|
1162
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1163
|
name: "actions",
|
|
1164
|
extendee: nil,
|
|
1165
|
number: 4,
|
|
1166
|
label: :LABEL_REPEATED,
|
|
1167
|
type: :TYPE_MESSAGE,
|
|
1168
|
type_name: ".eigr.functions.protocol.actors.Action",
|
|
1169
|
default_value: nil,
|
|
1170
|
options: nil,
|
|
1171
|
oneof_index: nil,
|
|
1172
|
json_name: "actions",
|
|
1173
|
proto3_optional: nil,
|
|
1174
|
__unknown_fields__: []
|
|
1175
|
},
|
|
1176
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1177
|
name: "timer_actions",
|
|
1178
|
extendee: nil,
|
|
1179
|
number: 5,
|
|
1180
|
label: :LABEL_REPEATED,
|
|
1181
|
type: :TYPE_MESSAGE,
|
|
1182
|
type_name: ".eigr.functions.protocol.actors.FixedTimerAction",
|
|
1183
|
default_value: nil,
|
|
1184
|
options: nil,
|
|
1185
|
oneof_index: nil,
|
|
1186
|
json_name: "timerActions",
|
|
1187
|
proto3_optional: nil,
|
|
1188
|
__unknown_fields__: []
|
|
1189
|
}
|
|
1190
|
],
|
|
1191
|
nested_type: [],
|
|
1192
|
enum_type: [],
|
|
1193
|
extension_range: [],
|
|
1194
|
extension: [],
|
|
1195
|
options: nil,
|
|
1196
|
oneof_decl: [],
|
|
1197
|
reserved_range: [],
|
|
1198
|
reserved_name: [],
|
|
1199
|
__unknown_fields__: []
|
|
1200
|
}
|
|
1201
|
end
|
|
1202
|
|
|
1203
|
field(:id, 1, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1204
|
field(:state, 2, type: Eigr.Functions.Protocol.Actors.ActorState)
|
|
1205
|
field(:metadata, 6, type: Eigr.Functions.Protocol.Actors.Metadata)
|
|
1206
|
field(:settings, 3, type: Eigr.Functions.Protocol.Actors.ActorSettings)
|
|
1207
|
field(:actions, 4, repeated: true, type: Eigr.Functions.Protocol.Actors.Action)
|
|
1208
|
|
|
1209
|
field(:timer_actions, 5,
|
|
1210
|
repeated: true,
|
|
1211
|
type: Eigr.Functions.Protocol.Actors.FixedTimerAction,
|
|
1212
|
json_name: "timerActions"
|
|
1213
|
)
|
|
1214
|
end
|
added
lib/spawn/actors/eigr/functions/protocol/actors/extensions.pb.ex
|
|
@@ -0,0 1,10 @@
|
|
1
|
defmodule Eigr.Functions.Protocol.Actors.PbExtension do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
4
|
|
|
5
|
extend(Google.Protobuf.FieldOptions, :actor_id, 9999,
|
|
6
|
optional: true,
|
|
7
|
type: :bool,
|
|
8
|
json_name: "actorId"
|
|
9
|
)
|
|
10
|
end
|
added
lib/spawn/actors/eigr/functions/protocol/actors/healthcheck.pb.ex
|
|
@@ -0,0 1,692 @@
|
|
1
|
defmodule Eigr.Functions.Protocol.Actors.Healthcheck.Status do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
name: "Status",
|
|
9
|
field: [
|
|
10
|
%Google.Protobuf.FieldDescriptorProto{
|
|
11
|
name: "status",
|
|
12
|
extendee: nil,
|
|
13
|
number: 1,
|
|
14
|
label: :LABEL_OPTIONAL,
|
|
15
|
type: :TYPE_STRING,
|
|
16
|
type_name: nil,
|
|
17
|
default_value: nil,
|
|
18
|
options: nil,
|
|
19
|
oneof_index: nil,
|
|
20
|
json_name: "status",
|
|
21
|
proto3_optional: nil,
|
|
22
|
__unknown_fields__: []
|
|
23
|
},
|
|
24
|
%Google.Protobuf.FieldDescriptorProto{
|
|
25
|
name: "details",
|
|
26
|
extendee: nil,
|
|
27
|
number: 2,
|
|
28
|
label: :LABEL_OPTIONAL,
|
|
29
|
type: :TYPE_STRING,
|
|
30
|
type_name: nil,
|
|
31
|
default_value: nil,
|
|
32
|
options: nil,
|
|
33
|
oneof_index: nil,
|
|
34
|
json_name: "details",
|
|
35
|
proto3_optional: nil,
|
|
36
|
__unknown_fields__: []
|
|
37
|
},
|
|
38
|
%Google.Protobuf.FieldDescriptorProto{
|
|
39
|
name: "updated_at",
|
|
40
|
extendee: nil,
|
|
41
|
number: 3,
|
|
42
|
label: :LABEL_OPTIONAL,
|
|
43
|
type: :TYPE_MESSAGE,
|
|
44
|
type_name: ".google.protobuf.Timestamp",
|
|
45
|
default_value: nil,
|
|
46
|
options: nil,
|
|
47
|
oneof_index: nil,
|
|
48
|
json_name: "updatedAt",
|
|
49
|
proto3_optional: nil,
|
|
50
|
__unknown_fields__: []
|
|
51
|
}
|
|
52
|
],
|
|
53
|
nested_type: [],
|
|
54
|
enum_type: [],
|
|
55
|
extension_range: [],
|
|
56
|
extension: [],
|
|
57
|
options: nil,
|
|
58
|
oneof_decl: [],
|
|
59
|
reserved_range: [],
|
|
60
|
reserved_name: [],
|
|
61
|
__unknown_fields__: []
|
|
62
|
}
|
|
63
|
end
|
|
64
|
|
|
65
|
field(:status, 1, type: :string)
|
|
66
|
field(:details, 2, type: :string)
|
|
67
|
field(:updated_at, 3, type: Google.Protobuf.Timestamp, json_name: "updatedAt")
|
|
68
|
end
|
|
69
|
|
|
70
|
defmodule Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckReply do
|
|
71
|
@moduledoc false
|
|
72
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
73
|
|
|
74
|
def descriptor do
|
|
75
|
# credo:disable-for-next-line
|
|
76
|
%Google.Protobuf.DescriptorProto{
|
|
77
|
name: "HealthCheckReply",
|
|
78
|
field: [
|
|
79
|
%Google.Protobuf.FieldDescriptorProto{
|
|
80
|
name: "status",
|
|
81
|
extendee: nil,
|
|
82
|
number: 1,
|
|
83
|
label: :LABEL_OPTIONAL,
|
|
84
|
type: :TYPE_MESSAGE,
|
|
85
|
type_name: ".eigr.functions.protocol.actors.healthcheck.Status",
|
|
86
|
default_value: nil,
|
|
87
|
options: nil,
|
|
88
|
oneof_index: nil,
|
|
89
|
json_name: "status",
|
|
90
|
proto3_optional: nil,
|
|
91
|
__unknown_fields__: []
|
|
92
|
}
|
|
93
|
],
|
|
94
|
nested_type: [],
|
|
95
|
enum_type: [],
|
|
96
|
extension_range: [],
|
|
97
|
extension: [],
|
|
98
|
options: nil,
|
|
99
|
oneof_decl: [],
|
|
100
|
reserved_range: [],
|
|
101
|
reserved_name: [],
|
|
102
|
__unknown_fields__: []
|
|
103
|
}
|
|
104
|
end
|
|
105
|
|
|
106
|
field(:status, 1, type: Eigr.Functions.Protocol.Actors.Healthcheck.Status)
|
|
107
|
end
|
|
108
|
|
|
109
|
defmodule Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckActor.Service do
|
|
110
|
@moduledoc false
|
|
111
|
use GRPC.Service,
|
|
112
|
name: "eigr.functions.protocol.actors.healthcheck.HealthCheckActor",
|
|
113
|
protoc_gen_elixir_version: "0.12.0"
|
|
114
|
|
|
115
|
def descriptor do
|
|
116
|
# credo:disable-for-next-line
|
|
117
|
%Google.Protobuf.FileDescriptorProto{
|
|
118
|
name: "eigr/functions/protocol/actors/healthcheck.proto",
|
|
119
|
package: "eigr.functions.protocol.actors.healthcheck",
|
|
120
|
dependency: [
|
|
121
|
"google/api/annotations.proto",
|
|
122
|
"google/protobuf/empty.proto",
|
|
123
|
"google/protobuf/timestamp.proto",
|
|
124
|
"eigr/functions/protocol/actors/extensions.proto"
|
|
125
|
],
|
|
126
|
message_type: [
|
|
127
|
%Google.Protobuf.DescriptorProto{
|
|
128
|
name: "Status",
|
|
129
|
field: [
|
|
130
|
%Google.Protobuf.FieldDescriptorProto{
|
|
131
|
name: "status",
|
|
132
|
extendee: nil,
|
|
133
|
number: 1,
|
|
134
|
label: :LABEL_OPTIONAL,
|
|
135
|
type: :TYPE_STRING,
|
|
136
|
type_name: nil,
|
|
137
|
default_value: nil,
|
|
138
|
options: nil,
|
|
139
|
oneof_index: nil,
|
|
140
|
json_name: "status",
|
|
141
|
proto3_optional: nil,
|
|
142
|
__unknown_fields__: []
|
|
143
|
},
|
|
144
|
%Google.Protobuf.FieldDescriptorProto{
|
|
145
|
name: "details",
|
|
146
|
extendee: nil,
|
|
147
|
number: 2,
|
|
148
|
label: :LABEL_OPTIONAL,
|
|
149
|
type: :TYPE_STRING,
|
|
150
|
type_name: nil,
|
|
151
|
default_value: nil,
|
|
152
|
options: nil,
|
|
153
|
oneof_index: nil,
|
|
154
|
json_name: "details",
|
|
155
|
proto3_optional: nil,
|
|
156
|
__unknown_fields__: []
|
|
157
|
},
|
|
158
|
%Google.Protobuf.FieldDescriptorProto{
|
|
159
|
name: "updated_at",
|
|
160
|
extendee: nil,
|
|
161
|
number: 3,
|
|
162
|
label: :LABEL_OPTIONAL,
|
|
163
|
type: :TYPE_MESSAGE,
|
|
164
|
type_name: ".google.protobuf.Timestamp",
|
|
165
|
default_value: nil,
|
|
166
|
options: nil,
|
|
167
|
oneof_index: nil,
|
|
168
|
json_name: "updatedAt",
|
|
169
|
proto3_optional: nil,
|
|
170
|
__unknown_fields__: []
|
|
171
|
}
|
|
172
|
],
|
|
173
|
nested_type: [],
|
|
174
|
enum_type: [],
|
|
175
|
extension_range: [],
|
|
176
|
extension: [],
|
|
177
|
options: nil,
|
|
178
|
oneof_decl: [],
|
|
179
|
reserved_range: [],
|
|
180
|
reserved_name: [],
|
|
181
|
__unknown_fields__: []
|
|
182
|
},
|
|
183
|
%Google.Protobuf.DescriptorProto{
|
|
184
|
name: "HealthCheckReply",
|
|
185
|
field: [
|
|
186
|
%Google.Protobuf.FieldDescriptorProto{
|
|
187
|
name: "status",
|
|
188
|
extendee: nil,
|
|
189
|
number: 1,
|
|
190
|
label: :LABEL_OPTIONAL,
|
|
191
|
type: :TYPE_MESSAGE,
|
|
192
|
type_name: ".eigr.functions.protocol.actors.healthcheck.Status",
|
|
193
|
default_value: nil,
|
|
194
|
options: nil,
|
|
195
|
oneof_index: nil,
|
|
196
|
json_name: "status",
|
|
197
|
proto3_optional: nil,
|
|
198
|
__unknown_fields__: []
|
|
199
|
}
|
|
200
|
],
|
|
201
|
nested_type: [],
|
|
202
|
enum_type: [],
|
|
203
|
extension_range: [],
|
|
204
|
extension: [],
|
|
205
|
options: nil,
|
|
206
|
oneof_decl: [],
|
|
207
|
reserved_range: [],
|
|
208
|
reserved_name: [],
|
|
209
|
__unknown_fields__: []
|
|
210
|
}
|
|
211
|
],
|
|
212
|
enum_type: [],
|
|
213
|
service: [
|
|
214
|
%Google.Protobuf.ServiceDescriptorProto{
|
|
215
|
name: "HealthCheckActor",
|
|
216
|
method: [
|
|
217
|
%Google.Protobuf.MethodDescriptorProto{
|
|
218
|
name: "Liveness",
|
|
219
|
input_type: ".google.protobuf.Empty",
|
|
220
|
output_type: ".eigr.functions.protocol.actors.healthcheck.HealthCheckReply",
|
|
221
|
options: %Google.Protobuf.MethodOptions{
|
|
222
|
deprecated: false,
|
|
223
|
idempotency_level: :IDEMPOTENCY_UNKNOWN,
|
|
224
|
# features: nil,
|
|
225
|
uninterpreted_option: [],
|
|
226
|
__pb_extensions__: %{
|
|
227
|
{Google.Api.PbExtension, :http} => %Google.Api.HttpRule{
|
|
228
|
selector: "",
|
|
229
|
body: "",
|
|
230
|
additional_bindings: [],
|
|
231
|
response_body: "",
|
|
232
|
pattern: {:get, "/health/liveness"},
|
|
233
|
__unknown_fields__: []
|
|
234
|
}
|
|
235
|
},
|
|
236
|
__unknown_fields__: []
|
|
237
|
},
|
|
238
|
client_streaming: false,
|
|
239
|
server_streaming: false,
|
|
240
|
__unknown_fields__: []
|
|
241
|
},
|
|
242
|
%Google.Protobuf.MethodDescriptorProto{
|
|
243
|
name: "Readiness",
|
|
244
|
input_type: ".google.protobuf.Empty",
|
|
245
|
output_type: ".eigr.functions.protocol.actors.healthcheck.HealthCheckReply",
|
|
246
|
options: %Google.Protobuf.MethodOptions{
|
|
247
|
deprecated: false,
|
|
248
|
idempotency_level: :IDEMPOTENCY_UNKNOWN,
|
|
249
|
# features: nil,
|
|
250
|
uninterpreted_option: [],
|
|
251
|
__pb_extensions__: %{
|
|
252
|
{Google.Api.PbExtension, :http} => %Google.Api.HttpRule{
|
|
253
|
selector: "",
|
|
254
|
body: "",
|
|
255
|
additional_bindings: [],
|
|
256
|
response_body: "",
|
|
257
|
pattern: {:get, "/health/readiness"},
|
|
258
|
__unknown_fields__: []
|
|
259
|
}
|
|
260
|
},
|
|
261
|
__unknown_fields__: []
|
|
262
|
},
|
|
263
|
client_streaming: false,
|
|
264
|
server_streaming: false,
|
|
265
|
__unknown_fields__: []
|
|
266
|
}
|
|
267
|
],
|
|
268
|
options: nil,
|
|
269
|
__unknown_fields__: []
|
|
270
|
}
|
|
271
|
],
|
|
272
|
extension: [],
|
|
273
|
options: %Google.Protobuf.FileOptions{
|
|
274
|
java_package: nil,
|
|
275
|
java_outer_classname: nil,
|
|
276
|
optimize_for: :SPEED,
|
|
277
|
java_multiple_files: false,
|
|
278
|
go_package: nil,
|
|
279
|
cc_generic_services: false,
|
|
280
|
java_generic_services: false,
|
|
281
|
py_generic_services: false,
|
|
282
|
java_generate_equals_and_hash: nil,
|
|
283
|
deprecated: false,
|
|
284
|
java_string_check_utf8: false,
|
|
285
|
cc_enable_arenas: true,
|
|
286
|
objc_class_prefix: "HLW",
|
|
287
|
csharp_namespace: nil,
|
|
288
|
swift_prefix: nil,
|
|
289
|
php_class_prefix: nil,
|
|
290
|
php_namespace: nil,
|
|
291
|
php_metadata_namespace: nil,
|
|
292
|
ruby_package: nil,
|
|
293
|
# features: nil,
|
|
294
|
uninterpreted_option: [],
|
|
295
|
__pb_extensions__: %{},
|
|
296
|
__unknown_fields__: []
|
|
297
|
},
|
|
298
|
source_code_info: %Google.Protobuf.SourceCodeInfo{
|
|
299
|
location: [
|
|
300
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
301
|
path: [],
|
|
302
|
span: [0, 0, 35, 1],
|
|
303
|
leading_comments: nil,
|
|
304
|
trailing_comments: nil,
|
|
305
|
leading_detached_comments: [],
|
|
306
|
__unknown_fields__: []
|
|
307
|
},
|
|
308
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
309
|
path: ~c"\f",
|
|
310
|
span: [0, 0, 18],
|
|
311
|
leading_comments: nil,
|
|
312
|
trailing_comments: nil,
|
|
313
|
leading_detached_comments: [],
|
|
314
|
__unknown_fields__: []
|
|
315
|
},
|
|
316
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
317
|
path: ~c"\b",
|
|
318
|
span: [2, 0, 33],
|
|
319
|
leading_comments: nil,
|
|
320
|
trailing_comments: nil,
|
|
321
|
leading_detached_comments: [],
|
|
322
|
__unknown_fields__: []
|
|
323
|
},
|
|
324
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
325
|
path: ~c"\b$",
|
|
326
|
span: [2, 0, 33],
|
|
327
|
leading_comments: nil,
|
|
328
|
trailing_comments: nil,
|
|
329
|
leading_detached_comments: [],
|
|
330
|
__unknown_fields__: []
|
|
331
|
},
|
|
332
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
333
|
path: [3, 0],
|
|
334
|
span: [4, 0, 38],
|
|
335
|
leading_comments: nil,
|
|
336
|
trailing_comments: nil,
|
|
337
|
leading_detached_comments: [],
|
|
338
|
__unknown_fields__: []
|
|
339
|
},
|
|
340
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
341
|
path: [3, 1],
|
|
342
|
span: [5, 0, 37],
|
|
343
|
leading_comments: nil,
|
|
344
|
trailing_comments: nil,
|
|
345
|
leading_detached_comments: [],
|
|
346
|
__unknown_fields__: []
|
|
347
|
},
|
|
348
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
349
|
path: [3, 2],
|
|
350
|
span: [6, 0, 41],
|
|
351
|
leading_comments: nil,
|
|
352
|
trailing_comments: nil,
|
|
353
|
leading_detached_comments: [],
|
|
354
|
__unknown_fields__: []
|
|
355
|
},
|
|
356
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
357
|
path: [3, 3],
|
|
358
|
span: [7, 0, 57],
|
|
359
|
leading_comments: nil,
|
|
360
|
trailing_comments: nil,
|
|
361
|
leading_detached_comments: [],
|
|
362
|
__unknown_fields__: []
|
|
363
|
},
|
|
364
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
365
|
path: [2],
|
|
366
|
span: [9, 0, 51],
|
|
367
|
leading_comments: nil,
|
|
368
|
trailing_comments: nil,
|
|
369
|
leading_detached_comments: [],
|
|
370
|
__unknown_fields__: []
|
|
371
|
},
|
|
372
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
373
|
path: [4, 0],
|
|
374
|
span: [11, 0, 15, 1],
|
|
375
|
leading_comments: nil,
|
|
376
|
trailing_comments: nil,
|
|
377
|
leading_detached_comments: [],
|
|
378
|
__unknown_fields__: []
|
|
379
|
},
|
|
380
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
381
|
path: [4, 0, 1],
|
|
382
|
span: [11, 8, 14],
|
|
383
|
leading_comments: nil,
|
|
384
|
trailing_comments: nil,
|
|
385
|
leading_detached_comments: [],
|
|
386
|
__unknown_fields__: []
|
|
387
|
},
|
|
388
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
389
|
path: [4, 0, 2, 0],
|
|
390
|
span: [12, 2, 20],
|
|
391
|
leading_comments: nil,
|
|
392
|
trailing_comments: nil,
|
|
393
|
leading_detached_comments: [],
|
|
394
|
__unknown_fields__: []
|
|
395
|
},
|
|
396
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
397
|
path: [4, 0, 2, 0, 5],
|
|
398
|
span: [12, 2, 8],
|
|
399
|
leading_comments: nil,
|
|
400
|
trailing_comments: nil,
|
|
401
|
leading_detached_comments: [],
|
|
402
|
__unknown_fields__: []
|
|
403
|
},
|
|
404
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
405
|
path: [4, 0, 2, 0, 1],
|
|
406
|
span: [12, 9, 15],
|
|
407
|
leading_comments: nil,
|
|
408
|
trailing_comments: nil,
|
|
409
|
leading_detached_comments: [],
|
|
410
|
__unknown_fields__: []
|
|
411
|
},
|
|
412
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
413
|
path: [4, 0, 2, 0, 3],
|
|
414
|
span: [12, 18, 19],
|
|
415
|
leading_comments: nil,
|
|
416
|
trailing_comments: nil,
|
|
417
|
leading_detached_comments: [],
|
|
418
|
__unknown_fields__: []
|
|
419
|
},
|
|
420
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
421
|
path: [4, 0, 2, 1],
|
|
422
|
span: [13, 2, 21],
|
|
423
|
leading_comments: nil,
|
|
424
|
trailing_comments: nil,
|
|
425
|
leading_detached_comments: [],
|
|
426
|
__unknown_fields__: []
|
|
427
|
},
|
|
428
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
429
|
path: [4, 0, 2, 1, 5],
|
|
430
|
span: [13, 2, 8],
|
|
431
|
leading_comments: nil,
|
|
432
|
trailing_comments: nil,
|
|
433
|
leading_detached_comments: [],
|
|
434
|
__unknown_fields__: []
|
|
435
|
},
|
|
436
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
437
|
path: [4, 0, 2, 1, 1],
|
|
438
|
span: [13, 9, 16],
|
|
439
|
leading_comments: nil,
|
|
440
|
trailing_comments: nil,
|
|
441
|
leading_detached_comments: [],
|
|
442
|
__unknown_fields__: []
|
|
443
|
},
|
|
444
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
445
|
path: [4, 0, 2, 1, 3],
|
|
446
|
span: [13, 19, 20],
|
|
447
|
leading_comments: nil,
|
|
448
|
trailing_comments: nil,
|
|
449
|
leading_detached_comments: [],
|
|
450
|
__unknown_fields__: []
|
|
451
|
},
|
|
452
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
453
|
path: [4, 0, 2, 2],
|
|
454
|
span: [14, 2, 43],
|
|
455
|
leading_comments: nil,
|
|
456
|
trailing_comments: nil,
|
|
457
|
leading_detached_comments: [],
|
|
458
|
__unknown_fields__: []
|
|
459
|
},
|
|
460
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
461
|
path: [4, 0, 2, 2, 6],
|
|
462
|
span: [14, 2, 27],
|
|
463
|
leading_comments: nil,
|
|
464
|
trailing_comments: nil,
|
|
465
|
leading_detached_comments: [],
|
|
466
|
__unknown_fields__: []
|
|
467
|
},
|
|
468
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
469
|
path: [4, 0, 2, 2, 1],
|
|
470
|
span: [14, 28, 38],
|
|
471
|
leading_comments: nil,
|
|
472
|
trailing_comments: nil,
|
|
473
|
leading_detached_comments: [],
|
|
474
|
__unknown_fields__: []
|
|
475
|
},
|
|
476
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
477
|
path: [4, 0, 2, 2, 3],
|
|
478
|
span: [14, 41, 42],
|
|
479
|
leading_comments: nil,
|
|
480
|
trailing_comments: nil,
|
|
481
|
leading_detached_comments: [],
|
|
482
|
__unknown_fields__: []
|
|
483
|
},
|
|
484
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
485
|
path: [4, 1],
|
|
486
|
span: [18, 0, 47],
|
|
487
|
leading_comments: " The state of HealthCheckActor\n",
|
|
488
|
trailing_comments: nil,
|
|
489
|
leading_detached_comments: [],
|
|
490
|
__unknown_fields__: []
|
|
491
|
},
|
|
492
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
493
|
path: [4, 1, 1],
|
|
494
|
span: [18, 8, 24],
|
|
495
|
leading_comments: nil,
|
|
496
|
trailing_comments: nil,
|
|
497
|
leading_detached_comments: [],
|
|
498
|
__unknown_fields__: []
|
|
499
|
},
|
|
500
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
501
|
path: [4, 1, 2, 0],
|
|
502
|
span: [18, 27, 45],
|
|
503
|
leading_comments: nil,
|
|
504
|
trailing_comments: nil,
|
|
505
|
leading_detached_comments: [],
|
|
506
|
__unknown_fields__: []
|
|
507
|
},
|
|
508
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
509
|
path: [4, 1, 2, 0, 6],
|
|
510
|
span: [18, 27, 33],
|
|
511
|
leading_comments: nil,
|
|
512
|
trailing_comments: nil,
|
|
513
|
leading_detached_comments: [],
|
|
514
|
__unknown_fields__: []
|
|
515
|
},
|
|
516
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
517
|
path: [4, 1, 2, 0, 1],
|
|
518
|
span: [18, 34, 40],
|
|
519
|
leading_comments: nil,
|
|
520
|
trailing_comments: nil,
|
|
521
|
leading_detached_comments: [],
|
|
522
|
__unknown_fields__: []
|
|
523
|
},
|
|
524
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
525
|
path: [4, 1, 2, 0, 3],
|
|
526
|
span: [18, 43, 44],
|
|
527
|
leading_comments: nil,
|
|
528
|
trailing_comments: nil,
|
|
529
|
leading_detached_comments: [],
|
|
530
|
__unknown_fields__: []
|
|
531
|
},
|
|
532
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
533
|
path: [6, 0],
|
|
534
|
span: [21, 0, 35, 1],
|
|
535
|
leading_comments: " The HealthCheck actor service definition.\n",
|
|
536
|
trailing_comments: nil,
|
|
537
|
leading_detached_comments: [],
|
|
538
|
__unknown_fields__: []
|
|
539
|
},
|
|
540
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
541
|
path: [6, 0, 1],
|
|
542
|
span: [21, 8, 24],
|
|
543
|
leading_comments: nil,
|
|
544
|
trailing_comments: nil,
|
|
545
|
leading_detached_comments: [],
|
|
546
|
__unknown_fields__: []
|
|
547
|
},
|
|
548
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
549
|
path: [6, 0, 2, 0],
|
|
550
|
span: [24, 2, 28, 3],
|
|
551
|
leading_comments: " Get Pong Message\n",
|
|
552
|
trailing_comments: nil,
|
|
553
|
leading_detached_comments: [],
|
|
554
|
__unknown_fields__: []
|
|
555
|
},
|
|
556
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
557
|
path: [6, 0, 2, 0, 1],
|
|
558
|
span: [24, 6, 14],
|
|
559
|
leading_comments: nil,
|
|
560
|
trailing_comments: nil,
|
|
561
|
leading_detached_comments: [],
|
|
562
|
__unknown_fields__: []
|
|
563
|
},
|
|
564
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
565
|
path: [6, 0, 2, 0, 2],
|
|
566
|
span: [24, 15, 36],
|
|
567
|
leading_comments: nil,
|
|
568
|
trailing_comments: nil,
|
|
569
|
leading_detached_comments: [],
|
|
570
|
__unknown_fields__: []
|
|
571
|
},
|
|
572
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
573
|
path: [6, 0, 2, 0, 3],
|
|
574
|
span: [24, 47, 63],
|
|
575
|
leading_comments: nil,
|
|
576
|
trailing_comments: nil,
|
|
577
|
leading_detached_comments: [],
|
|
578
|
__unknown_fields__: []
|
|
579
|
},
|
|
580
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
581
|
path: [6, 0, 2, 0, 4],
|
|
582
|
span: [25, 4, 27, 6],
|
|
583
|
leading_comments: nil,
|
|
584
|
trailing_comments: nil,
|
|
585
|
leading_detached_comments: [],
|
|
586
|
__unknown_fields__: []
|
|
587
|
},
|
|
588
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
589
|
path: [6, 0, 2, 0, 4, 72_295_728],
|
|
590
|
span: [25, 4, 27, 6],
|
|
591
|
leading_comments: nil,
|
|
592
|
trailing_comments: nil,
|
|
593
|
leading_detached_comments: [],
|
|
863
|
__unknown_fields__: []
|
|
595
|
},
|
|
596
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
597
|
path: [6, 0, 2, 1],
|
|
598
|
span: [30, 2, 34, 3],
|
|
599
|
leading_comments: nil,
|
|
600
|
trailing_comments: nil,
|
|
601
|
leading_detached_comments: [],
|
|
602
|
__unknown_fields__: []
|
|
603
|
},
|
|
604
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
605
|
path: [6, 0, 2, 1, 1],
|
|
606
|
span: [30, 6, 15],
|
|
607
|
leading_comments: nil,
|
|
608
|
trailing_comments: nil,
|
|
609
|
leading_detached_comments: [],
|
|
610
|
__unknown_fields__: []
|
|
611
|
},
|
|
612
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
613
|
path: [6, 0, 2, 1, 2],
|
|
614
|
span: [30, 16, 37],
|
|
615
|
leading_comments: nil,
|
|
616
|
trailing_comments: nil,
|
|
617
|
leading_detached_comments: [],
|
|
618
|
__unknown_fields__: []
|
|
619
|
},
|
|
620
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
621
|
path: [6, 0, 2, 1, 3],
|
|
622
|
span: [30, 48, 64],
|
|
623
|
leading_comments: nil,
|
|
624
|
trailing_comments: nil,
|
|
625
|
leading_detached_comments: [],
|
|
626
|
__unknown_fields__: []
|
|
627
|
},
|
|
628
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
629
|
path: [6, 0, 2, 1, 4],
|
|
630
|
span: [31, 4, 33, 6],
|
|
631
|
leading_comments: nil,
|
|
632
|
trailing_comments: nil,
|
|
633
|
leading_detached_comments: [],
|
|
634
|
__unknown_fields__: []
|
|
635
|
},
|
|
636
|
%Google.Protobuf.SourceCodeInfo.Location{
|
|
637
|
path: [6, 0, 2, 1, 4, 72_295_728],
|
|
638
|
span: [31, 4, 33, 6],
|
|
639
|
leading_comments: nil,
|
|
640
|
trailing_comments: nil,
|
|
641
|
leading_detached_comments: [],
|
|
642
|
__unknown_fields__: []
|
|
643
|
}
|
|
644
|
],
|
|
645
|
__unknown_fields__: []
|
|
646
|
},
|
|
647
|
public_dependency: [],
|
|
648
|
weak_dependency: [],
|
|
649
|
syntax: "proto3",
|
|
650
|
edition: nil,
|
|
651
|
__unknown_fields__: []
|
|
652
|
}
|
|
653
|
end
|
|
654
|
|
|
655
|
rpc(
|
|
656
|
:Liveness,
|
|
657
|
Google.Protobuf.Empty,
|
|
658
|
Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckReply,
|
|
659
|
%{
|
|
660
|
http: %{
|
|
661
|
type: Google.Api.PbExtension,
|
|
662
|
value: %Google.Api.HttpRule{
|
|
663
|
selector: "",
|
|
664
|
body: "",
|
|
665
|
additional_bindings: [],
|
|
666
|
response_body: "",
|
|
667
|
pattern: {:get, "/health/liveness"},
|
|
668
|
__unknown_fields__: []
|
|
669
|
}
|
|
670
|
}
|
|
671
|
}
|
|
672
|
)
|
|
673
|
|
|
674
|
rpc(
|
|
675
|
:Readiness,
|
|
676
|
Google.Protobuf.Empty,
|
|
677
|
Eigr.Functions.Protocol.Actors.Healthcheck.HealthCheckReply,
|
|
678
|
%{
|
|
679
|
http: %{
|
|
680
|
type: Google.Api.PbExtension,
|
|
681
|
value: %Google.Api.HttpRule{
|
|
682
|
selector: "",
|
|
683
|
body: "",
|
|
684
|
additional_bindings: [],
|
|
685
|
response_body: "",
|
|
686
|
pattern: {:get, "/health/readiness"},
|
|
687
|
__unknown_fields__: []
|
|
688
|
}
|
|
689
|
}
|
|
690
|
}
|
|
691
|
)
|
|
692
|
end
|
added
lib/spawn/actors/eigr/functions/protocol/actors/protocol.pb.ex
|
|
@@ -0,0 1,1904 @@
|
|
1
|
defmodule Eigr.Functions.Protocol.Status do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.EnumDescriptorProto{
|
|
8
|
name: "Status",
|
|
9
|
value: [
|
|
10
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
11
|
name: "UNKNOWN",
|
|
12
|
number: 0,
|
|
13
|
options: nil,
|
|
14
|
__unknown_fields__: []
|
|
15
|
},
|
|
16
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
17
|
name: "OK",
|
|
18
|
number: 1,
|
|
19
|
options: nil,
|
|
20
|
__unknown_fields__: []
|
|
21
|
},
|
|
22
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
23
|
name: "ACTOR_NOT_FOUND",
|
|
24
|
number: 2,
|
|
25
|
options: nil,
|
|
26
|
__unknown_fields__: []
|
|
27
|
},
|
|
28
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
29
|
name: "ERROR",
|
|
30
|
number: 3,
|
|
31
|
options: nil,
|
|
32
|
__unknown_fields__: []
|
|
33
|
}
|
|
34
|
],
|
|
35
|
options: nil,
|
|
36
|
reserved_range: [],
|
|
37
|
reserved_name: [],
|
|
38
|
__unknown_fields__: []
|
|
39
|
}
|
|
40
|
end
|
|
41
|
|
|
42
|
field(:UNKNOWN, 0)
|
|
43
|
field(:OK, 1)
|
|
44
|
field(:ACTOR_NOT_FOUND, 2)
|
|
45
|
field(:ERROR, 3)
|
|
46
|
end
|
|
47
|
|
|
48
|
defmodule Eigr.Functions.Protocol.Context.MetadataEntry do
|
|
49
|
@moduledoc false
|
|
50
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
51
|
|
|
52
|
def descriptor do
|
|
53
|
# credo:disable-for-next-line
|
|
54
|
%Google.Protobuf.DescriptorProto{
|
|
55
|
name: "MetadataEntry",
|
|
56
|
field: [
|
|
57
|
%Google.Protobuf.FieldDescriptorProto{
|
|
58
|
name: "key",
|
|
59
|
extendee: nil,
|
|
60
|
number: 1,
|
|
61
|
label: :LABEL_OPTIONAL,
|
|
62
|
type: :TYPE_STRING,
|
|
63
|
type_name: nil,
|
|
64
|
default_value: nil,
|
|
65
|
options: nil,
|
|
66
|
oneof_index: nil,
|
|
67
|
json_name: "key",
|
|
68
|
proto3_optional: nil,
|
|
69
|
__unknown_fields__: []
|
|
70
|
},
|
|
71
|
%Google.Protobuf.FieldDescriptorProto{
|
|
72
|
name: "value",
|
|
73
|
extendee: nil,
|
|
74
|
number: 2,
|
|
75
|
label: :LABEL_OPTIONAL,
|
|
76
|
type: :TYPE_STRING,
|
|
77
|
type_name: nil,
|
|
78
|
default_value: nil,
|
|
79
|
options: nil,
|
|
80
|
oneof_index: nil,
|
|
81
|
json_name: "value",
|
|
82
|
proto3_optional: nil,
|
|
83
|
__unknown_fields__: []
|
|
84
|
}
|
|
85
|
],
|
|
86
|
nested_type: [],
|
|
87
|
enum_type: [],
|
|
88
|
extension_range: [],
|
|
89
|
extension: [],
|
|
90
|
options: %Google.Protobuf.MessageOptions{
|
|
91
|
message_set_wire_format: false,
|
|
92
|
no_standard_descriptor_accessor: false,
|
|
93
|
deprecated: false,
|
|
94
|
map_entry: true,
|
|
95
|
deprecated_legacy_json_field_conflicts: nil,
|
|
96
|
# features: nil,
|
|
97
|
uninterpreted_option: [],
|
|
98
|
__pb_extensions__: %{},
|
|
99
|
__unknown_fields__: []
|
|
100
|
},
|
|
101
|
oneof_decl: [],
|
|
102
|
reserved_range: [],
|
|
103
|
reserved_name: [],
|
|
104
|
__unknown_fields__: []
|
|
105
|
}
|
|
106
|
end
|
|
107
|
|
|
108
|
field(:key, 1, type: :string)
|
|
109
|
field(:value, 2, type: :string)
|
|
110
|
end
|
|
111
|
|
|
112
|
defmodule Eigr.Functions.Protocol.Context.TagsEntry do
|
|
113
|
@moduledoc false
|
|
114
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
115
|
|
|
116
|
def descriptor do
|
|
117
|
# credo:disable-for-next-line
|
|
118
|
%Google.Protobuf.DescriptorProto{
|
|
119
|
name: "TagsEntry",
|
|
120
|
field: [
|
|
121
|
%Google.Protobuf.FieldDescriptorProto{
|
|
122
|
name: "key",
|
|
123
|
extendee: nil,
|
|
124
|
number: 1,
|
|
125
|
label: :LABEL_OPTIONAL,
|
|
126
|
type: :TYPE_STRING,
|
|
127
|
type_name: nil,
|
|
128
|
default_value: nil,
|
|
129
|
options: nil,
|
|
130
|
oneof_index: nil,
|
|
131
|
json_name: "key",
|
|
132
|
proto3_optional: nil,
|
|
133
|
__unknown_fields__: []
|
|
134
|
},
|
|
135
|
%Google.Protobuf.FieldDescriptorProto{
|
|
136
|
name: "value",
|
|
137
|
extendee: nil,
|
|
138
|
number: 2,
|
|
139
|
label: :LABEL_OPTIONAL,
|
|
140
|
type: :TYPE_STRING,
|
|
141
|
type_name: nil,
|
|
142
|
default_value: nil,
|
|
143
|
options: nil,
|
|
144
|
oneof_index: nil,
|
|
145
|
json_name: "value",
|
|
146
|
proto3_optional: nil,
|
|
147
|
__unknown_fields__: []
|
|
148
|
}
|
|
149
|
],
|
|
150
|
nested_type: [],
|
|
151
|
enum_type: [],
|
|
152
|
extension_range: [],
|
|
153
|
extension: [],
|
|
154
|
options: %Google.Protobuf.MessageOptions{
|
|
155
|
message_set_wire_format: false,
|
|
156
|
no_standard_descriptor_accessor: false,
|
|
157
|
deprecated: false,
|
|
158
|
map_entry: true,
|
|
159
|
deprecated_legacy_json_field_conflicts: nil,
|
|
160
|
# features: nil,
|
|
161
|
uninterpreted_option: [],
|
|
162
|
__pb_extensions__: %{},
|
|
163
|
__unknown_fields__: []
|
|
164
|
},
|
|
165
|
oneof_decl: [],
|
|
166
|
reserved_range: [],
|
|
167
|
reserved_name: [],
|
|
168
|
__unknown_fields__: []
|
|
169
|
}
|
|
170
|
end
|
|
171
|
|
|
172
|
field(:key, 1, type: :string)
|
|
173
|
field(:value, 2, type: :string)
|
|
174
|
end
|
|
175
|
|
|
176
|
defmodule Eigr.Functions.Protocol.Context do
|
|
177
|
@moduledoc false
|
|
178
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
179
|
|
|
180
|
def descriptor do
|
|
181
|
# credo:disable-for-next-line
|
|
182
|
%Google.Protobuf.DescriptorProto{
|
|
183
|
name: "Context",
|
|
184
|
field: [
|
|
185
|
%Google.Protobuf.FieldDescriptorProto{
|
|
186
|
name: "state",
|
|
187
|
extendee: nil,
|
|
188
|
number: 1,
|
|
189
|
label: :LABEL_OPTIONAL,
|
|
190
|
type: :TYPE_MESSAGE,
|
|
191
|
type_name: ".google.protobuf.Any",
|
|
192
|
default_value: nil,
|
|
193
|
options: nil,
|
|
194
|
oneof_index: nil,
|
|
195
|
json_name: "state",
|
|
196
|
proto3_optional: nil,
|
|
197
|
__unknown_fields__: []
|
|
198
|
},
|
|
199
|
%Google.Protobuf.FieldDescriptorProto{
|
|
200
|
name: "metadata",
|
|
201
|
extendee: nil,
|
|
202
|
number: 4,
|
|
203
|
label: :LABEL_REPEATED,
|
|
204
|
type: :TYPE_MESSAGE,
|
|
205
|
type_name: ".eigr.functions.protocol.Context.MetadataEntry",
|
|
206
|
default_value: nil,
|
|
207
|
options: nil,
|
|
208
|
oneof_index: nil,
|
|
209
|
json_name: "metadata",
|
|
210
|
proto3_optional: nil,
|
|
211
|
__unknown_fields__: []
|
|
212
|
},
|
|
213
|
%Google.Protobuf.FieldDescriptorProto{
|
|
214
|
name: "tags",
|
|
215
|
extendee: nil,
|
|
216
|
number: 5,
|
|
217
|
label: :LABEL_REPEATED,
|
|
218
|
type: :TYPE_MESSAGE,
|
|
219
|
type_name: ".eigr.functions.protocol.Context.TagsEntry",
|
|
220
|
default_value: nil,
|
|
221
|
options: nil,
|
|
222
|
oneof_index: nil,
|
|
223
|
json_name: "tags",
|
|
224
|
proto3_optional: nil,
|
|
225
|
__unknown_fields__: []
|
|
226
|
},
|
|
227
|
%Google.Protobuf.FieldDescriptorProto{
|
|
228
|
name: "caller",
|
|
229
|
extendee: nil,
|
|
230
|
number: 2,
|
|
231
|
label: :LABEL_OPTIONAL,
|
|
232
|
type: :TYPE_MESSAGE,
|
|
233
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
234
|
default_value: nil,
|
|
235
|
options: nil,
|
|
236
|
oneof_index: nil,
|
|
237
|
json_name: "caller",
|
|
238
|
proto3_optional: nil,
|
|
239
|
__unknown_fields__: []
|
|
240
|
},
|
|
241
|
%Google.Protobuf.FieldDescriptorProto{
|
|
242
|
name: "self",
|
|
243
|
extendee: nil,
|
|
244
|
number: 3,
|
|
245
|
label: :LABEL_OPTIONAL,
|
|
246
|
type: :TYPE_MESSAGE,
|
|
247
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
248
|
default_value: nil,
|
|
249
|
options: nil,
|
|
250
|
oneof_index: nil,
|
|
251
|
json_name: "self",
|
|
252
|
proto3_optional: nil,
|
|
253
|
__unknown_fields__: []
|
|
254
|
}
|
|
255
|
],
|
|
256
|
nested_type: [
|
|
257
|
%Google.Protobuf.DescriptorProto{
|
|
258
|
name: "MetadataEntry",
|
|
259
|
field: [
|
|
260
|
%Google.Protobuf.FieldDescriptorProto{
|
|
261
|
name: "key",
|
|
262
|
extendee: nil,
|
|
263
|
number: 1,
|
|
264
|
label: :LABEL_OPTIONAL,
|
|
265
|
type: :TYPE_STRING,
|
|
266
|
type_name: nil,
|
|
267
|
default_value: nil,
|
|
268
|
options: nil,
|
|
269
|
oneof_index: nil,
|
|
270
|
json_name: "key",
|
|
271
|
proto3_optional: nil,
|
|
272
|
__unknown_fields__: []
|
|
273
|
},
|
|
274
|
%Google.Protobuf.FieldDescriptorProto{
|
|
275
|
name: "value",
|
|
276
|
extendee: nil,
|
|
277
|
number: 2,
|
|
278
|
label: :LABEL_OPTIONAL,
|
|
279
|
type: :TYPE_STRING,
|
|
280
|
type_name: nil,
|
|
281
|
default_value: nil,
|
|
282
|
options: nil,
|
|
283
|
oneof_index: nil,
|
|
284
|
json_name: "value",
|
|
285
|
proto3_optional: nil,
|
|
286
|
__unknown_fields__: []
|
|
287
|
}
|
|
288
|
],
|
|
289
|
nested_type: [],
|
|
290
|
enum_type: [],
|
|
291
|
extension_range: [],
|
|
292
|
extension: [],
|
|
293
|
options: %Google.Protobuf.MessageOptions{
|
|
294
|
message_set_wire_format: false,
|
|
295
|
no_standard_descriptor_accessor: false,
|
|
296
|
deprecated: false,
|
|
297
|
map_entry: true,
|
|
298
|
deprecated_legacy_json_field_conflicts: nil,
|
|
299
|
# features: nil,
|
|
300
|
uninterpreted_option: [],
|
|
301
|
__pb_extensions__: %{},
|
|
302
|
__unknown_fields__: []
|
|
303
|
},
|
|
304
|
oneof_decl: [],
|
|
305
|
reserved_range: [],
|
|
306
|
reserved_name: [],
|
|
307
|
__unknown_fields__: []
|
|
308
|
},
|
|
309
|
%Google.Protobuf.DescriptorProto{
|
|
310
|
name: "TagsEntry",
|
|
311
|
field: [
|
|
312
|
%Google.Protobuf.FieldDescriptorProto{
|
|
313
|
name: "key",
|
|
314
|
extendee: nil,
|
|
315
|
number: 1,
|
|
316
|
label: :LABEL_OPTIONAL,
|
|
317
|
type: :TYPE_STRING,
|
|
318
|
type_name: nil,
|
|
319
|
default_value: nil,
|
|
320
|
options: nil,
|
|
321
|
oneof_index: nil,
|
|
322
|
json_name: "key",
|
|
323
|
proto3_optional: nil,
|
|
324
|
__unknown_fields__: []
|
|
325
|
},
|
|
326
|
%Google.Protobuf.FieldDescriptorProto{
|
|
327
|
name: "value",
|
|
328
|
extendee: nil,
|
|
329
|
number: 2,
|
|
330
|
label: :LABEL_OPTIONAL,
|
|
331
|
type: :TYPE_STRING,
|
|
332
|
type_name: nil,
|
|
333
|
default_value: nil,
|
|
334
|
options: nil,
|
|
335
|
oneof_index: nil,
|
|
336
|
json_name: "value",
|
|
337
|
proto3_optional: nil,
|
|
338
|
__unknown_fields__: []
|
|
339
|
}
|
|
340
|
],
|
|
341
|
nested_type: [],
|
|
342
|
enum_type: [],
|
|
343
|
extension_range: [],
|
|
344
|
extension: [],
|
|
345
|
options: %Google.Protobuf.MessageOptions{
|
|
346
|
message_set_wire_format: false,
|
|
347
|
no_standard_descriptor_accessor: false,
|
|
348
|
deprecated: false,
|
|
349
|
map_entry: true,
|
|
350
|
deprecated_legacy_json_field_conflicts: nil,
|
|
351
|
# features: nil,
|
|
352
|
uninterpreted_option: [],
|
|
353
|
__pb_extensions__: %{},
|
|
354
|
__unknown_fields__: []
|
|
355
|
},
|
|
356
|
oneof_decl: [],
|
|
357
|
reserved_range: [],
|
|
358
|
reserved_name: [],
|
|
359
|
__unknown_fields__: []
|
|
360
|
}
|
|
361
|
],
|
|
362
|
enum_type: [],
|
|
363
|
extension_range: [],
|
|
364
|
extension: [],
|
|
365
|
options: nil,
|
|
366
|
oneof_decl: [],
|
|
367
|
reserved_range: [],
|
|
368
|
reserved_name: [],
|
|
369
|
__unknown_fields__: []
|
|
370
|
}
|
|
371
|
end
|
|
372
|
|
|
373
|
field(:state, 1, type: Google.Protobuf.Any)
|
|
374
|
|
|
375
|
field(:metadata, 4,
|
|
376
|
repeated: true,
|
|
377
|
type: Eigr.Functions.Protocol.Context.MetadataEntry,
|
|
378
|
map: true
|
|
379
|
)
|
|
380
|
|
|
381
|
field(:tags, 5, repeated: true, type: Eigr.Functions.Protocol.Context.TagsEntry, map: true)
|
|
382
|
field(:caller, 2, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
383
|
field(:self, 3, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
384
|
end
|
|
385
|
|
|
386
|
defmodule Eigr.Functions.Protocol.Noop do
|
|
387
|
@moduledoc false
|
|
388
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
389
|
|
|
390
|
def descriptor do
|
|
391
|
# credo:disable-for-next-line
|
|
392
|
%Google.Protobuf.DescriptorProto{
|
|
393
|
name: "Noop",
|
|
394
|
field: [],
|
|
395
|
nested_type: [],
|
|
396
|
enum_type: [],
|
|
397
|
extension_range: [],
|
|
398
|
extension: [],
|
|
399
|
options: nil,
|
|
400
|
oneof_decl: [],
|
|
401
|
reserved_range: [],
|
|
402
|
reserved_name: [],
|
|
403
|
__unknown_fields__: []
|
|
404
|
}
|
|
405
|
end
|
|
406
|
end
|
|
407
|
|
|
408
|
defmodule Eigr.Functions.Protocol.JSONType do
|
|
409
|
@moduledoc false
|
|
410
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
411
|
|
|
412
|
def descriptor do
|
|
413
|
# credo:disable-for-next-line
|
|
414
|
%Google.Protobuf.DescriptorProto{
|
|
415
|
name: "JSONType",
|
|
416
|
field: [
|
|
417
|
%Google.Protobuf.FieldDescriptorProto{
|
|
418
|
name: "content",
|
|
419
|
extendee: nil,
|
|
420
|
number: 1,
|
|
421
|
label: :LABEL_OPTIONAL,
|
|
422
|
type: :TYPE_STRING,
|
|
423
|
type_name: nil,
|
|
424
|
default_value: nil,
|
|
425
|
options: nil,
|
|
426
|
oneof_index: nil,
|
|
427
|
json_name: "content",
|
|
428
|
proto3_optional: nil,
|
|
429
|
__unknown_fields__: []
|
|
430
|
}
|
|
431
|
],
|
|
432
|
nested_type: [],
|
|
433
|
enum_type: [],
|
|
434
|
extension_range: [],
|
|
435
|
extension: [],
|
|
436
|
options: nil,
|
|
437
|
oneof_decl: [],
|
|
438
|
reserved_range: [],
|
|
439
|
reserved_name: [],
|
|
440
|
__unknown_fields__: []
|
|
441
|
}
|
|
442
|
end
|
|
443
|
|
|
444
|
field(:content, 1, type: :string)
|
|
445
|
end
|
|
446
|
|
|
447
|
defmodule Eigr.Functions.Protocol.RegistrationRequest do
|
|
448
|
@moduledoc false
|
|
449
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
450
|
|
|
451
|
def descriptor do
|
|
452
|
# credo:disable-for-next-line
|
|
453
|
%Google.Protobuf.DescriptorProto{
|
|
454
|
name: "RegistrationRequest",
|
|
455
|
field: [
|
|
456
|
%Google.Protobuf.FieldDescriptorProto{
|
|
457
|
name: "service_info",
|
|
458
|
extendee: nil,
|
|
459
|
number: 1,
|
|
460
|
label: :LABEL_OPTIONAL,
|
|
461
|
type: :TYPE_MESSAGE,
|
|
462
|
type_name: ".eigr.functions.protocol.ServiceInfo",
|
|
463
|
default_value: nil,
|
|
464
|
options: nil,
|
|
465
|
oneof_index: nil,
|
|
466
|
json_name: "serviceInfo",
|
|
467
|
proto3_optional: nil,
|
|
468
|
__unknown_fields__: []
|
|
469
|
},
|
|
470
|
%Google.Protobuf.FieldDescriptorProto{
|
|
471
|
name: "actor_system",
|
|
472
|
extendee: nil,
|
|
473
|
number: 2,
|
|
474
|
label: :LABEL_OPTIONAL,
|
|
475
|
type: :TYPE_MESSAGE,
|
|
476
|
type_name: ".eigr.functions.protocol.actors.ActorSystem",
|
|
477
|
default_value: nil,
|
|
478
|
options: nil,
|
|
479
|
oneof_index: nil,
|
|
480
|
json_name: "actorSystem",
|
|
481
|
proto3_optional: nil,
|
|
482
|
__unknown_fields__: []
|
|
483
|
}
|
|
484
|
],
|
|
485
|
nested_type: [],
|
|
486
|
enum_type: [],
|
|
487
|
extension_range: [],
|
|
488
|
extension: [],
|
|
489
|
options: nil,
|
|
490
|
oneof_decl: [],
|
|
491
|
reserved_range: [],
|
|
492
|
reserved_name: [],
|
|
493
|
__unknown_fields__: []
|
|
494
|
}
|
|
495
|
end
|
|
496
|
|
|
497
|
field(:service_info, 1, type: Eigr.Functions.Protocol.ServiceInfo, json_name: "serviceInfo")
|
|
498
|
|
|
499
|
field(:actor_system, 2,
|
|
500
|
type: Eigr.Functions.Protocol.Actors.ActorSystem,
|
|
501
|
json_name: "actorSystem"
|
|
502
|
)
|
|
503
|
end
|
|
504
|
|
|
505
|
defmodule Eigr.Functions.Protocol.RegistrationResponse do
|
|
506
|
@moduledoc false
|
|
507
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
508
|
|
|
509
|
def descriptor do
|
|
510
|
# credo:disable-for-next-line
|
|
511
|
%Google.Protobuf.DescriptorProto{
|
|
512
|
name: "RegistrationResponse",
|
|
513
|
field: [
|
|
514
|
%Google.Protobuf.FieldDescriptorProto{
|
|
515
|
name: "status",
|
|
516
|
extendee: nil,
|
|
517
|
number: 1,
|
|
518
|
label: :LABEL_OPTIONAL,
|
|
519
|
type: :TYPE_MESSAGE,
|
|
520
|
type_name: ".eigr.functions.protocol.RequestStatus",
|
|
521
|
default_value: nil,
|
|
522
|
options: nil,
|
|
523
|
oneof_index: nil,
|
|
524
|
json_name: "status",
|
|
525
|
proto3_optional: nil,
|
|
526
|
__unknown_fields__: []
|
|
527
|
},
|
|
528
|
%Google.Protobuf.FieldDescriptorProto{
|
|
529
|
name: "proxy_info",
|
|
530
|
extendee: nil,
|
|
531
|
number: 2,
|
|
532
|
label: :LABEL_OPTIONAL,
|
|
533
|
type: :TYPE_MESSAGE,
|
|
534
|
type_name: ".eigr.functions.protocol.ProxyInfo",
|
|
535
|
default_value: nil,
|
|
536
|
options: nil,
|
|
537
|
oneof_index: nil,
|
|
538
|
json_name: "proxyInfo",
|
|
539
|
proto3_optional: nil,
|
|
540
|
__unknown_fields__: []
|
|
541
|
}
|
|
542
|
],
|
|
543
|
nested_type: [],
|
|
544
|
enum_type: [],
|
|
545
|
extension_range: [],
|
|
546
|
extension: [],
|
|
547
|
options: nil,
|
|
548
|
oneof_decl: [],
|
|
549
|
reserved_range: [],
|
|
550
|
reserved_name: [],
|
|
551
|
__unknown_fields__: []
|
|
552
|
}
|
|
553
|
end
|
|
554
|
|
|
555
|
field(:status, 1, type: Eigr.Functions.Protocol.RequestStatus)
|
|
556
|
field(:proxy_info, 2, type: Eigr.Functions.Protocol.ProxyInfo, json_name: "proxyInfo")
|
|
557
|
end
|
|
558
|
|
|
559
|
defmodule Eigr.Functions.Protocol.ServiceInfo do
|
|
560
|
@moduledoc false
|
|
561
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
562
|
|
|
563
|
def descriptor do
|
|
564
|
# credo:disable-for-next-line
|
|
565
|
%Google.Protobuf.DescriptorProto{
|
|
566
|
name: "ServiceInfo",
|
|
567
|
field: [
|
|
568
|
%Google.Protobuf.FieldDescriptorProto{
|
|
569
|
name: "service_name",
|
|
570
|
extendee: nil,
|
|
571
|
number: 1,
|
|
572
|
label: :LABEL_OPTIONAL,
|
|
573
|
type: :TYPE_STRING,
|
|
574
|
type_name: nil,
|
|
575
|
default_value: nil,
|
|
576
|
options: nil,
|
|
577
|
oneof_index: nil,
|
|
578
|
json_name: "serviceName",
|
|
579
|
proto3_optional: nil,
|
|
580
|
__unknown_fields__: []
|
|
581
|
},
|
|
582
|
%Google.Protobuf.FieldDescriptorProto{
|
|
583
|
name: "service_version",
|
|
584
|
extendee: nil,
|
|
585
|
number: 2,
|
|
586
|
label: :LABEL_OPTIONAL,
|
|
587
|
type: :TYPE_STRING,
|
|
588
|
type_name: nil,
|
|
589
|
default_value: nil,
|
|
590
|
options: nil,
|
|
591
|
oneof_index: nil,
|
|
592
|
json_name: "serviceVersion",
|
|
593
|
proto3_optional: nil,
|
|
863
|
__unknown_fields__: []
|
|
595
|
},
|
|
596
|
%Google.Protobuf.FieldDescriptorProto{
|
|
597
|
name: "service_runtime",
|
|
598
|
extendee: nil,
|
|
599
|
number: 3,
|
|
600
|
label: :LABEL_OPTIONAL,
|
|
601
|
type: :TYPE_STRING,
|
|
602
|
type_name: nil,
|
|
603
|
default_value: nil,
|
|
604
|
options: nil,
|
|
605
|
oneof_index: nil,
|
|
606
|
json_name: "serviceRuntime",
|
|
607
|
proto3_optional: nil,
|
|
608
|
__unknown_fields__: []
|
|
609
|
},
|
|
610
|
%Google.Protobuf.FieldDescriptorProto{
|
|
611
|
name: "support_library_name",
|
|
612
|
extendee: nil,
|
|
613
|
number: 4,
|
|
614
|
label: :LABEL_OPTIONAL,
|
|
615
|
type: :TYPE_STRING,
|
|
616
|
type_name: nil,
|
|
617
|
default_value: nil,
|
|
618
|
options: nil,
|
|
619
|
oneof_index: nil,
|
|
620
|
json_name: "supportLibraryName",
|
|
621
|
proto3_optional: nil,
|
|
622
|
__unknown_fields__: []
|
|
623
|
},
|
|
624
|
%Google.Protobuf.FieldDescriptorProto{
|
|
625
|
name: "support_library_version",
|
|
626
|
extendee: nil,
|
|
627
|
number: 5,
|
|
628
|
label: :LABEL_OPTIONAL,
|
|
629
|
type: :TYPE_STRING,
|
|
630
|
type_name: nil,
|
|
631
|
default_value: nil,
|
|
632
|
options: nil,
|
|
633
|
oneof_index: nil,
|
|
634
|
json_name: "supportLibraryVersion",
|
|
635
|
proto3_optional: nil,
|
|
636
|
__unknown_fields__: []
|
|
637
|
},
|
|
638
|
%Google.Protobuf.FieldDescriptorProto{
|
|
639
|
name: "protocol_major_version",
|
|
640
|
extendee: nil,
|
|
641
|
number: 6,
|
|
642
|
label: :LABEL_OPTIONAL,
|
|
643
|
type: :TYPE_INT32,
|
|
644
|
type_name: nil,
|
|
645
|
default_value: nil,
|
|
646
|
options: nil,
|
|
647
|
oneof_index: nil,
|
|
648
|
json_name: "protocolMajorVersion",
|
|
649
|
proto3_optional: nil,
|
|
650
|
__unknown_fields__: []
|
|
651
|
},
|
|
652
|
%Google.Protobuf.FieldDescriptorProto{
|
|
653
|
name: "protocol_minor_version",
|
|
654
|
extendee: nil,
|
|
655
|
number: 7,
|
|
656
|
label: :LABEL_OPTIONAL,
|
|
657
|
type: :TYPE_INT32,
|
|
658
|
type_name: nil,
|
|
659
|
default_value: nil,
|
|
660
|
options: nil,
|
|
661
|
oneof_index: nil,
|
|
662
|
json_name: "protocolMinorVersion",
|
|
663
|
proto3_optional: nil,
|
|
664
|
__unknown_fields__: []
|
|
665
|
}
|
|
666
|
],
|
|
667
|
nested_type: [],
|
|
668
|
enum_type: [],
|
|
669
|
extension_range: [],
|
|
670
|
extension: [],
|
|
671
|
options: nil,
|
|
672
|
oneof_decl: [],
|
|
673
|
reserved_range: [],
|
|
674
|
reserved_name: [],
|
|
675
|
__unknown_fields__: []
|
|
676
|
}
|
|
677
|
end
|
|
678
|
|
|
679
|
field(:service_name, 1, type: :string, json_name: "serviceName")
|
|
680
|
field(:service_version, 2, type: :string, json_name: "serviceVersion")
|
|
681
|
field(:service_runtime, 3, type: :string, json_name: "serviceRuntime")
|
|
682
|
field(:support_library_name, 4, type: :string, json_name: "supportLibraryName")
|
|
683
|
field(:support_library_version, 5, type: :string, json_name: "supportLibraryVersion")
|
|
684
|
field(:protocol_major_version, 6, type: :int32, json_name: "protocolMajorVersion")
|
|
685
|
field(:protocol_minor_version, 7, type: :int32, json_name: "protocolMinorVersion")
|
|
686
|
end
|
|
687
|
|
|
688
|
defmodule Eigr.Functions.Protocol.SpawnRequest do
|
|
689
|
@moduledoc false
|
|
690
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
691
|
|
|
692
|
def descriptor do
|
|
693
|
# credo:disable-for-next-line
|
|
694
|
%Google.Protobuf.DescriptorProto{
|
|
695
|
name: "SpawnRequest",
|
|
696
|
field: [
|
|
697
|
%Google.Protobuf.FieldDescriptorProto{
|
|
698
|
name: "actors",
|
|
699
|
extendee: nil,
|
|
700
|
number: 1,
|
|
701
|
label: :LABEL_REPEATED,
|
|
702
|
type: :TYPE_MESSAGE,
|
|
703
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
704
|
default_value: nil,
|
|
705
|
options: nil,
|
|
706
|
oneof_index: nil,
|
|
707
|
json_name: "actors",
|
|
708
|
proto3_optional: nil,
|
|
709
|
__unknown_fields__: []
|
|
710
|
}
|
|
711
|
],
|
|
712
|
nested_type: [],
|
|
713
|
enum_type: [],
|
|
714
|
extension_range: [],
|
|
715
|
extension: [],
|
|
716
|
options: nil,
|
|
717
|
oneof_decl: [],
|
|
718
|
reserved_range: [],
|
|
719
|
reserved_name: [],
|
|
720
|
__unknown_fields__: []
|
|
721
|
}
|
|
722
|
end
|
|
723
|
|
|
724
|
field(:actors, 1, repeated: true, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
725
|
end
|
|
726
|
|
|
727
|
defmodule Eigr.Functions.Protocol.SpawnResponse do
|
|
728
|
@moduledoc false
|
|
729
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
730
|
|
|
731
|
def descriptor do
|
|
732
|
# credo:disable-for-next-line
|
|
733
|
%Google.Protobuf.DescriptorProto{
|
|
734
|
name: "SpawnResponse",
|
|
735
|
field: [
|
|
736
|
%Google.Protobuf.FieldDescriptorProto{
|
|
737
|
name: "status",
|
|
738
|
extendee: nil,
|
|
739
|
number: 1,
|
|
740
|
label: :LABEL_OPTIONAL,
|
|
741
|
type: :TYPE_MESSAGE,
|
|
742
|
type_name: ".eigr.functions.protocol.RequestStatus",
|
|
743
|
default_value: nil,
|
|
744
|
options: nil,
|
|
745
|
oneof_index: nil,
|
|
746
|
json_name: "status",
|
|
747
|
proto3_optional: nil,
|
|
748
|
__unknown_fields__: []
|
|
749
|
}
|
|
750
|
],
|
|
751
|
nested_type: [],
|
|
752
|
enum_type: [],
|
|
753
|
extension_range: [],
|
|
754
|
extension: [],
|
|
755
|
options: nil,
|
|
756
|
oneof_decl: [],
|
|
757
|
reserved_range: [],
|
|
758
|
reserved_name: [],
|
|
759
|
__unknown_fields__: []
|
|
760
|
}
|
|
761
|
end
|
|
762
|
|
|
763
|
field(:status, 1, type: Eigr.Functions.Protocol.RequestStatus)
|
|
764
|
end
|
|
765
|
|
|
766
|
defmodule Eigr.Functions.Protocol.ProxyInfo do
|
|
767
|
@moduledoc false
|
|
768
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
769
|
|
|
770
|
def descriptor do
|
|
771
|
# credo:disable-for-next-line
|
|
772
|
%Google.Protobuf.DescriptorProto{
|
|
773
|
name: "ProxyInfo",
|
|
774
|
field: [
|
|
775
|
%Google.Protobuf.FieldDescriptorProto{
|
|
776
|
name: "protocol_major_version",
|
|
777
|
extendee: nil,
|
|
778
|
number: 1,
|
|
779
|
label: :LABEL_OPTIONAL,
|
|
780
|
type: :TYPE_INT32,
|
|
781
|
type_name: nil,
|
|
782
|
default_value: nil,
|
|
783
|
options: nil,
|
|
784
|
oneof_index: nil,
|
|
785
|
json_name: "protocolMajorVersion",
|
|
786
|
proto3_optional: nil,
|
|
787
|
__unknown_fields__: []
|
|
788
|
},
|
|
789
|
%Google.Protobuf.FieldDescriptorProto{
|
|
790
|
name: "protocol_minor_version",
|
|
791
|
extendee: nil,
|
|
792
|
number: 2,
|
|
793
|
label: :LABEL_OPTIONAL,
|
|
794
|
type: :TYPE_INT32,
|
|
795
|
type_name: nil,
|
|
796
|
default_value: nil,
|
|
797
|
options: nil,
|
|
798
|
oneof_index: nil,
|
|
799
|
json_name: "protocolMinorVersion",
|
|
800
|
proto3_optional: nil,
|
|
801
|
__unknown_fields__: []
|
|
802
|
},
|
|
803
|
%Google.Protobuf.FieldDescriptorProto{
|
|
804
|
name: "proxy_name",
|
|
805
|
extendee: nil,
|
|
806
|
number: 3,
|
|
807
|
label: :LABEL_OPTIONAL,
|
|
808
|
type: :TYPE_STRING,
|
|
809
|
type_name: nil,
|
|
810
|
default_value: nil,
|
|
811
|
options: nil,
|
|
812
|
oneof_index: nil,
|
|
813
|
json_name: "proxyName",
|
|
814
|
proto3_optional: nil,
|
|
815
|
__unknown_fields__: []
|
|
816
|
},
|
|
817
|
%Google.Protobuf.FieldDescriptorProto{
|
|
818
|
name: "proxy_version",
|
|
819
|
extendee: nil,
|
|
820
|
number: 4,
|
|
821
|
label: :LABEL_OPTIONAL,
|
|
822
|
type: :TYPE_STRING,
|
|
823
|
type_name: nil,
|
|
824
|
default_value: nil,
|
|
825
|
options: nil,
|
|
826
|
oneof_index: nil,
|
|
827
|
json_name: "proxyVersion",
|
|
828
|
proto3_optional: nil,
|
|
829
|
__unknown_fields__: []
|
|
830
|
}
|
|
831
|
],
|
|
832
|
nested_type: [],
|
|
833
|
enum_type: [],
|
|
834
|
extension_range: [],
|
|
835
|
extension: [],
|
|
836
|
options: nil,
|
|
837
|
oneof_decl: [],
|
|
838
|
reserved_range: [],
|
|
839
|
reserved_name: [],
|
|
840
|
__unknown_fields__: []
|
|
841
|
}
|
|
842
|
end
|
|
843
|
|
|
844
|
field(:protocol_major_version, 1, type: :int32, json_name: "protocolMajorVersion")
|
|
845
|
field(:protocol_minor_version, 2, type: :int32, json_name: "protocolMinorVersion")
|
|
846
|
field(:proxy_name, 3, type: :string, json_name: "proxyName")
|
|
847
|
field(:proxy_version, 4, type: :string, json_name: "proxyVersion")
|
|
848
|
end
|
|
849
|
|
|
850
|
defmodule Eigr.Functions.Protocol.SideEffect do
|
|
851
|
@moduledoc false
|
|
852
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
853
|
|
|
854
|
def descriptor do
|
|
855
|
# credo:disable-for-next-line
|
|
856
|
%Google.Protobuf.DescriptorProto{
|
|
857
|
name: "SideEffect",
|
|
858
|
field: [
|
|
859
|
%Google.Protobuf.FieldDescriptorProto{
|
|
860
|
name: "request",
|
|
861
|
extendee: nil,
|
|
862
|
number: 1,
|
|
863
|
label: :LABEL_OPTIONAL,
|
|
864
|
type: :TYPE_MESSAGE,
|
|
865
|
type_name: ".eigr.functions.protocol.InvocationRequest",
|
|
866
|
default_value: nil,
|
|
867
|
options: nil,
|
|
868
|
oneof_index: nil,
|
|
869
|
json_name: "request",
|
|
870
|
proto3_optional: nil,
|
|
871
|
__unknown_fields__: []
|
|
872
|
}
|
|
873
|
],
|
|
874
|
nested_type: [],
|
|
875
|
enum_type: [],
|
|
876
|
extension_range: [],
|
|
877
|
extension: [],
|
|
878
|
options: nil,
|
|
879
|
oneof_decl: [],
|
|
880
|
reserved_range: [],
|
|
881
|
reserved_name: [],
|
|
882
|
__unknown_fields__: []
|
|
883
|
}
|
|
884
|
end
|
|
885
|
|
|
886
|
field(:request, 1, type: Eigr.Functions.Protocol.InvocationRequest)
|
|
887
|
end
|
|
888
|
|
|
889
|
defmodule Eigr.Functions.Protocol.Broadcast do
|
|
890
|
@moduledoc false
|
|
891
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
892
|
|
|
893
|
def descriptor do
|
|
894
|
# credo:disable-for-next-line
|
|
895
|
%Google.Protobuf.DescriptorProto{
|
|
896
|
name: "Broadcast",
|
|
897
|
field: [
|
|
898
|
%Google.Protobuf.FieldDescriptorProto{
|
|
899
|
name: "channel_group",
|
|
900
|
extendee: nil,
|
|
901
|
number: 1,
|
|
902
|
label: :LABEL_OPTIONAL,
|
|
903
|
type: :TYPE_STRING,
|
|
904
|
type_name: nil,
|
|
905
|
default_value: nil,
|
|
906
|
options: nil,
|
|
907
|
oneof_index: nil,
|
|
908
|
json_name: "channelGroup",
|
|
909
|
proto3_optional: nil,
|
|
910
|
__unknown_fields__: []
|
|
911
|
},
|
|
912
|
%Google.Protobuf.FieldDescriptorProto{
|
|
913
|
name: "value",
|
|
914
|
extendee: nil,
|
|
915
|
number: 3,
|
|
916
|
label: :LABEL_OPTIONAL,
|
|
917
|
type: :TYPE_MESSAGE,
|
|
918
|
type_name: ".google.protobuf.Any",
|
|
919
|
default_value: nil,
|
|
920
|
options: nil,
|
|
921
|
oneof_index: 0,
|
|
922
|
json_name: "value",
|
|
923
|
proto3_optional: nil,
|
|
924
|
__unknown_fields__: []
|
|
925
|
},
|
|
926
|
%Google.Protobuf.FieldDescriptorProto{
|
|
927
|
name: "noop",
|
|
928
|
extendee: nil,
|
|
929
|
number: 4,
|
|
930
|
label: :LABEL_OPTIONAL,
|
|
931
|
type: :TYPE_MESSAGE,
|
|
932
|
type_name: ".eigr.functions.protocol.Noop",
|
|
933
|
default_value: nil,
|
|
934
|
options: nil,
|
|
935
|
oneof_index: 0,
|
|
936
|
json_name: "noop",
|
|
937
|
proto3_optional: nil,
|
|
938
|
__unknown_fields__: []
|
|
939
|
}
|
|
940
|
],
|
|
941
|
nested_type: [],
|
|
942
|
enum_type: [],
|
|
943
|
extension_range: [],
|
|
944
|
extension: [],
|
|
945
|
options: nil,
|
|
946
|
oneof_decl: [
|
|
947
|
%Google.Protobuf.OneofDescriptorProto{
|
|
948
|
name: "payload",
|
|
949
|
options: nil,
|
|
950
|
__unknown_fields__: []
|
|
951
|
}
|
|
952
|
],
|
|
953
|
reserved_range: [],
|
|
954
|
reserved_name: [],
|
|
955
|
__unknown_fields__: []
|
|
956
|
}
|
|
957
|
end
|
|
958
|
|
|
959
|
oneof(:payload, 0)
|
|
960
|
|
|
961
|
field(:channel_group, 1, type: :string, json_name: "channelGroup")
|
|
962
|
field(:value, 3, type: Google.Protobuf.Any, oneof: 0)
|
|
963
|
field(:noop, 4, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
964
|
end
|
|
965
|
|
|
966
|
defmodule Eigr.Functions.Protocol.Pipe do
|
|
967
|
@moduledoc false
|
|
968
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
969
|
|
|
970
|
def descriptor do
|
|
971
|
# credo:disable-for-next-line
|
|
972
|
%Google.Protobuf.DescriptorProto{
|
|
973
|
name: "Pipe",
|
|
974
|
field: [
|
|
975
|
%Google.Protobuf.FieldDescriptorProto{
|
|
976
|
name: "actor",
|
|
977
|
extendee: nil,
|
|
978
|
number: 1,
|
|
979
|
label: :LABEL_OPTIONAL,
|
|
980
|
type: :TYPE_STRING,
|
|
981
|
type_name: nil,
|
|
982
|
default_value: nil,
|
|
983
|
options: nil,
|
|
984
|
oneof_index: nil,
|
|
985
|
json_name: "actor",
|
|
986
|
proto3_optional: nil,
|
|
987
|
__unknown_fields__: []
|
|
988
|
},
|
|
989
|
%Google.Protobuf.FieldDescriptorProto{
|
|
990
|
name: "action_name",
|
|
991
|
extendee: nil,
|
|
992
|
number: 2,
|
|
993
|
label: :LABEL_OPTIONAL,
|
|
994
|
type: :TYPE_STRING,
|
|
995
|
type_name: nil,
|
|
996
|
default_value: nil,
|
|
997
|
options: nil,
|
|
998
|
oneof_index: nil,
|
|
999
|
json_name: "actionName",
|
|
1000
|
proto3_optional: nil,
|
|
1001
|
__unknown_fields__: []
|
|
1002
|
}
|
|
1003
|
],
|
|
1004
|
nested_type: [],
|
|
1005
|
enum_type: [],
|
|
1006
|
extension_range: [],
|
|
1007
|
extension: [],
|
|
1008
|
options: nil,
|
|
1009
|
oneof_decl: [],
|
|
1010
|
reserved_range: [],
|
|
1011
|
reserved_name: [],
|
|
1012
|
__unknown_fields__: []
|
|
1013
|
}
|
|
1014
|
end
|
|
1015
|
|
|
1016
|
field(:actor, 1, type: :string)
|
|
1017
|
field(:action_name, 2, type: :string, json_name: "actionName")
|
|
1018
|
end
|
|
1019
|
|
|
1020
|
defmodule Eigr.Functions.Protocol.Forward do
|
|
1021
|
@moduledoc false
|
|
1022
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1023
|
|
|
1024
|
def descriptor do
|
|
1025
|
# credo:disable-for-next-line
|
|
1026
|
%Google.Protobuf.DescriptorProto{
|
|
1027
|
name: "Forward",
|
|
1028
|
field: [
|
|
1029
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1030
|
name: "actor",
|
|
1031
|
extendee: nil,
|
|
1032
|
number: 1,
|
|
1033
|
label: :LABEL_OPTIONAL,
|
|
1034
|
type: :TYPE_STRING,
|
|
1035
|
type_name: nil,
|
|
1036
|
default_value: nil,
|
|
1037
|
options: nil,
|
|
1038
|
oneof_index: nil,
|
|
1039
|
json_name: "actor",
|
|
1040
|
proto3_optional: nil,
|
|
1041
|
__unknown_fields__: []
|
|
1042
|
},
|
|
1043
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1044
|
name: "action_name",
|
|
1045
|
extendee: nil,
|
|
1046
|
number: 2,
|
|
1047
|
label: :LABEL_OPTIONAL,
|
|
1048
|
type: :TYPE_STRING,
|
|
1049
|
type_name: nil,
|
|
1050
|
default_value: nil,
|
|
1051
|
options: nil,
|
|
1052
|
oneof_index: nil,
|
|
1053
|
json_name: "actionName",
|
|
1054
|
proto3_optional: nil,
|
|
1055
|
__unknown_fields__: []
|
|
1056
|
}
|
|
1057
|
],
|
|
1058
|
nested_type: [],
|
|
1059
|
enum_type: [],
|
|
1060
|
extension_range: [],
|
|
1061
|
extension: [],
|
|
1062
|
options: nil,
|
|
1063
|
oneof_decl: [],
|
|
1064
|
reserved_range: [],
|
|
1065
|
reserved_name: [],
|
|
1066
|
__unknown_fields__: []
|
|
1067
|
}
|
|
1068
|
end
|
|
1069
|
|
|
1070
|
field(:actor, 1, type: :string)
|
|
1071
|
field(:action_name, 2, type: :string, json_name: "actionName")
|
|
1072
|
end
|
|
1073
|
|
|
1074
|
defmodule Eigr.Functions.Protocol.Workflow do
|
|
1075
|
@moduledoc false
|
|
1076
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1077
|
|
|
1078
|
def descriptor do
|
|
1079
|
# credo:disable-for-next-line
|
|
1080
|
%Google.Protobuf.DescriptorProto{
|
|
1081
|
name: "Workflow",
|
|
1082
|
field: [
|
|
1083
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1084
|
name: "broadcast",
|
|
1085
|
extendee: nil,
|
|
1086
|
number: 2,
|
|
1087
|
label: :LABEL_OPTIONAL,
|
|
1088
|
type: :TYPE_MESSAGE,
|
|
1089
|
type_name: ".eigr.functions.protocol.Broadcast",
|
|
1090
|
default_value: nil,
|
|
1091
|
options: nil,
|
|
1092
|
oneof_index: nil,
|
|
1093
|
json_name: "broadcast",
|
|
1094
|
proto3_optional: nil,
|
|
1095
|
__unknown_fields__: []
|
|
1096
|
},
|
|
1097
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1098
|
name: "effects",
|
|
1099
|
extendee: nil,
|
|
1100
|
number: 1,
|
|
1101
|
label: :LABEL_REPEATED,
|
|
1102
|
type: :TYPE_MESSAGE,
|
|
1103
|
type_name: ".eigr.functions.protocol.SideEffect",
|
|
1104
|
default_value: nil,
|
|
1105
|
options: nil,
|
|
1106
|
oneof_index: nil,
|
|
1107
|
json_name: "effects",
|
|
1108
|
proto3_optional: nil,
|
|
1109
|
__unknown_fields__: []
|
|
1110
|
},
|
|
1111
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1112
|
name: "pipe",
|
|
1113
|
extendee: nil,
|
|
1114
|
number: 3,
|
|
1115
|
label: :LABEL_OPTIONAL,
|
|
1116
|
type: :TYPE_MESSAGE,
|
|
1117
|
type_name: ".eigr.functions.protocol.Pipe",
|
|
1118
|
default_value: nil,
|
|
1119
|
options: nil,
|
|
1120
|
oneof_index: 0,
|
|
1121
|
json_name: "pipe",
|
|
1122
|
proto3_optional: nil,
|
|
1123
|
__unknown_fields__: []
|
|
1124
|
},
|
|
1125
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1126
|
name: "forward",
|
|
1127
|
extendee: nil,
|
|
1128
|
number: 4,
|
|
1129
|
label: :LABEL_OPTIONAL,
|
|
1130
|
type: :TYPE_MESSAGE,
|
|
1131
|
type_name: ".eigr.functions.protocol.Forward",
|
|
1132
|
default_value: nil,
|
|
1133
|
options: nil,
|
|
1134
|
oneof_index: 0,
|
|
1135
|
json_name: "forward",
|
|
1136
|
proto3_optional: nil,
|
|
1137
|
__unknown_fields__: []
|
|
1138
|
}
|
|
1139
|
],
|
|
1140
|
nested_type: [],
|
|
1141
|
enum_type: [],
|
|
1142
|
extension_range: [],
|
|
1143
|
extension: [],
|
|
1144
|
options: nil,
|
|
1145
|
oneof_decl: [
|
|
1146
|
%Google.Protobuf.OneofDescriptorProto{
|
|
1147
|
name: "routing",
|
|
1148
|
options: nil,
|
|
1149
|
__unknown_fields__: []
|
|
1150
|
}
|
|
1151
|
],
|
|
1152
|
reserved_range: [],
|
|
1153
|
reserved_name: [],
|
|
1154
|
__unknown_fields__: []
|
|
1155
|
}
|
|
1156
|
end
|
|
1157
|
|
|
1158
|
oneof(:routing, 0)
|
|
1159
|
|
|
1160
|
field(:broadcast, 2, type: Eigr.Functions.Protocol.Broadcast)
|
|
1161
|
field(:effects, 1, repeated: true, type: Eigr.Functions.Protocol.SideEffect)
|
|
1162
|
field(:pipe, 3, type: Eigr.Functions.Protocol.Pipe, oneof: 0)
|
|
1163
|
field(:forward, 4, type: Eigr.Functions.Protocol.Forward, oneof: 0)
|
|
1164
|
end
|
|
1165
|
|
|
1166
|
defmodule Eigr.Functions.Protocol.InvocationRequest.MetadataEntry do
|
|
1167
|
@moduledoc false
|
|
1168
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1169
|
|
|
1170
|
def descriptor do
|
|
1171
|
# credo:disable-for-next-line
|
|
1172
|
%Google.Protobuf.DescriptorProto{
|
|
1173
|
name: "MetadataEntry",
|
|
1174
|
field: [
|
|
1175
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1176
|
name: "key",
|
|
1177
|
extendee: nil,
|
|
1178
|
number: 1,
|
|
1179
|
label: :LABEL_OPTIONAL,
|
|
1180
|
type: :TYPE_STRING,
|
|
1181
|
type_name: nil,
|
|
1182
|
default_value: nil,
|
|
1183
|
options: nil,
|
|
1184
|
oneof_index: nil,
|
|
1185
|
json_name: "key",
|
|
1186
|
proto3_optional: nil,
|
|
1187
|
__unknown_fields__: []
|
|
1188
|
},
|
|
1189
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1190
|
name: "value",
|
|
1191
|
extendee: nil,
|
|
1192
|
number: 2,
|
|
1193
|
label: :LABEL_OPTIONAL,
|
|
1194
|
type: :TYPE_STRING,
|
|
1195
|
type_name: nil,
|
|
1196
|
default_value: nil,
|
|
1197
|
options: nil,
|
|
1198
|
oneof_index: nil,
|
|
1199
|
json_name: "value",
|
|
1200
|
proto3_optional: nil,
|
|
1201
|
__unknown_fields__: []
|
|
1202
|
}
|
|
1203
|
],
|
|
1204
|
nested_type: [],
|
|
1205
|
enum_type: [],
|
|
1206
|
extension_range: [],
|
|
1207
|
extension: [],
|
|
1208
|
options: %Google.Protobuf.MessageOptions{
|
|
1209
|
message_set_wire_format: false,
|
|
1210
|
no_standard_descriptor_accessor: false,
|
|
1211
|
deprecated: false,
|
|
1212
|
map_entry: true,
|
|
1213
|
deprecated_legacy_json_field_conflicts: nil,
|
|
1214
|
# features: nil,
|
|
1215
|
uninterpreted_option: [],
|
|
1216
|
__pb_extensions__: %{},
|
|
1217
|
__unknown_fields__: []
|
|
1218
|
},
|
|
1219
|
oneof_decl: [],
|
|
1220
|
reserved_range: [],
|
|
1221
|
reserved_name: [],
|
|
1222
|
__unknown_fields__: []
|
|
1223
|
}
|
|
1224
|
end
|
|
1225
|
|
|
1226
|
field(:key, 1, type: :string)
|
|
1227
|
field(:value, 2, type: :string)
|
|
1228
|
end
|
|
1229
|
|
|
1230
|
defmodule Eigr.Functions.Protocol.InvocationRequest do
|
|
1231
|
@moduledoc false
|
|
1232
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1233
|
|
|
1234
|
def descriptor do
|
|
1235
|
# credo:disable-for-next-line
|
|
1236
|
%Google.Protobuf.DescriptorProto{
|
|
1237
|
name: "InvocationRequest",
|
|
1238
|
field: [
|
|
1239
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1240
|
name: "system",
|
|
1241
|
extendee: nil,
|
|
1242
|
number: 1,
|
|
1243
|
label: :LABEL_OPTIONAL,
|
|
1244
|
type: :TYPE_MESSAGE,
|
|
1245
|
type_name: ".eigr.functions.protocol.actors.ActorSystem",
|
|
1246
|
default_value: nil,
|
|
1247
|
options: nil,
|
|
1248
|
oneof_index: nil,
|
|
1249
|
json_name: "system",
|
|
1250
|
proto3_optional: nil,
|
|
1251
|
__unknown_fields__: []
|
|
1252
|
},
|
|
1253
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1254
|
name: "actor",
|
|
1255
|
extendee: nil,
|
|
1256
|
number: 2,
|
|
1257
|
label: :LABEL_OPTIONAL,
|
|
1258
|
type: :TYPE_MESSAGE,
|
|
1259
|
type_name: ".eigr.functions.protocol.actors.Actor",
|
|
1260
|
default_value: nil,
|
|
1261
|
options: nil,
|
|
1262
|
oneof_index: nil,
|
|
1263
|
json_name: "actor",
|
|
1264
|
proto3_optional: nil,
|
|
1265
|
__unknown_fields__: []
|
|
1266
|
},
|
|
1267
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1268
|
name: "action_name",
|
|
1269
|
extendee: nil,
|
|
1270
|
number: 3,
|
|
1271
|
label: :LABEL_OPTIONAL,
|
|
1272
|
type: :TYPE_STRING,
|
|
1273
|
type_name: nil,
|
|
1274
|
default_value: nil,
|
|
1275
|
options: nil,
|
|
1276
|
oneof_index: nil,
|
|
1277
|
json_name: "actionName",
|
|
1278
|
proto3_optional: nil,
|
|
1279
|
__unknown_fields__: []
|
|
1280
|
},
|
|
1281
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1282
|
name: "value",
|
|
1283
|
extendee: nil,
|
|
1284
|
number: 4,
|
|
1285
|
label: :LABEL_OPTIONAL,
|
|
1286
|
type: :TYPE_MESSAGE,
|
|
1287
|
type_name: ".google.protobuf.Any",
|
|
1288
|
default_value: nil,
|
|
1289
|
options: nil,
|
|
1290
|
oneof_index: 0,
|
|
1291
|
json_name: "value",
|
|
1292
|
proto3_optional: nil,
|
|
1293
|
__unknown_fields__: []
|
|
1294
|
},
|
|
1295
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1296
|
name: "noop",
|
|
1297
|
extendee: nil,
|
|
1298
|
number: 7,
|
|
1299
|
label: :LABEL_OPTIONAL,
|
|
1300
|
type: :TYPE_MESSAGE,
|
|
1301
|
type_name: ".eigr.functions.protocol.Noop",
|
|
1302
|
default_value: nil,
|
|
1303
|
options: nil,
|
|
1304
|
oneof_index: 0,
|
|
1305
|
json_name: "noop",
|
|
1306
|
proto3_optional: nil,
|
|
1307
|
__unknown_fields__: []
|
|
1308
|
},
|
|
1309
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1310
|
name: "async",
|
|
1311
|
extendee: nil,
|
|
1312
|
number: 5,
|
|
1313
|
label: :LABEL_OPTIONAL,
|
|
1314
|
type: :TYPE_BOOL,
|
|
1315
|
type_name: nil,
|
|
1316
|
default_value: nil,
|
|
1317
|
options: nil,
|
|
1318
|
oneof_index: nil,
|
|
1319
|
json_name: "async",
|
|
1320
|
proto3_optional: nil,
|
|
1321
|
__unknown_fields__: []
|
|
1322
|
},
|
|
1323
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1324
|
name: "caller",
|
|
1325
|
extendee: nil,
|
|
1326
|
number: 6,
|
|
1327
|
label: :LABEL_OPTIONAL,
|
|
1328
|
type: :TYPE_MESSAGE,
|
|
1329
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1330
|
default_value: nil,
|
|
1331
|
options: nil,
|
|
1332
|
oneof_index: nil,
|
|
1333
|
json_name: "caller",
|
|
1334
|
proto3_optional: nil,
|
|
1335
|
__unknown_fields__: []
|
|
1336
|
},
|
|
1337
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1338
|
name: "metadata",
|
|
1339
|
extendee: nil,
|
|
1340
|
number: 8,
|
|
1341
|
label: :LABEL_REPEATED,
|
|
1342
|
type: :TYPE_MESSAGE,
|
|
1343
|
type_name: ".eigr.functions.protocol.InvocationRequest.MetadataEntry",
|
|
1344
|
default_value: nil,
|
|
1345
|
options: nil,
|
|
1346
|
oneof_index: nil,
|
|
1347
|
json_name: "metadata",
|
|
1348
|
proto3_optional: nil,
|
|
1349
|
__unknown_fields__: []
|
|
1350
|
},
|
|
1351
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1352
|
name: "scheduled_to",
|
|
1353
|
extendee: nil,
|
|
1354
|
number: 9,
|
|
1355
|
label: :LABEL_OPTIONAL,
|
|
1356
|
type: :TYPE_INT64,
|
|
1357
|
type_name: nil,
|
|
1358
|
default_value: nil,
|
|
1359
|
options: nil,
|
|
1360
|
oneof_index: nil,
|
|
1361
|
json_name: "scheduledTo",
|
|
1362
|
proto3_optional: nil,
|
|
1363
|
__unknown_fields__: []
|
|
1364
|
},
|
|
1365
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1366
|
name: "pooled",
|
|
1367
|
extendee: nil,
|
|
1368
|
number: 10,
|
|
1369
|
label: :LABEL_OPTIONAL,
|
|
1370
|
type: :TYPE_BOOL,
|
|
1371
|
type_name: nil,
|
|
1372
|
default_value: nil,
|
|
1373
|
options: nil,
|
|
1374
|
oneof_index: nil,
|
|
1375
|
json_name: "pooled",
|
|
1376
|
proto3_optional: nil,
|
|
1377
|
__unknown_fields__: []
|
|
1378
|
},
|
|
1379
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1380
|
name: "register_ref",
|
|
1381
|
extendee: nil,
|
|
1382
|
number: 11,
|
|
1383
|
label: :LABEL_OPTIONAL,
|
|
1384
|
type: :TYPE_STRING,
|
|
1385
|
type_name: nil,
|
|
1386
|
default_value: nil,
|
|
1387
|
options: nil,
|
|
1388
|
oneof_index: nil,
|
|
1389
|
json_name: "registerRef",
|
|
1390
|
proto3_optional: nil,
|
|
1391
|
__unknown_fields__: []
|
|
1392
|
}
|
|
1393
|
],
|
|
1394
|
nested_type: [
|
|
1395
|
%Google.Protobuf.DescriptorProto{
|
|
1396
|
name: "MetadataEntry",
|
|
1397
|
field: [
|
|
1398
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1399
|
name: "key",
|
|
1400
|
extendee: nil,
|
|
1401
|
number: 1,
|
|
1402
|
label: :LABEL_OPTIONAL,
|
|
1403
|
type: :TYPE_STRING,
|
|
1404
|
type_name: nil,
|
|
1405
|
default_value: nil,
|
|
1406
|
options: nil,
|
|
1407
|
oneof_index: nil,
|
|
1408
|
json_name: "key",
|
|
1409
|
proto3_optional: nil,
|
|
1410
|
__unknown_fields__: []
|
|
1411
|
},
|
|
1412
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1413
|
name: "value",
|
|
1414
|
extendee: nil,
|
|
1415
|
number: 2,
|
|
1416
|
label: :LABEL_OPTIONAL,
|
|
1417
|
type: :TYPE_STRING,
|
|
1418
|
type_name: nil,
|
|
1419
|
default_value: nil,
|
|
1420
|
options: nil,
|
|
1421
|
oneof_index: nil,
|
|
1422
|
json_name: "value",
|
|
1423
|
proto3_optional: nil,
|
|
1424
|
__unknown_fields__: []
|
|
1425
|
}
|
|
1426
|
],
|
|
1427
|
nested_type: [],
|
|
1428
|
enum_type: [],
|
|
1429
|
extension_range: [],
|
|
1430
|
extension: [],
|
|
1431
|
options: %Google.Protobuf.MessageOptions{
|
|
1432
|
message_set_wire_format: false,
|
|
1433
|
no_standard_descriptor_accessor: false,
|
|
1434
|
deprecated: false,
|
|
1435
|
map_entry: true,
|
|
1436
|
deprecated_legacy_json_field_conflicts: nil,
|
|
1437
|
# features: nil,
|
|
1438
|
uninterpreted_option: [],
|
|
1439
|
__pb_extensions__: %{},
|
|
1440
|
__unknown_fields__: []
|
|
1441
|
},
|
|
1442
|
oneof_decl: [],
|
|
1443
|
reserved_range: [],
|
|
1444
|
reserved_name: [],
|
|
1445
|
__unknown_fields__: []
|
|
1446
|
}
|
|
1447
|
],
|
|
1448
|
enum_type: [],
|
|
1449
|
extension_range: [],
|
|
1450
|
extension: [],
|
|
1451
|
options: nil,
|
|
1452
|
oneof_decl: [
|
|
1453
|
%Google.Protobuf.OneofDescriptorProto{
|
|
1454
|
name: "payload",
|
|
1455
|
options: nil,
|
|
1456
|
__unknown_fields__: []
|
|
1457
|
}
|
|
1458
|
],
|
|
1459
|
reserved_range: [],
|
|
1460
|
reserved_name: [],
|
|
1461
|
__unknown_fields__: []
|
|
1462
|
}
|
|
1463
|
end
|
|
1464
|
|
|
1465
|
oneof(:payload, 0)
|
|
1466
|
|
|
1467
|
field(:system, 1, type: Eigr.Functions.Protocol.Actors.ActorSystem)
|
|
1468
|
field(:actor, 2, type: Eigr.Functions.Protocol.Actors.Actor)
|
|
1469
|
field(:action_name, 3, type: :string, json_name: "actionName")
|
|
1470
|
field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1471
|
field(:noop, 7, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1472
|
field(:async, 5, type: :bool)
|
|
1473
|
field(:caller, 6, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1474
|
|
|
1475
|
field(:metadata, 8,
|
|
1476
|
repeated: true,
|
|
1477
|
type: Eigr.Functions.Protocol.InvocationRequest.MetadataEntry,
|
|
1478
|
map: true
|
|
1479
|
)
|
|
1480
|
|
|
1481
|
field(:scheduled_to, 9, type: :int64, json_name: "scheduledTo")
|
|
1482
|
field(:pooled, 10, type: :bool)
|
|
1483
|
field(:register_ref, 11, type: :string, json_name: "registerRef")
|
|
1484
|
end
|
|
1485
|
|
|
1486
|
defmodule Eigr.Functions.Protocol.ActorInvocation do
|
|
1487
|
@moduledoc false
|
|
1488
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1489
|
|
|
1490
|
def descriptor do
|
|
1491
|
# credo:disable-for-next-line
|
|
1492
|
%Google.Protobuf.DescriptorProto{
|
|
1493
|
name: "ActorInvocation",
|
|
1494
|
field: [
|
|
1495
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1496
|
name: "actor",
|
|
1497
|
extendee: nil,
|
|
1498
|
number: 1,
|
|
1499
|
label: :LABEL_OPTIONAL,
|
|
1500
|
type: :TYPE_MESSAGE,
|
|
1501
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1502
|
default_value: nil,
|
|
1503
|
options: nil,
|
|
1504
|
oneof_index: nil,
|
|
1505
|
json_name: "actor",
|
|
1506
|
proto3_optional: nil,
|
|
1507
|
__unknown_fields__: []
|
|
1508
|
},
|
|
1509
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1510
|
name: "action_name",
|
|
1511
|
extendee: nil,
|
|
1512
|
number: 2,
|
|
1513
|
label: :LABEL_OPTIONAL,
|
|
1514
|
type: :TYPE_STRING,
|
|
1515
|
type_name: nil,
|
|
1516
|
default_value: nil,
|
|
1517
|
options: nil,
|
|
1518
|
oneof_index: nil,
|
|
1519
|
json_name: "actionName",
|
|
1520
|
proto3_optional: nil,
|
|
1521
|
__unknown_fields__: []
|
|
1522
|
},
|
|
1523
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1524
|
name: "current_context",
|
|
1525
|
extendee: nil,
|
|
1526
|
number: 3,
|
|
1527
|
label: :LABEL_OPTIONAL,
|
|
1528
|
type: :TYPE_MESSAGE,
|
|
1529
|
type_name: ".eigr.functions.protocol.Context",
|
|
1530
|
default_value: nil,
|
|
1531
|
options: nil,
|
|
1532
|
oneof_index: nil,
|
|
1533
|
json_name: "currentContext",
|
|
1534
|
proto3_optional: nil,
|
|
1535
|
__unknown_fields__: []
|
|
1536
|
},
|
|
1537
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1538
|
name: "value",
|
|
1539
|
extendee: nil,
|
|
1540
|
number: 4,
|
|
1541
|
label: :LABEL_OPTIONAL,
|
|
1542
|
type: :TYPE_MESSAGE,
|
|
1543
|
type_name: ".google.protobuf.Any",
|
|
1544
|
default_value: nil,
|
|
1545
|
options: nil,
|
|
1546
|
oneof_index: 0,
|
|
1547
|
json_name: "value",
|
|
1548
|
proto3_optional: nil,
|
|
1549
|
__unknown_fields__: []
|
|
1550
|
},
|
|
1551
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1552
|
name: "noop",
|
|
1553
|
extendee: nil,
|
|
1554
|
number: 5,
|
|
1555
|
label: :LABEL_OPTIONAL,
|
|
1556
|
type: :TYPE_MESSAGE,
|
|
1557
|
type_name: ".eigr.functions.protocol.Noop",
|
|
1558
|
default_value: nil,
|
|
1559
|
options: nil,
|
|
1560
|
oneof_index: 0,
|
|
1561
|
json_name: "noop",
|
|
1562
|
proto3_optional: nil,
|
|
1563
|
__unknown_fields__: []
|
|
1564
|
},
|
|
1565
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1566
|
name: "caller",
|
|
1567
|
extendee: nil,
|
|
1568
|
number: 6,
|
|
1569
|
label: :LABEL_OPTIONAL,
|
|
1570
|
type: :TYPE_MESSAGE,
|
|
1571
|
type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1572
|
default_value: nil,
|
|
1573
|
options: nil,
|
|
1574
|
oneof_index: nil,
|
|
1575
|
json_name: "caller",
|
|
1576
|
proto3_optional: nil,
|
|
1577
|
__unknown_fields__: []
|
|
1578
|
}
|
|
1579
|
],
|
|
1580
|
nested_type: [],
|
|
1581
|
enum_type: [],
|
|
1582
|
extension_range: [],
|
|
1583
|
extension: [],
|
|
1584
|
options: nil,
|
|
1585
|
oneof_decl: [
|
|
1586
|
%Google.Protobuf.OneofDescriptorProto{
|
|
1587
|
name: "payload",
|
|
1588
|
options: nil,
|
|
1589
|
__unknown_fields__: []
|
|
1590
|
}
|
|
1591
|
],
|
|
1592
|
reserved_range: [],
|
|
1593
|
reserved_name: [],
|
|
1863
|
__unknown_fields__: []
|
|
1595
|
}
|
|
1596
|
end
|
|
1597
|
|
|
1598
|
oneof(:payload, 0)
|
|
1599
|
|
|
1600
|
field(:actor, 1, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1601
|
field(:action_name, 2, type: :string, json_name: "actionName")
|
|
1602
|
field(:current_context, 3, type: Eigr.Functions.Protocol.Context, json_name: "currentContext")
|
|
1603
|
field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1604
|
field(:noop, 5, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1605
|
field(:caller, 6, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1606
|
end
|
|
1607
|
|
|
1608
|
defmodule Eigr.Functions.Protocol.ActorInvocationResponse do
|
|
1609
|
@moduledoc false
|
|
1610
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1611
|
|
|
1612
|
def descriptor do
|
|
1613
|
# credo:disable-for-next-line
|
|
1614
|
%Google.Protobuf.DescriptorProto{
|
|
1615
|
name: "ActorInvocationResponse",
|
|
1616
|
field: [
|
|
1617
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1618
|
name: "actor_name",
|
|
1619
|
extendee: nil,
|
|
1620
|
number: 1,
|
|
1621
|
label: :LABEL_OPTIONAL,
|
|
1622
|
type: :TYPE_STRING,
|
|
1623
|
type_name: nil,
|
|
1624
|
default_value: nil,
|
|
1625
|
options: nil,
|
|
1626
|
oneof_index: nil,
|
|
1627
|
json_name: "actorName",
|
|
1628
|
proto3_optional: nil,
|
|
1629
|
__unknown_fields__: []
|
|
1630
|
},
|
|
1631
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1632
|
name: "actor_system",
|
|
1633
|
extendee: nil,
|
|
1634
|
number: 2,
|
|
1635
|
label: :LABEL_OPTIONAL,
|
|
1636
|
type: :TYPE_STRING,
|
|
1637
|
type_name: nil,
|
|
1638
|
default_value: nil,
|
|
1639
|
options: nil,
|
|
1640
|
oneof_index: nil,
|
|
1641
|
json_name: "actorSystem",
|
|
1642
|
proto3_optional: nil,
|
|
1643
|
__unknown_fields__: []
|
|
1644
|
},
|
|
1645
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1646
|
name: "updated_context",
|
|
1647
|
extendee: nil,
|
|
1648
|
number: 3,
|
|
1649
|
label: :LABEL_OPTIONAL,
|
|
1650
|
type: :TYPE_MESSAGE,
|
|
1651
|
type_name: ".eigr.functions.protocol.Context",
|
|
1652
|
default_value: nil,
|
|
1653
|
options: nil,
|
|
1654
|
oneof_index: nil,
|
|
1655
|
json_name: "updatedContext",
|
|
1656
|
proto3_optional: nil,
|
|
1657
|
__unknown_fields__: []
|
|
1658
|
},
|
|
1659
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1660
|
name: "value",
|
|
1661
|
extendee: nil,
|
|
1662
|
number: 4,
|
|
1663
|
label: :LABEL_OPTIONAL,
|
|
1664
|
type: :TYPE_MESSAGE,
|
|
1665
|
type_name: ".google.protobuf.Any",
|
|
1666
|
default_value: nil,
|
|
1667
|
options: nil,
|
|
1668
|
oneof_index: 0,
|
|
1669
|
json_name: "value",
|
|
1670
|
proto3_optional: nil,
|
|
1671
|
__unknown_fields__: []
|
|
1672
|
},
|
|
1673
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1674
|
name: "noop",
|
|
1675
|
extendee: nil,
|
|
1676
|
number: 6,
|
|
1677
|
label: :LABEL_OPTIONAL,
|
|
1678
|
type: :TYPE_MESSAGE,
|
|
1679
|
type_name: ".eigr.functions.protocol.Noop",
|
|
1680
|
default_value: nil,
|
|
1681
|
options: nil,
|
|
1682
|
oneof_index: 0,
|
|
1683
|
json_name: "noop",
|
|
1684
|
proto3_optional: nil,
|
|
1685
|
__unknown_fields__: []
|
|
1686
|
},
|
|
1687
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1688
|
name: "workflow",
|
|
1689
|
extendee: nil,
|
|
1690
|
number: 5,
|
|
1691
|
label: :LABEL_OPTIONAL,
|
|
1692
|
type: :TYPE_MESSAGE,
|
|
1693
|
type_name: ".eigr.functions.protocol.Workflow",
|
|
1694
|
default_value: nil,
|
|
1695
|
options: nil,
|
|
1696
|
oneof_index: nil,
|
|
1697
|
json_name: "workflow",
|
|
1698
|
proto3_optional: nil,
|
|
1699
|
__unknown_fields__: []
|
|
1700
|
},
|
|
1701
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1702
|
name: "checkpoint",
|
|
1703
|
extendee: nil,
|
|
1704
|
number: 7,
|
|
1705
|
label: :LABEL_OPTIONAL,
|
|
1706
|
type: :TYPE_BOOL,
|
|
1707
|
type_name: nil,
|
|
1708
|
default_value: nil,
|
|
1709
|
options: nil,
|
|
1710
|
oneof_index: nil,
|
|
1711
|
json_name: "checkpoint",
|
|
1712
|
proto3_optional: nil,
|
|
1713
|
__unknown_fields__: []
|
|
1714
|
}
|
|
1715
|
],
|
|
1716
|
nested_type: [],
|
|
1717
|
enum_type: [],
|
|
1718
|
extension_range: [],
|
|
1719
|
extension: [],
|
|
1720
|
options: nil,
|
|
1721
|
oneof_decl: [
|
|
1722
|
%Google.Protobuf.OneofDescriptorProto{
|
|
1723
|
name: "payload",
|
|
1724
|
options: nil,
|
|
1725
|
__unknown_fields__: []
|
|
1726
|
}
|
|
1727
|
],
|
|
1728
|
reserved_range: [],
|
|
1729
|
reserved_name: [],
|
|
1730
|
__unknown_fields__: []
|
|
1731
|
}
|
|
1732
|
end
|
|
1733
|
|
|
1734
|
oneof(:payload, 0)
|
|
1735
|
|
|
1736
|
field(:actor_name, 1, type: :string, json_name: "actorName")
|
|
1737
|
field(:actor_system, 2, type: :string, json_name: "actorSystem")
|
|
1738
|
field(:updated_context, 3, type: Eigr.Functions.Protocol.Context, json_name: "updatedContext")
|
|
1739
|
field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1740
|
field(:noop, 6, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1741
|
field(:workflow, 5, type: Eigr.Functions.Protocol.Workflow)
|
|
1742
|
field(:checkpoint, 7, type: :bool)
|
|
1743
|
end
|
|
1744
|
|
|
1745
|
defmodule Eigr.Functions.Protocol.InvocationResponse do
|
|
1746
|
@moduledoc false
|
|
1747
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1748
|
|
|
1749
|
def descriptor do
|
|
1750
|
# credo:disable-for-next-line
|
|
1751
|
%Google.Protobuf.DescriptorProto{
|
|
1752
|
name: "InvocationResponse",
|
|
1753
|
field: [
|
|
1754
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1755
|
name: "status",
|
|
1756
|
extendee: nil,
|
|
1757
|
number: 1,
|
|
1758
|
label: :LABEL_OPTIONAL,
|
|
1759
|
type: :TYPE_MESSAGE,
|
|
1760
|
type_name: ".eigr.functions.protocol.RequestStatus",
|
|
1761
|
default_value: nil,
|
|
1762
|
options: nil,
|
|
1763
|
oneof_index: nil,
|
|
1764
|
json_name: "status",
|
|
1765
|
proto3_optional: nil,
|
|
1766
|
__unknown_fields__: []
|
|
1767
|
},
|
|
1768
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1769
|
name: "system",
|
|
1770
|
extendee: nil,
|
|
1771
|
number: 2,
|
|
1772
|
label: :LABEL_OPTIONAL,
|
|
1773
|
type: :TYPE_MESSAGE,
|
|
1774
|
type_name: ".eigr.functions.protocol.actors.ActorSystem",
|
|
1775
|
default_value: nil,
|
|
1776
|
options: nil,
|
|
1777
|
oneof_index: nil,
|
|
1778
|
json_name: "system",
|
|
1779
|
proto3_optional: nil,
|
|
1780
|
__unknown_fields__: []
|
|
1781
|
},
|
|
1782
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1783
|
name: "actor",
|
|
1784
|
extendee: nil,
|
|
1785
|
number: 3,
|
|
1786
|
label: :LABEL_OPTIONAL,
|
|
1787
|
type: :TYPE_MESSAGE,
|
|
1788
|
type_name: ".eigr.functions.protocol.actors.Actor",
|
|
1789
|
default_value: nil,
|
|
1790
|
options: nil,
|
|
1791
|
oneof_index: nil,
|
|
1792
|
json_name: "actor",
|
|
1793
|
proto3_optional: nil,
|
|
1794
|
__unknown_fields__: []
|
|
1795
|
},
|
|
1796
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1797
|
name: "value",
|
|
1798
|
extendee: nil,
|
|
1799
|
number: 4,
|
|
1800
|
label: :LABEL_OPTIONAL,
|
|
1801
|
type: :TYPE_MESSAGE,
|
|
1802
|
type_name: ".google.protobuf.Any",
|
|
1803
|
default_value: nil,
|
|
1804
|
options: nil,
|
|
1805
|
oneof_index: 0,
|
|
1806
|
json_name: "value",
|
|
1807
|
proto3_optional: nil,
|
|
1808
|
__unknown_fields__: []
|
|
1809
|
},
|
|
1810
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1811
|
name: "noop",
|
|
1812
|
extendee: nil,
|
|
1813
|
number: 5,
|
|
1814
|
label: :LABEL_OPTIONAL,
|
|
1815
|
type: :TYPE_MESSAGE,
|
|
1816
|
type_name: ".eigr.functions.protocol.Noop",
|
|
1817
|
default_value: nil,
|
|
1818
|
options: nil,
|
|
1819
|
oneof_index: 0,
|
|
1820
|
json_name: "noop",
|
|
1821
|
proto3_optional: nil,
|
|
1822
|
__unknown_fields__: []
|
|
1823
|
}
|
|
1824
|
],
|
|
1825
|
nested_type: [],
|
|
1826
|
enum_type: [],
|
|
1827
|
extension_range: [],
|
|
1828
|
extension: [],
|
|
1829
|
options: nil,
|
|
1830
|
oneof_decl: [
|
|
1831
|
%Google.Protobuf.OneofDescriptorProto{
|
|
1832
|
name: "payload",
|
|
1833
|
options: nil,
|
|
1834
|
__unknown_fields__: []
|
|
1835
|
}
|
|
1836
|
],
|
|
1837
|
reserved_range: [],
|
|
1838
|
reserved_name: [],
|
|
1839
|
__unknown_fields__: []
|
|
1840
|
}
|
|
1841
|
end
|
|
1842
|
|
|
1843
|
oneof(:payload, 0)
|
|
1844
|
|
|
1845
|
field(:status, 1, type: Eigr.Functions.Protocol.RequestStatus)
|
|
1846
|
field(:system, 2, type: Eigr.Functions.Protocol.Actors.ActorSystem)
|
|
1847
|
field(:actor, 3, type: Eigr.Functions.Protocol.Actors.Actor)
|
|
1848
|
field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1849
|
field(:noop, 5, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1850
|
end
|
|
1851
|
|
|
1852
|
defmodule Eigr.Functions.Protocol.RequestStatus do
|
|
1853
|
@moduledoc false
|
|
1854
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
1855
|
|
|
1856
|
def descriptor do
|
|
1857
|
# credo:disable-for-next-line
|
|
1858
|
%Google.Protobuf.DescriptorProto{
|
|
1859
|
name: "RequestStatus",
|
|
1860
|
field: [
|
|
1861
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1862
|
name: "status",
|
|
1863
|
extendee: nil,
|
|
1864
|
number: 1,
|
|
1865
|
label: :LABEL_OPTIONAL,
|
|
1866
|
type: :TYPE_ENUM,
|
|
1867
|
type_name: ".eigr.functions.protocol.Status",
|
|
1868
|
default_value: nil,
|
|
1869
|
options: nil,
|
|
1870
|
oneof_index: nil,
|
|
1871
|
json_name: "status",
|
|
1872
|
proto3_optional: nil,
|
|
1873
|
__unknown_fields__: []
|
|
1874
|
},
|
|
1875
|
%Google.Protobuf.FieldDescriptorProto{
|
|
1876
|
name: "message",
|
|
1877
|
extendee: nil,
|
|
1878
|
number: 2,
|
|
1879
|
label: :LABEL_OPTIONAL,
|
|
1880
|
type: :TYPE_STRING,
|
|
1881
|
type_name: nil,
|
|
1882
|
default_value: nil,
|
|
1883
|
options: nil,
|
|
1884
|
oneof_index: nil,
|
|
1885
|
json_name: "message",
|
|
1886
|
proto3_optional: nil,
|
|
1887
|
__unknown_fields__: []
|
|
1888
|
}
|
|
1889
|
],
|
|
1890
|
nested_type: [],
|
|
1891
|
enum_type: [],
|
|
1892
|
extension_range: [],
|
|
1893
|
extension: [],
|
|
1894
|
options: nil,
|
|
1895
|
oneof_decl: [],
|
|
1896
|
reserved_range: [],
|
|
1897
|
reserved_name: [],
|
|
1898
|
__unknown_fields__: []
|
|
1899
|
}
|
|
1900
|
end
|
|
1901
|
|
|
1902
|
field(:status, 1, type: Eigr.Functions.Protocol.Status, enum: true)
|
|
1903
|
field(:message, 2, type: :string)
|
|
1904
|
end
|
added
lib/spawn/actors/eigr/functions/protocol/actors/state.pb.ex
|
|
@@ -0,0 1,92 @@
|
|
1
|
defmodule Eigr.Functions.Protocol.State.Revision do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
name: "Revision",
|
|
9
|
field: [
|
|
10
|
%Google.Protobuf.FieldDescriptorProto{
|
|
11
|
name: "value",
|
|
12
|
extendee: nil,
|
|
13
|
number: 1,
|
|
14
|
label: :LABEL_OPTIONAL,
|
|
15
|
type: :TYPE_INT64,
|
|
16
|
type_name: nil,
|
|
17
|
default_value: nil,
|
|
18
|
options: nil,
|
|
19
|
oneof_index: nil,
|
|
20
|
json_name: "value",
|
|
21
|
proto3_optional: nil,
|
|
22
|
__unknown_fields__: []
|
|
23
|
}
|
|
24
|
],
|
|
25
|
nested_type: [],
|
|
26
|
enum_type: [],
|
|
27
|
extension_range: [],
|
|
28
|
extension: [],
|
|
29
|
options: nil,
|
|
30
|
oneof_decl: [],
|
|
31
|
reserved_range: [],
|
|
32
|
reserved_name: [],
|
|
33
|
__unknown_fields__: []
|
|
34
|
}
|
|
35
|
end
|
|
36
|
|
|
37
|
field(:value, 1, type: :int64)
|
|
38
|
end
|
|
39
|
|
|
40
|
defmodule Eigr.Functions.Protocol.State.Checkpoint do
|
|
41
|
@moduledoc false
|
|
42
|
use Protobuf, protoc_gen_elixir_version: "0.12.0", syntax: :proto3
|
|
43
|
|
|
44
|
def descriptor do
|
|
45
|
# credo:disable-for-next-line
|
|
46
|
%Google.Protobuf.DescriptorProto{
|
|
47
|
name: "Checkpoint",
|
|
48
|
field: [
|
|
49
|
%Google.Protobuf.FieldDescriptorProto{
|
|
50
|
name: "revision",
|
|
51
|
extendee: nil,
|
|
52
|
number: 1,
|
|
53
|
label: :LABEL_OPTIONAL,
|
|
54
|
type: :TYPE_MESSAGE,
|
|
55
|
type_name: ".eigr.functions.protocol.state.Revision",
|
|
56
|
default_value: nil,
|
|
57
|
options: nil,
|
|
58
|
oneof_index: nil,
|
|
59
|
json_name: "revision",
|
|
60
|
proto3_optional: nil,
|
|
61
|
__unknown_fields__: []
|
|
62
|
},
|
|
63
|
%Google.Protobuf.FieldDescriptorProto{
|
|
64
|
name: "state",
|
|
65
|
extendee: nil,
|
|
66
|
number: 2,
|
|
67
|
label: :LABEL_OPTIONAL,
|
|
68
|
type: :TYPE_MESSAGE,
|
|
69
|
type_name: ".eigr.functions.protocol.actors.ActorState",
|
|
70
|
default_value: nil,
|
|
71
|
options: nil,
|
|
72
|
oneof_index: nil,
|
|
73
|
json_name: "state",
|
|
74
|
proto3_optional: nil,
|
|
75
|
__unknown_fields__: []
|
|
76
|
}
|
|
77
|
],
|
|
78
|
nested_type: [],
|
|
79
|
enum_type: [],
|
|
80
|
extension_range: [],
|
|
81
|
extension: [],
|
|
82
|
options: nil,
|
|
83
|
oneof_decl: [],
|
|
84
|
reserved_range: [],
|
|
85
|
reserved_name: [],
|
|
86
|
__unknown_fields__: []
|
|
87
|
}
|
|
88
|
end
|
|
89
|
|
|
90
|
field(:revision, 1, type: Eigr.Functions.Protocol.State.Revision)
|
|
91
|
field(:state, 2, type: Eigr.Functions.Protocol.Actors.ActorState)
|
|
92
|
end
|
removed
lib/spawn/actors/protocol.pb.ex
|
|
@@ -1,1892 0,0 @@
|
|
1
|
- defmodule Eigr.Functions.Protocol.Status do
|
|
2
|
- @moduledoc false
|
|
3
|
- use Protobuf, enum: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
4
|
-
|
|
5
|
- def descriptor do
|
|
6
|
- # credo:disable-for-next-line
|
|
7
|
- %Google.Protobuf.EnumDescriptorProto{
|
|
8
|
- name: "Status",
|
|
9
|
- value: [
|
|
10
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
11
|
- name: "UNKNOWN",
|
|
12
|
- number: 0,
|
|
13
|
- options: nil,
|
|
14
|
- __unknown_fields__: []
|
|
15
|
- },
|
|
16
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
17
|
- name: "OK",
|
|
18
|
- number: 1,
|
|
19
|
- options: nil,
|
|
20
|
- __unknown_fields__: []
|
|
21
|
- },
|
|
22
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
23
|
- name: "ACTOR_NOT_FOUND",
|
|
24
|
- number: 2,
|
|
25
|
- options: nil,
|
|
26
|
- __unknown_fields__: []
|
|
27
|
- },
|
|
28
|
- %Google.Protobuf.EnumValueDescriptorProto{
|
|
29
|
- name: "ERROR",
|
|
30
|
- number: 3,
|
|
31
|
- options: nil,
|
|
32
|
- __unknown_fields__: []
|
|
33
|
- }
|
|
34
|
- ],
|
|
35
|
- options: nil,
|
|
36
|
- reserved_range: [],
|
|
37
|
- reserved_name: [],
|
|
38
|
- __unknown_fields__: []
|
|
39
|
- }
|
|
40
|
- end
|
|
41
|
-
|
|
42
|
- field(:UNKNOWN, 0)
|
|
43
|
- field(:OK, 1)
|
|
44
|
- field(:ACTOR_NOT_FOUND, 2)
|
|
45
|
- field(:ERROR, 3)
|
|
46
|
- end
|
|
47
|
-
|
|
48
|
- defmodule Eigr.Functions.Protocol.Context.MetadataEntry do
|
|
49
|
- @moduledoc false
|
|
50
|
- use Protobuf, map: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
51
|
-
|
|
52
|
- def descriptor do
|
|
53
|
- # credo:disable-for-next-line
|
|
54
|
- %Google.Protobuf.DescriptorProto{
|
|
55
|
- name: "MetadataEntry",
|
|
56
|
- field: [
|
|
57
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
58
|
- name: "key",
|
|
59
|
- extendee: nil,
|
|
60
|
- number: 1,
|
|
61
|
- label: :LABEL_OPTIONAL,
|
|
62
|
- type: :TYPE_STRING,
|
|
63
|
- type_name: nil,
|
|
64
|
- default_value: nil,
|
|
65
|
- options: nil,
|
|
66
|
- oneof_index: nil,
|
|
67
|
- json_name: "key",
|
|
68
|
- proto3_optional: nil,
|
|
69
|
- __unknown_fields__: []
|
|
70
|
- },
|
|
71
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
72
|
- name: "value",
|
|
73
|
- extendee: nil,
|
|
74
|
- number: 2,
|
|
75
|
- label: :LABEL_OPTIONAL,
|
|
76
|
- type: :TYPE_STRING,
|
|
77
|
- type_name: nil,
|
|
78
|
- default_value: nil,
|
|
79
|
- options: nil,
|
|
80
|
- oneof_index: nil,
|
|
81
|
- json_name: "value",
|
|
82
|
- proto3_optional: nil,
|
|
83
|
- __unknown_fields__: []
|
|
84
|
- }
|
|
85
|
- ],
|
|
86
|
- nested_type: [],
|
|
87
|
- enum_type: [],
|
|
88
|
- extension_range: [],
|
|
89
|
- extension: [],
|
|
90
|
- options: %Google.Protobuf.MessageOptions{
|
|
91
|
- message_set_wire_format: false,
|
|
92
|
- no_standard_descriptor_accessor: false,
|
|
93
|
- deprecated: false,
|
|
94
|
- map_entry: true,
|
|
95
|
- uninterpreted_option: [],
|
|
96
|
- __pb_extensions__: %{},
|
|
97
|
- __unknown_fields__: []
|
|
98
|
- },
|
|
99
|
- oneof_decl: [],
|
|
100
|
- reserved_range: [],
|
|
101
|
- reserved_name: [],
|
|
102
|
- __unknown_fields__: []
|
|
103
|
- }
|
|
104
|
- end
|
|
105
|
-
|
|
106
|
- field(:key, 1, type: :string)
|
|
107
|
- field(:value, 2, type: :string)
|
|
108
|
- end
|
|
109
|
-
|
|
110
|
- defmodule Eigr.Functions.Protocol.Context.TagsEntry do
|
|
111
|
- @moduledoc false
|
|
112
|
- use Protobuf, map: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
113
|
-
|
|
114
|
- def descriptor do
|
|
115
|
- # credo:disable-for-next-line
|
|
116
|
- %Google.Protobuf.DescriptorProto{
|
|
117
|
- name: "TagsEntry",
|
|
118
|
- field: [
|
|
119
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
120
|
- name: "key",
|
|
121
|
- extendee: nil,
|
|
122
|
- number: 1,
|
|
123
|
- label: :LABEL_OPTIONAL,
|
|
124
|
- type: :TYPE_STRING,
|
|
125
|
- type_name: nil,
|
|
126
|
- default_value: nil,
|
|
127
|
- options: nil,
|
|
128
|
- oneof_index: nil,
|
|
129
|
- json_name: "key",
|
|
130
|
- proto3_optional: nil,
|
|
131
|
- __unknown_fields__: []
|
|
132
|
- },
|
|
133
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
134
|
- name: "value",
|
|
135
|
- extendee: nil,
|
|
136
|
- number: 2,
|
|
137
|
- label: :LABEL_OPTIONAL,
|
|
138
|
- type: :TYPE_STRING,
|
|
139
|
- type_name: nil,
|
|
140
|
- default_value: nil,
|
|
141
|
- options: nil,
|
|
142
|
- oneof_index: nil,
|
|
143
|
- json_name: "value",
|
|
144
|
- proto3_optional: nil,
|
|
145
|
- __unknown_fields__: []
|
|
146
|
- }
|
|
147
|
- ],
|
|
148
|
- nested_type: [],
|
|
149
|
- enum_type: [],
|
|
150
|
- extension_range: [],
|
|
151
|
- extension: [],
|
|
152
|
- options: %Google.Protobuf.MessageOptions{
|
|
153
|
- message_set_wire_format: false,
|
|
154
|
- no_standard_descriptor_accessor: false,
|
|
155
|
- deprecated: false,
|
|
156
|
- map_entry: true,
|
|
157
|
- uninterpreted_option: [],
|
|
158
|
- __pb_extensions__: %{},
|
|
159
|
- __unknown_fields__: []
|
|
160
|
- },
|
|
161
|
- oneof_decl: [],
|
|
162
|
- reserved_range: [],
|
|
163
|
- reserved_name: [],
|
|
164
|
- __unknown_fields__: []
|
|
165
|
- }
|
|
166
|
- end
|
|
167
|
-
|
|
168
|
- field(:key, 1, type: :string)
|
|
169
|
- field(:value, 2, type: :string)
|
|
170
|
- end
|
|
171
|
-
|
|
172
|
- defmodule Eigr.Functions.Protocol.Context do
|
|
173
|
- @moduledoc false
|
|
174
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
175
|
-
|
|
176
|
- def descriptor do
|
|
177
|
- # credo:disable-for-next-line
|
|
178
|
- %Google.Protobuf.DescriptorProto{
|
|
179
|
- name: "Context",
|
|
180
|
- field: [
|
|
181
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
182
|
- name: "state",
|
|
183
|
- extendee: nil,
|
|
184
|
- number: 1,
|
|
185
|
- label: :LABEL_OPTIONAL,
|
|
186
|
- type: :TYPE_MESSAGE,
|
|
187
|
- type_name: ".google.protobuf.Any",
|
|
188
|
- default_value: nil,
|
|
189
|
- options: nil,
|
|
190
|
- oneof_index: nil,
|
|
191
|
- json_name: "state",
|
|
192
|
- proto3_optional: nil,
|
|
193
|
- __unknown_fields__: []
|
|
194
|
- },
|
|
195
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
196
|
- name: "metadata",
|
|
197
|
- extendee: nil,
|
|
198
|
- number: 4,
|
|
199
|
- label: :LABEL_REPEATED,
|
|
200
|
- type: :TYPE_MESSAGE,
|
|
201
|
- type_name: ".eigr.functions.protocol.Context.MetadataEntry",
|
|
202
|
- default_value: nil,
|
|
203
|
- options: nil,
|
|
204
|
- oneof_index: nil,
|
|
205
|
- json_name: "metadata",
|
|
206
|
- proto3_optional: nil,
|
|
207
|
- __unknown_fields__: []
|
|
208
|
- },
|
|
209
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
210
|
- name: "tags",
|
|
211
|
- extendee: nil,
|
|
212
|
- number: 5,
|
|
213
|
- label: :LABEL_REPEATED,
|
|
214
|
- type: :TYPE_MESSAGE,
|
|
215
|
- type_name: ".eigr.functions.protocol.Context.TagsEntry",
|
|
216
|
- default_value: nil,
|
|
217
|
- options: nil,
|
|
218
|
- oneof_index: nil,
|
|
219
|
- json_name: "tags",
|
|
220
|
- proto3_optional: nil,
|
|
221
|
- __unknown_fields__: []
|
|
222
|
- },
|
|
223
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
224
|
- name: "caller",
|
|
225
|
- extendee: nil,
|
|
226
|
- number: 2,
|
|
227
|
- label: :LABEL_OPTIONAL,
|
|
228
|
- type: :TYPE_MESSAGE,
|
|
229
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
230
|
- default_value: nil,
|
|
231
|
- options: nil,
|
|
232
|
- oneof_index: nil,
|
|
233
|
- json_name: "caller",
|
|
234
|
- proto3_optional: nil,
|
|
235
|
- __unknown_fields__: []
|
|
236
|
- },
|
|
237
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
238
|
- name: "self",
|
|
239
|
- extendee: nil,
|
|
240
|
- number: 3,
|
|
241
|
- label: :LABEL_OPTIONAL,
|
|
242
|
- type: :TYPE_MESSAGE,
|
|
243
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
244
|
- default_value: nil,
|
|
245
|
- options: nil,
|
|
246
|
- oneof_index: nil,
|
|
247
|
- json_name: "self",
|
|
248
|
- proto3_optional: nil,
|
|
249
|
- __unknown_fields__: []
|
|
250
|
- }
|
|
251
|
- ],
|
|
252
|
- nested_type: [
|
|
253
|
- %Google.Protobuf.DescriptorProto{
|
|
254
|
- name: "MetadataEntry",
|
|
255
|
- field: [
|
|
256
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
257
|
- name: "key",
|
|
258
|
- extendee: nil,
|
|
259
|
- number: 1,
|
|
260
|
- label: :LABEL_OPTIONAL,
|
|
261
|
- type: :TYPE_STRING,
|
|
262
|
- type_name: nil,
|
|
263
|
- default_value: nil,
|
|
264
|
- options: nil,
|
|
265
|
- oneof_index: nil,
|
|
266
|
- json_name: "key",
|
|
267
|
- proto3_optional: nil,
|
|
268
|
- __unknown_fields__: []
|
|
269
|
- },
|
|
270
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
271
|
- name: "value",
|
|
272
|
- extendee: nil,
|
|
273
|
- number: 2,
|
|
274
|
- label: :LABEL_OPTIONAL,
|
|
275
|
- type: :TYPE_STRING,
|
|
276
|
- type_name: nil,
|
|
277
|
- default_value: nil,
|
|
278
|
- options: nil,
|
|
279
|
- oneof_index: nil,
|
|
280
|
- json_name: "value",
|
|
281
|
- proto3_optional: nil,
|
|
282
|
- __unknown_fields__: []
|
|
283
|
- }
|
|
284
|
- ],
|
|
285
|
- nested_type: [],
|
|
286
|
- enum_type: [],
|
|
287
|
- extension_range: [],
|
|
288
|
- extension: [],
|
|
289
|
- options: %Google.Protobuf.MessageOptions{
|
|
290
|
- message_set_wire_format: false,
|
|
291
|
- no_standard_descriptor_accessor: false,
|
|
292
|
- deprecated: false,
|
|
293
|
- map_entry: true,
|
|
294
|
- uninterpreted_option: [],
|
|
295
|
- __pb_extensions__: %{},
|
|
296
|
- __unknown_fields__: []
|
|
297
|
- },
|
|
298
|
- oneof_decl: [],
|
|
299
|
- reserved_range: [],
|
|
300
|
- reserved_name: [],
|
|
301
|
- __unknown_fields__: []
|
|
302
|
- },
|
|
303
|
- %Google.Protobuf.DescriptorProto{
|
|
304
|
- name: "TagsEntry",
|
|
305
|
- field: [
|
|
306
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
307
|
- name: "key",
|
|
308
|
- extendee: nil,
|
|
309
|
- number: 1,
|
|
310
|
- label: :LABEL_OPTIONAL,
|
|
311
|
- type: :TYPE_STRING,
|
|
312
|
- type_name: nil,
|
|
313
|
- default_value: nil,
|
|
314
|
- options: nil,
|
|
315
|
- oneof_index: nil,
|
|
316
|
- json_name: "key",
|
|
317
|
- proto3_optional: nil,
|
|
318
|
- __unknown_fields__: []
|
|
319
|
- },
|
|
320
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
321
|
- name: "value",
|
|
322
|
- extendee: nil,
|
|
323
|
- number: 2,
|
|
324
|
- label: :LABEL_OPTIONAL,
|
|
325
|
- type: :TYPE_STRING,
|
|
326
|
- type_name: nil,
|
|
327
|
- default_value: nil,
|
|
328
|
- options: nil,
|
|
329
|
- oneof_index: nil,
|
|
330
|
- json_name: "value",
|
|
331
|
- proto3_optional: nil,
|
|
332
|
- __unknown_fields__: []
|
|
333
|
- }
|
|
334
|
- ],
|
|
335
|
- nested_type: [],
|
|
336
|
- enum_type: [],
|
|
337
|
- extension_range: [],
|
|
338
|
- extension: [],
|
|
339
|
- options: %Google.Protobuf.MessageOptions{
|
|
340
|
- message_set_wire_format: false,
|
|
341
|
- no_standard_descriptor_accessor: false,
|
|
342
|
- deprecated: false,
|
|
343
|
- map_entry: true,
|
|
344
|
- uninterpreted_option: [],
|
|
345
|
- __pb_extensions__: %{},
|
|
346
|
- __unknown_fields__: []
|
|
347
|
- },
|
|
348
|
- oneof_decl: [],
|
|
349
|
- reserved_range: [],
|
|
350
|
- reserved_name: [],
|
|
351
|
- __unknown_fields__: []
|
|
352
|
- }
|
|
353
|
- ],
|
|
354
|
- enum_type: [],
|
|
355
|
- extension_range: [],
|
|
356
|
- extension: [],
|
|
357
|
- options: nil,
|
|
358
|
- oneof_decl: [],
|
|
359
|
- reserved_range: [],
|
|
360
|
- reserved_name: [],
|
|
361
|
- __unknown_fields__: []
|
|
362
|
- }
|
|
363
|
- end
|
|
364
|
-
|
|
365
|
- field(:state, 1, type: Google.Protobuf.Any)
|
|
366
|
-
|
|
367
|
- field(:metadata, 4,
|
|
368
|
- repeated: true,
|
|
369
|
- type: Eigr.Functions.Protocol.Context.MetadataEntry,
|
|
370
|
- map: true
|
|
371
|
- )
|
|
372
|
-
|
|
373
|
- field(:tags, 5, repeated: true, type: Eigr.Functions.Protocol.Context.TagsEntry, map: true)
|
|
374
|
- field(:caller, 2, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
375
|
- field(:self, 3, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
376
|
- end
|
|
377
|
-
|
|
378
|
- defmodule Eigr.Functions.Protocol.Noop do
|
|
379
|
- @moduledoc false
|
|
380
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
381
|
-
|
|
382
|
- def descriptor do
|
|
383
|
- # credo:disable-for-next-line
|
|
384
|
- %Google.Protobuf.DescriptorProto{
|
|
385
|
- name: "Noop",
|
|
386
|
- field: [],
|
|
387
|
- nested_type: [],
|
|
388
|
- enum_type: [],
|
|
389
|
- extension_range: [],
|
|
390
|
- extension: [],
|
|
391
|
- options: nil,
|
|
392
|
- oneof_decl: [],
|
|
393
|
- reserved_range: [],
|
|
394
|
- reserved_name: [],
|
|
395
|
- __unknown_fields__: []
|
|
396
|
- }
|
|
397
|
- end
|
|
398
|
- end
|
|
399
|
-
|
|
400
|
- defmodule Eigr.Functions.Protocol.JSONType do
|
|
401
|
- @moduledoc false
|
|
402
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
403
|
-
|
|
404
|
- def descriptor do
|
|
405
|
- # credo:disable-for-next-line
|
|
406
|
- %Google.Protobuf.DescriptorProto{
|
|
407
|
- name: "JSONType",
|
|
408
|
- field: [
|
|
409
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
410
|
- name: "content",
|
|
411
|
- extendee: nil,
|
|
412
|
- number: 1,
|
|
413
|
- label: :LABEL_OPTIONAL,
|
|
414
|
- type: :TYPE_STRING,
|
|
415
|
- type_name: nil,
|
|
416
|
- default_value: nil,
|
|
417
|
- options: nil,
|
|
418
|
- oneof_index: nil,
|
|
419
|
- json_name: "content",
|
|
420
|
- proto3_optional: nil,
|
|
421
|
- __unknown_fields__: []
|
|
422
|
- }
|
|
423
|
- ],
|
|
424
|
- nested_type: [],
|
|
425
|
- enum_type: [],
|
|
426
|
- extension_range: [],
|
|
427
|
- extension: [],
|
|
428
|
- options: nil,
|
|
429
|
- oneof_decl: [],
|
|
430
|
- reserved_range: [],
|
|
431
|
- reserved_name: [],
|
|
432
|
- __unknown_fields__: []
|
|
433
|
- }
|
|
434
|
- end
|
|
435
|
-
|
|
436
|
- field(:content, 1, type: :string)
|
|
437
|
- end
|
|
438
|
-
|
|
439
|
- defmodule Eigr.Functions.Protocol.RegistrationRequest do
|
|
440
|
- @moduledoc false
|
|
441
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
442
|
-
|
|
443
|
- def descriptor do
|
|
444
|
- # credo:disable-for-next-line
|
|
445
|
- %Google.Protobuf.DescriptorProto{
|
|
446
|
- name: "RegistrationRequest",
|
|
447
|
- field: [
|
|
448
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
449
|
- name: "service_info",
|
|
450
|
- extendee: nil,
|
|
451
|
- number: 1,
|
|
452
|
- label: :LABEL_OPTIONAL,
|
|
453
|
- type: :TYPE_MESSAGE,
|
|
454
|
- type_name: ".eigr.functions.protocol.ServiceInfo",
|
|
455
|
- default_value: nil,
|
|
456
|
- options: nil,
|
|
457
|
- oneof_index: nil,
|
|
458
|
- json_name: "serviceInfo",
|
|
459
|
- proto3_optional: nil,
|
|
460
|
- __unknown_fields__: []
|
|
461
|
- },
|
|
462
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
463
|
- name: "actor_system",
|
|
464
|
- extendee: nil,
|
|
465
|
- number: 2,
|
|
466
|
- label: :LABEL_OPTIONAL,
|
|
467
|
- type: :TYPE_MESSAGE,
|
|
468
|
- type_name: ".eigr.functions.protocol.actors.ActorSystem",
|
|
469
|
- default_value: nil,
|
|
470
|
- options: nil,
|
|
471
|
- oneof_index: nil,
|
|
472
|
- json_name: "actorSystem",
|
|
473
|
- proto3_optional: nil,
|
|
474
|
- __unknown_fields__: []
|
|
475
|
- }
|
|
476
|
- ],
|
|
477
|
- nested_type: [],
|
|
478
|
- enum_type: [],
|
|
479
|
- extension_range: [],
|
|
480
|
- extension: [],
|
|
481
|
- options: nil,
|
|
482
|
- oneof_decl: [],
|
|
483
|
- reserved_range: [],
|
|
484
|
- reserved_name: [],
|
|
485
|
- __unknown_fields__: []
|
|
486
|
- }
|
|
487
|
- end
|
|
488
|
-
|
|
489
|
- field(:service_info, 1, type: Eigr.Functions.Protocol.ServiceInfo, json_name: "serviceInfo")
|
|
490
|
-
|
|
491
|
- field(:actor_system, 2,
|
|
492
|
- type: Eigr.Functions.Protocol.Actors.ActorSystem,
|
|
493
|
- json_name: "actorSystem"
|
|
494
|
- )
|
|
495
|
- end
|
|
496
|
-
|
|
497
|
- defmodule Eigr.Functions.Protocol.RegistrationResponse do
|
|
498
|
- @moduledoc false
|
|
499
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
500
|
-
|
|
501
|
- def descriptor do
|
|
502
|
- # credo:disable-for-next-line
|
|
503
|
- %Google.Protobuf.DescriptorProto{
|
|
504
|
- name: "RegistrationResponse",
|
|
505
|
- field: [
|
|
506
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
507
|
- name: "status",
|
|
508
|
- extendee: nil,
|
|
509
|
- number: 1,
|
|
510
|
- label: :LABEL_OPTIONAL,
|
|
511
|
- type: :TYPE_MESSAGE,
|
|
512
|
- type_name: ".eigr.functions.protocol.RequestStatus",
|
|
513
|
- default_value: nil,
|
|
514
|
- options: nil,
|
|
515
|
- oneof_index: nil,
|
|
516
|
- json_name: "status",
|
|
517
|
- proto3_optional: nil,
|
|
518
|
- __unknown_fields__: []
|
|
519
|
- },
|
|
520
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
521
|
- name: "proxy_info",
|
|
522
|
- extendee: nil,
|
|
523
|
- number: 2,
|
|
524
|
- label: :LABEL_OPTIONAL,
|
|
525
|
- type: :TYPE_MESSAGE,
|
|
526
|
- type_name: ".eigr.functions.protocol.ProxyInfo",
|
|
527
|
- default_value: nil,
|
|
528
|
- options: nil,
|
|
529
|
- oneof_index: nil,
|
|
530
|
- json_name: "proxyInfo",
|
|
531
|
- proto3_optional: nil,
|
|
532
|
- __unknown_fields__: []
|
|
533
|
- }
|
|
534
|
- ],
|
|
535
|
- nested_type: [],
|
|
536
|
- enum_type: [],
|
|
537
|
- extension_range: [],
|
|
538
|
- extension: [],
|
|
539
|
- options: nil,
|
|
540
|
- oneof_decl: [],
|
|
541
|
- reserved_range: [],
|
|
542
|
- reserved_name: [],
|
|
543
|
- __unknown_fields__: []
|
|
544
|
- }
|
|
545
|
- end
|
|
546
|
-
|
|
547
|
- field(:status, 1, type: Eigr.Functions.Protocol.RequestStatus)
|
|
548
|
- field(:proxy_info, 2, type: Eigr.Functions.Protocol.ProxyInfo, json_name: "proxyInfo")
|
|
549
|
- end
|
|
550
|
-
|
|
551
|
- defmodule Eigr.Functions.Protocol.ServiceInfo do
|
|
552
|
- @moduledoc false
|
|
553
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
554
|
-
|
|
555
|
- def descriptor do
|
|
556
|
- # credo:disable-for-next-line
|
|
557
|
- %Google.Protobuf.DescriptorProto{
|
|
558
|
- name: "ServiceInfo",
|
|
559
|
- field: [
|
|
560
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
561
|
- name: "service_name",
|
|
562
|
- extendee: nil,
|
|
563
|
- number: 1,
|
|
564
|
- label: :LABEL_OPTIONAL,
|
|
565
|
- type: :TYPE_STRING,
|
|
566
|
- type_name: nil,
|
|
567
|
- default_value: nil,
|
|
568
|
- options: nil,
|
|
569
|
- oneof_index: nil,
|
|
570
|
- json_name: "serviceName",
|
|
571
|
- proto3_optional: nil,
|
|
572
|
- __unknown_fields__: []
|
|
573
|
- },
|
|
574
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
575
|
- name: "service_version",
|
|
576
|
- extendee: nil,
|
|
577
|
- number: 2,
|
|
578
|
- label: :LABEL_OPTIONAL,
|
|
579
|
- type: :TYPE_STRING,
|
|
580
|
- type_name: nil,
|
|
581
|
- default_value: nil,
|
|
582
|
- options: nil,
|
|
583
|
- oneof_index: nil,
|
|
584
|
- json_name: "serviceVersion",
|
|
585
|
- proto3_optional: nil,
|
|
586
|
- __unknown_fields__: []
|
|
587
|
- },
|
|
588
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
589
|
- name: "service_runtime",
|
|
590
|
- extendee: nil,
|
|
591
|
- number: 3,
|
|
592
|
- label: :LABEL_OPTIONAL,
|
|
593
|
- type: :TYPE_STRING,
|
|
863
|
- type_name: nil,
|
|
595
|
- default_value: nil,
|
|
596
|
- options: nil,
|
|
597
|
- oneof_index: nil,
|
|
598
|
- json_name: "serviceRuntime",
|
|
599
|
- proto3_optional: nil,
|
|
600
|
- __unknown_fields__: []
|
|
601
|
- },
|
|
602
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
603
|
- name: "support_library_name",
|
|
604
|
- extendee: nil,
|
|
605
|
- number: 4,
|
|
606
|
- label: :LABEL_OPTIONAL,
|
|
607
|
- type: :TYPE_STRING,
|
|
608
|
- type_name: nil,
|
|
609
|
- default_value: nil,
|
|
610
|
- options: nil,
|
|
611
|
- oneof_index: nil,
|
|
612
|
- json_name: "supportLibraryName",
|
|
613
|
- proto3_optional: nil,
|
|
614
|
- __unknown_fields__: []
|
|
615
|
- },
|
|
616
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
617
|
- name: "support_library_version",
|
|
618
|
- extendee: nil,
|
|
619
|
- number: 5,
|
|
620
|
- label: :LABEL_OPTIONAL,
|
|
621
|
- type: :TYPE_STRING,
|
|
622
|
- type_name: nil,
|
|
623
|
- default_value: nil,
|
|
624
|
- options: nil,
|
|
625
|
- oneof_index: nil,
|
|
626
|
- json_name: "supportLibraryVersion",
|
|
627
|
- proto3_optional: nil,
|
|
628
|
- __unknown_fields__: []
|
|
629
|
- },
|
|
630
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
631
|
- name: "protocol_major_version",
|
|
632
|
- extendee: nil,
|
|
633
|
- number: 6,
|
|
634
|
- label: :LABEL_OPTIONAL,
|
|
635
|
- type: :TYPE_INT32,
|
|
636
|
- type_name: nil,
|
|
637
|
- default_value: nil,
|
|
638
|
- options: nil,
|
|
639
|
- oneof_index: nil,
|
|
640
|
- json_name: "protocolMajorVersion",
|
|
641
|
- proto3_optional: nil,
|
|
642
|
- __unknown_fields__: []
|
|
643
|
- },
|
|
644
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
645
|
- name: "protocol_minor_version",
|
|
646
|
- extendee: nil,
|
|
647
|
- number: 7,
|
|
648
|
- label: :LABEL_OPTIONAL,
|
|
649
|
- type: :TYPE_INT32,
|
|
650
|
- type_name: nil,
|
|
651
|
- default_value: nil,
|
|
652
|
- options: nil,
|
|
653
|
- oneof_index: nil,
|
|
654
|
- json_name: "protocolMinorVersion",
|
|
655
|
- proto3_optional: nil,
|
|
656
|
- __unknown_fields__: []
|
|
657
|
- }
|
|
658
|
- ],
|
|
659
|
- nested_type: [],
|
|
660
|
- enum_type: [],
|
|
661
|
- extension_range: [],
|
|
662
|
- extension: [],
|
|
663
|
- options: nil,
|
|
664
|
- oneof_decl: [],
|
|
665
|
- reserved_range: [],
|
|
666
|
- reserved_name: [],
|
|
667
|
- __unknown_fields__: []
|
|
668
|
- }
|
|
669
|
- end
|
|
670
|
-
|
|
671
|
- field(:service_name, 1, type: :string, json_name: "serviceName")
|
|
672
|
- field(:service_version, 2, type: :string, json_name: "serviceVersion")
|
|
673
|
- field(:service_runtime, 3, type: :string, json_name: "serviceRuntime")
|
|
674
|
- field(:support_library_name, 4, type: :string, json_name: "supportLibraryName")
|
|
675
|
- field(:support_library_version, 5, type: :string, json_name: "supportLibraryVersion")
|
|
676
|
- field(:protocol_major_version, 6, type: :int32, json_name: "protocolMajorVersion")
|
|
677
|
- field(:protocol_minor_version, 7, type: :int32, json_name: "protocolMinorVersion")
|
|
678
|
- end
|
|
679
|
-
|
|
680
|
- defmodule Eigr.Functions.Protocol.SpawnRequest do
|
|
681
|
- @moduledoc false
|
|
682
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
683
|
-
|
|
684
|
- def descriptor do
|
|
685
|
- # credo:disable-for-next-line
|
|
686
|
- %Google.Protobuf.DescriptorProto{
|
|
687
|
- name: "SpawnRequest",
|
|
688
|
- field: [
|
|
689
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
690
|
- name: "actors",
|
|
691
|
- extendee: nil,
|
|
692
|
- number: 1,
|
|
693
|
- label: :LABEL_REPEATED,
|
|
694
|
- type: :TYPE_MESSAGE,
|
|
695
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
696
|
- default_value: nil,
|
|
697
|
- options: nil,
|
|
698
|
- oneof_index: nil,
|
|
699
|
- json_name: "actors",
|
|
700
|
- proto3_optional: nil,
|
|
701
|
- __unknown_fields__: []
|
|
702
|
- }
|
|
703
|
- ],
|
|
704
|
- nested_type: [],
|
|
705
|
- enum_type: [],
|
|
706
|
- extension_range: [],
|
|
707
|
- extension: [],
|
|
708
|
- options: nil,
|
|
709
|
- oneof_decl: [],
|
|
710
|
- reserved_range: [],
|
|
711
|
- reserved_name: [],
|
|
712
|
- __unknown_fields__: []
|
|
713
|
- }
|
|
714
|
- end
|
|
715
|
-
|
|
716
|
- field(:actors, 1, repeated: true, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
717
|
- end
|
|
718
|
-
|
|
719
|
- defmodule Eigr.Functions.Protocol.SpawnResponse do
|
|
720
|
- @moduledoc false
|
|
721
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
722
|
-
|
|
723
|
- def descriptor do
|
|
724
|
- # credo:disable-for-next-line
|
|
725
|
- %Google.Protobuf.DescriptorProto{
|
|
726
|
- name: "SpawnResponse",
|
|
727
|
- field: [
|
|
728
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
729
|
- name: "status",
|
|
730
|
- extendee: nil,
|
|
731
|
- number: 1,
|
|
732
|
- label: :LABEL_OPTIONAL,
|
|
733
|
- type: :TYPE_MESSAGE,
|
|
734
|
- type_name: ".eigr.functions.protocol.RequestStatus",
|
|
735
|
- default_value: nil,
|
|
736
|
- options: nil,
|
|
737
|
- oneof_index: nil,
|
|
738
|
- json_name: "status",
|
|
739
|
- proto3_optional: nil,
|
|
740
|
- __unknown_fields__: []
|
|
741
|
- }
|
|
742
|
- ],
|
|
743
|
- nested_type: [],
|
|
744
|
- enum_type: [],
|
|
745
|
- extension_range: [],
|
|
746
|
- extension: [],
|
|
747
|
- options: nil,
|
|
748
|
- oneof_decl: [],
|
|
749
|
- reserved_range: [],
|
|
750
|
- reserved_name: [],
|
|
751
|
- __unknown_fields__: []
|
|
752
|
- }
|
|
753
|
- end
|
|
754
|
-
|
|
755
|
- field(:status, 1, type: Eigr.Functions.Protocol.RequestStatus)
|
|
756
|
- end
|
|
757
|
-
|
|
758
|
- defmodule Eigr.Functions.Protocol.ProxyInfo do
|
|
759
|
- @moduledoc false
|
|
760
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
761
|
-
|
|
762
|
- def descriptor do
|
|
763
|
- # credo:disable-for-next-line
|
|
764
|
- %Google.Protobuf.DescriptorProto{
|
|
765
|
- name: "ProxyInfo",
|
|
766
|
- field: [
|
|
767
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
768
|
- name: "protocol_major_version",
|
|
769
|
- extendee: nil,
|
|
770
|
- number: 1,
|
|
771
|
- label: :LABEL_OPTIONAL,
|
|
772
|
- type: :TYPE_INT32,
|
|
773
|
- type_name: nil,
|
|
774
|
- default_value: nil,
|
|
775
|
- options: nil,
|
|
776
|
- oneof_index: nil,
|
|
777
|
- json_name: "protocolMajorVersion",
|
|
778
|
- proto3_optional: nil,
|
|
779
|
- __unknown_fields__: []
|
|
780
|
- },
|
|
781
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
782
|
- name: "protocol_minor_version",
|
|
783
|
- extendee: nil,
|
|
784
|
- number: 2,
|
|
785
|
- label: :LABEL_OPTIONAL,
|
|
786
|
- type: :TYPE_INT32,
|
|
787
|
- type_name: nil,
|
|
788
|
- default_value: nil,
|
|
789
|
- options: nil,
|
|
790
|
- oneof_index: nil,
|
|
791
|
- json_name: "protocolMinorVersion",
|
|
792
|
- proto3_optional: nil,
|
|
793
|
- __unknown_fields__: []
|
|
794
|
- },
|
|
795
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
796
|
- name: "proxy_name",
|
|
797
|
- extendee: nil,
|
|
798
|
- number: 3,
|
|
799
|
- label: :LABEL_OPTIONAL,
|
|
800
|
- type: :TYPE_STRING,
|
|
801
|
- type_name: nil,
|
|
802
|
- default_value: nil,
|
|
803
|
- options: nil,
|
|
804
|
- oneof_index: nil,
|
|
805
|
- json_name: "proxyName",
|
|
806
|
- proto3_optional: nil,
|
|
807
|
- __unknown_fields__: []
|
|
808
|
- },
|
|
809
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
810
|
- name: "proxy_version",
|
|
811
|
- extendee: nil,
|
|
812
|
- number: 4,
|
|
813
|
- label: :LABEL_OPTIONAL,
|
|
814
|
- type: :TYPE_STRING,
|
|
815
|
- type_name: nil,
|
|
816
|
- default_value: nil,
|
|
817
|
- options: nil,
|
|
818
|
- oneof_index: nil,
|
|
819
|
- json_name: "proxyVersion",
|
|
820
|
- proto3_optional: nil,
|
|
821
|
- __unknown_fields__: []
|
|
822
|
- }
|
|
823
|
- ],
|
|
824
|
- nested_type: [],
|
|
825
|
- enum_type: [],
|
|
826
|
- extension_range: [],
|
|
827
|
- extension: [],
|
|
828
|
- options: nil,
|
|
829
|
- oneof_decl: [],
|
|
830
|
- reserved_range: [],
|
|
831
|
- reserved_name: [],
|
|
832
|
- __unknown_fields__: []
|
|
833
|
- }
|
|
834
|
- end
|
|
835
|
-
|
|
836
|
- field(:protocol_major_version, 1, type: :int32, json_name: "protocolMajorVersion")
|
|
837
|
- field(:protocol_minor_version, 2, type: :int32, json_name: "protocolMinorVersion")
|
|
838
|
- field(:proxy_name, 3, type: :string, json_name: "proxyName")
|
|
839
|
- field(:proxy_version, 4, type: :string, json_name: "proxyVersion")
|
|
840
|
- end
|
|
841
|
-
|
|
842
|
- defmodule Eigr.Functions.Protocol.SideEffect do
|
|
843
|
- @moduledoc false
|
|
844
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
845
|
-
|
|
846
|
- def descriptor do
|
|
847
|
- # credo:disable-for-next-line
|
|
848
|
- %Google.Protobuf.DescriptorProto{
|
|
849
|
- name: "SideEffect",
|
|
850
|
- field: [
|
|
851
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
852
|
- name: "request",
|
|
853
|
- extendee: nil,
|
|
854
|
- number: 1,
|
|
855
|
- label: :LABEL_OPTIONAL,
|
|
856
|
- type: :TYPE_MESSAGE,
|
|
857
|
- type_name: ".eigr.functions.protocol.InvocationRequest",
|
|
858
|
- default_value: nil,
|
|
859
|
- options: nil,
|
|
860
|
- oneof_index: nil,
|
|
861
|
- json_name: "request",
|
|
862
|
- proto3_optional: nil,
|
|
863
|
- __unknown_fields__: []
|
|
864
|
- }
|
|
865
|
- ],
|
|
866
|
- nested_type: [],
|
|
867
|
- enum_type: [],
|
|
868
|
- extension_range: [],
|
|
869
|
- extension: [],
|
|
870
|
- options: nil,
|
|
871
|
- oneof_decl: [],
|
|
872
|
- reserved_range: [],
|
|
873
|
- reserved_name: [],
|
|
874
|
- __unknown_fields__: []
|
|
875
|
- }
|
|
876
|
- end
|
|
877
|
-
|
|
878
|
- field(:request, 1, type: Eigr.Functions.Protocol.InvocationRequest)
|
|
879
|
- end
|
|
880
|
-
|
|
881
|
- defmodule Eigr.Functions.Protocol.Broadcast do
|
|
882
|
- @moduledoc false
|
|
883
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
884
|
-
|
|
885
|
- def descriptor do
|
|
886
|
- # credo:disable-for-next-line
|
|
887
|
- %Google.Protobuf.DescriptorProto{
|
|
888
|
- name: "Broadcast",
|
|
889
|
- field: [
|
|
890
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
891
|
- name: "channel_group",
|
|
892
|
- extendee: nil,
|
|
893
|
- number: 1,
|
|
894
|
- label: :LABEL_OPTIONAL,
|
|
895
|
- type: :TYPE_STRING,
|
|
896
|
- type_name: nil,
|
|
897
|
- default_value: nil,
|
|
898
|
- options: nil,
|
|
899
|
- oneof_index: nil,
|
|
900
|
- json_name: "channelGroup",
|
|
901
|
- proto3_optional: nil,
|
|
902
|
- __unknown_fields__: []
|
|
903
|
- },
|
|
904
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
905
|
- name: "value",
|
|
906
|
- extendee: nil,
|
|
907
|
- number: 3,
|
|
908
|
- label: :LABEL_OPTIONAL,
|
|
909
|
- type: :TYPE_MESSAGE,
|
|
910
|
- type_name: ".google.protobuf.Any",
|
|
911
|
- default_value: nil,
|
|
912
|
- options: nil,
|
|
913
|
- oneof_index: 0,
|
|
914
|
- json_name: "value",
|
|
915
|
- proto3_optional: nil,
|
|
916
|
- __unknown_fields__: []
|
|
917
|
- },
|
|
918
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
919
|
- name: "noop",
|
|
920
|
- extendee: nil,
|
|
921
|
- number: 4,
|
|
922
|
- label: :LABEL_OPTIONAL,
|
|
923
|
- type: :TYPE_MESSAGE,
|
|
924
|
- type_name: ".eigr.functions.protocol.Noop",
|
|
925
|
- default_value: nil,
|
|
926
|
- options: nil,
|
|
927
|
- oneof_index: 0,
|
|
928
|
- json_name: "noop",
|
|
929
|
- proto3_optional: nil,
|
|
930
|
- __unknown_fields__: []
|
|
931
|
- }
|
|
932
|
- ],
|
|
933
|
- nested_type: [],
|
|
934
|
- enum_type: [],
|
|
935
|
- extension_range: [],
|
|
936
|
- extension: [],
|
|
937
|
- options: nil,
|
|
938
|
- oneof_decl: [
|
|
939
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
940
|
- name: "payload",
|
|
941
|
- options: nil,
|
|
942
|
- __unknown_fields__: []
|
|
943
|
- }
|
|
944
|
- ],
|
|
945
|
- reserved_range: [],
|
|
946
|
- reserved_name: [],
|
|
947
|
- __unknown_fields__: []
|
|
948
|
- }
|
|
949
|
- end
|
|
950
|
-
|
|
951
|
- oneof(:payload, 0)
|
|
952
|
-
|
|
953
|
- field(:channel_group, 1, type: :string, json_name: "channelGroup")
|
|
954
|
- field(:value, 3, type: Google.Protobuf.Any, oneof: 0)
|
|
955
|
- field(:noop, 4, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
956
|
- end
|
|
957
|
-
|
|
958
|
- defmodule Eigr.Functions.Protocol.Pipe do
|
|
959
|
- @moduledoc false
|
|
960
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
961
|
-
|
|
962
|
- def descriptor do
|
|
963
|
- # credo:disable-for-next-line
|
|
964
|
- %Google.Protobuf.DescriptorProto{
|
|
965
|
- name: "Pipe",
|
|
966
|
- field: [
|
|
967
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
968
|
- name: "actor",
|
|
969
|
- extendee: nil,
|
|
970
|
- number: 1,
|
|
971
|
- label: :LABEL_OPTIONAL,
|
|
972
|
- type: :TYPE_STRING,
|
|
973
|
- type_name: nil,
|
|
974
|
- default_value: nil,
|
|
975
|
- options: nil,
|
|
976
|
- oneof_index: nil,
|
|
977
|
- json_name: "actor",
|
|
978
|
- proto3_optional: nil,
|
|
979
|
- __unknown_fields__: []
|
|
980
|
- },
|
|
981
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
982
|
- name: "action_name",
|
|
983
|
- extendee: nil,
|
|
984
|
- number: 2,
|
|
985
|
- label: :LABEL_OPTIONAL,
|
|
986
|
- type: :TYPE_STRING,
|
|
987
|
- type_name: nil,
|
|
988
|
- default_value: nil,
|
|
989
|
- options: nil,
|
|
990
|
- oneof_index: nil,
|
|
991
|
- json_name: "actionName",
|
|
992
|
- proto3_optional: nil,
|
|
993
|
- __unknown_fields__: []
|
|
994
|
- }
|
|
995
|
- ],
|
|
996
|
- nested_type: [],
|
|
997
|
- enum_type: [],
|
|
998
|
- extension_range: [],
|
|
999
|
- extension: [],
|
|
1000
|
- options: nil,
|
|
1001
|
- oneof_decl: [],
|
|
1002
|
- reserved_range: [],
|
|
1003
|
- reserved_name: [],
|
|
1004
|
- __unknown_fields__: []
|
|
1005
|
- }
|
|
1006
|
- end
|
|
1007
|
-
|
|
1008
|
- field(:actor, 1, type: :string)
|
|
1009
|
- field(:action_name, 2, type: :string, json_name: "actionName")
|
|
1010
|
- end
|
|
1011
|
-
|
|
1012
|
- defmodule Eigr.Functions.Protocol.Forward do
|
|
1013
|
- @moduledoc false
|
|
1014
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1015
|
-
|
|
1016
|
- def descriptor do
|
|
1017
|
- # credo:disable-for-next-line
|
|
1018
|
- %Google.Protobuf.DescriptorProto{
|
|
1019
|
- name: "Forward",
|
|
1020
|
- field: [
|
|
1021
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1022
|
- name: "actor",
|
|
1023
|
- extendee: nil,
|
|
1024
|
- number: 1,
|
|
1025
|
- label: :LABEL_OPTIONAL,
|
|
1026
|
- type: :TYPE_STRING,
|
|
1027
|
- type_name: nil,
|
|
1028
|
- default_value: nil,
|
|
1029
|
- options: nil,
|
|
1030
|
- oneof_index: nil,
|
|
1031
|
- json_name: "actor",
|
|
1032
|
- proto3_optional: nil,
|
|
1033
|
- __unknown_fields__: []
|
|
1034
|
- },
|
|
1035
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1036
|
- name: "action_name",
|
|
1037
|
- extendee: nil,
|
|
1038
|
- number: 2,
|
|
1039
|
- label: :LABEL_OPTIONAL,
|
|
1040
|
- type: :TYPE_STRING,
|
|
1041
|
- type_name: nil,
|
|
1042
|
- default_value: nil,
|
|
1043
|
- options: nil,
|
|
1044
|
- oneof_index: nil,
|
|
1045
|
- json_name: "actionName",
|
|
1046
|
- proto3_optional: nil,
|
|
1047
|
- __unknown_fields__: []
|
|
1048
|
- }
|
|
1049
|
- ],
|
|
1050
|
- nested_type: [],
|
|
1051
|
- enum_type: [],
|
|
1052
|
- extension_range: [],
|
|
1053
|
- extension: [],
|
|
1054
|
- options: nil,
|
|
1055
|
- oneof_decl: [],
|
|
1056
|
- reserved_range: [],
|
|
1057
|
- reserved_name: [],
|
|
1058
|
- __unknown_fields__: []
|
|
1059
|
- }
|
|
1060
|
- end
|
|
1061
|
-
|
|
1062
|
- field(:actor, 1, type: :string)
|
|
1063
|
- field(:action_name, 2, type: :string, json_name: "actionName")
|
|
1064
|
- end
|
|
1065
|
-
|
|
1066
|
- defmodule Eigr.Functions.Protocol.Workflow do
|
|
1067
|
- @moduledoc false
|
|
1068
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1069
|
-
|
|
1070
|
- def descriptor do
|
|
1071
|
- # credo:disable-for-next-line
|
|
1072
|
- %Google.Protobuf.DescriptorProto{
|
|
1073
|
- name: "Workflow",
|
|
1074
|
- field: [
|
|
1075
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1076
|
- name: "broadcast",
|
|
1077
|
- extendee: nil,
|
|
1078
|
- number: 2,
|
|
1079
|
- label: :LABEL_OPTIONAL,
|
|
1080
|
- type: :TYPE_MESSAGE,
|
|
1081
|
- type_name: ".eigr.functions.protocol.Broadcast",
|
|
1082
|
- default_value: nil,
|
|
1083
|
- options: nil,
|
|
1084
|
- oneof_index: nil,
|
|
1085
|
- json_name: "broadcast",
|
|
1086
|
- proto3_optional: nil,
|
|
1087
|
- __unknown_fields__: []
|
|
1088
|
- },
|
|
1089
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1090
|
- name: "effects",
|
|
1091
|
- extendee: nil,
|
|
1092
|
- number: 1,
|
|
1093
|
- label: :LABEL_REPEATED,
|
|
1094
|
- type: :TYPE_MESSAGE,
|
|
1095
|
- type_name: ".eigr.functions.protocol.SideEffect",
|
|
1096
|
- default_value: nil,
|
|
1097
|
- options: nil,
|
|
1098
|
- oneof_index: nil,
|
|
1099
|
- json_name: "effects",
|
|
1100
|
- proto3_optional: nil,
|
|
1101
|
- __unknown_fields__: []
|
|
1102
|
- },
|
|
1103
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1104
|
- name: "pipe",
|
|
1105
|
- extendee: nil,
|
|
1106
|
- number: 3,
|
|
1107
|
- label: :LABEL_OPTIONAL,
|
|
1108
|
- type: :TYPE_MESSAGE,
|
|
1109
|
- type_name: ".eigr.functions.protocol.Pipe",
|
|
1110
|
- default_value: nil,
|
|
1111
|
- options: nil,
|
|
1112
|
- oneof_index: 0,
|
|
1113
|
- json_name: "pipe",
|
|
1114
|
- proto3_optional: nil,
|
|
1115
|
- __unknown_fields__: []
|
|
1116
|
- },
|
|
1117
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1118
|
- name: "forward",
|
|
1119
|
- extendee: nil,
|
|
1120
|
- number: 4,
|
|
1121
|
- label: :LABEL_OPTIONAL,
|
|
1122
|
- type: :TYPE_MESSAGE,
|
|
1123
|
- type_name: ".eigr.functions.protocol.Forward",
|
|
1124
|
- default_value: nil,
|
|
1125
|
- options: nil,
|
|
1126
|
- oneof_index: 0,
|
|
1127
|
- json_name: "forward",
|
|
1128
|
- proto3_optional: nil,
|
|
1129
|
- __unknown_fields__: []
|
|
1130
|
- }
|
|
1131
|
- ],
|
|
1132
|
- nested_type: [],
|
|
1133
|
- enum_type: [],
|
|
1134
|
- extension_range: [],
|
|
1135
|
- extension: [],
|
|
1136
|
- options: nil,
|
|
1137
|
- oneof_decl: [
|
|
1138
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
1139
|
- name: "routing",
|
|
1140
|
- options: nil,
|
|
1141
|
- __unknown_fields__: []
|
|
1142
|
- }
|
|
1143
|
- ],
|
|
1144
|
- reserved_range: [],
|
|
1145
|
- reserved_name: [],
|
|
1146
|
- __unknown_fields__: []
|
|
1147
|
- }
|
|
1148
|
- end
|
|
1149
|
-
|
|
1150
|
- oneof(:routing, 0)
|
|
1151
|
-
|
|
1152
|
- field(:broadcast, 2, type: Eigr.Functions.Protocol.Broadcast)
|
|
1153
|
- field(:effects, 1, repeated: true, type: Eigr.Functions.Protocol.SideEffect)
|
|
1154
|
- field(:pipe, 3, type: Eigr.Functions.Protocol.Pipe, oneof: 0)
|
|
1155
|
- field(:forward, 4, type: Eigr.Functions.Protocol.Forward, oneof: 0)
|
|
1156
|
- end
|
|
1157
|
-
|
|
1158
|
- defmodule Eigr.Functions.Protocol.InvocationRequest.MetadataEntry do
|
|
1159
|
- @moduledoc false
|
|
1160
|
- use Protobuf, map: true, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1161
|
-
|
|
1162
|
- def descriptor do
|
|
1163
|
- # credo:disable-for-next-line
|
|
1164
|
- %Google.Protobuf.DescriptorProto{
|
|
1165
|
- name: "MetadataEntry",
|
|
1166
|
- field: [
|
|
1167
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1168
|
- name: "key",
|
|
1169
|
- extendee: nil,
|
|
1170
|
- number: 1,
|
|
1171
|
- label: :LABEL_OPTIONAL,
|
|
1172
|
- type: :TYPE_STRING,
|
|
1173
|
- type_name: nil,
|
|
1174
|
- default_value: nil,
|
|
1175
|
- options: nil,
|
|
1176
|
- oneof_index: nil,
|
|
1177
|
- json_name: "key",
|
|
1178
|
- proto3_optional: nil,
|
|
1179
|
- __unknown_fields__: []
|
|
1180
|
- },
|
|
1181
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1182
|
- name: "value",
|
|
1183
|
- extendee: nil,
|
|
1184
|
- number: 2,
|
|
1185
|
- label: :LABEL_OPTIONAL,
|
|
1186
|
- type: :TYPE_STRING,
|
|
1187
|
- type_name: nil,
|
|
1188
|
- default_value: nil,
|
|
1189
|
- options: nil,
|
|
1190
|
- oneof_index: nil,
|
|
1191
|
- json_name: "value",
|
|
1192
|
- proto3_optional: nil,
|
|
1193
|
- __unknown_fields__: []
|
|
1194
|
- }
|
|
1195
|
- ],
|
|
1196
|
- nested_type: [],
|
|
1197
|
- enum_type: [],
|
|
1198
|
- extension_range: [],
|
|
1199
|
- extension: [],
|
|
1200
|
- options: %Google.Protobuf.MessageOptions{
|
|
1201
|
- message_set_wire_format: false,
|
|
1202
|
- no_standard_descriptor_accessor: false,
|
|
1203
|
- deprecated: false,
|
|
1204
|
- map_entry: true,
|
|
1205
|
- uninterpreted_option: [],
|
|
1206
|
- __pb_extensions__: %{},
|
|
1207
|
- __unknown_fields__: []
|
|
1208
|
- },
|
|
1209
|
- oneof_decl: [],
|
|
1210
|
- reserved_range: [],
|
|
1211
|
- reserved_name: [],
|
|
1212
|
- __unknown_fields__: []
|
|
1213
|
- }
|
|
1214
|
- end
|
|
1215
|
-
|
|
1216
|
- field(:key, 1, type: :string)
|
|
1217
|
- field(:value, 2, type: :string)
|
|
1218
|
- end
|
|
1219
|
-
|
|
1220
|
- defmodule Eigr.Functions.Protocol.InvocationRequest do
|
|
1221
|
- @moduledoc false
|
|
1222
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1223
|
-
|
|
1224
|
- def descriptor do
|
|
1225
|
- # credo:disable-for-next-line
|
|
1226
|
- %Google.Protobuf.DescriptorProto{
|
|
1227
|
- name: "InvocationRequest",
|
|
1228
|
- field: [
|
|
1229
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1230
|
- name: "system",
|
|
1231
|
- extendee: nil,
|
|
1232
|
- number: 1,
|
|
1233
|
- label: :LABEL_OPTIONAL,
|
|
1234
|
- type: :TYPE_MESSAGE,
|
|
1235
|
- type_name: ".eigr.functions.protocol.actors.ActorSystem",
|
|
1236
|
- default_value: nil,
|
|
1237
|
- options: nil,
|
|
1238
|
- oneof_index: nil,
|
|
1239
|
- json_name: "system",
|
|
1240
|
- proto3_optional: nil,
|
|
1241
|
- __unknown_fields__: []
|
|
1242
|
- },
|
|
1243
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1244
|
- name: "actor",
|
|
1245
|
- extendee: nil,
|
|
1246
|
- number: 2,
|
|
1247
|
- label: :LABEL_OPTIONAL,
|
|
1248
|
- type: :TYPE_MESSAGE,
|
|
1249
|
- type_name: ".eigr.functions.protocol.actors.Actor",
|
|
1250
|
- default_value: nil,
|
|
1251
|
- options: nil,
|
|
1252
|
- oneof_index: nil,
|
|
1253
|
- json_name: "actor",
|
|
1254
|
- proto3_optional: nil,
|
|
1255
|
- __unknown_fields__: []
|
|
1256
|
- },
|
|
1257
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1258
|
- name: "action_name",
|
|
1259
|
- extendee: nil,
|
|
1260
|
- number: 3,
|
|
1261
|
- label: :LABEL_OPTIONAL,
|
|
1262
|
- type: :TYPE_STRING,
|
|
1263
|
- type_name: nil,
|
|
1264
|
- default_value: nil,
|
|
1265
|
- options: nil,
|
|
1266
|
- oneof_index: nil,
|
|
1267
|
- json_name: "actionName",
|
|
1268
|
- proto3_optional: nil,
|
|
1269
|
- __unknown_fields__: []
|
|
1270
|
- },
|
|
1271
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1272
|
- name: "value",
|
|
1273
|
- extendee: nil,
|
|
1274
|
- number: 4,
|
|
1275
|
- label: :LABEL_OPTIONAL,
|
|
1276
|
- type: :TYPE_MESSAGE,
|
|
1277
|
- type_name: ".google.protobuf.Any",
|
|
1278
|
- default_value: nil,
|
|
1279
|
- options: nil,
|
|
1280
|
- oneof_index: 0,
|
|
1281
|
- json_name: "value",
|
|
1282
|
- proto3_optional: nil,
|
|
1283
|
- __unknown_fields__: []
|
|
1284
|
- },
|
|
1285
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1286
|
- name: "noop",
|
|
1287
|
- extendee: nil,
|
|
1288
|
- number: 7,
|
|
1289
|
- label: :LABEL_OPTIONAL,
|
|
1290
|
- type: :TYPE_MESSAGE,
|
|
1291
|
- type_name: ".eigr.functions.protocol.Noop",
|
|
1292
|
- default_value: nil,
|
|
1293
|
- options: nil,
|
|
1294
|
- oneof_index: 0,
|
|
1295
|
- json_name: "noop",
|
|
1296
|
- proto3_optional: nil,
|
|
1297
|
- __unknown_fields__: []
|
|
1298
|
- },
|
|
1299
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1300
|
- name: "async",
|
|
1301
|
- extendee: nil,
|
|
1302
|
- number: 5,
|
|
1303
|
- label: :LABEL_OPTIONAL,
|
|
1304
|
- type: :TYPE_BOOL,
|
|
1305
|
- type_name: nil,
|
|
1306
|
- default_value: nil,
|
|
1307
|
- options: nil,
|
|
1308
|
- oneof_index: nil,
|
|
1309
|
- json_name: "async",
|
|
1310
|
- proto3_optional: nil,
|
|
1311
|
- __unknown_fields__: []
|
|
1312
|
- },
|
|
1313
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1314
|
- name: "caller",
|
|
1315
|
- extendee: nil,
|
|
1316
|
- number: 6,
|
|
1317
|
- label: :LABEL_OPTIONAL,
|
|
1318
|
- type: :TYPE_MESSAGE,
|
|
1319
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1320
|
- default_value: nil,
|
|
1321
|
- options: nil,
|
|
1322
|
- oneof_index: nil,
|
|
1323
|
- json_name: "caller",
|
|
1324
|
- proto3_optional: nil,
|
|
1325
|
- __unknown_fields__: []
|
|
1326
|
- },
|
|
1327
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1328
|
- name: "metadata",
|
|
1329
|
- extendee: nil,
|
|
1330
|
- number: 8,
|
|
1331
|
- label: :LABEL_REPEATED,
|
|
1332
|
- type: :TYPE_MESSAGE,
|
|
1333
|
- type_name: ".eigr.functions.protocol.InvocationRequest.MetadataEntry",
|
|
1334
|
- default_value: nil,
|
|
1335
|
- options: nil,
|
|
1336
|
- oneof_index: nil,
|
|
1337
|
- json_name: "metadata",
|
|
1338
|
- proto3_optional: nil,
|
|
1339
|
- __unknown_fields__: []
|
|
1340
|
- },
|
|
1341
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1342
|
- name: "scheduled_to",
|
|
1343
|
- extendee: nil,
|
|
1344
|
- number: 9,
|
|
1345
|
- label: :LABEL_OPTIONAL,
|
|
1346
|
- type: :TYPE_INT64,
|
|
1347
|
- type_name: nil,
|
|
1348
|
- default_value: nil,
|
|
1349
|
- options: nil,
|
|
1350
|
- oneof_index: nil,
|
|
1351
|
- json_name: "scheduledTo",
|
|
1352
|
- proto3_optional: nil,
|
|
1353
|
- __unknown_fields__: []
|
|
1354
|
- },
|
|
1355
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1356
|
- name: "pooled",
|
|
1357
|
- extendee: nil,
|
|
1358
|
- number: 10,
|
|
1359
|
- label: :LABEL_OPTIONAL,
|
|
1360
|
- type: :TYPE_BOOL,
|
|
1361
|
- type_name: nil,
|
|
1362
|
- default_value: nil,
|
|
1363
|
- options: nil,
|
|
1364
|
- oneof_index: nil,
|
|
1365
|
- json_name: "pooled",
|
|
1366
|
- proto3_optional: nil,
|
|
1367
|
- __unknown_fields__: []
|
|
1368
|
- },
|
|
1369
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1370
|
- name: "register_ref",
|
|
1371
|
- extendee: nil,
|
|
1372
|
- number: 11,
|
|
1373
|
- label: :LABEL_OPTIONAL,
|
|
1374
|
- type: :TYPE_STRING,
|
|
1375
|
- type_name: nil,
|
|
1376
|
- default_value: nil,
|
|
1377
|
- options: nil,
|
|
1378
|
- oneof_index: nil,
|
|
1379
|
- json_name: "registerRef",
|
|
1380
|
- proto3_optional: nil,
|
|
1381
|
- __unknown_fields__: []
|
|
1382
|
- }
|
|
1383
|
- ],
|
|
1384
|
- nested_type: [
|
|
1385
|
- %Google.Protobuf.DescriptorProto{
|
|
1386
|
- name: "MetadataEntry",
|
|
1387
|
- field: [
|
|
1388
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1389
|
- name: "key",
|
|
1390
|
- extendee: nil,
|
|
1391
|
- number: 1,
|
|
1392
|
- label: :LABEL_OPTIONAL,
|
|
1393
|
- type: :TYPE_STRING,
|
|
1394
|
- type_name: nil,
|
|
1395
|
- default_value: nil,
|
|
1396
|
- options: nil,
|
|
1397
|
- oneof_index: nil,
|
|
1398
|
- json_name: "key",
|
|
1399
|
- proto3_optional: nil,
|
|
1400
|
- __unknown_fields__: []
|
|
1401
|
- },
|
|
1402
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1403
|
- name: "value",
|
|
1404
|
- extendee: nil,
|
|
1405
|
- number: 2,
|
|
1406
|
- label: :LABEL_OPTIONAL,
|
|
1407
|
- type: :TYPE_STRING,
|
|
1408
|
- type_name: nil,
|
|
1409
|
- default_value: nil,
|
|
1410
|
- options: nil,
|
|
1411
|
- oneof_index: nil,
|
|
1412
|
- json_name: "value",
|
|
1413
|
- proto3_optional: nil,
|
|
1414
|
- __unknown_fields__: []
|
|
1415
|
- }
|
|
1416
|
- ],
|
|
1417
|
- nested_type: [],
|
|
1418
|
- enum_type: [],
|
|
1419
|
- extension_range: [],
|
|
1420
|
- extension: [],
|
|
1421
|
- options: %Google.Protobuf.MessageOptions{
|
|
1422
|
- message_set_wire_format: false,
|
|
1423
|
- no_standard_descriptor_accessor: false,
|
|
1424
|
- deprecated: false,
|
|
1425
|
- map_entry: true,
|
|
1426
|
- uninterpreted_option: [],
|
|
1427
|
- __pb_extensions__: %{},
|
|
1428
|
- __unknown_fields__: []
|
|
1429
|
- },
|
|
1430
|
- oneof_decl: [],
|
|
1431
|
- reserved_range: [],
|
|
1432
|
- reserved_name: [],
|
|
1433
|
- __unknown_fields__: []
|
|
1434
|
- }
|
|
1435
|
- ],
|
|
1436
|
- enum_type: [],
|
|
1437
|
- extension_range: [],
|
|
1438
|
- extension: [],
|
|
1439
|
- options: nil,
|
|
1440
|
- oneof_decl: [
|
|
1441
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
1442
|
- name: "payload",
|
|
1443
|
- options: nil,
|
|
1444
|
- __unknown_fields__: []
|
|
1445
|
- }
|
|
1446
|
- ],
|
|
1447
|
- reserved_range: [],
|
|
1448
|
- reserved_name: [],
|
|
1449
|
- __unknown_fields__: []
|
|
1450
|
- }
|
|
1451
|
- end
|
|
1452
|
-
|
|
1453
|
- oneof(:payload, 0)
|
|
1454
|
-
|
|
1455
|
- field(:system, 1, type: Eigr.Functions.Protocol.Actors.ActorSystem)
|
|
1456
|
- field(:actor, 2, type: Eigr.Functions.Protocol.Actors.Actor)
|
|
1457
|
- field(:action_name, 3, type: :string, json_name: "actionName")
|
|
1458
|
- field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1459
|
- field(:noop, 7, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1460
|
- field(:async, 5, type: :bool)
|
|
1461
|
- field(:caller, 6, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1462
|
-
|
|
1463
|
- field(:metadata, 8,
|
|
1464
|
- repeated: true,
|
|
1465
|
- type: Eigr.Functions.Protocol.InvocationRequest.MetadataEntry,
|
|
1466
|
- map: true
|
|
1467
|
- )
|
|
1468
|
-
|
|
1469
|
- field(:scheduled_to, 9, type: :int64, json_name: "scheduledTo")
|
|
1470
|
- field(:pooled, 10, type: :bool)
|
|
1471
|
- field(:register_ref, 11, type: :string, json_name: "registerRef")
|
|
1472
|
- end
|
|
1473
|
-
|
|
1474
|
- defmodule Eigr.Functions.Protocol.ActorInvocation do
|
|
1475
|
- @moduledoc false
|
|
1476
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1477
|
-
|
|
1478
|
- def descriptor do
|
|
1479
|
- # credo:disable-for-next-line
|
|
1480
|
- %Google.Protobuf.DescriptorProto{
|
|
1481
|
- name: "ActorInvocation",
|
|
1482
|
- field: [
|
|
1483
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1484
|
- name: "actor",
|
|
1485
|
- extendee: nil,
|
|
1486
|
- number: 1,
|
|
1487
|
- label: :LABEL_OPTIONAL,
|
|
1488
|
- type: :TYPE_MESSAGE,
|
|
1489
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1490
|
- default_value: nil,
|
|
1491
|
- options: nil,
|
|
1492
|
- oneof_index: nil,
|
|
1493
|
- json_name: "actor",
|
|
1494
|
- proto3_optional: nil,
|
|
1495
|
- __unknown_fields__: []
|
|
1496
|
- },
|
|
1497
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1498
|
- name: "action_name",
|
|
1499
|
- extendee: nil,
|
|
1500
|
- number: 2,
|
|
1501
|
- label: :LABEL_OPTIONAL,
|
|
1502
|
- type: :TYPE_STRING,
|
|
1503
|
- type_name: nil,
|
|
1504
|
- default_value: nil,
|
|
1505
|
- options: nil,
|
|
1506
|
- oneof_index: nil,
|
|
1507
|
- json_name: "actionName",
|
|
1508
|
- proto3_optional: nil,
|
|
1509
|
- __unknown_fields__: []
|
|
1510
|
- },
|
|
1511
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1512
|
- name: "current_context",
|
|
1513
|
- extendee: nil,
|
|
1514
|
- number: 3,
|
|
1515
|
- label: :LABEL_OPTIONAL,
|
|
1516
|
- type: :TYPE_MESSAGE,
|
|
1517
|
- type_name: ".eigr.functions.protocol.Context",
|
|
1518
|
- default_value: nil,
|
|
1519
|
- options: nil,
|
|
1520
|
- oneof_index: nil,
|
|
1521
|
- json_name: "currentContext",
|
|
1522
|
- proto3_optional: nil,
|
|
1523
|
- __unknown_fields__: []
|
|
1524
|
- },
|
|
1525
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1526
|
- name: "value",
|
|
1527
|
- extendee: nil,
|
|
1528
|
- number: 4,
|
|
1529
|
- label: :LABEL_OPTIONAL,
|
|
1530
|
- type: :TYPE_MESSAGE,
|
|
1531
|
- type_name: ".google.protobuf.Any",
|
|
1532
|
- default_value: nil,
|
|
1533
|
- options: nil,
|
|
1534
|
- oneof_index: 0,
|
|
1535
|
- json_name: "value",
|
|
1536
|
- proto3_optional: nil,
|
|
1537
|
- __unknown_fields__: []
|
|
1538
|
- },
|
|
1539
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1540
|
- name: "noop",
|
|
1541
|
- extendee: nil,
|
|
1542
|
- number: 5,
|
|
1543
|
- label: :LABEL_OPTIONAL,
|
|
1544
|
- type: :TYPE_MESSAGE,
|
|
1545
|
- type_name: ".eigr.functions.protocol.Noop",
|
|
1546
|
- default_value: nil,
|
|
1547
|
- options: nil,
|
|
1548
|
- oneof_index: 0,
|
|
1549
|
- json_name: "noop",
|
|
1550
|
- proto3_optional: nil,
|
|
1551
|
- __unknown_fields__: []
|
|
1552
|
- },
|
|
1553
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1554
|
- name: "caller",
|
|
1555
|
- extendee: nil,
|
|
1556
|
- number: 6,
|
|
1557
|
- label: :LABEL_OPTIONAL,
|
|
1558
|
- type: :TYPE_MESSAGE,
|
|
1559
|
- type_name: ".eigr.functions.protocol.actors.ActorId",
|
|
1560
|
- default_value: nil,
|
|
1561
|
- options: nil,
|
|
1562
|
- oneof_index: nil,
|
|
1563
|
- json_name: "caller",
|
|
1564
|
- proto3_optional: nil,
|
|
1565
|
- __unknown_fields__: []
|
|
1566
|
- }
|
|
1567
|
- ],
|
|
1568
|
- nested_type: [],
|
|
1569
|
- enum_type: [],
|
|
1570
|
- extension_range: [],
|
|
1571
|
- extension: [],
|
|
1572
|
- options: nil,
|
|
1573
|
- oneof_decl: [
|
|
1574
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
1575
|
- name: "payload",
|
|
1576
|
- options: nil,
|
|
1577
|
- __unknown_fields__: []
|
|
1578
|
- }
|
|
1579
|
- ],
|
|
1580
|
- reserved_range: [],
|
|
1581
|
- reserved_name: [],
|
|
1582
|
- __unknown_fields__: []
|
|
1583
|
- }
|
|
1584
|
- end
|
|
1585
|
-
|
|
1586
|
- oneof(:payload, 0)
|
|
1587
|
-
|
|
1588
|
- field(:actor, 1, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1589
|
- field(:action_name, 2, type: :string, json_name: "actionName")
|
|
1590
|
- field(:current_context, 3, type: Eigr.Functions.Protocol.Context, json_name: "currentContext")
|
|
1591
|
- field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1592
|
- field(:noop, 5, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1593
|
- field(:caller, 6, type: Eigr.Functions.Protocol.Actors.ActorId)
|
|
1863
|
- end
|
|
1595
|
-
|
|
1596
|
- defmodule Eigr.Functions.Protocol.ActorInvocationResponse do
|
|
1597
|
- @moduledoc false
|
|
1598
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1599
|
-
|
|
1600
|
- def descriptor do
|
|
1601
|
- # credo:disable-for-next-line
|
|
1602
|
- %Google.Protobuf.DescriptorProto{
|
|
1603
|
- name: "ActorInvocationResponse",
|
|
1604
|
- field: [
|
|
1605
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1606
|
- name: "actor_name",
|
|
1607
|
- extendee: nil,
|
|
1608
|
- number: 1,
|
|
1609
|
- label: :LABEL_OPTIONAL,
|
|
1610
|
- type: :TYPE_STRING,
|
|
1611
|
- type_name: nil,
|
|
1612
|
- default_value: nil,
|
|
1613
|
- options: nil,
|
|
1614
|
- oneof_index: nil,
|
|
1615
|
- json_name: "actorName",
|
|
1616
|
- proto3_optional: nil,
|
|
1617
|
- __unknown_fields__: []
|
|
1618
|
- },
|
|
1619
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1620
|
- name: "actor_system",
|
|
1621
|
- extendee: nil,
|
|
1622
|
- number: 2,
|
|
1623
|
- label: :LABEL_OPTIONAL,
|
|
1624
|
- type: :TYPE_STRING,
|
|
1625
|
- type_name: nil,
|
|
1626
|
- default_value: nil,
|
|
1627
|
- options: nil,
|
|
1628
|
- oneof_index: nil,
|
|
1629
|
- json_name: "actorSystem",
|
|
1630
|
- proto3_optional: nil,
|
|
1631
|
- __unknown_fields__: []
|
|
1632
|
- },
|
|
1633
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1634
|
- name: "updated_context",
|
|
1635
|
- extendee: nil,
|
|
1636
|
- number: 3,
|
|
1637
|
- label: :LABEL_OPTIONAL,
|
|
1638
|
- type: :TYPE_MESSAGE,
|
|
1639
|
- type_name: ".eigr.functions.protocol.Context",
|
|
1640
|
- default_value: nil,
|
|
1641
|
- options: nil,
|
|
1642
|
- oneof_index: nil,
|
|
1643
|
- json_name: "updatedContext",
|
|
1644
|
- proto3_optional: nil,
|
|
1645
|
- __unknown_fields__: []
|
|
1646
|
- },
|
|
1647
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1648
|
- name: "value",
|
|
1649
|
- extendee: nil,
|
|
1650
|
- number: 4,
|
|
1651
|
- label: :LABEL_OPTIONAL,
|
|
1652
|
- type: :TYPE_MESSAGE,
|
|
1653
|
- type_name: ".google.protobuf.Any",
|
|
1654
|
- default_value: nil,
|
|
1655
|
- options: nil,
|
|
1656
|
- oneof_index: 0,
|
|
1657
|
- json_name: "value",
|
|
1658
|
- proto3_optional: nil,
|
|
1659
|
- __unknown_fields__: []
|
|
1660
|
- },
|
|
1661
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1662
|
- name: "noop",
|
|
1663
|
- extendee: nil,
|
|
1664
|
- number: 6,
|
|
1665
|
- label: :LABEL_OPTIONAL,
|
|
1666
|
- type: :TYPE_MESSAGE,
|
|
1667
|
- type_name: ".eigr.functions.protocol.Noop",
|
|
1668
|
- default_value: nil,
|
|
1669
|
- options: nil,
|
|
1670
|
- oneof_index: 0,
|
|
1671
|
- json_name: "noop",
|
|
1672
|
- proto3_optional: nil,
|
|
1673
|
- __unknown_fields__: []
|
|
1674
|
- },
|
|
1675
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1676
|
- name: "workflow",
|
|
1677
|
- extendee: nil,
|
|
1678
|
- number: 5,
|
|
1679
|
- label: :LABEL_OPTIONAL,
|
|
1680
|
- type: :TYPE_MESSAGE,
|
|
1681
|
- type_name: ".eigr.functions.protocol.Workflow",
|
|
1682
|
- default_value: nil,
|
|
1683
|
- options: nil,
|
|
1684
|
- oneof_index: nil,
|
|
1685
|
- json_name: "workflow",
|
|
1686
|
- proto3_optional: nil,
|
|
1687
|
- __unknown_fields__: []
|
|
1688
|
- },
|
|
1689
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1690
|
- name: "checkpoint",
|
|
1691
|
- extendee: nil,
|
|
1692
|
- number: 7,
|
|
1693
|
- label: :LABEL_OPTIONAL,
|
|
1694
|
- type: :TYPE_BOOL,
|
|
1695
|
- type_name: nil,
|
|
1696
|
- default_value: nil,
|
|
1697
|
- options: nil,
|
|
1698
|
- oneof_index: nil,
|
|
1699
|
- json_name: "checkpoint",
|
|
1700
|
- proto3_optional: nil,
|
|
1701
|
- __unknown_fields__: []
|
|
1702
|
- }
|
|
1703
|
- ],
|
|
1704
|
- nested_type: [],
|
|
1705
|
- enum_type: [],
|
|
1706
|
- extension_range: [],
|
|
1707
|
- extension: [],
|
|
1708
|
- options: nil,
|
|
1709
|
- oneof_decl: [
|
|
1710
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
1711
|
- name: "payload",
|
|
1712
|
- options: nil,
|
|
1713
|
- __unknown_fields__: []
|
|
1714
|
- }
|
|
1715
|
- ],
|
|
1716
|
- reserved_range: [],
|
|
1717
|
- reserved_name: [],
|
|
1718
|
- __unknown_fields__: []
|
|
1719
|
- }
|
|
1720
|
- end
|
|
1721
|
-
|
|
1722
|
- oneof(:payload, 0)
|
|
1723
|
-
|
|
1724
|
- field(:actor_name, 1, type: :string, json_name: "actorName")
|
|
1725
|
- field(:actor_system, 2, type: :string, json_name: "actorSystem")
|
|
1726
|
- field(:updated_context, 3, type: Eigr.Functions.Protocol.Context, json_name: "updatedContext")
|
|
1727
|
- field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1728
|
- field(:noop, 6, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1729
|
- field(:workflow, 5, type: Eigr.Functions.Protocol.Workflow)
|
|
1730
|
- field(:checkpoint, 7, type: :bool)
|
|
1731
|
- end
|
|
1732
|
-
|
|
1733
|
- defmodule Eigr.Functions.Protocol.InvocationResponse do
|
|
1734
|
- @moduledoc false
|
|
1735
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1736
|
-
|
|
1737
|
- def descriptor do
|
|
1738
|
- # credo:disable-for-next-line
|
|
1739
|
- %Google.Protobuf.DescriptorProto{
|
|
1740
|
- name: "InvocationResponse",
|
|
1741
|
- field: [
|
|
1742
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1743
|
- name: "status",
|
|
1744
|
- extendee: nil,
|
|
1745
|
- number: 1,
|
|
1746
|
- label: :LABEL_OPTIONAL,
|
|
1747
|
- type: :TYPE_MESSAGE,
|
|
1748
|
- type_name: ".eigr.functions.protocol.RequestStatus",
|
|
1749
|
- default_value: nil,
|
|
1750
|
- options: nil,
|
|
1751
|
- oneof_index: nil,
|
|
1752
|
- json_name: "status",
|
|
1753
|
- proto3_optional: nil,
|
|
1754
|
- __unknown_fields__: []
|
|
1755
|
- },
|
|
1756
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1757
|
- name: "system",
|
|
1758
|
- extendee: nil,
|
|
1759
|
- number: 2,
|
|
1760
|
- label: :LABEL_OPTIONAL,
|
|
1761
|
- type: :TYPE_MESSAGE,
|
|
1762
|
- type_name: ".eigr.functions.protocol.actors.ActorSystem",
|
|
1763
|
- default_value: nil,
|
|
1764
|
- options: nil,
|
|
1765
|
- oneof_index: nil,
|
|
1766
|
- json_name: "system",
|
|
1767
|
- proto3_optional: nil,
|
|
1768
|
- __unknown_fields__: []
|
|
1769
|
- },
|
|
1770
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1771
|
- name: "actor",
|
|
1772
|
- extendee: nil,
|
|
1773
|
- number: 3,
|
|
1774
|
- label: :LABEL_OPTIONAL,
|
|
1775
|
- type: :TYPE_MESSAGE,
|
|
1776
|
- type_name: ".eigr.functions.protocol.actors.Actor",
|
|
1777
|
- default_value: nil,
|
|
1778
|
- options: nil,
|
|
1779
|
- oneof_index: nil,
|
|
1780
|
- json_name: "actor",
|
|
1781
|
- proto3_optional: nil,
|
|
1782
|
- __unknown_fields__: []
|
|
1783
|
- },
|
|
1784
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1785
|
- name: "value",
|
|
1786
|
- extendee: nil,
|
|
1787
|
- number: 4,
|
|
1788
|
- label: :LABEL_OPTIONAL,
|
|
1789
|
- type: :TYPE_MESSAGE,
|
|
1790
|
- type_name: ".google.protobuf.Any",
|
|
1791
|
- default_value: nil,
|
|
1792
|
- options: nil,
|
|
1793
|
- oneof_index: 0,
|
|
1794
|
- json_name: "value",
|
|
1795
|
- proto3_optional: nil,
|
|
1796
|
- __unknown_fields__: []
|
|
1797
|
- },
|
|
1798
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1799
|
- name: "noop",
|
|
1800
|
- extendee: nil,
|
|
1801
|
- number: 5,
|
|
1802
|
- label: :LABEL_OPTIONAL,
|
|
1803
|
- type: :TYPE_MESSAGE,
|
|
1804
|
- type_name: ".eigr.functions.protocol.Noop",
|
|
1805
|
- default_value: nil,
|
|
1806
|
- options: nil,
|
|
1807
|
- oneof_index: 0,
|
|
1808
|
- json_name: "noop",
|
|
1809
|
- proto3_optional: nil,
|
|
1810
|
- __unknown_fields__: []
|
|
1811
|
- }
|
|
1812
|
- ],
|
|
1813
|
- nested_type: [],
|
|
1814
|
- enum_type: [],
|
|
1815
|
- extension_range: [],
|
|
1816
|
- extension: [],
|
|
1817
|
- options: nil,
|
|
1818
|
- oneof_decl: [
|
|
1819
|
- %Google.Protobuf.OneofDescriptorProto{
|
|
1820
|
- name: "payload",
|
|
1821
|
- options: nil,
|
|
1822
|
- __unknown_fields__: []
|
|
1823
|
- }
|
|
1824
|
- ],
|
|
1825
|
- reserved_range: [],
|
|
1826
|
- reserved_name: [],
|
|
1827
|
- __unknown_fields__: []
|
|
1828
|
- }
|
|
1829
|
- end
|
|
1830
|
-
|
|
1831
|
- oneof(:payload, 0)
|
|
1832
|
-
|
|
1833
|
- field(:status, 1, type: Eigr.Functions.Protocol.RequestStatus)
|
|
1834
|
- field(:system, 2, type: Eigr.Functions.Protocol.Actors.ActorSystem)
|
|
1835
|
- field(:actor, 3, type: Eigr.Functions.Protocol.Actors.Actor)
|
|
1836
|
- field(:value, 4, type: Google.Protobuf.Any, oneof: 0)
|
|
1837
|
- field(:noop, 5, type: Eigr.Functions.Protocol.Noop, oneof: 0)
|
|
1838
|
- end
|
|
1839
|
-
|
|
1840
|
- defmodule Eigr.Functions.Protocol.RequestStatus do
|
|
1841
|
- @moduledoc false
|
|
1842
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
1843
|
-
|
|
1844
|
- def descriptor do
|
|
1845
|
- # credo:disable-for-next-line
|
|
1846
|
- %Google.Protobuf.DescriptorProto{
|
|
1847
|
- name: "RequestStatus",
|
|
1848
|
- field: [
|
|
1849
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1850
|
- name: "status",
|
|
1851
|
- extendee: nil,
|
|
1852
|
- number: 1,
|
|
1853
|
- label: :LABEL_OPTIONAL,
|
|
1854
|
- type: :TYPE_ENUM,
|
|
1855
|
- type_name: ".eigr.functions.protocol.Status",
|
|
1856
|
- default_value: nil,
|
|
1857
|
- options: nil,
|
|
1858
|
- oneof_index: nil,
|
|
1859
|
- json_name: "status",
|
|
1860
|
- proto3_optional: nil,
|
|
1861
|
- __unknown_fields__: []
|
|
1862
|
- },
|
|
1863
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
1864
|
- name: "message",
|
|
1865
|
- extendee: nil,
|
|
1866
|
- number: 2,
|
|
1867
|
- label: :LABEL_OPTIONAL,
|
|
1868
|
- type: :TYPE_STRING,
|
|
1869
|
- type_name: nil,
|
|
1870
|
- default_value: nil,
|
|
1871
|
- options: nil,
|
|
1872
|
- oneof_index: nil,
|
|
1873
|
- json_name: "message",
|
|
1874
|
- proto3_optional: nil,
|
|
1875
|
- __unknown_fields__: []
|
|
1876
|
- }
|
|
1877
|
- ],
|
|
1878
|
- nested_type: [],
|
|
1879
|
- enum_type: [],
|
|
1880
|
- extension_range: [],
|
|
1881
|
- extension: [],
|
|
1882
|
- options: nil,
|
|
1883
|
- oneof_decl: [],
|
|
1884
|
- reserved_range: [],
|
|
1885
|
- reserved_name: [],
|
|
1886
|
- __unknown_fields__: []
|
|
1887
|
- }
|
|
1888
|
- end
|
|
1889
|
-
|
|
1890
|
- field(:status, 1, type: Eigr.Functions.Protocol.Status, enum: true)
|
|
1891
|
- field(:message, 2, type: :string)
|
|
1892
|
- end
|
removed
lib/spawn/actors/state.pb.ex
|
|
@@ -1,92 0,0 @@
|
|
1
|
- defmodule Eigr.Functions.Protocol.State.Revision do
|
|
2
|
- @moduledoc false
|
|
3
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
4
|
-
|
|
5
|
- def descriptor do
|
|
6
|
- # credo:disable-for-next-line
|
|
7
|
- %Google.Protobuf.DescriptorProto{
|
|
8
|
- name: "Revision",
|
|
9
|
- field: [
|
|
10
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
11
|
- name: "value",
|
|
12
|
- extendee: nil,
|
|
13
|
- number: 1,
|
|
14
|
- label: :LABEL_OPTIONAL,
|
|
15
|
- type: :TYPE_INT64,
|
|
16
|
- type_name: nil,
|
|
17
|
- default_value: nil,
|
|
18
|
- options: nil,
|
|
19
|
- oneof_index: nil,
|
|
20
|
- json_name: "value",
|
|
21
|
- proto3_optional: nil,
|
|
22
|
- __unknown_fields__: []
|
|
23
|
- }
|
|
24
|
- ],
|
|
25
|
- nested_type: [],
|
|
26
|
- enum_type: [],
|
|
27
|
- extension_range: [],
|
|
28
|
- extension: [],
|
|
29
|
- options: nil,
|
|
30
|
- oneof_decl: [],
|
|
31
|
- reserved_range: [],
|
|
32
|
- reserved_name: [],
|
|
33
|
- __unknown_fields__: []
|
|
34
|
- }
|
|
35
|
- end
|
|
36
|
-
|
|
37
|
- field(:value, 1, type: :int64)
|
|
38
|
- end
|
|
39
|
-
|
|
40
|
- defmodule Eigr.Functions.Protocol.State.Checkpoint do
|
|
41
|
- @moduledoc false
|
|
42
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
43
|
-
|
|
44
|
- def descriptor do
|
|
45
|
- # credo:disable-for-next-line
|
|
46
|
- %Google.Protobuf.DescriptorProto{
|
|
47
|
- name: "Checkpoint",
|
|
48
|
- field: [
|
|
49
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
50
|
- name: "revision",
|
|
51
|
- extendee: nil,
|
|
52
|
- number: 1,
|
|
53
|
- label: :LABEL_OPTIONAL,
|
|
54
|
- type: :TYPE_MESSAGE,
|
|
55
|
- type_name: ".eigr.functions.protocol.state.Revision",
|
|
56
|
- default_value: nil,
|
|
57
|
- options: nil,
|
|
58
|
- oneof_index: nil,
|
|
59
|
- json_name: "revision",
|
|
60
|
- proto3_optional: nil,
|
|
61
|
- __unknown_fields__: []
|
|
62
|
- },
|
|
63
|
- %Google.Protobuf.FieldDescriptorProto{
|
|
64
|
- name: "state",
|
|
65
|
- extendee: nil,
|
|
66
|
- number: 2,
|
|
67
|
- label: :LABEL_OPTIONAL,
|
|
68
|
- type: :TYPE_MESSAGE,
|
|
69
|
- type_name: ".eigr.functions.protocol.actors.ActorState",
|
|
70
|
- default_value: nil,
|
|
71
|
- options: nil,
|
|
72
|
- oneof_index: nil,
|
|
73
|
- json_name: "state",
|
|
74
|
- proto3_optional: nil,
|
|
75
|
- __unknown_fields__: []
|
|
76
|
- }
|
|
77
|
- ],
|
|
78
|
- nested_type: [],
|
|
79
|
- enum_type: [],
|
|
80
|
- extension_range: [],
|
|
81
|
- extension: [],
|
|
82
|
- options: nil,
|
|
83
|
- oneof_decl: [],
|
|
84
|
- reserved_range: [],
|
|
85
|
- reserved_name: [],
|
|
86
|
- __unknown_fields__: []
|
|
87
|
- }
|
|
88
|
- end
|
|
89
|
-
|
|
90
|
- field(:revision, 1, type: Eigr.Functions.Protocol.State.Revision)
|
|
91
|
- field(:state, 2, type: Eigr.Functions.Protocol.Actors.ActorState)
|
|
92
|
- end
|
changed
lib/spawn/google/protobuf/any.pb.ex
|
|
@@ -1,50 1,50 @@
|
|
1
1
|
defmodule Google.Protobuf.Any do
|
|
2
2
|
@moduledoc false
|
|
3
|
- use Protobuf, protoc_gen_elixir_version: "0.11.0", syntax: :proto3
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
4
|
|
|
5
5
|
def descriptor do
|
|
6
6
|
# credo:disable-for-next-line
|
|
7
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
- name: "Any",
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
9
12
|
field: [
|
|
10
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
11
|
- name: "type_url",
|
|
12
|
- extendee: nil,
|
|
13
|
- number: 1,
|
|
14
|
- label: :LABEL_OPTIONAL,
|
|
15
|
- type: :TYPE_STRING,
|
|
16
|
- type_name: nil,
|
|
14
|
__unknown_fields__: [],
|
|
17
15
|
default_value: nil,
|
|
18
|
- options: nil,
|
|
19
|
- oneof_index: nil,
|
|
16
|
extendee: nil,
|
|
20
17
|
json_name: "typeUrl",
|
|
18
|
label: :LABEL_OPTIONAL,
|
|
19
|
name: "type_url",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
21
23
|
proto3_optional: nil,
|
|
22
|
- __unknown_fields__: []
|
|
24
|
type: :TYPE_STRING,
|
|
25
|
type_name: nil
|
|
23
26
|
},
|
|
24
27
|
%Google.Protobuf.FieldDescriptorProto{
|
|
25
|
- name: "value",
|
|
26
|
- extendee: nil,
|
|
27
|
- number: 2,
|
|
28
|
- label: :LABEL_OPTIONAL,
|
|
29
|
- type: :TYPE_BYTES,
|
|
30
|
- type_name: nil,
|
|
28
|
__unknown_fields__: [],
|
|
31
29
|
default_value: nil,
|
|
32
|
- options: nil,
|
|
33
|
- oneof_index: nil,
|
|
30
|
extendee: nil,
|
|
34
31
|
json_name: "value",
|
|
32
|
label: :LABEL_OPTIONAL,
|
|
33
|
name: "value",
|
|
34
|
number: 2,
|
|
35
|
oneof_index: nil,
|
|
36
|
options: nil,
|
|
35
37
|
proto3_optional: nil,
|
|
36
|
- __unknown_fields__: []
|
|
38
|
type: :TYPE_BYTES,
|
|
39
|
type_name: nil
|
|
37
40
|
}
|
|
38
41
|
],
|
|
42
|
name: "Any",
|
|
39
43
|
nested_type: [],
|
|
40
|
- enum_type: [],
|
|
41
|
- extension_range: [],
|
|
42
|
- extension: [],
|
|
43
|
- options: nil,
|
|
44
44
|
oneof_decl: [],
|
|
45
|
- reserved_range: [],
|
|
45
|
options: nil,
|
|
46
46
|
reserved_name: [],
|
|
47
|
- __unknown_fields__: []
|
|
47
|
reserved_range: []
|
|
48
48
|
}
|
|
49
49
|
end
|
added
lib/spawn/google/protobuf/descriptor.pb.ex
|
|
@@ -0,0 1,663 @@
|
|
1
|
defmodule Google.Protobuf.Edition do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
4
|
|
|
5
|
field(:EDITION_UNKNOWN, 0)
|
|
6
|
field(:EDITION_PROTO2, 998)
|
|
7
|
field(:EDITION_PROTO3, 999)
|
|
8
|
field(:EDITION_2023, 1000)
|
|
9
|
field(:EDITION_2024, 1001)
|
|
10
|
field(:EDITION_1_TEST_ONLY, 1)
|
|
11
|
field(:EDITION_2_TEST_ONLY, 2)
|
|
12
|
field(:EDITION_99997_TEST_ONLY, 99997)
|
|
13
|
field(:EDITION_99998_TEST_ONLY, 99998)
|
|
14
|
field(:EDITION_99999_TEST_ONLY, 99999)
|
|
15
|
field(:EDITION_MAX, 2_147_483_647)
|
|
16
|
end
|
|
17
|
|
|
18
|
defmodule Google.Protobuf.ExtensionRangeOptions.VerificationState do
|
|
19
|
@moduledoc false
|
|
20
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
21
|
|
|
22
|
field(:DECLARATION, 0)
|
|
23
|
field(:UNVERIFIED, 1)
|
|
24
|
end
|
|
25
|
|
|
26
|
defmodule Google.Protobuf.FieldDescriptorProto.Type do
|
|
27
|
@moduledoc false
|
|
28
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
29
|
|
|
30
|
field(:TYPE_DOUBLE, 1)
|
|
31
|
field(:TYPE_FLOAT, 2)
|
|
32
|
field(:TYPE_INT64, 3)
|
|
33
|
field(:TYPE_UINT64, 4)
|
|
34
|
field(:TYPE_INT32, 5)
|
|
35
|
field(:TYPE_FIXED64, 6)
|
|
36
|
field(:TYPE_FIXED32, 7)
|
|
37
|
field(:TYPE_BOOL, 8)
|
|
38
|
field(:TYPE_STRING, 9)
|
|
39
|
field(:TYPE_GROUP, 10)
|
|
40
|
field(:TYPE_MESSAGE, 11)
|
|
41
|
field(:TYPE_BYTES, 12)
|
|
42
|
field(:TYPE_UINT32, 13)
|
|
43
|
field(:TYPE_ENUM, 14)
|
|
44
|
field(:TYPE_SFIXED32, 15)
|
|
45
|
field(:TYPE_SFIXED64, 16)
|
|
46
|
field(:TYPE_SINT32, 17)
|
|
47
|
field(:TYPE_SINT64, 18)
|
|
48
|
end
|
|
49
|
|
|
50
|
defmodule Google.Protobuf.FieldDescriptorProto.Label do
|
|
51
|
@moduledoc false
|
|
52
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
53
|
|
|
54
|
field(:LABEL_OPTIONAL, 1)
|
|
55
|
field(:LABEL_REPEATED, 3)
|
|
56
|
field(:LABEL_REQUIRED, 2)
|
|
57
|
end
|
|
58
|
|
|
59
|
defmodule Google.Protobuf.FileOptions.OptimizeMode do
|
|
60
|
@moduledoc false
|
|
61
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
62
|
|
|
63
|
field(:SPEED, 1)
|
|
64
|
field(:CODE_SIZE, 2)
|
|
65
|
field(:LITE_RUNTIME, 3)
|
|
66
|
end
|
|
67
|
|
|
68
|
defmodule Google.Protobuf.FieldOptions.CType do
|
|
69
|
@moduledoc false
|
|
70
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
71
|
|
|
72
|
field(:STRING, 0)
|
|
73
|
field(:CORD, 1)
|
|
74
|
field(:STRING_PIECE, 2)
|
|
75
|
end
|
|
76
|
|
|
77
|
defmodule Google.Protobuf.FieldOptions.JSType do
|
|
78
|
@moduledoc false
|
|
79
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
80
|
|
|
81
|
field(:JS_NORMAL, 0)
|
|
82
|
field(:JS_STRING, 1)
|
|
83
|
field(:JS_NUMBER, 2)
|
|
84
|
end
|
|
85
|
|
|
86
|
defmodule Google.Protobuf.FieldOptions.OptionRetention do
|
|
87
|
@moduledoc false
|
|
88
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
89
|
|
|
90
|
field(:RETENTION_UNKNOWN, 0)
|
|
91
|
field(:RETENTION_RUNTIME, 1)
|
|
92
|
field(:RETENTION_SOURCE, 2)
|
|
93
|
end
|
|
94
|
|
|
95
|
defmodule Google.Protobuf.FieldOptions.OptionTargetType do
|
|
96
|
@moduledoc false
|
|
97
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
98
|
|
|
99
|
field(:TARGET_TYPE_UNKNOWN, 0)
|
|
100
|
field(:TARGET_TYPE_FILE, 1)
|
|
101
|
field(:TARGET_TYPE_EXTENSION_RANGE, 2)
|
|
102
|
field(:TARGET_TYPE_MESSAGE, 3)
|
|
103
|
field(:TARGET_TYPE_FIELD, 4)
|
|
104
|
field(:TARGET_TYPE_ONEOF, 5)
|
|
105
|
field(:TARGET_TYPE_ENUM, 6)
|
|
106
|
field(:TARGET_TYPE_ENUM_ENTRY, 7)
|
|
107
|
field(:TARGET_TYPE_SERVICE, 8)
|
|
108
|
field(:TARGET_TYPE_METHOD, 9)
|
|
109
|
end
|
|
110
|
|
|
111
|
defmodule Google.Protobuf.MethodOptions.IdempotencyLevel do
|
|
112
|
@moduledoc false
|
|
113
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
114
|
|
|
115
|
field(:IDEMPOTENCY_UNKNOWN, 0)
|
|
116
|
field(:NO_SIDE_EFFECTS, 1)
|
|
117
|
field(:IDEMPOTENT, 2)
|
|
118
|
end
|
|
119
|
|
|
120
|
defmodule Google.Protobuf.FeatureSet.FieldPresence do
|
|
121
|
@moduledoc false
|
|
122
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
123
|
|
|
124
|
field(:FIELD_PRESENCE_UNKNOWN, 0)
|
|
125
|
field(:EXPLICIT, 1)
|
|
126
|
field(:IMPLICIT, 2)
|
|
127
|
field(:LEGACY_REQUIRED, 3)
|
|
128
|
end
|
|
129
|
|
|
130
|
defmodule Google.Protobuf.FeatureSet.EnumType do
|
|
131
|
@moduledoc false
|
|
132
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
133
|
|
|
134
|
field(:ENUM_TYPE_UNKNOWN, 0)
|
|
135
|
field(:OPEN, 1)
|
|
136
|
field(:CLOSED, 2)
|
|
137
|
end
|
|
138
|
|
|
139
|
defmodule Google.Protobuf.FeatureSet.RepeatedFieldEncoding do
|
|
140
|
@moduledoc false
|
|
141
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
142
|
|
|
143
|
field(:REPEATED_FIELD_ENCODING_UNKNOWN, 0)
|
|
144
|
field(:PACKED, 1)
|
|
145
|
field(:EXPANDED, 2)
|
|
146
|
end
|
|
147
|
|
|
148
|
defmodule Google.Protobuf.FeatureSet.Utf8Validation do
|
|
149
|
@moduledoc false
|
|
150
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
151
|
|
|
152
|
field(:UTF8_VALIDATION_UNKNOWN, 0)
|
|
153
|
field(:VERIFY, 2)
|
|
154
|
field(:NONE, 3)
|
|
155
|
end
|
|
156
|
|
|
157
|
defmodule Google.Protobuf.FeatureSet.MessageEncoding do
|
|
158
|
@moduledoc false
|
|
159
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
160
|
|
|
161
|
field(:MESSAGE_ENCODING_UNKNOWN, 0)
|
|
162
|
field(:LENGTH_PREFIXED, 1)
|
|
163
|
field(:DELIMITED, 2)
|
|
164
|
end
|
|
165
|
|
|
166
|
defmodule Google.Protobuf.FeatureSet.JsonFormat do
|
|
167
|
@moduledoc false
|
|
168
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
169
|
|
|
170
|
field(:JSON_FORMAT_UNKNOWN, 0)
|
|
171
|
field(:ALLOW, 1)
|
|
172
|
field(:LEGACY_BEST_EFFORT, 2)
|
|
173
|
end
|
|
174
|
|
|
175
|
defmodule Google.Protobuf.GeneratedCodeInfo.Annotation.Semantic do
|
|
176
|
@moduledoc false
|
|
177
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
178
|
|
|
179
|
field(:NONE, 0)
|
|
180
|
field(:SET, 1)
|
|
181
|
field(:ALIAS, 2)
|
|
182
|
end
|
|
183
|
|
|
184
|
defmodule Google.Protobuf.FileDescriptorSet do
|
|
185
|
@moduledoc false
|
|
186
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
187
|
|
|
188
|
field(:file, 1, repeated: true, type: Google.Protobuf.FileDescriptorProto)
|
|
189
|
end
|
|
190
|
|
|
191
|
defmodule Google.Protobuf.FileDescriptorProto do
|
|
192
|
@moduledoc false
|
|
193
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
194
|
|
|
195
|
field(:name, 1, optional: true, type: :string)
|
|
196
|
field(:package, 2, optional: true, type: :string)
|
|
197
|
field(:dependency, 3, repeated: true, type: :string)
|
|
198
|
field(:public_dependency, 10, repeated: true, type: :int32)
|
|
199
|
field(:weak_dependency, 11, repeated: true, type: :int32)
|
|
200
|
field(:message_type, 4, repeated: true, type: Google.Protobuf.DescriptorProto)
|
|
201
|
field(:enum_type, 5, repeated: true, type: Google.Protobuf.EnumDescriptorProto)
|
|
202
|
field(:service, 6, repeated: true, type: Google.Protobuf.ServiceDescriptorProto)
|
|
203
|
field(:extension, 7, repeated: true, type: Google.Protobuf.FieldDescriptorProto)
|
|
204
|
field(:options, 8, optional: true, type: Google.Protobuf.FileOptions)
|
|
205
|
field(:source_code_info, 9, optional: true, type: Google.Protobuf.SourceCodeInfo)
|
|
206
|
field(:syntax, 12, optional: true, type: :string)
|
|
207
|
field(:edition, 14, optional: true, type: Google.Protobuf.Edition, enum: true)
|
|
208
|
end
|
|
209
|
|
|
210
|
defmodule Google.Protobuf.DescriptorProto.ExtensionRange do
|
|
211
|
@moduledoc false
|
|
212
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
213
|
|
|
214
|
field(:start, 1, optional: true, type: :int32)
|
|
215
|
field(:end, 2, optional: true, type: :int32)
|
|
216
|
field(:options, 3, optional: true, type: Google.Protobuf.ExtensionRangeOptions)
|
|
217
|
end
|
|
218
|
|
|
219
|
defmodule Google.Protobuf.DescriptorProto.ReservedRange do
|
|
220
|
@moduledoc false
|
|
221
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
222
|
|
|
223
|
field(:start, 1, optional: true, type: :int32)
|
|
224
|
field(:end, 2, optional: true, type: :int32)
|
|
225
|
end
|
|
226
|
|
|
227
|
defmodule Google.Protobuf.DescriptorProto do
|
|
228
|
@moduledoc false
|
|
229
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
230
|
|
|
231
|
field(:name, 1, optional: true, type: :string)
|
|
232
|
field(:field, 2, repeated: true, type: Google.Protobuf.FieldDescriptorProto)
|
|
233
|
field(:extension, 6, repeated: true, type: Google.Protobuf.FieldDescriptorProto)
|
|
234
|
field(:nested_type, 3, repeated: true, type: Google.Protobuf.DescriptorProto)
|
|
235
|
field(:enum_type, 4, repeated: true, type: Google.Protobuf.EnumDescriptorProto)
|
|
236
|
field(:extension_range, 5, repeated: true, type: Google.Protobuf.DescriptorProto.ExtensionRange)
|
|
237
|
field(:oneof_decl, 8, repeated: true, type: Google.Protobuf.OneofDescriptorProto)
|
|
238
|
field(:options, 7, optional: true, type: Google.Protobuf.MessageOptions)
|
|
239
|
field(:reserved_range, 9, repeated: true, type: Google.Protobuf.DescriptorProto.ReservedRange)
|
|
240
|
field(:reserved_name, 10, repeated: true, type: :string)
|
|
241
|
end
|
|
242
|
|
|
243
|
defmodule Google.Protobuf.ExtensionRangeOptions.Declaration do
|
|
244
|
@moduledoc false
|
|
245
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
246
|
|
|
247
|
field(:number, 1, optional: true, type: :int32)
|
|
248
|
field(:full_name, 2, optional: true, type: :string)
|
|
249
|
field(:type, 3, optional: true, type: :string)
|
|
250
|
field(:reserved, 5, optional: true, type: :bool)
|
|
251
|
field(:repeated, 6, optional: true, type: :bool)
|
|
252
|
end
|
|
253
|
|
|
254
|
defmodule Google.Protobuf.ExtensionRangeOptions do
|
|
255
|
@moduledoc false
|
|
256
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
257
|
|
|
258
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
259
|
|
|
260
|
field(:declaration, 2,
|
|
261
|
repeated: true,
|
|
262
|
type: Google.Protobuf.ExtensionRangeOptions.Declaration,
|
|
263
|
deprecated: false
|
|
264
|
)
|
|
265
|
|
|
266
|
field(:features, 50, optional: true, type: Google.Protobuf.FeatureSet)
|
|
267
|
|
|
268
|
field(:verification, 3,
|
|
269
|
optional: true,
|
|
270
|
type: Google.Protobuf.ExtensionRangeOptions.VerificationState,
|
|
271
|
default: :UNVERIFIED,
|
|
272
|
enum: true,
|
|
273
|
deprecated: false
|
|
274
|
)
|
|
275
|
|
|
276
|
extensions([{1000, 536_870_912}])
|
|
277
|
end
|
|
278
|
|
|
279
|
defmodule Google.Protobuf.FieldDescriptorProto do
|
|
280
|
@moduledoc false
|
|
281
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
282
|
|
|
283
|
field(:name, 1, optional: true, type: :string)
|
|
284
|
field(:number, 3, optional: true, type: :int32)
|
|
285
|
field(:label, 4, optional: true, type: Google.Protobuf.FieldDescriptorProto.Label, enum: true)
|
|
286
|
field(:type, 5, optional: true, type: Google.Protobuf.FieldDescriptorProto.Type, enum: true)
|
|
287
|
field(:type_name, 6, optional: true, type: :string)
|
|
288
|
field(:extendee, 2, optional: true, type: :string)
|
|
289
|
field(:default_value, 7, optional: true, type: :string)
|
|
290
|
field(:oneof_index, 9, optional: true, type: :int32)
|
|
291
|
field(:json_name, 10, optional: true, type: :string)
|
|
292
|
field(:options, 8, optional: true, type: Google.Protobuf.FieldOptions)
|
|
293
|
field(:proto3_optional, 17, optional: true, type: :bool)
|
|
294
|
end
|
|
295
|
|
|
296
|
defmodule Google.Protobuf.OneofDescriptorProto do
|
|
297
|
@moduledoc false
|
|
298
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
299
|
|
|
300
|
field(:name, 1, optional: true, type: :string)
|
|
301
|
field(:options, 2, optional: true, type: Google.Protobuf.OneofOptions)
|
|
302
|
end
|
|
303
|
|
|
304
|
defmodule Google.Protobuf.EnumDescriptorProto.EnumReservedRange do
|
|
305
|
@moduledoc false
|
|
306
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
307
|
|
|
308
|
field(:start, 1, optional: true, type: :int32)
|
|
309
|
field(:end, 2, optional: true, type: :int32)
|
|
310
|
end
|
|
311
|
|
|
312
|
defmodule Google.Protobuf.EnumDescriptorProto do
|
|
313
|
@moduledoc false
|
|
314
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
315
|
|
|
316
|
field(:name, 1, optional: true, type: :string)
|
|
317
|
field(:value, 2, repeated: true, type: Google.Protobuf.EnumValueDescriptorProto)
|
|
318
|
field(:options, 3, optional: true, type: Google.Protobuf.EnumOptions)
|
|
319
|
|
|
320
|
field(:reserved_range, 4,
|
|
321
|
repeated: true,
|
|
322
|
type: Google.Protobuf.EnumDescriptorProto.EnumReservedRange
|
|
323
|
)
|
|
324
|
|
|
325
|
field(:reserved_name, 5, repeated: true, type: :string)
|
|
326
|
end
|
|
327
|
|
|
328
|
defmodule Google.Protobuf.EnumValueDescriptorProto do
|
|
329
|
@moduledoc false
|
|
330
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
331
|
|
|
332
|
field(:name, 1, optional: true, type: :string)
|
|
333
|
field(:number, 2, optional: true, type: :int32)
|
|
334
|
field(:options, 3, optional: true, type: Google.Protobuf.EnumValueOptions)
|
|
335
|
end
|
|
336
|
|
|
337
|
defmodule Google.Protobuf.ServiceDescriptorProto do
|
|
338
|
@moduledoc false
|
|
339
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
340
|
|
|
341
|
field(:name, 1, optional: true, type: :string)
|
|
342
|
field(:method, 2, repeated: true, type: Google.Protobuf.MethodDescriptorProto)
|
|
343
|
field(:options, 3, optional: true, type: Google.Protobuf.ServiceOptions)
|
|
344
|
end
|
|
345
|
|
|
346
|
defmodule Google.Protobuf.MethodDescriptorProto do
|
|
347
|
@moduledoc false
|
|
348
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
349
|
|
|
350
|
field(:name, 1, optional: true, type: :string)
|
|
351
|
field(:input_type, 2, optional: true, type: :string)
|
|
352
|
field(:output_type, 3, optional: true, type: :string)
|
|
353
|
field(:options, 4, optional: true, type: Google.Protobuf.MethodOptions)
|
|
354
|
field(:client_streaming, 5, optional: true, type: :bool, default: false)
|
|
355
|
field(:server_streaming, 6, optional: true, type: :bool, default: false)
|
|
356
|
end
|
|
357
|
|
|
358
|
defmodule Google.Protobuf.FileOptions do
|
|
359
|
@moduledoc false
|
|
360
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
361
|
|
|
362
|
field(:java_package, 1, optional: true, type: :string)
|
|
363
|
field(:java_outer_classname, 8, optional: true, type: :string)
|
|
364
|
field(:java_multiple_files, 10, optional: true, type: :bool, default: false)
|
|
365
|
field(:java_generate_equals_and_hash, 20, optional: true, type: :bool, deprecated: true)
|
|
366
|
field(:java_string_check_utf8, 27, optional: true, type: :bool, default: false)
|
|
367
|
|
|
368
|
field(:optimize_for, 9,
|
|
369
|
optional: true,
|
|
370
|
type: Google.Protobuf.FileOptions.OptimizeMode,
|
|
371
|
default: :SPEED,
|
|
372
|
enum: true
|
|
373
|
)
|
|
374
|
|
|
375
|
field(:go_package, 11, optional: true, type: :string)
|
|
376
|
field(:cc_generic_services, 16, optional: true, type: :bool, default: false)
|
|
377
|
field(:java_generic_services, 17, optional: true, type: :bool, default: false)
|
|
378
|
field(:py_generic_services, 18, optional: true, type: :bool, default: false)
|
|
379
|
field(:deprecated, 23, optional: true, type: :bool, default: false)
|
|
380
|
field(:cc_enable_arenas, 31, optional: true, type: :bool, default: true)
|
|
381
|
field(:objc_class_prefix, 36, optional: true, type: :string)
|
|
382
|
field(:csharp_namespace, 37, optional: true, type: :string)
|
|
383
|
field(:swift_prefix, 39, optional: true, type: :string)
|
|
384
|
field(:php_class_prefix, 40, optional: true, type: :string)
|
|
385
|
field(:php_namespace, 41, optional: true, type: :string)
|
|
386
|
field(:php_metadata_namespace, 44, optional: true, type: :string)
|
|
387
|
field(:ruby_package, 45, optional: true, type: :string)
|
|
388
|
field(:features, 50, optional: true, type: Google.Protobuf.FeatureSet)
|
|
389
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
390
|
|
|
391
|
extensions([{1000, 536_870_912}])
|
|
392
|
end
|
|
393
|
|
|
394
|
defmodule Google.Protobuf.MessageOptions do
|
|
395
|
@moduledoc false
|
|
396
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
397
|
|
|
398
|
field(:message_set_wire_format, 1, optional: true, type: :bool, default: false)
|
|
399
|
field(:no_standard_descriptor_accessor, 2, optional: true, type: :bool, default: false)
|
|
400
|
field(:deprecated, 3, optional: true, type: :bool, default: false)
|
|
401
|
field(:map_entry, 7, optional: true, type: :bool)
|
|
402
|
|
|
403
|
field(:deprecated_legacy_json_field_conflicts, 11,
|
|
404
|
optional: true,
|
|
405
|
type: :bool,
|
|
406
|
deprecated: true
|
|
407
|
)
|
|
408
|
|
|
409
|
field(:features, 12, optional: true, type: Google.Protobuf.FeatureSet)
|
|
410
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
411
|
|
|
412
|
extensions([{1000, 536_870_912}])
|
|
413
|
end
|
|
414
|
|
|
415
|
defmodule Google.Protobuf.FieldOptions.EditionDefault do
|
|
416
|
@moduledoc false
|
|
417
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
418
|
|
|
419
|
field(:edition, 3, optional: true, type: Google.Protobuf.Edition, enum: true)
|
|
420
|
field(:value, 2, optional: true, type: :string)
|
|
421
|
end
|
|
422
|
|
|
423
|
defmodule Google.Protobuf.FieldOptions do
|
|
424
|
@moduledoc false
|
|
425
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
426
|
|
|
427
|
field(:ctype, 1,
|
|
428
|
optional: true,
|
|
429
|
type: Google.Protobuf.FieldOptions.CType,
|
|
430
|
default: :STRING,
|
|
431
|
enum: true
|
|
432
|
)
|
|
433
|
|
|
434
|
field(:packed, 2, optional: true, type: :bool)
|
|
435
|
|
|
436
|
field(:jstype, 6,
|
|
437
|
optional: true,
|
|
438
|
type: Google.Protobuf.FieldOptions.JSType,
|
|
439
|
default: :JS_NORMAL,
|
|
440
|
enum: true
|
|
441
|
)
|
|
442
|
|
|
443
|
field(:lazy, 5, optional: true, type: :bool, default: false)
|
|
444
|
field(:unverified_lazy, 15, optional: true, type: :bool, default: false)
|
|
445
|
field(:deprecated, 3, optional: true, type: :bool, default: false)
|
|
446
|
field(:weak, 10, optional: true, type: :bool, default: false)
|
|
447
|
field(:debug_redact, 16, optional: true, type: :bool, default: false)
|
|
448
|
|
|
449
|
field(:retention, 17,
|
|
450
|
optional: true,
|
|
451
|
type: Google.Protobuf.FieldOptions.OptionRetention,
|
|
452
|
enum: true
|
|
453
|
)
|
|
454
|
|
|
455
|
field(:targets, 19,
|
|
456
|
repeated: true,
|
|
457
|
type: Google.Protobuf.FieldOptions.OptionTargetType,
|
|
458
|
enum: true
|
|
459
|
)
|
|
460
|
|
|
461
|
field(:edition_defaults, 20, repeated: true, type: Google.Protobuf.FieldOptions.EditionDefault)
|
|
462
|
field(:features, 21, optional: true, type: Google.Protobuf.FeatureSet)
|
|
463
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
464
|
|
|
465
|
extensions([{1000, 536_870_912}])
|
|
466
|
end
|
|
467
|
|
|
468
|
defmodule Google.Protobuf.OneofOptions do
|
|
469
|
@moduledoc false
|
|
470
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
471
|
|
|
472
|
field(:features, 1, optional: true, type: Google.Protobuf.FeatureSet)
|
|
473
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
474
|
|
|
475
|
extensions([{1000, 536_870_912}])
|
|
476
|
end
|
|
477
|
|
|
478
|
defmodule Google.Protobuf.EnumOptions do
|
|
479
|
@moduledoc false
|
|
480
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
481
|
|
|
482
|
field(:allow_alias, 2, optional: true, type: :bool)
|
|
483
|
field(:deprecated, 3, optional: true, type: :bool, default: false)
|
|
484
|
field(:deprecated_legacy_json_field_conflicts, 6, optional: true, type: :bool, deprecated: true)
|
|
485
|
field(:features, 7, optional: true, type: Google.Protobuf.FeatureSet)
|
|
486
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
487
|
|
|
488
|
extensions([{1000, 536_870_912}])
|
|
489
|
end
|
|
490
|
|
|
491
|
defmodule Google.Protobuf.EnumValueOptions do
|
|
492
|
@moduledoc false
|
|
493
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
494
|
|
|
495
|
field(:deprecated, 1, optional: true, type: :bool, default: false)
|
|
496
|
field(:features, 2, optional: true, type: Google.Protobuf.FeatureSet)
|
|
497
|
field(:debug_redact, 3, optional: true, type: :bool, default: false)
|
|
498
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
499
|
|
|
500
|
extensions([{1000, 536_870_912}])
|
|
501
|
end
|
|
502
|
|
|
503
|
defmodule Google.Protobuf.ServiceOptions do
|
|
504
|
@moduledoc false
|
|
505
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
506
|
|
|
507
|
field(:features, 34, optional: true, type: Google.Protobuf.FeatureSet)
|
|
508
|
field(:deprecated, 33, optional: true, type: :bool, default: false)
|
|
509
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
510
|
|
|
511
|
extensions([{1000, 536_870_912}])
|
|
512
|
end
|
|
513
|
|
|
514
|
defmodule Google.Protobuf.MethodOptions do
|
|
515
|
@moduledoc false
|
|
516
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
517
|
|
|
518
|
field(:deprecated, 33, optional: true, type: :bool, default: false)
|
|
519
|
|
|
520
|
field(:idempotency_level, 34,
|
|
521
|
optional: true,
|
|
522
|
type: Google.Protobuf.MethodOptions.IdempotencyLevel,
|
|
523
|
default: :IDEMPOTENCY_UNKNOWN,
|
|
524
|
enum: true
|
|
525
|
)
|
|
526
|
|
|
527
|
field(:features, 35, optional: true, type: Google.Protobuf.FeatureSet)
|
|
528
|
field(:uninterpreted_option, 999, repeated: true, type: Google.Protobuf.UninterpretedOption)
|
|
529
|
|
|
530
|
extensions([{1000, 536_870_912}])
|
|
531
|
end
|
|
532
|
|
|
533
|
defmodule Google.Protobuf.UninterpretedOption.NamePart do
|
|
534
|
@moduledoc false
|
|
535
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
536
|
|
|
537
|
field(:name_part, 1, required: true, type: :string)
|
|
538
|
field(:is_extension, 2, required: true, type: :bool)
|
|
539
|
end
|
|
540
|
|
|
541
|
defmodule Google.Protobuf.UninterpretedOption do
|
|
542
|
@moduledoc false
|
|
543
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
544
|
|
|
545
|
field(:name, 2, repeated: true, type: Google.Protobuf.UninterpretedOption.NamePart)
|
|
546
|
field(:identifier_value, 3, optional: true, type: :string)
|
|
547
|
field(:positive_int_value, 4, optional: true, type: :uint64)
|
|
548
|
field(:negative_int_value, 5, optional: true, type: :int64)
|
|
549
|
field(:double_value, 6, optional: true, type: :double)
|
|
550
|
field(:string_value, 7, optional: true, type: :bytes)
|
|
551
|
field(:aggregate_value, 8, optional: true, type: :string)
|
|
552
|
end
|
|
553
|
|
|
554
|
defmodule Google.Protobuf.FeatureSet do
|
|
555
|
@moduledoc false
|
|
556
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
557
|
|
|
558
|
field(:field_presence, 1,
|
|
559
|
optional: true,
|
|
560
|
type: Google.Protobuf.FeatureSet.FieldPresence,
|
|
561
|
enum: true,
|
|
562
|
deprecated: false
|
|
563
|
)
|
|
564
|
|
|
565
|
field(:enum_type, 2,
|
|
566
|
optional: true,
|
|
567
|
type: Google.Protobuf.FeatureSet.EnumType,
|
|
568
|
enum: true,
|
|
569
|
deprecated: false
|
|
570
|
)
|
|
571
|
|
|
572
|
field(:repeated_field_encoding, 3,
|
|
573
|
optional: true,
|
|
574
|
type: Google.Protobuf.FeatureSet.RepeatedFieldEncoding,
|
|
575
|
enum: true,
|
|
576
|
deprecated: false
|
|
577
|
)
|
|
578
|
|
|
579
|
field(:utf8_validation, 4,
|
|
580
|
optional: true,
|
|
581
|
type: Google.Protobuf.FeatureSet.Utf8Validation,
|
|
582
|
enum: true,
|
|
583
|
deprecated: false
|
|
584
|
)
|
|
585
|
|
|
586
|
field(:message_encoding, 5,
|
|
587
|
optional: true,
|
|
588
|
type: Google.Protobuf.FeatureSet.MessageEncoding,
|
|
589
|
enum: true,
|
|
590
|
deprecated: false
|
|
591
|
)
|
|
592
|
|
|
593
|
field(:json_format, 6,
|
|
863
|
optional: true,
|
|
595
|
type: Google.Protobuf.FeatureSet.JsonFormat,
|
|
596
|
enum: true,
|
|
597
|
deprecated: false
|
|
598
|
)
|
|
599
|
|
|
600
|
extensions([{1000, 1001}, {1001, 1002}, {1002, 1003}, {9995, 10000}, {10000, 10001}])
|
|
601
|
end
|
|
602
|
|
|
603
|
defmodule Google.Protobuf.FeatureSetDefaults.FeatureSetEditionDefault do
|
|
604
|
@moduledoc false
|
|
605
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
606
|
|
|
607
|
field(:edition, 3, optional: true, type: Google.Protobuf.Edition, enum: true)
|
|
608
|
field(:features, 2, optional: true, type: Google.Protobuf.FeatureSet)
|
|
609
|
end
|
|
610
|
|
|
611
|
defmodule Google.Protobuf.FeatureSetDefaults do
|
|
612
|
@moduledoc false
|
|
613
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
614
|
|
|
615
|
field(:defaults, 1,
|
|
616
|
repeated: true,
|
|
617
|
type: Google.Protobuf.FeatureSetDefaults.FeatureSetEditionDefault
|
|
618
|
)
|
|
619
|
|
|
620
|
field(:minimum_edition, 4, optional: true, type: Google.Protobuf.Edition, enum: true)
|
|
621
|
field(:maximum_edition, 5, optional: true, type: Google.Protobuf.Edition, enum: true)
|
|
622
|
end
|
|
623
|
|
|
624
|
defmodule Google.Protobuf.SourceCodeInfo.Location do
|
|
625
|
@moduledoc false
|
|
626
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
627
|
|
|
628
|
field(:path, 1, repeated: true, type: :int32, packed: true, deprecated: false)
|
|
629
|
field(:span, 2, repeated: true, type: :int32, packed: true, deprecated: false)
|
|
630
|
field(:leading_comments, 3, optional: true, type: :string)
|
|
631
|
field(:trailing_comments, 4, optional: true, type: :string)
|
|
632
|
field(:leading_detached_comments, 6, repeated: true, type: :string)
|
|
633
|
end
|
|
634
|
|
|
635
|
defmodule Google.Protobuf.SourceCodeInfo do
|
|
636
|
@moduledoc false
|
|
637
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
638
|
|
|
639
|
field(:location, 1, repeated: true, type: Google.Protobuf.SourceCodeInfo.Location)
|
|
640
|
end
|
|
641
|
|
|
642
|
defmodule Google.Protobuf.GeneratedCodeInfo.Annotation do
|
|
643
|
@moduledoc false
|
|
644
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
645
|
|
|
646
|
field(:path, 1, repeated: true, type: :int32, packed: true, deprecated: false)
|
|
647
|
field(:source_file, 2, optional: true, type: :string)
|
|
648
|
field(:begin, 3, optional: true, type: :int32)
|
|
649
|
field(:end, 4, optional: true, type: :int32)
|
|
650
|
|
|
651
|
field(:semantic, 5,
|
|
652
|
optional: true,
|
|
653
|
type: Google.Protobuf.GeneratedCodeInfo.Annotation.Semantic,
|
|
654
|
enum: true
|
|
655
|
)
|
|
656
|
end
|
|
657
|
|
|
658
|
defmodule Google.Protobuf.GeneratedCodeInfo do
|
|
659
|
@moduledoc false
|
|
660
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto2
|
|
661
|
|
|
662
|
field(:annotation, 1, repeated: true, type: Google.Protobuf.GeneratedCodeInfo.Annotation)
|
|
663
|
end
|
added
lib/spawn/google/protobuf/duration.pb.ex
|
|
@@ -0,0 1,53 @@
|
|
1
|
defmodule Google.Protobuf.Duration do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [
|
|
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
14
|
__unknown_fields__: [],
|
|
15
|
default_value: nil,
|
|
16
|
extendee: nil,
|
|
17
|
json_name: "seconds",
|
|
18
|
label: :LABEL_OPTIONAL,
|
|
19
|
name: "seconds",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
23
|
proto3_optional: nil,
|
|
24
|
type: :TYPE_INT64,
|
|
25
|
type_name: nil
|
|
26
|
},
|
|
27
|
%Google.Protobuf.FieldDescriptorProto{
|
|
28
|
__unknown_fields__: [],
|
|
29
|
default_value: nil,
|
|
30
|
extendee: nil,
|
|
31
|
json_name: "nanos",
|
|
32
|
label: :LABEL_OPTIONAL,
|
|
33
|
name: "nanos",
|
|
34
|
number: 2,
|
|
35
|
oneof_index: nil,
|
|
36
|
options: nil,
|
|
37
|
proto3_optional: nil,
|
|
38
|
type: :TYPE_INT32,
|
|
39
|
type_name: nil
|
|
40
|
}
|
|
41
|
],
|
|
42
|
name: "Duration",
|
|
43
|
nested_type: [],
|
|
44
|
oneof_decl: [],
|
|
45
|
options: nil,
|
|
46
|
reserved_name: [],
|
|
47
|
reserved_range: []
|
|
48
|
}
|
|
49
|
end
|
|
50
|
|
|
51
|
field(:seconds, 1, type: :int64)
|
|
52
|
field(:nanos, 2, type: :int32)
|
|
53
|
end
|
added
lib/spawn/google/protobuf/empty.pb.ex
|
|
@@ -0,0 1,21 @@
|
|
1
|
defmodule Google.Protobuf.Empty do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [],
|
|
13
|
name: "Empty",
|
|
14
|
nested_type: [],
|
|
15
|
oneof_decl: [],
|
|
16
|
options: nil,
|
|
17
|
reserved_name: [],
|
|
18
|
reserved_range: []
|
|
19
|
}
|
|
20
|
end
|
|
21
|
end
|
added
lib/spawn/google/protobuf/field_mask.pb.ex
|
|
@@ -0,0 1,38 @@
|
|
1
|
defmodule Google.Protobuf.FieldMask do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [
|
|
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
14
|
__unknown_fields__: [],
|
|
15
|
default_value: nil,
|
|
16
|
extendee: nil,
|
|
17
|
json_name: "paths",
|
|
18
|
label: :LABEL_REPEATED,
|
|
19
|
name: "paths",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
23
|
proto3_optional: nil,
|
|
24
|
type: :TYPE_STRING,
|
|
25
|
type_name: nil
|
|
26
|
}
|
|
27
|
],
|
|
28
|
name: "FieldMask",
|
|
29
|
nested_type: [],
|
|
30
|
oneof_decl: [],
|
|
31
|
options: nil,
|
|
32
|
reserved_name: [],
|
|
33
|
reserved_range: []
|
|
34
|
}
|
|
35
|
end
|
|
36
|
|
|
37
|
field(:paths, 1, repeated: true, type: :string)
|
|
38
|
end
|
added
lib/spawn/google/protobuf/source_context.pb.ex
|
|
@@ -0,0 1,38 @@
|
|
1
|
defmodule Google.Protobuf.SourceContext do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [
|
|
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
14
|
__unknown_fields__: [],
|
|
15
|
default_value: nil,
|
|
16
|
extendee: nil,
|
|
17
|
json_name: "fileName",
|
|
18
|
label: :LABEL_OPTIONAL,
|
|
19
|
name: "file_name",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
23
|
proto3_optional: nil,
|
|
24
|
type: :TYPE_STRING,
|
|
25
|
type_name: nil
|
|
26
|
}
|
|
27
|
],
|
|
28
|
name: "SourceContext",
|
|
29
|
nested_type: [],
|
|
30
|
oneof_decl: [],
|
|
31
|
options: nil,
|
|
32
|
reserved_name: [],
|
|
33
|
reserved_range: []
|
|
34
|
}
|
|
35
|
end
|
|
36
|
|
|
37
|
field(:file_name, 1, type: :string, json_name: "fileName")
|
|
38
|
end
|
added
lib/spawn/google/protobuf/struct.pb.ex
|
|
@@ -0,0 1,340 @@
|
|
1
|
defmodule Google.Protobuf.NullValue do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, enum: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.EnumDescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
name: "NullValue",
|
|
10
|
options: nil,
|
|
11
|
reserved_name: [],
|
|
12
|
reserved_range: [],
|
|
13
|
value: [
|
|
14
|
%Google.Protobuf.EnumValueDescriptorProto{
|
|
15
|
__unknown_fields__: [],
|
|
16
|
name: "NULL_VALUE",
|
|
17
|
number: 0,
|
|
18
|
options: nil
|
|
19
|
}
|
|
20
|
]
|
|
21
|
}
|
|
22
|
end
|
|
23
|
|
|
24
|
field(:NULL_VALUE, 0)
|
|
25
|
end
|
|
26
|
|
|
27
|
defmodule Google.Protobuf.Struct.FieldsEntry do
|
|
28
|
@moduledoc false
|
|
29
|
use Protobuf, map: true, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
30
|
|
|
31
|
def descriptor do
|
|
32
|
# credo:disable-for-next-line
|
|
33
|
%Google.Protobuf.DescriptorProto{
|
|
34
|
__unknown_fields__: [],
|
|
35
|
enum_type: [],
|
|
36
|
extension: [],
|
|
37
|
extension_range: [],
|
|
38
|
field: [
|
|
39
|
%Google.Protobuf.FieldDescriptorProto{
|
|
40
|
__unknown_fields__: [],
|
|
41
|
default_value: nil,
|
|
42
|
extendee: nil,
|
|
43
|
json_name: "key",
|
|
44
|
label: :LABEL_OPTIONAL,
|
|
45
|
name: "key",
|
|
46
|
number: 1,
|
|
47
|
oneof_index: nil,
|
|
48
|
options: nil,
|
|
49
|
proto3_optional: nil,
|
|
50
|
type: :TYPE_STRING,
|
|
51
|
type_name: nil
|
|
52
|
},
|
|
53
|
%Google.Protobuf.FieldDescriptorProto{
|
|
54
|
__unknown_fields__: [],
|
|
55
|
default_value: nil,
|
|
56
|
extendee: nil,
|
|
57
|
json_name: "value",
|
|
58
|
label: :LABEL_OPTIONAL,
|
|
59
|
name: "value",
|
|
60
|
number: 2,
|
|
61
|
oneof_index: nil,
|
|
62
|
options: nil,
|
|
63
|
proto3_optional: nil,
|
|
64
|
type: :TYPE_MESSAGE,
|
|
65
|
type_name: ".google.protobuf.Value"
|
|
66
|
}
|
|
67
|
],
|
|
68
|
name: "FieldsEntry",
|
|
69
|
nested_type: [],
|
|
70
|
oneof_decl: [],
|
|
71
|
options: %Google.Protobuf.MessageOptions{
|
|
72
|
__pb_extensions__: %{},
|
|
73
|
__unknown_fields__: [],
|
|
74
|
deprecated: false,
|
|
75
|
map_entry: true,
|
|
76
|
message_set_wire_format: false,
|
|
77
|
no_standard_descriptor_accessor: false,
|
|
78
|
uninterpreted_option: []
|
|
79
|
},
|
|
80
|
reserved_name: [],
|
|
81
|
reserved_range: []
|
|
82
|
}
|
|
83
|
end
|
|
84
|
|
|
85
|
field(:key, 1, type: :string)
|
|
86
|
field(:value, 2, type: Google.Protobuf.Value)
|
|
87
|
end
|
|
88
|
|
|
89
|
defmodule Google.Protobuf.Struct do
|
|
90
|
@moduledoc false
|
|
91
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
92
|
|
|
93
|
def descriptor do
|
|
94
|
# credo:disable-for-next-line
|
|
95
|
%Google.Protobuf.DescriptorProto{
|
|
96
|
__unknown_fields__: [],
|
|
97
|
enum_type: [],
|
|
98
|
extension: [],
|
|
99
|
extension_range: [],
|
|
100
|
field: [
|
|
101
|
%Google.Protobuf.FieldDescriptorProto{
|
|
102
|
__unknown_fields__: [],
|
|
103
|
default_value: nil,
|
|
104
|
extendee: nil,
|
|
105
|
json_name: "fields",
|
|
106
|
label: :LABEL_REPEATED,
|
|
107
|
name: "fields",
|
|
108
|
number: 1,
|
|
109
|
oneof_index: nil,
|
|
110
|
options: nil,
|
|
111
|
proto3_optional: nil,
|
|
112
|
type: :TYPE_MESSAGE,
|
|
113
|
type_name: ".google.protobuf.Struct.FieldsEntry"
|
|
114
|
}
|
|
115
|
],
|
|
116
|
name: "Struct",
|
|
117
|
nested_type: [
|
|
118
|
%Google.Protobuf.DescriptorProto{
|
|
119
|
__unknown_fields__: [],
|
|
120
|
enum_type: [],
|
|
121
|
extension: [],
|
|
122
|
extension_range: [],
|
|
123
|
field: [
|
|
124
|
%Google.Protobuf.FieldDescriptorProto{
|
|
125
|
__unknown_fields__: [],
|
|
126
|
default_value: nil,
|
|
127
|
extendee: nil,
|
|
128
|
json_name: "key",
|
|
129
|
label: :LABEL_OPTIONAL,
|
|
130
|
name: "key",
|
|
131
|
number: 1,
|
|
132
|
oneof_index: nil,
|
|
133
|
options: nil,
|
|
134
|
proto3_optional: nil,
|
|
135
|
type: :TYPE_STRING,
|
|
136
|
type_name: nil
|
|
137
|
},
|
|
138
|
%Google.Protobuf.FieldDescriptorProto{
|
|
139
|
__unknown_fields__: [],
|
|
140
|
default_value: nil,
|
|
141
|
extendee: nil,
|
|
142
|
json_name: "value",
|
|
143
|
label: :LABEL_OPTIONAL,
|
|
144
|
name: "value",
|
|
145
|
number: 2,
|
|
146
|
oneof_index: nil,
|
|
147
|
options: nil,
|
|
148
|
proto3_optional: nil,
|
|
149
|
type: :TYPE_MESSAGE,
|
|
150
|
type_name: ".google.protobuf.Value"
|
|
151
|
}
|
|
152
|
],
|
|
153
|
name: "FieldsEntry",
|
|
154
|
nested_type: [],
|
|
155
|
oneof_decl: [],
|
|
156
|
options: %Google.Protobuf.MessageOptions{
|
|
157
|
__pb_extensions__: %{},
|
|
158
|
__unknown_fields__: [],
|
|
159
|
deprecated: false,
|
|
160
|
map_entry: true,
|
|
161
|
message_set_wire_format: false,
|
|
162
|
no_standard_descriptor_accessor: false,
|
|
163
|
uninterpreted_option: []
|
|
164
|
},
|
|
165
|
reserved_name: [],
|
|
166
|
reserved_range: []
|
|
167
|
}
|
|
168
|
],
|
|
169
|
oneof_decl: [],
|
|
170
|
options: nil,
|
|
171
|
reserved_name: [],
|
|
172
|
reserved_range: []
|
|
173
|
}
|
|
174
|
end
|
|
175
|
|
|
176
|
field(:fields, 1, repeated: true, type: Google.Protobuf.Struct.FieldsEntry, map: true)
|
|
177
|
end
|
|
178
|
|
|
179
|
defmodule Google.Protobuf.Value do
|
|
180
|
@moduledoc false
|
|
181
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
182
|
|
|
183
|
def descriptor do
|
|
184
|
# credo:disable-for-next-line
|
|
185
|
%Google.Protobuf.DescriptorProto{
|
|
186
|
__unknown_fields__: [],
|
|
187
|
enum_type: [],
|
|
188
|
extension: [],
|
|
189
|
extension_range: [],
|
|
190
|
field: [
|
|
191
|
%Google.Protobuf.FieldDescriptorProto{
|
|
192
|
__unknown_fields__: [],
|
|
193
|
default_value: nil,
|
|
194
|
extendee: nil,
|
|
195
|
json_name: "nullValue",
|
|
196
|
label: :LABEL_OPTIONAL,
|
|
197
|
name: "null_value",
|
|
198
|
number: 1,
|
|
199
|
oneof_index: 0,
|
|
200
|
options: nil,
|
|
201
|
proto3_optional: nil,
|
|
202
|
type: :TYPE_ENUM,
|
|
203
|
type_name: ".google.protobuf.NullValue"
|
|
204
|
},
|
|
205
|
%Google.Protobuf.FieldDescriptorProto{
|
|
206
|
__unknown_fields__: [],
|
|
207
|
default_value: nil,
|
|
208
|
extendee: nil,
|
|
209
|
json_name: "numberValue",
|
|
210
|
label: :LABEL_OPTIONAL,
|
|
211
|
name: "number_value",
|
|
212
|
number: 2,
|
|
213
|
oneof_index: 0,
|
|
214
|
options: nil,
|
|
215
|
proto3_optional: nil,
|
|
216
|
type: :TYPE_DOUBLE,
|
|
217
|
type_name: nil
|
|
218
|
},
|
|
219
|
%Google.Protobuf.FieldDescriptorProto{
|
|
220
|
__unknown_fields__: [],
|
|
221
|
default_value: nil,
|
|
222
|
extendee: nil,
|
|
223
|
json_name: "stringValue",
|
|
224
|
label: :LABEL_OPTIONAL,
|
|
225
|
name: "string_value",
|
|
226
|
number: 3,
|
|
227
|
oneof_index: 0,
|
|
228
|
options: nil,
|
|
229
|
proto3_optional: nil,
|
|
230
|
type: :TYPE_STRING,
|
|
231
|
type_name: nil
|
|
232
|
},
|
|
233
|
%Google.Protobuf.FieldDescriptorProto{
|
|
234
|
__unknown_fields__: [],
|
|
235
|
default_value: nil,
|
|
236
|
extendee: nil,
|
|
237
|
json_name: "boolValue",
|
|
238
|
label: :LABEL_OPTIONAL,
|
|
239
|
name: "bool_value",
|
|
240
|
number: 4,
|
|
241
|
oneof_index: 0,
|
|
242
|
options: nil,
|
|
243
|
proto3_optional: nil,
|
|
244
|
type: :TYPE_BOOL,
|
|
245
|
type_name: nil
|
|
246
|
},
|
|
247
|
%Google.Protobuf.FieldDescriptorProto{
|
|
248
|
__unknown_fields__: [],
|
|
249
|
default_value: nil,
|
|
250
|
extendee: nil,
|
|
251
|
json_name: "structValue",
|
|
252
|
label: :LABEL_OPTIONAL,
|
|
253
|
name: "struct_value",
|
|
254
|
number: 5,
|
|
255
|
oneof_index: 0,
|
|
256
|
options: nil,
|
|
257
|
proto3_optional: nil,
|
|
258
|
type: :TYPE_MESSAGE,
|
|
259
|
type_name: ".google.protobuf.Struct"
|
|
260
|
},
|
|
261
|
%Google.Protobuf.FieldDescriptorProto{
|
|
262
|
__unknown_fields__: [],
|
|
263
|
default_value: nil,
|
|
264
|
extendee: nil,
|
|
265
|
json_name: "listValue",
|
|
266
|
label: :LABEL_OPTIONAL,
|
|
267
|
name: "list_value",
|
|
268
|
number: 6,
|
|
269
|
oneof_index: 0,
|
|
270
|
options: nil,
|
|
271
|
proto3_optional: nil,
|
|
272
|
type: :TYPE_MESSAGE,
|
|
273
|
type_name: ".google.protobuf.ListValue"
|
|
274
|
}
|
|
275
|
],
|
|
276
|
name: "Value",
|
|
277
|
nested_type: [],
|
|
278
|
oneof_decl: [
|
|
279
|
%Google.Protobuf.OneofDescriptorProto{__unknown_fields__: [], name: "kind", options: nil}
|
|
280
|
],
|
|
281
|
options: nil,
|
|
282
|
reserved_name: [],
|
|
283
|
reserved_range: []
|
|
284
|
}
|
|
285
|
end
|
|
286
|
|
|
287
|
oneof(:kind, 0)
|
|
288
|
|
|
289
|
field(:null_value, 1,
|
|
290
|
type: Google.Protobuf.NullValue,
|
|
291
|
json_name: "nullValue",
|
|
292
|
enum: true,
|
|
293
|
oneof: 0
|
|
294
|
)
|
|
295
|
|
|
296
|
field(:number_value, 2, type: :double, json_name: "numberValue", oneof: 0)
|
|
297
|
field(:string_value, 3, type: :string, json_name: "stringValue", oneof: 0)
|
|
298
|
field(:bool_value, 4, type: :bool, json_name: "boolValue", oneof: 0)
|
|
299
|
field(:struct_value, 5, type: Google.Protobuf.Struct, json_name: "structValue", oneof: 0)
|
|
300
|
field(:list_value, 6, type: Google.Protobuf.ListValue, json_name: "listValue", oneof: 0)
|
|
301
|
end
|
|
302
|
|
|
303
|
defmodule Google.Protobuf.ListValue do
|
|
304
|
@moduledoc false
|
|
305
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
306
|
|
|
307
|
def descriptor do
|
|
308
|
# credo:disable-for-next-line
|
|
309
|
%Google.Protobuf.DescriptorProto{
|
|
310
|
__unknown_fields__: [],
|
|
311
|
enum_type: [],
|
|
312
|
extension: [],
|
|
313
|
extension_range: [],
|
|
314
|
field: [
|
|
315
|
%Google.Protobuf.FieldDescriptorProto{
|
|
316
|
__unknown_fields__: [],
|
|
317
|
default_value: nil,
|
|
318
|
extendee: nil,
|
|
319
|
json_name: "values",
|
|
320
|
label: :LABEL_REPEATED,
|
|
321
|
name: "values",
|
|
322
|
number: 1,
|
|
323
|
oneof_index: nil,
|
|
324
|
options: nil,
|
|
325
|
proto3_optional: nil,
|
|
326
|
type: :TYPE_MESSAGE,
|
|
327
|
type_name: ".google.protobuf.Value"
|
|
328
|
}
|
|
329
|
],
|
|
330
|
name: "ListValue",
|
|
331
|
nested_type: [],
|
|
332
|
oneof_decl: [],
|
|
333
|
options: nil,
|
|
334
|
reserved_name: [],
|
|
335
|
reserved_range: []
|
|
336
|
}
|
|
337
|
end
|
|
338
|
|
|
339
|
field(:values, 1, repeated: true, type: Google.Protobuf.Value)
|
|
340
|
end
|
added
lib/spawn/google/protobuf/timestamp.pb.ex
|
|
@@ -0,0 1,53 @@
|
|
1
|
defmodule Google.Protobuf.Timestamp do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [
|
|
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
14
|
__unknown_fields__: [],
|
|
15
|
default_value: nil,
|
|
16
|
extendee: nil,
|
|
17
|
json_name: "seconds",
|
|
18
|
label: :LABEL_OPTIONAL,
|
|
19
|
name: "seconds",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
23
|
proto3_optional: nil,
|
|
24
|
type: :TYPE_INT64,
|
|
25
|
type_name: nil
|
|
26
|
},
|
|
27
|
%Google.Protobuf.FieldDescriptorProto{
|
|
28
|
__unknown_fields__: [],
|
|
29
|
default_value: nil,
|
|
30
|
extendee: nil,
|
|
31
|
json_name: "nanos",
|
|
32
|
label: :LABEL_OPTIONAL,
|
|
33
|
name: "nanos",
|
|
34
|
number: 2,
|
|
35
|
oneof_index: nil,
|
|
36
|
options: nil,
|
|
37
|
proto3_optional: nil,
|
|
38
|
type: :TYPE_INT32,
|
|
39
|
type_name: nil
|
|
40
|
}
|
|
41
|
],
|
|
42
|
name: "Timestamp",
|
|
43
|
nested_type: [],
|
|
44
|
oneof_decl: [],
|
|
45
|
options: nil,
|
|
46
|
reserved_name: [],
|
|
47
|
reserved_range: []
|
|
48
|
}
|
|
49
|
end
|
|
50
|
|
|
51
|
field(:seconds, 1, type: :int64)
|
|
52
|
field(:nanos, 2, type: :int32)
|
|
53
|
end
|
added
lib/spawn/google/protobuf/wrappers.pb.ex
|
|
@@ -0,0 1,350 @@
|
|
1
|
defmodule Google.Protobuf.DoubleValue do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [
|
|
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
14
|
__unknown_fields__: [],
|
|
15
|
default_value: nil,
|
|
16
|
extendee: nil,
|
|
17
|
json_name: "value",
|
|
18
|
label: :LABEL_OPTIONAL,
|
|
19
|
name: "value",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
23
|
proto3_optional: nil,
|
|
24
|
type: :TYPE_DOUBLE,
|
|
25
|
type_name: nil
|
|
26
|
}
|
|
27
|
],
|
|
28
|
name: "DoubleValue",
|
|
29
|
nested_type: [],
|
|
30
|
oneof_decl: [],
|
|
31
|
options: nil,
|
|
32
|
reserved_name: [],
|
|
33
|
reserved_range: []
|
|
34
|
}
|
|
35
|
end
|
|
36
|
|
|
37
|
field(:value, 1, type: :double)
|
|
38
|
end
|
|
39
|
|
|
40
|
defmodule Google.Protobuf.FloatValue do
|
|
41
|
@moduledoc false
|
|
42
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
43
|
|
|
44
|
def descriptor do
|
|
45
|
# credo:disable-for-next-line
|
|
46
|
%Google.Protobuf.DescriptorProto{
|
|
47
|
__unknown_fields__: [],
|
|
48
|
enum_type: [],
|
|
49
|
extension: [],
|
|
50
|
extension_range: [],
|
|
51
|
field: [
|
|
52
|
%Google.Protobuf.FieldDescriptorProto{
|
|
53
|
__unknown_fields__: [],
|
|
54
|
default_value: nil,
|
|
55
|
extendee: nil,
|
|
56
|
json_name: "value",
|
|
57
|
label: :LABEL_OPTIONAL,
|
|
58
|
name: "value",
|
|
59
|
number: 1,
|
|
60
|
oneof_index: nil,
|
|
61
|
options: nil,
|
|
62
|
proto3_optional: nil,
|
|
63
|
type: :TYPE_FLOAT,
|
|
64
|
type_name: nil
|
|
65
|
}
|
|
66
|
],
|
|
67
|
name: "FloatValue",
|
|
68
|
nested_type: [],
|
|
69
|
oneof_decl: [],
|
|
70
|
options: nil,
|
|
71
|
reserved_name: [],
|
|
72
|
reserved_range: []
|
|
73
|
}
|
|
74
|
end
|
|
75
|
|
|
76
|
field(:value, 1, type: :float)
|
|
77
|
end
|
|
78
|
|
|
79
|
defmodule Google.Protobuf.Int64Value do
|
|
80
|
@moduledoc false
|
|
81
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
82
|
|
|
83
|
def descriptor do
|
|
84
|
# credo:disable-for-next-line
|
|
85
|
%Google.Protobuf.DescriptorProto{
|
|
86
|
__unknown_fields__: [],
|
|
87
|
enum_type: [],
|
|
88
|
extension: [],
|
|
89
|
extension_range: [],
|
|
90
|
field: [
|
|
91
|
%Google.Protobuf.FieldDescriptorProto{
|
|
92
|
__unknown_fields__: [],
|
|
93
|
default_value: nil,
|
|
94
|
extendee: nil,
|
|
95
|
json_name: "value",
|
|
96
|
label: :LABEL_OPTIONAL,
|
|
97
|
name: "value",
|
|
98
|
number: 1,
|
|
99
|
oneof_index: nil,
|
|
100
|
options: nil,
|
|
101
|
proto3_optional: nil,
|
|
102
|
type: :TYPE_INT64,
|
|
103
|
type_name: nil
|
|
104
|
}
|
|
105
|
],
|
|
106
|
name: "Int64Value",
|
|
107
|
nested_type: [],
|
|
108
|
oneof_decl: [],
|
|
109
|
options: nil,
|
|
110
|
reserved_name: [],
|
|
111
|
reserved_range: []
|
|
112
|
}
|
|
113
|
end
|
|
114
|
|
|
115
|
field(:value, 1, type: :int64)
|
|
116
|
end
|
|
117
|
|
|
118
|
defmodule Google.Protobuf.UInt64Value do
|
|
119
|
@moduledoc false
|
|
120
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
121
|
|
|
122
|
def descriptor do
|
|
123
|
# credo:disable-for-next-line
|
|
124
|
%Google.Protobuf.DescriptorProto{
|
|
125
|
__unknown_fields__: [],
|
|
126
|
enum_type: [],
|
|
127
|
extension: [],
|
|
128
|
extension_range: [],
|
|
129
|
field: [
|
|
130
|
%Google.Protobuf.FieldDescriptorProto{
|
|
131
|
__unknown_fields__: [],
|
|
132
|
default_value: nil,
|
|
133
|
extendee: nil,
|
|
134
|
json_name: "value",
|
|
135
|
label: :LABEL_OPTIONAL,
|
|
136
|
name: "value",
|
|
137
|
number: 1,
|
|
138
|
oneof_index: nil,
|
|
139
|
options: nil,
|
|
140
|
proto3_optional: nil,
|
|
141
|
type: :TYPE_UINT64,
|
|
142
|
type_name: nil
|
|
143
|
}
|
|
144
|
],
|
|
145
|
name: "UInt64Value",
|
|
146
|
nested_type: [],
|
|
147
|
oneof_decl: [],
|
|
148
|
options: nil,
|
|
149
|
reserved_name: [],
|
|
150
|
reserved_range: []
|
|
151
|
}
|
|
152
|
end
|
|
153
|
|
|
154
|
field(:value, 1, type: :uint64)
|
|
155
|
end
|
|
156
|
|
|
157
|
defmodule Google.Protobuf.Int32Value do
|
|
158
|
@moduledoc false
|
|
159
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
160
|
|
|
161
|
def descriptor do
|
|
162
|
# credo:disable-for-next-line
|
|
163
|
%Google.Protobuf.DescriptorProto{
|
|
164
|
__unknown_fields__: [],
|
|
165
|
enum_type: [],
|
|
166
|
extension: [],
|
|
167
|
extension_range: [],
|
|
168
|
field: [
|
|
169
|
%Google.Protobuf.FieldDescriptorProto{
|
|
170
|
__unknown_fields__: [],
|
|
171
|
default_value: nil,
|
|
172
|
extendee: nil,
|
|
173
|
json_name: "value",
|
|
174
|
label: :LABEL_OPTIONAL,
|
|
175
|
name: "value",
|
|
176
|
number: 1,
|
|
177
|
oneof_index: nil,
|
|
178
|
options: nil,
|
|
179
|
proto3_optional: nil,
|
|
180
|
type: :TYPE_INT32,
|
|
181
|
type_name: nil
|
|
182
|
}
|
|
183
|
],
|
|
184
|
name: "Int32Value",
|
|
185
|
nested_type: [],
|
|
186
|
oneof_decl: [],
|
|
187
|
options: nil,
|
|
188
|
reserved_name: [],
|
|
189
|
reserved_range: []
|
|
190
|
}
|
|
191
|
end
|
|
192
|
|
|
193
|
field(:value, 1, type: :int32)
|
|
194
|
end
|
|
195
|
|
|
196
|
defmodule Google.Protobuf.UInt32Value do
|
|
197
|
@moduledoc false
|
|
198
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
199
|
|
|
200
|
def descriptor do
|
|
201
|
# credo:disable-for-next-line
|
|
202
|
%Google.Protobuf.DescriptorProto{
|
|
203
|
__unknown_fields__: [],
|
|
204
|
enum_type: [],
|
|
205
|
extension: [],
|
|
206
|
extension_range: [],
|
|
207
|
field: [
|
|
208
|
%Google.Protobuf.FieldDescriptorProto{
|
|
209
|
__unknown_fields__: [],
|
|
210
|
default_value: nil,
|
|
211
|
extendee: nil,
|
|
212
|
json_name: "value",
|
|
213
|
label: :LABEL_OPTIONAL,
|
|
214
|
name: "value",
|
|
215
|
number: 1,
|
|
216
|
oneof_index: nil,
|
|
217
|
options: nil,
|
|
218
|
proto3_optional: nil,
|
|
219
|
type: :TYPE_UINT32,
|
|
220
|
type_name: nil
|
|
221
|
}
|
|
222
|
],
|
|
223
|
name: "UInt32Value",
|
|
224
|
nested_type: [],
|
|
225
|
oneof_decl: [],
|
|
226
|
options: nil,
|
|
227
|
reserved_name: [],
|
|
228
|
reserved_range: []
|
|
229
|
}
|
|
230
|
end
|
|
231
|
|
|
232
|
field(:value, 1, type: :uint32)
|
|
233
|
end
|
|
234
|
|
|
235
|
defmodule Google.Protobuf.BoolValue do
|
|
236
|
@moduledoc false
|
|
237
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
238
|
|
|
239
|
def descriptor do
|
|
240
|
# credo:disable-for-next-line
|
|
241
|
%Google.Protobuf.DescriptorProto{
|
|
242
|
__unknown_fields__: [],
|
|
243
|
enum_type: [],
|
|
244
|
extension: [],
|
|
245
|
extension_range: [],
|
|
246
|
field: [
|
|
247
|
%Google.Protobuf.FieldDescriptorProto{
|
|
248
|
__unknown_fields__: [],
|
|
249
|
default_value: nil,
|
|
250
|
extendee: nil,
|
|
251
|
json_name: "value",
|
|
252
|
label: :LABEL_OPTIONAL,
|
|
253
|
name: "value",
|
|
254
|
number: 1,
|
|
255
|
oneof_index: nil,
|
|
256
|
options: nil,
|
|
257
|
proto3_optional: nil,
|
|
258
|
type: :TYPE_BOOL,
|
|
259
|
type_name: nil
|
|
260
|
}
|
|
261
|
],
|
|
262
|
name: "BoolValue",
|
|
263
|
nested_type: [],
|
|
264
|
oneof_decl: [],
|
|
265
|
options: nil,
|
|
266
|
reserved_name: [],
|
|
267
|
reserved_range: []
|
|
268
|
}
|
|
269
|
end
|
|
270
|
|
|
271
|
field(:value, 1, type: :bool)
|
|
272
|
end
|
|
273
|
|
|
274
|
defmodule Google.Protobuf.StringValue do
|
|
275
|
@moduledoc false
|
|
276
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
277
|
|
|
278
|
def descriptor do
|
|
279
|
# credo:disable-for-next-line
|
|
280
|
%Google.Protobuf.DescriptorProto{
|
|
281
|
__unknown_fields__: [],
|
|
282
|
enum_type: [],
|
|
283
|
extension: [],
|
|
284
|
extension_range: [],
|
|
285
|
field: [
|
|
286
|
%Google.Protobuf.FieldDescriptorProto{
|
|
287
|
__unknown_fields__: [],
|
|
288
|
default_value: nil,
|
|
289
|
extendee: nil,
|
|
290
|
json_name: "value",
|
|
291
|
label: :LABEL_OPTIONAL,
|
|
292
|
name: "value",
|
|
293
|
number: 1,
|
|
294
|
oneof_index: nil,
|
|
295
|
options: nil,
|
|
296
|
proto3_optional: nil,
|
|
297
|
type: :TYPE_STRING,
|
|
298
|
type_name: nil
|
|
299
|
}
|
|
300
|
],
|
|
301
|
name: "StringValue",
|
|
302
|
nested_type: [],
|
|
303
|
oneof_decl: [],
|
|
304
|
options: nil,
|
|
305
|
reserved_name: [],
|
|
306
|
reserved_range: []
|
|
307
|
}
|
|
308
|
end
|
|
309
|
|
|
310
|
field(:value, 1, type: :string)
|
|
311
|
end
|
|
312
|
|
|
313
|
defmodule Google.Protobuf.BytesValue do
|
|
314
|
@moduledoc false
|
|
315
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
316
|
|
|
317
|
def descriptor do
|
|
318
|
# credo:disable-for-next-line
|
|
319
|
%Google.Protobuf.DescriptorProto{
|
|
320
|
__unknown_fields__: [],
|
|
321
|
enum_type: [],
|
|
322
|
extension: [],
|
|
323
|
extension_range: [],
|
|
324
|
field: [
|
|
325
|
%Google.Protobuf.FieldDescriptorProto{
|
|
326
|
__unknown_fields__: [],
|
|
327
|
default_value: nil,
|
|
328
|
extendee: nil,
|
|
329
|
json_name: "value",
|
|
330
|
label: :LABEL_OPTIONAL,
|
|
331
|
name: "value",
|
|
332
|
number: 1,
|
|
333
|
oneof_index: nil,
|
|
334
|
options: nil,
|
|
335
|
proto3_optional: nil,
|
|
336
|
type: :TYPE_BYTES,
|
|
337
|
type_name: nil
|
|
338
|
}
|
|
339
|
],
|
|
340
|
name: "BytesValue",
|
|
341
|
nested_type: [],
|
|
342
|
oneof_decl: [],
|
|
343
|
options: nil,
|
|
344
|
reserved_name: [],
|
|
345
|
reserved_range: []
|
|
346
|
}
|
|
347
|
end
|
|
348
|
|
|
349
|
field(:value, 1, type: :bytes)
|
|
350
|
end
|
added
lib/spawn/grpc/reflection/v1alpha/reflection.pb.ex
|
|
@@ -0,0 1,595 @@
|
|
1
|
defmodule Grpc.Reflection.V1alpha.ServerReflectionRequest do
|
|
2
|
@moduledoc false
|
|
3
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
4
|
|
|
5
|
def descriptor do
|
|
6
|
# credo:disable-for-next-line
|
|
7
|
%Google.Protobuf.DescriptorProto{
|
|
8
|
__unknown_fields__: [],
|
|
9
|
enum_type: [],
|
|
10
|
extension: [],
|
|
11
|
extension_range: [],
|
|
12
|
field: [
|
|
13
|
%Google.Protobuf.FieldDescriptorProto{
|
|
14
|
__unknown_fields__: [],
|
|
15
|
default_value: nil,
|
|
16
|
extendee: nil,
|
|
17
|
json_name: "host",
|
|
18
|
label: :LABEL_OPTIONAL,
|
|
19
|
name: "host",
|
|
20
|
number: 1,
|
|
21
|
oneof_index: nil,
|
|
22
|
options: nil,
|
|
23
|
proto3_optional: nil,
|
|
24
|
type: :TYPE_STRING,
|
|
25
|
type_name: nil
|
|
26
|
},
|
|
27
|
%Google.Protobuf.FieldDescriptorProto{
|
|
28
|
__unknown_fields__: [],
|
|
29
|
default_value: nil,
|
|
30
|
extendee: nil,
|
|
31
|
json_name: "fileByFilename",
|
|
32
|
label: :LABEL_OPTIONAL,
|
|
33
|
name: "file_by_filename",
|
|
34
|
number: 3,
|
|
35
|
oneof_index: 0,
|
|
36
|
options: nil,
|
|
37
|
proto3_optional: nil,
|
|
38
|
type: :TYPE_STRING,
|
|
39
|
type_name: nil
|
|
40
|
},
|
|
41
|
%Google.Protobuf.FieldDescriptorProto{
|
|
42
|
__unknown_fields__: [],
|
|
43
|
default_value: nil,
|
|
44
|
extendee: nil,
|
|
45
|
json_name: "fileContainingSymbol",
|
|
46
|
label: :LABEL_OPTIONAL,
|
|
47
|
name: "file_containing_symbol",
|
|
48
|
number: 4,
|
|
49
|
oneof_index: 0,
|
|
50
|
options: nil,
|
|
51
|
proto3_optional: nil,
|
|
52
|
type: :TYPE_STRING,
|
|
53
|
type_name: nil
|
|
54
|
},
|
|
55
|
%Google.Protobuf.FieldDescriptorProto{
|
|
56
|
__unknown_fields__: [],
|
|
57
|
default_value: nil,
|
|
58
|
extendee: nil,
|
|
59
|
json_name: "fileContainingExtension",
|
|
60
|
label: :LABEL_OPTIONAL,
|
|
61
|
name: "file_containing_extension",
|
|
62
|
number: 5,
|
|
63
|
oneof_index: 0,
|
|
64
|
options: nil,
|
|
65
|
proto3_optional: nil,
|
|
66
|
type: :TYPE_MESSAGE,
|
|
67
|
type_name: ".grpc.reflection.v1alpha.ExtensionRequest"
|
|
68
|
},
|
|
69
|
%Google.Protobuf.FieldDescriptorProto{
|
|
70
|
__unknown_fields__: [],
|
|
71
|
default_value: nil,
|
|
72
|
extendee: nil,
|
|
73
|
json_name: "allExtensionNumbersOfType",
|
|
74
|
label: :LABEL_OPTIONAL,
|
|
75
|
name: "all_extension_numbers_of_type",
|
|
76
|
number: 6,
|
|
77
|
oneof_index: 0,
|
|
78
|
options: nil,
|
|
79
|
proto3_optional: nil,
|
|
80
|
type: :TYPE_STRING,
|
|
81
|
type_name: nil
|
|
82
|
},
|
|
83
|
%Google.Protobuf.FieldDescriptorProto{
|
|
84
|
__unknown_fields__: [],
|
|
85
|
default_value: nil,
|
|
86
|
extendee: nil,
|
|
87
|
json_name: "listServices",
|
|
88
|
label: :LABEL_OPTIONAL,
|
|
89
|
name: "list_services",
|
|
90
|
number: 7,
|
|
91
|
oneof_index: 0,
|
|
92
|
options: nil,
|
|
93
|
proto3_optional: nil,
|
|
94
|
type: :TYPE_STRING,
|
|
95
|
type_name: nil
|
|
96
|
}
|
|
97
|
],
|
|
98
|
name: "ServerReflectionRequest",
|
|
99
|
nested_type: [],
|
|
100
|
oneof_decl: [
|
|
101
|
%Google.Protobuf.OneofDescriptorProto{
|
|
102
|
__unknown_fields__: [],
|
|
103
|
name: "message_request",
|
|
104
|
options: nil
|
|
105
|
}
|
|
106
|
],
|
|
107
|
options: nil,
|
|
108
|
reserved_name: [],
|
|
109
|
reserved_range: []
|
|
110
|
}
|
|
111
|
end
|
|
112
|
|
|
113
|
oneof(:message_request, 0)
|
|
114
|
|
|
115
|
field(:host, 1, type: :string)
|
|
116
|
field(:file_by_filename, 3, type: :string, json_name: "fileByFilename", oneof: 0)
|
|
117
|
field(:file_containing_symbol, 4, type: :string, json_name: "fileContainingSymbol", oneof: 0)
|
|
118
|
|
|
119
|
field(:file_containing_extension, 5,
|
|
120
|
type: Grpc.Reflection.V1alpha.ExtensionRequest,
|
|
121
|
json_name: "fileContainingExtension",
|
|
122
|
oneof: 0
|
|
123
|
)
|
|
124
|
|
|
125
|
field(:all_extension_numbers_of_type, 6,
|
|
126
|
type: :string,
|
|
127
|
json_name: "allExtensionNumbersOfType",
|
|
128
|
oneof: 0
|
|
129
|
)
|
|
130
|
|
|
131
|
field(:list_services, 7, type: :string, json_name: "listServices", oneof: 0)
|
|
132
|
end
|
|
133
|
|
|
134
|
defmodule Grpc.Reflection.V1alpha.ExtensionRequest do
|
|
135
|
@moduledoc false
|
|
136
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
137
|
|
|
138
|
def descriptor do
|
|
139
|
# credo:disable-for-next-line
|
|
140
|
%Google.Protobuf.DescriptorProto{
|
|
141
|
__unknown_fields__: [],
|
|
142
|
enum_type: [],
|
|
143
|
extension: [],
|
|
144
|
extension_range: [],
|
|
145
|
field: [
|
|
146
|
%Google.Protobuf.FieldDescriptorProto{
|
|
147
|
__unknown_fields__: [],
|
|
148
|
default_value: nil,
|
|
149
|
extendee: nil,
|
|
150
|
json_name: "containingType",
|
|
151
|
label: :LABEL_OPTIONAL,
|
|
152
|
name: "containing_type",
|
|
153
|
number: 1,
|
|
154
|
oneof_index: nil,
|
|
155
|
options: nil,
|
|
156
|
proto3_optional: nil,
|
|
157
|
type: :TYPE_STRING,
|
|
158
|
type_name: nil
|
|
159
|
},
|
|
160
|
%Google.Protobuf.FieldDescriptorProto{
|
|
161
|
__unknown_fields__: [],
|
|
162
|
default_value: nil,
|
|
163
|
extendee: nil,
|
|
164
|
json_name: "extensionNumber",
|
|
165
|
label: :LABEL_OPTIONAL,
|
|
166
|
name: "extension_number",
|
|
167
|
number: 2,
|
|
168
|
oneof_index: nil,
|
|
169
|
options: nil,
|
|
170
|
proto3_optional: nil,
|
|
171
|
type: :TYPE_INT32,
|
|
172
|
type_name: nil
|
|
173
|
}
|
|
174
|
],
|
|
175
|
name: "ExtensionRequest",
|
|
176
|
nested_type: [],
|
|
177
|
oneof_decl: [],
|
|
178
|
options: nil,
|
|
179
|
reserved_name: [],
|
|
180
|
reserved_range: []
|
|
181
|
}
|
|
182
|
end
|
|
183
|
|
|
184
|
field(:containing_type, 1, type: :string, json_name: "containingType")
|
|
185
|
field(:extension_number, 2, type: :int32, json_name: "extensionNumber")
|
|
186
|
end
|
|
187
|
|
|
188
|
defmodule Grpc.Reflection.V1alpha.ServerReflectionResponse do
|
|
189
|
@moduledoc false
|
|
190
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
191
|
|
|
192
|
def descriptor do
|
|
193
|
# credo:disable-for-next-line
|
|
194
|
%Google.Protobuf.DescriptorProto{
|
|
195
|
__unknown_fields__: [],
|
|
196
|
enum_type: [],
|
|
197
|
extension: [],
|
|
198
|
extension_range: [],
|
|
199
|
field: [
|
|
200
|
%Google.Protobuf.FieldDescriptorProto{
|
|
201
|
__unknown_fields__: [],
|
|
202
|
default_value: nil,
|
|
203
|
extendee: nil,
|
|
204
|
json_name: "validHost",
|
|
205
|
label: :LABEL_OPTIONAL,
|
|
206
|
name: "valid_host",
|
|
207
|
number: 1,
|
|
208
|
oneof_index: nil,
|
|
209
|
options: nil,
|
|
210
|
proto3_optional: nil,
|
|
211
|
type: :TYPE_STRING,
|
|
212
|
type_name: nil
|
|
213
|
},
|
|
214
|
%Google.Protobuf.FieldDescriptorProto{
|
|
215
|
__unknown_fields__: [],
|
|
216
|
default_value: nil,
|
|
217
|
extendee: nil,
|
|
218
|
json_name: "originalRequest",
|
|
219
|
label: :LABEL_OPTIONAL,
|
|
220
|
name: "original_request",
|
|
221
|
number: 2,
|
|
222
|
oneof_index: nil,
|
|
223
|
options: nil,
|
|
224
|
proto3_optional: nil,
|
|
225
|
type: :TYPE_MESSAGE,
|
|
226
|
type_name: ".grpc.reflection.v1alpha.ServerReflectionRequest"
|
|
227
|
},
|
|
228
|
%Google.Protobuf.FieldDescriptorProto{
|
|
229
|
__unknown_fields__: [],
|
|
230
|
default_value: nil,
|
|
231
|
extendee: nil,
|
|
232
|
json_name: "fileDescriptorResponse",
|
|
233
|
label: :LABEL_OPTIONAL,
|
|
234
|
name: "file_descriptor_response",
|
|
235
|
number: 4,
|
|
236
|
oneof_index: 0,
|
|
237
|
options: nil,
|
|
238
|
proto3_optional: nil,
|
|
239
|
type: :TYPE_MESSAGE,
|
|
240
|
type_name: ".grpc.reflection.v1alpha.FileDescriptorResponse"
|
|
241
|
},
|
|
242
|
%Google.Protobuf.FieldDescriptorProto{
|
|
243
|
__unknown_fields__: [],
|
|
244
|
default_value: nil,
|
|
245
|
extendee: nil,
|
|
246
|
json_name: "allExtensionNumbersResponse",
|
|
247
|
label: :LABEL_OPTIONAL,
|
|
248
|
name: "all_extension_numbers_response",
|
|
249
|
number: 5,
|
|
250
|
oneof_index: 0,
|
|
251
|
options: nil,
|
|
252
|
proto3_optional: nil,
|
|
253
|
type: :TYPE_MESSAGE,
|
|
254
|
type_name: ".grpc.reflection.v1alpha.ExtensionNumberResponse"
|
|
255
|
},
|
|
256
|
%Google.Protobuf.FieldDescriptorProto{
|
|
257
|
__unknown_fields__: [],
|
|
258
|
default_value: nil,
|
|
259
|
extendee: nil,
|
|
260
|
json_name: "listServicesResponse",
|
|
261
|
label: :LABEL_OPTIONAL,
|
|
262
|
name: "list_services_response",
|
|
263
|
number: 6,
|
|
264
|
oneof_index: 0,
|
|
265
|
options: nil,
|
|
266
|
proto3_optional: nil,
|
|
267
|
type: :TYPE_MESSAGE,
|
|
268
|
type_name: ".grpc.reflection.v1alpha.ListServiceResponse"
|
|
269
|
},
|
|
270
|
%Google.Protobuf.FieldDescriptorProto{
|
|
271
|
__unknown_fields__: [],
|
|
272
|
default_value: nil,
|
|
273
|
extendee: nil,
|
|
274
|
json_name: "errorResponse",
|
|
275
|
label: :LABEL_OPTIONAL,
|
|
276
|
name: "error_response",
|
|
277
|
number: 7,
|
|
278
|
oneof_index: 0,
|
|
279
|
options: nil,
|
|
280
|
proto3_optional: nil,
|
|
281
|
type: :TYPE_MESSAGE,
|
|
282
|
type_name: ".grpc.reflection.v1alpha.ErrorResponse"
|
|
283
|
}
|
|
284
|
],
|
|
285
|
name: "ServerReflectionResponse",
|
|
286
|
nested_type: [],
|
|
287
|
oneof_decl: [
|
|
288
|
%Google.Protobuf.OneofDescriptorProto{
|
|
289
|
__unknown_fields__: [],
|
|
290
|
name: "message_response",
|
|
291
|
options: nil
|
|
292
|
}
|
|
293
|
],
|
|
294
|
options: nil,
|
|
295
|
reserved_name: [],
|
|
296
|
reserved_range: []
|
|
297
|
}
|
|
298
|
end
|
|
299
|
|
|
300
|
oneof(:message_response, 0)
|
|
301
|
|
|
302
|
field(:valid_host, 1, type: :string, json_name: "validHost")
|
|
303
|
|
|
304
|
field(:original_request, 2,
|
|
305
|
type: Grpc.Reflection.V1alpha.ServerReflectionRequest,
|
|
306
|
json_name: "originalRequest"
|
|
307
|
)
|
|
308
|
|
|
309
|
field(:file_descriptor_response, 4,
|
|
310
|
type: Grpc.Reflection.V1alpha.FileDescriptorResponse,
|
|
311
|
json_name: "fileDescriptorResponse",
|
|
312
|
oneof: 0
|
|
313
|
)
|
|
314
|
|
|
315
|
field(:all_extension_numbers_response, 5,
|
|
316
|
type: Grpc.Reflection.V1alpha.ExtensionNumberResponse,
|
|
317
|
json_name: "allExtensionNumbersResponse",
|
|
318
|
oneof: 0
|
|
319
|
)
|
|
320
|
|
|
321
|
field(:list_services_response, 6,
|
|
322
|
type: Grpc.Reflection.V1alpha.ListServiceResponse,
|
|
323
|
json_name: "listServicesResponse",
|
|
324
|
oneof: 0
|
|
325
|
)
|
|
326
|
|
|
327
|
field(:error_response, 7,
|
|
328
|
type: Grpc.Reflection.V1alpha.ErrorResponse,
|
|
329
|
json_name: "errorResponse",
|
|
330
|
oneof: 0
|
|
331
|
)
|
|
332
|
end
|
|
333
|
|
|
334
|
defmodule Grpc.Reflection.V1alpha.FileDescriptorResponse do
|
|
335
|
@moduledoc false
|
|
336
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
337
|
|
|
338
|
def descriptor do
|
|
339
|
# credo:disable-for-next-line
|
|
340
|
%Google.Protobuf.DescriptorProto{
|
|
341
|
__unknown_fields__: [],
|
|
342
|
enum_type: [],
|
|
343
|
extension: [],
|
|
344
|
extension_range: [],
|
|
345
|
field: [
|
|
346
|
%Google.Protobuf.FieldDescriptorProto{
|
|
347
|
__unknown_fields__: [],
|
|
348
|
default_value: nil,
|
|
349
|
extendee: nil,
|
|
350
|
json_name: "fileDescriptorProto",
|
|
351
|
label: :LABEL_REPEATED,
|
|
352
|
name: "file_descriptor_proto",
|
|
353
|
number: 1,
|
|
354
|
oneof_index: nil,
|
|
355
|
options: nil,
|
|
356
|
proto3_optional: nil,
|
|
357
|
type: :TYPE_BYTES,
|
|
358
|
type_name: nil
|
|
359
|
}
|
|
360
|
],
|
|
361
|
name: "FileDescriptorResponse",
|
|
362
|
nested_type: [],
|
|
363
|
oneof_decl: [],
|
|
364
|
options: nil,
|
|
365
|
reserved_name: [],
|
|
366
|
reserved_range: []
|
|
367
|
}
|
|
368
|
end
|
|
369
|
|
|
370
|
field(:file_descriptor_proto, 1, repeated: true, type: :bytes, json_name: "fileDescriptorProto")
|
|
371
|
end
|
|
372
|
|
|
373
|
defmodule Grpc.Reflection.V1alpha.ExtensionNumberResponse do
|
|
374
|
@moduledoc false
|
|
375
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
376
|
|
|
377
|
def descriptor do
|
|
378
|
# credo:disable-for-next-line
|
|
379
|
%Google.Protobuf.DescriptorProto{
|
|
380
|
__unknown_fields__: [],
|
|
381
|
enum_type: [],
|
|
382
|
extension: [],
|
|
383
|
extension_range: [],
|
|
384
|
field: [
|
|
385
|
%Google.Protobuf.FieldDescriptorProto{
|
|
386
|
__unknown_fields__: [],
|
|
387
|
default_value: nil,
|
|
388
|
extendee: nil,
|
|
389
|
json_name: "baseTypeName",
|
|
390
|
label: :LABEL_OPTIONAL,
|
|
391
|
name: "base_type_name",
|
|
392
|
number: 1,
|
|
393
|
oneof_index: nil,
|
|
394
|
options: nil,
|
|
395
|
proto3_optional: nil,
|
|
396
|
type: :TYPE_STRING,
|
|
397
|
type_name: nil
|
|
398
|
},
|
|
399
|
%Google.Protobuf.FieldDescriptorProto{
|
|
400
|
__unknown_fields__: [],
|
|
401
|
default_value: nil,
|
|
402
|
extendee: nil,
|
|
403
|
json_name: "extensionNumber",
|
|
404
|
label: :LABEL_REPEATED,
|
|
405
|
name: "extension_number",
|
|
406
|
number: 2,
|
|
407
|
oneof_index: nil,
|
|
408
|
options: nil,
|
|
409
|
proto3_optional: nil,
|
|
410
|
type: :TYPE_INT32,
|
|
411
|
type_name: nil
|
|
412
|
}
|
|
413
|
],
|
|
414
|
name: "ExtensionNumberResponse",
|
|
415
|
nested_type: [],
|
|
416
|
oneof_decl: [],
|
|
417
|
options: nil,
|
|
418
|
reserved_name: [],
|
|
419
|
reserved_range: []
|
|
420
|
}
|
|
421
|
end
|
|
422
|
|
|
423
|
field(:base_type_name, 1, type: :string, json_name: "baseTypeName")
|
|
424
|
field(:extension_number, 2, repeated: true, type: :int32, json_name: "extensionNumber")
|
|
425
|
end
|
|
426
|
|
|
427
|
defmodule Grpc.Reflection.V1alpha.ListServiceResponse do
|
|
428
|
@moduledoc false
|
|
429
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
430
|
|
|
431
|
def descriptor do
|
|
432
|
# credo:disable-for-next-line
|
|
433
|
%Google.Protobuf.DescriptorProto{
|
|
434
|
__unknown_fields__: [],
|
|
435
|
enum_type: [],
|
|
436
|
extension: [],
|
|
437
|
extension_range: [],
|
|
438
|
field: [
|
|
439
|
%Google.Protobuf.FieldDescriptorProto{
|
|
440
|
__unknown_fields__: [],
|
|
441
|
default_value: nil,
|
|
442
|
extendee: nil,
|
|
443
|
json_name: "service",
|
|
444
|
label: :LABEL_REPEATED,
|
|
445
|
name: "service",
|
|
446
|
number: 1,
|
|
447
|
oneof_index: nil,
|
|
448
|
options: nil,
|
|
449
|
proto3_optional: nil,
|
|
450
|
type: :TYPE_MESSAGE,
|
|
451
|
type_name: ".grpc.reflection.v1alpha.ServiceResponse"
|
|
452
|
}
|
|
453
|
],
|
|
454
|
name: "ListServiceResponse",
|
|
455
|
nested_type: [],
|
|
456
|
oneof_decl: [],
|
|
457
|
options: nil,
|
|
458
|
reserved_name: [],
|
|
459
|
reserved_range: []
|
|
460
|
}
|
|
461
|
end
|
|
462
|
|
|
463
|
field(:service, 1, repeated: true, type: Grpc.Reflection.V1alpha.ServiceResponse)
|
|
464
|
end
|
|
465
|
|
|
466
|
defmodule Grpc.Reflection.V1alpha.ServiceResponse do
|
|
467
|
@moduledoc false
|
|
468
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
469
|
|
|
470
|
def descriptor do
|
|
471
|
# credo:disable-for-next-line
|
|
472
|
%Google.Protobuf.DescriptorProto{
|
|
473
|
__unknown_fields__: [],
|
|
474
|
enum_type: [],
|
|
475
|
extension: [],
|
|
476
|
extension_range: [],
|
|
477
|
field: [
|
|
478
|
%Google.Protobuf.FieldDescriptorProto{
|
|
479
|
__unknown_fields__: [],
|
|
480
|
default_value: nil,
|
|
481
|
extendee: nil,
|
|
482
|
json_name: "name",
|
|
483
|
label: :LABEL_OPTIONAL,
|
|
484
|
name: "name",
|
|
485
|
number: 1,
|
|
486
|
oneof_index: nil,
|
|
487
|
options: nil,
|
|
488
|
proto3_optional: nil,
|
|
489
|
type: :TYPE_STRING,
|
|
490
|
type_name: nil
|
|
491
|
}
|
|
492
|
],
|
|
493
|
name: "ServiceResponse",
|
|
494
|
nested_type: [],
|
|
495
|
oneof_decl: [],
|
|
496
|
options: nil,
|
|
497
|
reserved_name: [],
|
|
498
|
reserved_range: []
|
|
499
|
}
|
|
500
|
end
|
|
501
|
|
|
502
|
field(:name, 1, type: :string)
|
|
503
|
end
|
|
504
|
|
|
505
|
defmodule Grpc.Reflection.V1alpha.ErrorResponse do
|
|
506
|
@moduledoc false
|
|
507
|
use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3
|
|
508
|
|
|
509
|
def descriptor do
|
|
510
|
# credo:disable-for-next-line
|
|
511
|
%Google.Protobuf.DescriptorProto{
|
|
512
|
__unknown_fields__: [],
|
|
513
|
enum_type: [],
|
|
514
|
extension: [],
|
|
515
|
extension_range: [],
|
|
516
|
field: [
|
|
517
|
%Google.Protobuf.FieldDescriptorProto{
|
|
518
|
__unknown_fields__: [],
|
|
519
|
default_value: nil,
|
|
520
|
extendee: nil,
|
|
521
|
json_name: "errorCode",
|
|
522
|
label: :LABEL_OPTIONAL,
|
|
523
|
name: "error_code",
|
|
524
|
number: 1,
|
|
525
|
oneof_index: nil,
|
|
526
|
options: nil,
|
|
527
|
proto3_optional: nil,
|
|
528
|
type: :TYPE_INT32,
|
|
529
|
type_name: nil
|
|
530
|
},
|
|
531
|
%Google.Protobuf.FieldDescriptorProto{
|
|
532
|
__unknown_fields__: [],
|
|
533
|
default_value: nil,
|
|
534
|
extendee: nil,
|
|
535
|
json_name: "errorMessage",
|
|
536
|
label: :LABEL_OPTIONAL,
|
|
537
|
name: "error_message",
|
|
538
|
number: 2,
|
|
539
|
oneof_index: nil,
|
|
540
|
options: nil,
|
|
541
|
proto3_optional: nil,
|
|
542
|
type: :TYPE_STRING,
|
|
543
|
type_name: nil
|
|
544
|
}
|
|
545
|
],
|
|
546
|
name: "ErrorResponse",
|
|
547
|
nested_type: [],
|
|
548
|
oneof_decl: [],
|
|
549
|
options: nil,
|
|
550
|
reserved_name: [],
|
|
551
|
reserved_range: []
|
|
552
|
}
|
|
553
|
end
|
|
554
|
|
|
555
|
field(:error_code, 1, type: :int32, json_name: "errorCode")
|
|
556
|
field(:error_message, 2, type: :string, json_name: "errorMessage")
|
|
557
|
end
|
|
558
|
|
|
559
|
defmodule Grpc.Reflection.V1alpha.ServerReflection.Service do
|
|
560
|
@moduledoc false
|
|
561
|
use GRPC.Service,
|
|
562
|
name: "grpc.reflection.v1alpha.ServerReflection",
|
|
563
|
protoc_gen_elixir_version: "0.10.0"
|
|
564
|
|
|
565
|
def descriptor do
|
|
566
|
# credo:disable-for-next-line
|
|
567
|
%Google.Protobuf.ServiceDescriptorProto{
|
|
568
|
__unknown_fields__: [],
|
|
569
|
method: [
|
|
570
|
%Google.Protobuf.MethodDescriptorProto{
|
|
571
|
__unknown_fields__: [],
|
|
572
|
client_streaming: true,
|
|
573
|
input_type: ".grpc.reflection.v1alpha.ServerReflectionRequest",
|
|
574
|
name: "ServerReflectionInfo",
|
|
575
|
options: nil,
|
|
576
|
output_type: ".grpc.reflection.v1alpha.ServerReflectionResponse",
|
|
577
|
server_streaming: true
|
|
578
|
}
|
|
579
|
],
|
|
580
|
name: "ServerReflection",
|
|
581
|
options: nil
|
|
582
|
}
|
|
583
|
end
|
|
584
|
|
|
585
|
rpc(
|
|
586
|
:ServerReflectionInfo,
|
|
587
|
stream(Grpc.Reflection.V1alpha.ServerReflectionRequest),
|
|
588
|
stream(Grpc.Reflection.V1alpha.ServerReflectionResponse)
|
|
589
|
)
|
|
590
|
end
|
|
591
|
|
|
592
|
defmodule Grpc.Reflection.V1alpha.ServerReflection.Stub do
|
|
593
|
@moduledoc false
|
|
863
|
use GRPC.Stub, service: Grpc.Reflection.V1alpha.ServerReflection.Service
|
|
595
|
end
|
changed
lib/spawn/utils/any_serializer.ex
|
|
@@ -24,6 24,8 @@ defmodule Spawn.Utils.AnySerializer do
|
|
24
24
|
|> maybe_unpack_json!
|
|
25
25
|
end
|
|
26
26
|
|
|
27
|
def unpack_unknown(_), do: nil
|
|
28
|
|
|
27
29
|
defp normalize_package_name(type_url) do
|
|
28
30
|
type_url
|
|
29
31
|
|> String.replace("type.googleapis.com/", "")
|
|
|
@@ -49,8 51,6 @@ defmodule Spawn.Utils.AnySerializer do
|
|
49
51
|
end
|
|
50
52
|
end
|
|
51
53
|
|
|
52
|
- def unpack_unknown(_), do: nil
|
|
53
|
-
|
|
54
54
|
defp maybe_unpack_json!(%JSONType{} = json) do
|
|
55
55
|
Jason.decode!(json.content, keys: :atoms)
|
|
56
56
|
end
|
changed
mix.exs
|
|
@@ -4,7 4,7 @@ defmodule Spawn.MixProject do
|
|
4
4
|
Code.require_file("internal_versions.exs", "./priv")
|
|
5
5
|
|
|
6
6
|
@app :spawn
|
|
7
|
- @version "1.3.3"
|
|
7
|
@version "1.4.0"
|
|
8
8
|
@site "https://eigr.io/"
|
|
9
9
|
@source_url "https://github.com/eigr/spawn"
|
|
10
10
|
|
|
|
@@ -75,8 75,11 @@ defmodule Spawn.MixProject do
|
|
75
75
|
{:shards, "~> 1.1"},
|
|
76
76
|
{:telemetry, "~> 1.0"},
|
|
77
77
|
{:castore, "~> 1.0"},
|
|
78
|
- {:protobuf, "~> 0.11"},
|
|
79
|
- {:finch, "~> 0.16"},
|
|
78
|
{:protobuf, "~> 0.12"},
|
|
79
|
{:protobuf_generate, "~> 0.1"},
|
|
80
|
{:grpc, "~> 0.8"},
|
|
81
|
{:grpc_reflection, "~> 0.1"},
|
|
82
|
{:finch, "~> 0.18"},
|
|
80
83
|
{:retry, "~> 0.17"},
|
|
81
84
|
{:flow, "~> 1.2"},
|
|
82
85
|
{:libcluster, "~> 3.3"},
|
|
|
@@ -88,6 91,8 @@ defmodule Spawn.MixProject do
|
|
88
91
|
{:gnat, "~> 1.7"},
|
|
89
92
|
{:k8s, "~> 2.2"},
|
|
90
93
|
{:k8s_webhoox, "~> 0.2"},
|
|
94
|
# temporary until bandit releases 1.5.4
|
|
95
|
{:hpax, "~> 0.1.1"},
|
|
91
96
|
# Metrics & Tracing deps
|
|
92
97
|
{:telemetry_poller, "~> 1.0"},
|
|
93
98
|
{:telemetry_metrics, "~> 1.0"},
|
|
|
@@ -96,13 101,13 @@ defmodule Spawn.MixProject do
|
|
96
101
|
{:opentelemetry, "~> 1.0"},
|
|
97
102
|
{:opentelemetry_exporter, "~> 1.0"},
|
|
98
103
|
# Statestores deps
|
|
99
|
- {:spawn_statestores_mssql, "1.3.3", optional: true},
|
|
100
|
- {:spawn_statestores_mariadb, "1.3.3", optional: true},
|
|
101
|
- {:spawn_statestores_mysql, "1.3.3", optional: true},
|
|
102
|
- {:spawn_statestores_postgres, "1.3.3", optional: true},
|
|
103
|
- {:spawn_statestores_sqlite, "1.3.3", optional: true},
|
|
104
|
- {:spawn_statestores_cockroachdb, "1.3.3", optional: true},
|
|
105
|
- {:spawn_statestores_native, "1.3.3", optional: true},
|
|
104
|
{:spawn_statestores_mssql, "1.4.0", optional: true},
|
|
105
|
{:spawn_statestores_mariadb, "1.4.0", optional: true},
|
|
106
|
{:spawn_statestores_mysql, "1.4.0", optional: true},
|
|
107
|
{:spawn_statestores_postgres, "1.4.0", optional: true},
|
|
108
|
{:spawn_statestores_sqlite, "1.4.0", optional: true},
|
|
109
|
{:spawn_statestores_cockroachdb, "1.4.0", optional: true},
|
|
110
|
{:spawn_statestores_native, "1.4.0", optional: true},
|
|
106
111
|
{:pluggable, "~> 1.0"},
|
|
107
112
|
# Non runtime deps
|
|
108
113
|
{:credo, "~> 1.6", only: [:dev, :test], runtime: false},
|
changed
priv/internal_versions.exs
|
|
@@ -1,24 1,24 @@
|
|
1
1
|
defmodule InternalVersions do
|
|
2
2
|
# The order here is also the deploy order, its important to keep this way
|
|
3
3
|
@versions [
|
|
4
|
- spawn_statestores: "1.3.3",
|
|
5
|
- spawn_statestores_mariadb: "1.3.3",
|
|
6
|
- spawn_statestores_mysql: "1.3.3",
|
|
7
|
- spawn_statestores_mssql: "1.3.3",
|
|
8
|
- spawn_statestores_native: "1.3.3",
|
|
9
|
- spawn_statestores_postgres: "1.3.3",
|
|
10
|
- spawn_statestores_sqlite: "1.3.3",
|
|
11
|
- spawn_statestores_cockroachdb: "1.3.3",
|
|
12
|
- spawn: "1.3.3",
|
|
13
|
- spawn_sdk: "1.3.3",
|
|
14
|
- activator: "1.3.3",
|
|
15
|
- activator_api: "1.3.3",
|
|
16
|
- activator_kafka: "1.3.3",
|
|
17
|
- activator_pubsub: "1.3.3",
|
|
18
|
- activator_rabbitmq: "1.3.3",
|
|
19
|
- activator_sqs: "1.3.3",
|
|
20
|
- proxy: "1.3.3",
|
|
21
|
- spawn_operator: "1.3.3"
|
|
4
|
spawn_statestores: "1.4.0",
|
|
5
|
spawn_statestores_mariadb: "1.4.0",
|
|
6
|
spawn_statestores_mysql: "1.4.0",
|
|
7
|
spawn_statestores_mssql: "1.4.0",
|
|
8
|
spawn_statestores_native: "1.4.0",
|
|
9
|
spawn_statestores_postgres: "1.4.0",
|
|
10
|
spawn_statestores_sqlite: "1.4.0",
|
|
11
|
spawn_statestores_cockroachdb: "1.4.0",
|
|
12
|
spawn: "1.4.0",
|
|
13
|
spawn_sdk: "1.4.0",
|
|
14
|
activator: "1.4.0",
|
|
15
|
activator_api: "1.4.0",
|
|
16
|
activator_kafka: "1.4.0",
|
|
17
|
activator_pubsub: "1.4.0",
|
|
18
|
activator_rabbitmq: "1.4.0",
|
|
19
|
activator_sqs: "1.4.0",
|
|
20
|
proxy: "1.4.0",
|
|
21
|
spawn_operator: "1.4.0"
|
|
22
22
|
]
|
|
23
23
|
|
|
24
24
|
@doc """
|
changed
priv/protos/eigr/functions/protocol/actors/actor.proto
|
|
@@ -7,6 7,7 @@ import "google/protobuf/any.proto";
|
|
7
7
|
option java_package = "io.eigr.functions.protocol.actors";
|
|
8
8
|
option go_package = "github.com/eigr/go-support/eigr/actors;actors";
|
|
9
9
|
|
|
10
|
|
|
10
11
|
message Registry {
|
|
11
12
|
map<string, Actor> actors = 1;
|
|
12
13
|
}
|
added
priv/protos/eigr/functions/protocol/actors/extensions.proto
|
|
@@ -0,0 1,9 @@
|
|
1
|
syntax = "proto3";
|
|
2
|
|
|
3
|
package eigr.functions.protocol.actors;
|
|
4
|
|
|
5
|
import "google/protobuf/descriptor.proto";
|
|
6
|
|
|
7
|
extend google.protobuf.FieldOptions {
|
|
8
|
bool actor_id = 9999;
|
|
9
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/eigr/functions/protocol/actors/healthcheck.proto
|
|
@@ -0,0 1,36 @@
|
|
1
|
syntax = "proto3";
|
|
2
|
|
|
3
|
option objc_class_prefix = "HLW";
|
|
4
|
|
|
5
|
import "google/api/annotations.proto";
|
|
6
|
import "google/protobuf/empty.proto";
|
|
7
|
import "google/protobuf/timestamp.proto";
|
|
8
|
import "eigr/functions/protocol/actors/extensions.proto";
|
|
9
|
|
|
10
|
package eigr.functions.protocol.actors.healthcheck;
|
|
11
|
|
|
12
|
message Status {
|
|
13
|
string status = 1;
|
|
14
|
string details = 2;
|
|
15
|
google.protobuf.Timestamp updated_at = 3;
|
|
16
|
}
|
|
17
|
|
|
18
|
// The state of HealthCheckActor
|
|
19
|
message HealthCheckReply { Status status = 1; }
|
|
20
|
|
|
21
|
// The HealthCheck actor service definition.
|
|
22
|
service HealthCheckActor {
|
|
23
|
|
|
24
|
// Get Pong Message
|
|
25
|
rpc Liveness(google.protobuf.Empty) returns (HealthCheckReply) {
|
|
26
|
option (google.api.http) = {
|
|
27
|
get : "/health/liveness"
|
|
28
|
};
|
|
29
|
}
|
|
30
|
|
|
31
|
rpc Readiness(google.protobuf.Empty) returns (HealthCheckReply) {
|
|
32
|
option (google.api.http) = {
|
|
33
|
get : "/health/readiness"
|
|
34
|
};
|
|
35
|
}
|
|
36
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/google/api/annotations.proto
|
|
@@ -0,0 1,31 @@
|
|
1
|
// Copyright 2015 Google LLC
|
|
2
|
//
|
|
3
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
4
|
// you may not use this file except in compliance with the License.
|
|
5
|
// You may obtain a copy of the License at
|
|
6
|
//
|
|
7
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
8
|
//
|
|
9
|
// Unless required by applicable law or agreed to in writing, software
|
|
10
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
11
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
12
|
// See the License for the specific language governing permissions and
|
|
13
|
// limitations under the License.
|
|
14
|
|
|
15
|
syntax = "proto3";
|
|
16
|
|
|
17
|
package google.api;
|
|
18
|
|
|
19
|
import "google/api/http.proto";
|
|
20
|
import "google/protobuf/descriptor.proto";
|
|
21
|
|
|
22
|
option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
|
|
23
|
option java_multiple_files = true;
|
|
24
|
option java_outer_classname = "AnnotationsProto";
|
|
25
|
option java_package = "com.google.api";
|
|
26
|
option objc_class_prefix = "GAPI";
|
|
27
|
|
|
28
|
extend google.protobuf.MethodOptions {
|
|
29
|
// See `HttpRule`.
|
|
30
|
HttpRule http = 72295728;
|
|
31
|
}
|
added
priv/protos/google/api/http.proto
|
|
@@ -0,0 1,375 @@
|
|
1
|
// Copyright 2015 Google LLC
|
|
2
|
//
|
|
3
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
4
|
// you may not use this file except in compliance with the License.
|
|
5
|
// You may obtain a copy of the License at
|
|
6
|
//
|
|
7
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
8
|
//
|
|
9
|
// Unless required by applicable law or agreed to in writing, software
|
|
10
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
11
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
12
|
// See the License for the specific language governing permissions and
|
|
13
|
// limitations under the License.
|
|
14
|
|
|
15
|
syntax = "proto3";
|
|
16
|
|
|
17
|
package google.api;
|
|
18
|
|
|
19
|
option cc_enable_arenas = true;
|
|
20
|
option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
|
|
21
|
option java_multiple_files = true;
|
|
22
|
option java_outer_classname = "HttpProto";
|
|
23
|
option java_package = "com.google.api";
|
|
24
|
option objc_class_prefix = "GAPI";
|
|
25
|
|
|
26
|
// Defines the HTTP configuration for an API service. It contains a list of
|
|
27
|
// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
|
|
28
|
// to one or more HTTP REST API methods.
|
|
29
|
message Http {
|
|
30
|
// A list of HTTP configuration rules that apply to individual API methods.
|
|
31
|
//
|
|
32
|
// **NOTE:** All service configuration rules follow "last one wins" order.
|
|
33
|
repeated HttpRule rules = 1;
|
|
34
|
|
|
35
|
// When set to true, URL path parameters will be fully URI-decoded except in
|
|
36
|
// cases of single segment matches in reserved expansion, where "/" will be
|
|
37
|
// left encoded.
|
|
38
|
//
|
|
39
|
// The default behavior is to not decode RFC 6570 reserved characters in multi
|
|
40
|
// segment matches.
|
|
41
|
bool fully_decode_reserved_expansion = 2;
|
|
42
|
}
|
|
43
|
|
|
44
|
// # gRPC Transcoding
|
|
45
|
//
|
|
46
|
// gRPC Transcoding is a feature for mapping between a gRPC method and one or
|
|
47
|
// more HTTP REST endpoints. It allows developers to build a single API service
|
|
48
|
// that supports both gRPC APIs and REST APIs. Many systems, including [Google
|
|
49
|
// APIs](https://github.com/googleapis/googleapis),
|
|
50
|
// [Cloud Endpoints](https://cloud.google.com/endpoints), [gRPC
|
|
51
|
// Gateway](https://github.com/grpc-ecosystem/grpc-gateway),
|
|
52
|
// and [Envoy](https://github.com/envoyproxy/envoy) proxy support this feature
|
|
53
|
// and use it for large scale production services.
|
|
54
|
//
|
|
55
|
// `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies
|
|
56
|
// how different portions of the gRPC request message are mapped to the URL
|
|
57
|
// path, URL query parameters, and HTTP request body. It also controls how the
|
|
58
|
// gRPC response message is mapped to the HTTP response body. `HttpRule` is
|
|
59
|
// typically specified as an `google.api.http` annotation on the gRPC method.
|
|
60
|
//
|
|
61
|
// Each mapping specifies a URL path template and an HTTP method. The path
|
|
62
|
// template may refer to one or more fields in the gRPC request message, as long
|
|
63
|
// as each field is a non-repeated field with a primitive (non-message) type.
|
|
64
|
// The path template controls how fields of the request message are mapped to
|
|
65
|
// the URL path.
|
|
66
|
//
|
|
67
|
// Example:
|
|
68
|
//
|
|
69
|
// service Messaging {
|
|
70
|
// rpc GetMessage(GetMessageRequest) returns (Message) {
|
|
71
|
// option (google.api.http) = {
|
|
72
|
// get: "/v1/{name=messages/*}"
|
|
73
|
// };
|
|
74
|
// }
|
|
75
|
// }
|
|
76
|
// message GetMessageRequest {
|
|
77
|
// string name = 1; // Mapped to URL path.
|
|
78
|
// }
|
|
79
|
// message Message {
|
|
80
|
// string text = 1; // The resource content.
|
|
81
|
// }
|
|
82
|
//
|
|
83
|
// This enables an HTTP REST to gRPC mapping as below:
|
|
84
|
//
|
|
85
|
// HTTP | gRPC
|
|
86
|
// -----|-----
|
|
87
|
// `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")`
|
|
88
|
//
|
|
89
|
// Any fields in the request message which are not bound by the path template
|
|
90
|
// automatically become HTTP query parameters if there is no HTTP request body.
|
|
91
|
// For example:
|
|
92
|
//
|
|
93
|
// service Messaging {
|
|
94
|
// rpc GetMessage(GetMessageRequest) returns (Message) {
|
|
95
|
// option (google.api.http) = {
|
|
96
|
// get:"/v1/messages/{message_id}"
|
|
97
|
// };
|
|
98
|
// }
|
|
99
|
// }
|
|
100
|
// message GetMessageRequest {
|
|
101
|
// message SubMessage {
|
|
102
|
// string subfield = 1;
|
|
103
|
// }
|
|
104
|
// string message_id = 1; // Mapped to URL path.
|
|
105
|
// int64 revision = 2; // Mapped to URL query parameter `revision`.
|
|
106
|
// SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`.
|
|
107
|
// }
|
|
108
|
//
|
|
109
|
// This enables a HTTP JSON to RPC mapping as below:
|
|
110
|
//
|
|
111
|
// HTTP | gRPC
|
|
112
|
// -----|-----
|
|
113
|
// `GET /v1/messages/123456?revision=2&sub.subfield=foo` |
|
|
114
|
// `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield:
|
|
115
|
// "foo"))`
|
|
116
|
//
|
|
117
|
// Note that fields which are mapped to URL query parameters must have a
|
|
118
|
// primitive type or a repeated primitive type or a non-repeated message type.
|
|
119
|
// In the case of a repeated type, the parameter can be repeated in the URL
|
|
120
|
// as `...?param=A¶m=B`. In the case of a message type, each field of the
|
|
121
|
// message is mapped to a separate parameter, such as
|
|
122
|
// `...?foo.a=A&foo.b=B&foo.c=C`.
|
|
123
|
//
|
|
124
|
// For HTTP methods that allow a request body, the `body` field
|
|
125
|
// specifies the mapping. Consider a REST update method on the
|
|
126
|
// message resource collection:
|
|
127
|
//
|
|
128
|
// service Messaging {
|
|
129
|
// rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
|
|
130
|
// option (google.api.http) = {
|
|
131
|
// patch: "/v1/messages/{message_id}"
|
|
132
|
// body: "message"
|
|
133
|
// };
|
|
134
|
// }
|
|
135
|
// }
|
|
136
|
// message UpdateMessageRequest {
|
|
137
|
// string message_id = 1; // mapped to the URL
|
|
138
|
// Message message = 2; // mapped to the body
|
|
139
|
// }
|
|
140
|
//
|
|
141
|
// The following HTTP JSON to RPC mapping is enabled, where the
|
|
142
|
// representation of the JSON in the request body is determined by
|
|
143
|
// protos JSON encoding:
|
|
144
|
//
|
|
145
|
// HTTP | gRPC
|
|
146
|
// -----|-----
|
|
147
|
// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
|
|
148
|
// "123456" message { text: "Hi!" })`
|
|
149
|
//
|
|
150
|
// The special name `*` can be used in the body mapping to define that
|
|
151
|
// every field not bound by the path template should be mapped to the
|
|
152
|
// request body. This enables the following alternative definition of
|
|
153
|
// the update method:
|
|
154
|
//
|
|
155
|
// service Messaging {
|
|
156
|
// rpc UpdateMessage(Message) returns (Message) {
|
|
157
|
// option (google.api.http) = {
|
|
158
|
// patch: "/v1/messages/{message_id}"
|
|
159
|
// body: "*"
|
|
160
|
// };
|
|
161
|
// }
|
|
162
|
// }
|
|
163
|
// message Message {
|
|
164
|
// string message_id = 1;
|
|
165
|
// string text = 2;
|
|
166
|
// }
|
|
167
|
//
|
|
168
|
//
|
|
169
|
// The following HTTP JSON to RPC mapping is enabled:
|
|
170
|
//
|
|
171
|
// HTTP | gRPC
|
|
172
|
// -----|-----
|
|
173
|
// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id:
|
|
174
|
// "123456" text: "Hi!")`
|
|
175
|
//
|
|
176
|
// Note that when using `*` in the body mapping, it is not possible to
|
|
177
|
// have HTTP parameters, as all fields not bound by the path end in
|
|
178
|
// the body. This makes this option more rarely used in practice when
|
|
179
|
// defining REST APIs. The common usage of `*` is in custom methods
|
|
180
|
// which don't use the URL at all for transferring data.
|
|
181
|
//
|
|
182
|
// It is possible to define multiple HTTP methods for one RPC by using
|
|
183
|
// the `additional_bindings` option. Example:
|
|
184
|
//
|
|
185
|
// service Messaging {
|
|
186
|
// rpc GetMessage(GetMessageRequest) returns (Message) {
|
|
187
|
// option (google.api.http) = {
|
|
188
|
// get: "/v1/messages/{message_id}"
|
|
189
|
// additional_bindings {
|
|
190
|
// get: "/v1/users/{user_id}/messages/{message_id}"
|
|
191
|
// }
|
|
192
|
// };
|
|
193
|
// }
|
|
194
|
// }
|
|
195
|
// message GetMessageRequest {
|
|
196
|
// string message_id = 1;
|
|
197
|
// string user_id = 2;
|
|
198
|
// }
|
|
199
|
//
|
|
200
|
// This enables the following two alternative HTTP JSON to RPC mappings:
|
|
201
|
//
|
|
202
|
// HTTP | gRPC
|
|
203
|
// -----|-----
|
|
204
|
// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
|
|
205
|
// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id:
|
|
206
|
// "123456")`
|
|
207
|
//
|
|
208
|
// ## Rules for HTTP mapping
|
|
209
|
//
|
|
210
|
// 1. Leaf request fields (recursive expansion nested messages in the request
|
|
211
|
// message) are classified into three categories:
|
|
212
|
// - Fields referred by the path template. They are passed via the URL path.
|
|
213
|
// - Fields referred by the [HttpRule.body][google.api.HttpRule.body]. They are passed via the HTTP
|
|
214
|
// request body.
|
|
215
|
// - All other fields are passed via the URL query parameters, and the
|
|
216
|
// parameter name is the field path in the request message. A repeated
|
|
217
|
// field can be represented as multiple query parameters under the same
|
|
218
|
// name.
|
|
219
|
// 2. If [HttpRule.body][google.api.HttpRule.body] is "*", there is no URL query parameter, all fields
|
|
220
|
// are passed via URL path and HTTP request body.
|
|
221
|
// 3. If [HttpRule.body][google.api.HttpRule.body] is omitted, there is no HTTP request body, all
|
|
222
|
// fields are passed via URL path and URL query parameters.
|
|
223
|
//
|
|
224
|
// ### Path template syntax
|
|
225
|
//
|
|
226
|
// Template = "/" Segments [ Verb ] ;
|
|
227
|
// Segments = Segment { "/" Segment } ;
|
|
228
|
// Segment = "*" | "**" | LITERAL | Variable ;
|
|
229
|
// Variable = "{" FieldPath [ "=" Segments ] "}" ;
|
|
230
|
// FieldPath = IDENT { "." IDENT } ;
|
|
231
|
// Verb = ":" LITERAL ;
|
|
232
|
//
|
|
233
|
// The syntax `*` matches a single URL path segment. The syntax `**` matches
|
|
234
|
// zero or more URL path segments, which must be the last part of the URL path
|
|
235
|
// except the `Verb`.
|
|
236
|
//
|
|
237
|
// The syntax `Variable` matches part of the URL path as specified by its
|
|
238
|
// template. A variable template must not contain other variables. If a variable
|
|
239
|
// matches a single path segment, its template may be omitted, e.g. `{var}`
|
|
240
|
// is equivalent to `{var=*}`.
|
|
241
|
//
|
|
242
|
// The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL`
|
|
243
|
// contains any reserved character, such characters should be percent-encoded
|
|
244
|
// before the matching.
|
|
245
|
//
|
|
246
|
// If a variable contains exactly one path segment, such as `"{var}"` or
|
|
247
|
// `"{var=*}"`, when such a variable is expanded into a URL path on the client
|
|
248
|
// side, all characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The
|
|
249
|
// server side does the reverse decoding. Such variables show up in the
|
|
250
|
// [Discovery
|
|
251
|
// Document](https://developers.google.com/discovery/v1/reference/apis) as
|
|
252
|
// `{var}`.
|
|
253
|
//
|
|
254
|
// If a variable contains multiple path segments, such as `"{var=foo/*}"`
|
|
255
|
// or `"{var=**}"`, when such a variable is expanded into a URL path on the
|
|
256
|
// client side, all characters except `[-_.~/0-9a-zA-Z]` are percent-encoded.
|
|
257
|
// The server side does the reverse decoding, except "/" and "/" are left
|
|
258
|
// unchanged. Such variables show up in the
|
|
259
|
// [Discovery
|
|
260
|
// Document](https://developers.google.com/discovery/v1/reference/apis) as
|
|
261
|
// `{ var}`.
|
|
262
|
//
|
|
263
|
// ## Using gRPC API Service Configuration
|
|
264
|
//
|
|
265
|
// gRPC API Service Configuration (service config) is a configuration language
|
|
266
|
// for configuring a gRPC service to become a user-facing product. The
|
|
267
|
// service config is simply the YAML representation of the `google.api.Service`
|
|
268
|
// proto message.
|
|
269
|
//
|
|
270
|
// As an alternative to annotating your proto file, you can configure gRPC
|
|
271
|
// transcoding in your service config YAML files. You do this by specifying a
|
|
272
|
// `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same
|
|
273
|
// effect as the proto annotation. This can be particularly useful if you
|
|
274
|
// have a proto that is reused in multiple services. Note that any transcoding
|
|
275
|
// specified in the service config will override any matching transcoding
|
|
276
|
// configuration in the proto.
|
|
277
|
//
|
|
278
|
// Example:
|
|
279
|
//
|
|
280
|
// http:
|
|
281
|
// rules:
|
|
282
|
// # Selects a gRPC method and applies HttpRule to it.
|
|
283
|
// - selector: example.v1.Messaging.GetMessage
|
|
284
|
// get: /v1/messages/{message_id}/{sub.subfield}
|
|
285
|
//
|
|
286
|
// ## Special notes
|
|
287
|
//
|
|
288
|
// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the
|
|
289
|
// proto to JSON conversion must follow the [proto3
|
|
290
|
// specification](https://developers.google.com/protocol-buffers/docs/proto3#json).
|
|
291
|
//
|
|
292
|
// While the single segment variable follows the semantics of
|
|
293
|
// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
|
|
294
|
// Expansion, the multi segment variable **does not** follow RFC 6570 Section
|
|
295
|
// 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion
|
|
296
|
// does not expand special characters like `?` and `#`, which would lead
|
|
297
|
// to invalid URLs. As the result, gRPC Transcoding uses a custom encoding
|
|
298
|
// for multi segment variables.
|
|
299
|
//
|
|
300
|
// The path variables **must not** refer to any repeated or mapped field,
|
|
301
|
// because client libraries are not capable of handling such variable expansion.
|
|
302
|
//
|
|
303
|
// The path variables **must not** capture the leading "/" character. The reason
|
|
304
|
// is that the most common use case "{var}" does not capture the leading "/"
|
|
305
|
// character. For consistency, all path variables must share the same behavior.
|
|
306
|
//
|
|
307
|
// Repeated message fields must not be mapped to URL query parameters, because
|
|
308
|
// no client library can support such complicated mapping.
|
|
309
|
//
|
|
310
|
// If an API needs to use a JSON array for request or response body, it can map
|
|
311
|
// the request or response body to a repeated field. However, some gRPC
|
|
312
|
// Transcoding implementations may not support this feature.
|
|
313
|
message HttpRule {
|
|
314
|
// Selects a method to which this rule applies.
|
|
315
|
//
|
|
316
|
// Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
|
|
317
|
string selector = 1;
|
|
318
|
|
|
319
|
// Determines the URL pattern is matched by this rules. This pattern can be
|
|
320
|
// used with any of the {get|put|post|delete|patch} methods. A custom method
|
|
321
|
// can be defined using the 'custom' field.
|
|
322
|
oneof pattern {
|
|
323
|
// Maps to HTTP GET. Used for listing and getting information about
|
|
324
|
// resources.
|
|
325
|
string get = 2;
|
|
326
|
|
|
327
|
// Maps to HTTP PUT. Used for replacing a resource.
|
|
328
|
string put = 3;
|
|
329
|
|
|
330
|
// Maps to HTTP POST. Used for creating a resource or performing an action.
|
|
331
|
string post = 4;
|
|
332
|
|
|
333
|
// Maps to HTTP DELETE. Used for deleting a resource.
|
|
334
|
string delete = 5;
|
|
335
|
|
|
336
|
// Maps to HTTP PATCH. Used for updating a resource.
|
|
337
|
string patch = 6;
|
|
338
|
|
|
339
|
// The custom pattern is used for specifying an HTTP method that is not
|
|
340
|
// included in the `pattern` field, such as HEAD, or "*" to leave the
|
|
341
|
// HTTP method unspecified for this rule. The wild-card rule is useful
|
|
342
|
// for services that provide content to Web (HTML) clients.
|
|
343
|
CustomHttpPattern custom = 8;
|
|
344
|
}
|
|
345
|
|
|
346
|
// The name of the request field whose value is mapped to the HTTP request
|
|
347
|
// body, or `*` for mapping all request fields not captured by the path
|
|
348
|
// pattern to the HTTP body, or omitted for not having any HTTP request body.
|
|
349
|
//
|
|
350
|
// NOTE: the referred field must be present at the top-level of the request
|
|
351
|
// message type.
|
|
352
|
string body = 7;
|
|
353
|
|
|
354
|
// Optional. The name of the response field whose value is mapped to the HTTP
|
|
355
|
// response body. When omitted, the entire response message will be used
|
|
356
|
// as the HTTP response body.
|
|
357
|
//
|
|
358
|
// NOTE: The referred field must be present at the top-level of the response
|
|
359
|
// message type.
|
|
360
|
string response_body = 12;
|
|
361
|
|
|
362
|
// Additional HTTP bindings for the selector. Nested bindings must
|
|
363
|
// not contain an `additional_bindings` field themselves (that is,
|
|
364
|
// the nesting may only be one level deep).
|
|
365
|
repeated HttpRule additional_bindings = 11;
|
|
366
|
}
|
|
367
|
|
|
368
|
// A custom pattern is used for defining custom HTTP verb.
|
|
369
|
message CustomHttpPattern {
|
|
370
|
// The name of this custom HTTP verb.
|
|
371
|
string kind = 1;
|
|
372
|
|
|
373
|
// The path matched by this custom verb.
|
|
374
|
string path = 2;
|
|
375
|
}
|
added
priv/protos/google/protobuf/api.proto
|
|
@@ -0,0 1,207 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
import "google/protobuf/source_context.proto";
|
|
36
|
import "google/protobuf/type.proto";
|
|
37
|
|
|
38
|
option java_package = "com.google.protobuf";
|
|
39
|
option java_outer_classname = "ApiProto";
|
|
40
|
option java_multiple_files = true;
|
|
41
|
option objc_class_prefix = "GPB";
|
|
42
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
43
|
option go_package = "google.golang.org/protobuf/types/known/apipb";
|
|
44
|
|
|
45
|
// Api is a light-weight descriptor for an API Interface.
|
|
46
|
//
|
|
47
|
// Interfaces are also described as "protocol buffer services" in some contexts,
|
|
48
|
// such as by the "service" keyword in a .proto file, but they are different
|
|
49
|
// from API Services, which represent a concrete implementation of an interface
|
|
50
|
// as opposed to simply a description of methods and bindings. They are also
|
|
51
|
// sometimes simply referred to as "APIs" in other contexts, such as the name of
|
|
52
|
// this message itself. See https://cloud.google.com/apis/design/glossary for
|
|
53
|
// detailed terminology.
|
|
54
|
message Api {
|
|
55
|
// The fully qualified name of this interface, including package name
|
|
56
|
// followed by the interface's simple name.
|
|
57
|
string name = 1;
|
|
58
|
|
|
59
|
// The methods of this interface, in unspecified order.
|
|
60
|
repeated Method methods = 2;
|
|
61
|
|
|
62
|
// Any metadata attached to the interface.
|
|
63
|
repeated Option options = 3;
|
|
64
|
|
|
65
|
// A version string for this interface. If specified, must have the form
|
|
66
|
// `major-version.minor-version`, as in `1.10`. If the minor version is
|
|
67
|
// omitted, it defaults to zero. If the entire version field is empty, the
|
|
68
|
// major version is derived from the package name, as outlined below. If the
|
|
69
|
// field is not empty, the version in the package name will be verified to be
|
|
70
|
// consistent with what is provided here.
|
|
71
|
//
|
|
72
|
// The versioning schema uses [semantic
|
|
73
|
// versioning](http://semver.org) where the major version number
|
|
74
|
// indicates a breaking change and the minor version an additive,
|
|
75
|
// non-breaking change. Both version numbers are signals to users
|
|
76
|
// what to expect from different versions, and should be carefully
|
|
77
|
// chosen based on the product plan.
|
|
78
|
//
|
|
79
|
// The major version is also reflected in the package name of the
|
|
80
|
// interface, which must end in `v<major-version>`, as in
|
|
81
|
// `google.feature.v1`. For major versions 0 and 1, the suffix can
|
|
82
|
// be omitted. Zero major versions must only be used for
|
|
83
|
// experimental, non-GA interfaces.
|
|
84
|
//
|
|
85
|
string version = 4;
|
|
86
|
|
|
87
|
// Source context for the protocol buffer service represented by this
|
|
88
|
// message.
|
|
89
|
SourceContext source_context = 5;
|
|
90
|
|
|
91
|
// Included interfaces. See [Mixin][].
|
|
92
|
repeated Mixin mixins = 6;
|
|
93
|
|
|
94
|
// The source syntax of the service.
|
|
95
|
Syntax syntax = 7;
|
|
96
|
}
|
|
97
|
|
|
98
|
// Method represents a method of an API interface.
|
|
99
|
message Method {
|
|
100
|
// The simple name of this method.
|
|
101
|
string name = 1;
|
|
102
|
|
|
103
|
// A URL of the input message type.
|
|
104
|
string request_type_url = 2;
|
|
105
|
|
|
106
|
// If true, the request is streamed.
|
|
107
|
bool request_streaming = 3;
|
|
108
|
|
|
109
|
// The URL of the output message type.
|
|
110
|
string response_type_url = 4;
|
|
111
|
|
|
112
|
// If true, the response is streamed.
|
|
113
|
bool response_streaming = 5;
|
|
114
|
|
|
115
|
// Any metadata attached to the method.
|
|
116
|
repeated Option options = 6;
|
|
117
|
|
|
118
|
// The source syntax of this method.
|
|
119
|
Syntax syntax = 7;
|
|
120
|
}
|
|
121
|
|
|
122
|
// Declares an API Interface to be included in this interface. The including
|
|
123
|
// interface must redeclare all the methods from the included interface, but
|
|
124
|
// documentation and options are inherited as follows:
|
|
125
|
//
|
|
126
|
// - If after comment and whitespace stripping, the documentation
|
|
127
|
// string of the redeclared method is empty, it will be inherited
|
|
128
|
// from the original method.
|
|
129
|
//
|
|
130
|
// - Each annotation belonging to the service config (http,
|
|
131
|
// visibility) which is not set in the redeclared method will be
|
|
132
|
// inherited.
|
|
133
|
//
|
|
134
|
// - If an http annotation is inherited, the path pattern will be
|
|
135
|
// modified as follows. Any version prefix will be replaced by the
|
|
136
|
// version of the including interface plus the [root][] path if
|
|
137
|
// specified.
|
|
138
|
//
|
|
139
|
// Example of a simple mixin:
|
|
140
|
//
|
|
141
|
// package google.acl.v1;
|
|
142
|
// service AccessControl {
|
|
143
|
// // Get the underlying ACL object.
|
|
144
|
// rpc GetAcl(GetAclRequest) returns (Acl) {
|
|
145
|
// option (google.api.http).get = "/v1/{resource=**}:getAcl";
|
|
146
|
// }
|
|
147
|
// }
|
|
148
|
//
|
|
149
|
// package google.storage.v2;
|
|
150
|
// service Storage {
|
|
151
|
// rpc GetAcl(GetAclRequest) returns (Acl);
|
|
152
|
//
|
|
153
|
// // Get a data record.
|
|
154
|
// rpc GetData(GetDataRequest) returns (Data) {
|
|
155
|
// option (google.api.http).get = "/v2/{resource=**}";
|
|
156
|
// }
|
|
157
|
// }
|
|
158
|
//
|
|
159
|
// Example of a mixin configuration:
|
|
160
|
//
|
|
161
|
// apis:
|
|
162
|
// - name: google.storage.v2.Storage
|
|
163
|
// mixins:
|
|
164
|
// - name: google.acl.v1.AccessControl
|
|
165
|
//
|
|
166
|
// The mixin construct implies that all methods in `AccessControl` are
|
|
167
|
// also declared with same name and request/response types in
|
|
168
|
// `Storage`. A documentation generator or annotation processor will
|
|
169
|
// see the effective `Storage.GetAcl` method after inherting
|
|
170
|
// documentation and annotations as follows:
|
|
171
|
//
|
|
172
|
// service Storage {
|
|
173
|
// // Get the underlying ACL object.
|
|
174
|
// rpc GetAcl(GetAclRequest) returns (Acl) {
|
|
175
|
// option (google.api.http).get = "/v2/{resource=**}:getAcl";
|
|
176
|
// }
|
|
177
|
// ...
|
|
178
|
// }
|
|
179
|
//
|
|
180
|
// Note how the version in the path pattern changed from `v1` to `v2`.
|
|
181
|
//
|
|
182
|
// If the `root` field in the mixin is specified, it should be a
|
|
183
|
// relative path under which inherited HTTP paths are placed. Example:
|
|
184
|
//
|
|
185
|
// apis:
|
|
186
|
// - name: google.storage.v2.Storage
|
|
187
|
// mixins:
|
|
188
|
// - name: google.acl.v1.AccessControl
|
|
189
|
// root: acls
|
|
190
|
//
|
|
191
|
// This implies the following inherited HTTP annotation:
|
|
192
|
//
|
|
193
|
// service Storage {
|
|
194
|
// // Get the underlying ACL object.
|
|
195
|
// rpc GetAcl(GetAclRequest) returns (Acl) {
|
|
196
|
// option (google.api.http).get = "/v2/acls/{resource=**}:getAcl";
|
|
197
|
// }
|
|
198
|
// ...
|
|
199
|
// }
|
|
200
|
message Mixin {
|
|
201
|
// The fully qualified name of the interface which is included.
|
|
202
|
string name = 1;
|
|
203
|
|
|
204
|
// If non-empty specifies a path under which inherited HTTP paths
|
|
205
|
// are rooted.
|
|
206
|
string root = 2;
|
|
207
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/google/protobuf/descriptor.proto
|
|
@@ -0,0 1,1223 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
// Author: [email protected] (Kenton Varda)
|
|
32
|
// Based on original Protocol Buffers design by
|
|
33
|
// Sanjay Ghemawat, Jeff Dean, and others.
|
|
34
|
//
|
|
35
|
// The messages in this file describe the definitions found in .proto files.
|
|
36
|
// A valid .proto file can be translated directly to a FileDescriptorProto
|
|
37
|
// without any other information (e.g. without reading its imports).
|
|
38
|
|
|
39
|
syntax = "proto2";
|
|
40
|
|
|
41
|
package google.protobuf;
|
|
42
|
|
|
43
|
option go_package = "google.golang.org/protobuf/types/descriptorpb";
|
|
44
|
option java_package = "com.google.protobuf";
|
|
45
|
option java_outer_classname = "DescriptorProtos";
|
|
46
|
option csharp_namespace = "Google.Protobuf.Reflection";
|
|
47
|
option objc_class_prefix = "GPB";
|
|
48
|
option cc_enable_arenas = true;
|
|
49
|
|
|
50
|
// descriptor.proto must be optimized for speed because reflection-based
|
|
51
|
// algorithms don't work during bootstrapping.
|
|
52
|
option optimize_for = SPEED;
|
|
53
|
|
|
54
|
// The protocol compiler can output a FileDescriptorSet containing the .proto
|
|
55
|
// files it parses.
|
|
56
|
message FileDescriptorSet {
|
|
57
|
repeated FileDescriptorProto file = 1;
|
|
58
|
}
|
|
59
|
|
|
60
|
// The full set of known editions.
|
|
61
|
enum Edition {
|
|
62
|
// A placeholder for an unknown edition value.
|
|
63
|
EDITION_UNKNOWN = 0;
|
|
64
|
|
|
65
|
// Legacy syntax "editions". These pre-date editions, but behave much like
|
|
66
|
// distinct editions. These can't be used to specify the edition of proto
|
|
67
|
// files, but feature definitions must supply proto2/proto3 defaults for
|
|
68
|
// backwards compatibility.
|
|
69
|
EDITION_PROTO2 = 998;
|
|
70
|
EDITION_PROTO3 = 999;
|
|
71
|
|
|
72
|
// Editions that have been released. The specific values are arbitrary and
|
|
73
|
// should not be depended on, but they will always be time-ordered for easy
|
|
74
|
// comparison.
|
|
75
|
EDITION_2023 = 1000;
|
|
76
|
EDITION_2024 = 1001;
|
|
77
|
|
|
78
|
// Placeholder editions for testing feature resolution. These should not be
|
|
79
|
// used or relyed on outside of tests.
|
|
80
|
EDITION_1_TEST_ONLY = 1;
|
|
81
|
EDITION_2_TEST_ONLY = 2;
|
|
82
|
EDITION_99997_TEST_ONLY = 99997;
|
|
83
|
EDITION_99998_TEST_ONLY = 99998;
|
|
84
|
EDITION_99999_TEST_ONLY = 99999;
|
|
85
|
|
|
86
|
// Placeholder for specifying unbounded edition support. This should only
|
|
87
|
// ever be used by plugins that can expect to never require any changes to
|
|
88
|
// support a new edition.
|
|
89
|
EDITION_MAX = 0x7FFFFFFF;
|
|
90
|
}
|
|
91
|
|
|
92
|
// Describes a complete .proto file.
|
|
93
|
message FileDescriptorProto {
|
|
94
|
optional string name = 1; // file name, relative to root of source tree
|
|
95
|
optional string package = 2; // e.g. "foo", "foo.bar", etc.
|
|
96
|
|
|
97
|
// Names of files imported by this file.
|
|
98
|
repeated string dependency = 3;
|
|
99
|
// Indexes of the public imported files in the dependency list above.
|
|
100
|
repeated int32 public_dependency = 10;
|
|
101
|
// Indexes of the weak imported files in the dependency list.
|
|
102
|
// For Google-internal migration only. Do not use.
|
|
103
|
repeated int32 weak_dependency = 11;
|
|
104
|
|
|
105
|
// All top-level definitions in this file.
|
|
106
|
repeated DescriptorProto message_type = 4;
|
|
107
|
repeated EnumDescriptorProto enum_type = 5;
|
|
108
|
repeated ServiceDescriptorProto service = 6;
|
|
109
|
repeated FieldDescriptorProto extension = 7;
|
|
110
|
|
|
111
|
optional FileOptions options = 8;
|
|
112
|
|
|
113
|
// This field contains optional information about the original source code.
|
|
114
|
// You may safely remove this entire field without harming runtime
|
|
115
|
// functionality of the descriptors -- the information is needed only by
|
|
116
|
// development tools.
|
|
117
|
optional SourceCodeInfo source_code_info = 9;
|
|
118
|
|
|
119
|
// The syntax of the proto file.
|
|
120
|
// The supported values are "proto2", "proto3", and "editions".
|
|
121
|
//
|
|
122
|
// If `edition` is present, this value must be "editions".
|
|
123
|
optional string syntax = 12;
|
|
124
|
|
|
125
|
// The edition of the proto file.
|
|
126
|
optional Edition edition = 14;
|
|
127
|
}
|
|
128
|
|
|
129
|
// Describes a message type.
|
|
130
|
message DescriptorProto {
|
|
131
|
optional string name = 1;
|
|
132
|
|
|
133
|
repeated FieldDescriptorProto field = 2;
|
|
134
|
repeated FieldDescriptorProto extension = 6;
|
|
135
|
|
|
136
|
repeated DescriptorProto nested_type = 3;
|
|
137
|
repeated EnumDescriptorProto enum_type = 4;
|
|
138
|
|
|
139
|
message ExtensionRange {
|
|
140
|
optional int32 start = 1; // Inclusive.
|
|
141
|
optional int32 end = 2; // Exclusive.
|
|
142
|
|
|
143
|
optional ExtensionRangeOptions options = 3;
|
|
144
|
}
|
|
145
|
repeated ExtensionRange extension_range = 5;
|
|
146
|
|
|
147
|
repeated OneofDescriptorProto oneof_decl = 8;
|
|
148
|
|
|
149
|
optional MessageOptions options = 7;
|
|
150
|
|
|
151
|
// Range of reserved tag numbers. Reserved tag numbers may not be used by
|
|
152
|
// fields or extension ranges in the same message. Reserved ranges may
|
|
153
|
// not overlap.
|
|
154
|
message ReservedRange {
|
|
155
|
optional int32 start = 1; // Inclusive.
|
|
156
|
optional int32 end = 2; // Exclusive.
|
|
157
|
}
|
|
158
|
repeated ReservedRange reserved_range = 9;
|
|
159
|
// Reserved field names, which may not be used by fields in the same message.
|
|
160
|
// A given name may only be reserved once.
|
|
161
|
repeated string reserved_name = 10;
|
|
162
|
}
|
|
163
|
|
|
164
|
message ExtensionRangeOptions {
|
|
165
|
// The parser stores options it doesn't recognize here. See above.
|
|
166
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
167
|
|
|
168
|
message Declaration {
|
|
169
|
// The extension number declared within the extension range.
|
|
170
|
optional int32 number = 1;
|
|
171
|
|
|
172
|
// The fully-qualified name of the extension field. There must be a leading
|
|
173
|
// dot in front of the full name.
|
|
174
|
optional string full_name = 2;
|
|
175
|
|
|
176
|
// The fully-qualified type name of the extension field. Unlike
|
|
177
|
// Metadata.type, Declaration.type must have a leading dot for messages
|
|
178
|
// and enums.
|
|
179
|
optional string type = 3;
|
|
180
|
|
|
181
|
// If true, indicates that the number is reserved in the extension range,
|
|
182
|
// and any extension field with the number will fail to compile. Set this
|
|
183
|
// when a declared extension field is deleted.
|
|
184
|
optional bool reserved = 5;
|
|
185
|
|
|
186
|
// If true, indicates that the extension must be defined as repeated.
|
|
187
|
// Otherwise the extension must be defined as optional.
|
|
188
|
optional bool repeated = 6;
|
|
189
|
|
|
190
|
reserved 4; // removed is_repeated
|
|
191
|
}
|
|
192
|
|
|
193
|
// For external users: DO NOT USE. We are in the process of open sourcing
|
|
194
|
// extension declaration and executing internal cleanups before it can be
|
|
195
|
// used externally.
|
|
196
|
repeated Declaration declaration = 2 [retention = RETENTION_SOURCE];
|
|
197
|
|
|
198
|
// Any features defined in the specific edition.
|
|
199
|
optional FeatureSet features = 50;
|
|
200
|
|
|
201
|
// The verification state of the extension range.
|
|
202
|
enum VerificationState {
|
|
203
|
// All the extensions of the range must be declared.
|
|
204
|
DECLARATION = 0;
|
|
205
|
UNVERIFIED = 1;
|
|
206
|
}
|
|
207
|
|
|
208
|
// The verification state of the range.
|
|
209
|
// TODO: flip the default to DECLARATION once all empty ranges
|
|
210
|
// are marked as UNVERIFIED.
|
|
211
|
optional VerificationState verification = 3
|
|
212
|
[default = UNVERIFIED, retention = RETENTION_SOURCE];
|
|
213
|
|
|
214
|
// Clients can define custom options in extensions of this message. See above.
|
|
215
|
extensions 1000 to max;
|
|
216
|
}
|
|
217
|
|
|
218
|
// Describes a field within a message.
|
|
219
|
message FieldDescriptorProto {
|
|
220
|
enum Type {
|
|
221
|
// 0 is reserved for errors.
|
|
222
|
// Order is weird for historical reasons.
|
|
223
|
TYPE_DOUBLE = 1;
|
|
224
|
TYPE_FLOAT = 2;
|
|
225
|
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
|
|
226
|
// negative values are likely.
|
|
227
|
TYPE_INT64 = 3;
|
|
228
|
TYPE_UINT64 = 4;
|
|
229
|
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
|
|
230
|
// negative values are likely.
|
|
231
|
TYPE_INT32 = 5;
|
|
232
|
TYPE_FIXED64 = 6;
|
|
233
|
TYPE_FIXED32 = 7;
|
|
234
|
TYPE_BOOL = 8;
|
|
235
|
TYPE_STRING = 9;
|
|
236
|
// Tag-delimited aggregate.
|
|
237
|
// Group type is deprecated and not supported after google.protobuf. However, Proto3
|
|
238
|
// implementations should still be able to parse the group wire format and
|
|
239
|
// treat group fields as unknown fields. In Editions, the group wire format
|
|
240
|
// can be enabled via the `message_encoding` feature.
|
|
241
|
TYPE_GROUP = 10;
|
|
242
|
TYPE_MESSAGE = 11; // Length-delimited aggregate.
|
|
243
|
|
|
244
|
// New in version 2.
|
|
245
|
TYPE_BYTES = 12;
|
|
246
|
TYPE_UINT32 = 13;
|
|
247
|
TYPE_ENUM = 14;
|
|
248
|
TYPE_SFIXED32 = 15;
|
|
249
|
TYPE_SFIXED64 = 16;
|
|
250
|
TYPE_SINT32 = 17; // Uses ZigZag encoding.
|
|
251
|
TYPE_SINT64 = 18; // Uses ZigZag encoding.
|
|
252
|
}
|
|
253
|
|
|
254
|
enum Label {
|
|
255
|
// 0 is reserved for errors
|
|
256
|
LABEL_OPTIONAL = 1;
|
|
257
|
LABEL_REPEATED = 3;
|
|
258
|
// The required label is only allowed in google.protobuf. In proto3 and Editions
|
|
259
|
// it's explicitly prohibited. In Editions, the `field_presence` feature
|
|
260
|
// can be used to get this behavior.
|
|
261
|
LABEL_REQUIRED = 2;
|
|
262
|
}
|
|
263
|
|
|
264
|
optional string name = 1;
|
|
265
|
optional int32 number = 3;
|
|
266
|
optional Label label = 4;
|
|
267
|
|
|
268
|
// If type_name is set, this need not be set. If both this and type_name
|
|
269
|
// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
|
|
270
|
optional Type type = 5;
|
|
271
|
|
|
272
|
// For message and enum types, this is the name of the type. If the name
|
|
273
|
// starts with a '.', it is fully-qualified. Otherwise, C -like scoping
|
|
274
|
// rules are used to find the type (i.e. first the nested types within this
|
|
275
|
// message are searched, then within the parent, on up to the root
|
|
276
|
// namespace).
|
|
277
|
optional string type_name = 6;
|
|
278
|
|
|
279
|
// For extensions, this is the name of the type being extended. It is
|
|
280
|
// resolved in the same manner as type_name.
|
|
281
|
optional string extendee = 2;
|
|
282
|
|
|
283
|
// For numeric types, contains the original text representation of the value.
|
|
284
|
// For booleans, "true" or "false".
|
|
285
|
// For strings, contains the default text contents (not escaped in any way).
|
|
286
|
// For bytes, contains the C escaped value. All bytes >= 128 are escaped.
|
|
287
|
optional string default_value = 7;
|
|
288
|
|
|
289
|
// If set, gives the index of a oneof in the containing type's oneof_decl
|
|
290
|
// list. This field is a member of that oneof.
|
|
291
|
optional int32 oneof_index = 9;
|
|
292
|
|
|
293
|
// JSON name of this field. The value is set by protocol compiler. If the
|
|
294
|
// user has set a "json_name" option on this field, that option's value
|
|
295
|
// will be used. Otherwise, it's deduced from the field's name by converting
|
|
296
|
// it to camelCase.
|
|
297
|
optional string json_name = 10;
|
|
298
|
|
|
299
|
optional FieldOptions options = 8;
|
|
300
|
|
|
301
|
// If true, this is a proto3 "optional". When a proto3 field is optional, it
|
|
302
|
// tracks presence regardless of field type.
|
|
303
|
//
|
|
304
|
// When proto3_optional is true, this field must belong to a oneof to signal
|
|
305
|
// to old proto3 clients that presence is tracked for this field. This oneof
|
|
306
|
// is known as a "synthetic" oneof, and this field must be its sole member
|
|
307
|
// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
|
|
308
|
// exist in the descriptor only, and do not generate any API. Synthetic oneofs
|
|
309
|
// must be ordered after all "real" oneofs.
|
|
310
|
//
|
|
311
|
// For message fields, proto3_optional doesn't create any semantic change,
|
|
312
|
// since non-repeated message fields always track presence. However it still
|
|
313
|
// indicates the semantic detail of whether the user wrote "optional" or not.
|
|
314
|
// This can be useful for round-tripping the .proto file. For consistency we
|
|
315
|
// give message fields a synthetic oneof also, even though it is not required
|
|
316
|
// to track presence. This is especially important because the parser can't
|
|
317
|
// tell if a field is a message or an enum, so it must always create a
|
|
318
|
// synthetic oneof.
|
|
319
|
//
|
|
320
|
// Proto2 optional fields do not set this flag, because they already indicate
|
|
321
|
// optional with `LABEL_OPTIONAL`.
|
|
322
|
optional bool proto3_optional = 17;
|
|
323
|
}
|
|
324
|
|
|
325
|
// Describes a oneof.
|
|
326
|
message OneofDescriptorProto {
|
|
327
|
optional string name = 1;
|
|
328
|
optional OneofOptions options = 2;
|
|
329
|
}
|
|
330
|
|
|
331
|
// Describes an enum type.
|
|
332
|
message EnumDescriptorProto {
|
|
333
|
optional string name = 1;
|
|
334
|
|
|
335
|
repeated EnumValueDescriptorProto value = 2;
|
|
336
|
|
|
337
|
optional EnumOptions options = 3;
|
|
338
|
|
|
339
|
// Range of reserved numeric values. Reserved values may not be used by
|
|
340
|
// entries in the same enum. Reserved ranges may not overlap.
|
|
341
|
//
|
|
342
|
// Note that this is distinct from DescriptorProto.ReservedRange in that it
|
|
343
|
// is inclusive such that it can appropriately represent the entire int32
|
|
344
|
// domain.
|
|
345
|
message EnumReservedRange {
|
|
346
|
optional int32 start = 1; // Inclusive.
|
|
347
|
optional int32 end = 2; // Inclusive.
|
|
348
|
}
|
|
349
|
|
|
350
|
// Range of reserved numeric values. Reserved numeric values may not be used
|
|
351
|
// by enum values in the same enum declaration. Reserved ranges may not
|
|
352
|
// overlap.
|
|
353
|
repeated EnumReservedRange reserved_range = 4;
|
|
354
|
|
|
355
|
// Reserved enum value names, which may not be reused. A given name may only
|
|
356
|
// be reserved once.
|
|
357
|
repeated string reserved_name = 5;
|
|
358
|
}
|
|
359
|
|
|
360
|
// Describes a value within an enum.
|
|
361
|
message EnumValueDescriptorProto {
|
|
362
|
optional string name = 1;
|
|
363
|
optional int32 number = 2;
|
|
364
|
|
|
365
|
optional EnumValueOptions options = 3;
|
|
366
|
}
|
|
367
|
|
|
368
|
// Describes a service.
|
|
369
|
message ServiceDescriptorProto {
|
|
370
|
optional string name = 1;
|
|
371
|
repeated MethodDescriptorProto method = 2;
|
|
372
|
|
|
373
|
optional ServiceOptions options = 3;
|
|
374
|
}
|
|
375
|
|
|
376
|
// Describes a method of a service.
|
|
377
|
message MethodDescriptorProto {
|
|
378
|
optional string name = 1;
|
|
379
|
|
|
380
|
// Input and output type names. These are resolved in the same way as
|
|
381
|
// FieldDescriptorProto.type_name, but must refer to a message type.
|
|
382
|
optional string input_type = 2;
|
|
383
|
optional string output_type = 3;
|
|
384
|
|
|
385
|
optional MethodOptions options = 4;
|
|
386
|
|
|
387
|
// Identifies if client streams multiple client messages
|
|
388
|
optional bool client_streaming = 5 [default = false];
|
|
389
|
// Identifies if server streams multiple server messages
|
|
390
|
optional bool server_streaming = 6 [default = false];
|
|
391
|
}
|
|
392
|
|
|
393
|
// ===================================================================
|
|
394
|
// Options
|
|
395
|
|
|
396
|
// Each of the definitions above may have "options" attached. These are
|
|
397
|
// just annotations which may cause code to be generated slightly differently
|
|
398
|
// or may contain hints for code that manipulates protocol messages.
|
|
399
|
//
|
|
400
|
// Clients may define custom options as extensions of the *Options messages.
|
|
401
|
// These extensions may not yet be known at parsing time, so the parser cannot
|
|
402
|
// store the values in them. Instead it stores them in a field in the *Options
|
|
403
|
// message called uninterpreted_option. This field must have the same name
|
|
404
|
// across all *Options messages. We then use this field to populate the
|
|
405
|
// extensions when we build a descriptor, at which point all protos have been
|
|
406
|
// parsed and so all extensions are known.
|
|
407
|
//
|
|
408
|
// Extension numbers for custom options may be chosen as follows:
|
|
409
|
// * For options which will only be used within a single application or
|
|
410
|
// organization, or for experimental options, use field numbers 50000
|
|
411
|
// through 99999. It is up to you to ensure that you do not use the
|
|
412
|
// same number for multiple options.
|
|
413
|
// * For options which will be published and used publicly by multiple
|
|
414
|
// independent entities, e-mail [email protected]
|
|
415
|
// to reserve extension numbers. Simply provide your project name (e.g.
|
|
416
|
// Objective-C plugin) and your project website (if available) -- there's no
|
|
417
|
// need to explain how you intend to use them. Usually you only need one
|
|
418
|
// extension number. You can declare multiple options with only one extension
|
|
419
|
// number by putting them in a sub-message. See the Custom Options section of
|
|
420
|
// the docs for examples:
|
|
421
|
// https://developers.google.com/protocol-buffers/docs/proto#options
|
|
422
|
// If this turns out to be popular, a web service will be set up
|
|
423
|
// to automatically assign option numbers.
|
|
424
|
|
|
425
|
message FileOptions {
|
|
426
|
|
|
427
|
// Sets the Java package where classes generated from this .proto will be
|
|
428
|
// placed. By default, the proto package is used, but this is often
|
|
429
|
// inappropriate because proto packages do not normally start with backwards
|
|
430
|
// domain names.
|
|
431
|
optional string java_package = 1;
|
|
432
|
|
|
433
|
// Controls the name of the wrapper Java class generated for the .proto file.
|
|
434
|
// That class will always contain the .proto file's getDescriptor() method as
|
|
435
|
// well as any top-level extensions defined in the .proto file.
|
|
436
|
// If java_multiple_files is disabled, then all the other classes from the
|
|
437
|
// .proto file will be nested inside the single wrapper outer class.
|
|
438
|
optional string java_outer_classname = 8;
|
|
439
|
|
|
440
|
// If enabled, then the Java code generator will generate a separate .java
|
|
441
|
// file for each top-level message, enum, and service defined in the .proto
|
|
442
|
// file. Thus, these types will *not* be nested inside the wrapper class
|
|
443
|
// named by java_outer_classname. However, the wrapper class will still be
|
|
444
|
// generated to contain the file's getDescriptor() method as well as any
|
|
445
|
// top-level extensions defined in the file.
|
|
446
|
optional bool java_multiple_files = 10 [default = false];
|
|
447
|
|
|
448
|
// This option does nothing.
|
|
449
|
optional bool java_generate_equals_and_hash = 20 [deprecated=true];
|
|
450
|
|
|
451
|
// A proto2 file can set this to true to opt in to UTF-8 checking for Java,
|
|
452
|
// which will throw an exception if invalid UTF-8 is parsed from the wire or
|
|
453
|
// assigned to a string field.
|
|
454
|
//
|
|
455
|
// TODO: clarify exactly what kinds of field types this option
|
|
456
|
// applies to, and update these docs accordingly.
|
|
457
|
//
|
|
458
|
// Proto3 files already perform these checks. Setting the option explicitly to
|
|
459
|
// false has no effect: it cannot be used to opt proto3 files out of UTF-8
|
|
460
|
// checks.
|
|
461
|
optional bool java_string_check_utf8 = 27 [default = false];
|
|
462
|
|
|
463
|
// Generated classes can be optimized for speed or code size.
|
|
464
|
enum OptimizeMode {
|
|
465
|
SPEED = 1; // Generate complete code for parsing, serialization,
|
|
466
|
// etc.
|
|
467
|
CODE_SIZE = 2; // Use ReflectionOps to implement these methods.
|
|
468
|
LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
|
|
469
|
}
|
|
470
|
optional OptimizeMode optimize_for = 9 [default = SPEED];
|
|
471
|
|
|
472
|
// Sets the Go package where structs generated from this .proto will be
|
|
473
|
// placed. If omitted, the Go package will be derived from the following:
|
|
474
|
// - The basename of the package import path, if provided.
|
|
475
|
// - Otherwise, the package statement in the .proto file, if present.
|
|
476
|
// - Otherwise, the basename of the .proto file, without extension.
|
|
477
|
optional string go_package = 11;
|
|
478
|
|
|
479
|
// Should generic services be generated in each language? "Generic" services
|
|
480
|
// are not specific to any particular RPC system. They are generated by the
|
|
481
|
// main code generators in each language (without additional plugins).
|
|
482
|
// Generic services were the only kind of service generation supported by
|
|
483
|
// early versions of google.protobuf.
|
|
484
|
//
|
|
485
|
// Generic services are now considered deprecated in favor of using plugins
|
|
486
|
// that generate code specific to your particular RPC system. Therefore,
|
|
487
|
// these default to false. Old code which depends on generic services should
|
|
488
|
// explicitly set them to true.
|
|
489
|
optional bool cc_generic_services = 16 [default = false];
|
|
490
|
optional bool java_generic_services = 17 [default = false];
|
|
491
|
optional bool py_generic_services = 18 [default = false];
|
|
492
|
reserved 42; // removed php_generic_services
|
|
493
|
|
|
494
|
// Is this file deprecated?
|
|
495
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
496
|
// for everything in the file, or it will be completely ignored; in the very
|
|
497
|
// least, this is a formalization for deprecating files.
|
|
498
|
optional bool deprecated = 23 [default = false];
|
|
499
|
|
|
500
|
// Enables the use of arenas for the proto messages in this file. This applies
|
|
501
|
// only to generated classes for C .
|
|
502
|
optional bool cc_enable_arenas = 31 [default = true];
|
|
503
|
|
|
504
|
// Sets the objective c class prefix which is prepended to all objective c
|
|
505
|
// generated classes from this .proto. There is no default.
|
|
506
|
optional string objc_class_prefix = 36;
|
|
507
|
|
|
508
|
// Namespace for generated classes; defaults to the package.
|
|
509
|
optional string csharp_namespace = 37;
|
|
510
|
|
|
511
|
// By default Swift generators will take the proto package and CamelCase it
|
|
512
|
// replacing '.' with underscore and use that to prefix the types/symbols
|
|
513
|
// defined. When this options is provided, they will use this value instead
|
|
514
|
// to prefix the types/symbols defined.
|
|
515
|
optional string swift_prefix = 39;
|
|
516
|
|
|
517
|
// Sets the php class prefix which is prepended to all php generated classes
|
|
518
|
// from this .proto. Default is empty.
|
|
519
|
optional string php_class_prefix = 40;
|
|
520
|
|
|
521
|
// Use this option to change the namespace of php generated classes. Default
|
|
522
|
// is empty. When this option is empty, the package name will be used for
|
|
523
|
// determining the namespace.
|
|
524
|
optional string php_namespace = 41;
|
|
525
|
|
|
526
|
// Use this option to change the namespace of php generated metadata classes.
|
|
527
|
// Default is empty. When this option is empty, the proto file name will be
|
|
528
|
// used for determining the namespace.
|
|
529
|
optional string php_metadata_namespace = 44;
|
|
530
|
|
|
531
|
// Use this option to change the package of ruby generated classes. Default
|
|
532
|
// is empty. When this option is not set, the package name will be used for
|
|
533
|
// determining the ruby package.
|
|
534
|
optional string ruby_package = 45;
|
|
535
|
|
|
536
|
// Any features defined in the specific edition.
|
|
537
|
optional FeatureSet features = 50;
|
|
538
|
|
|
539
|
// The parser stores options it doesn't recognize here.
|
|
540
|
// See the documentation for the "Options" section above.
|
|
541
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
542
|
|
|
543
|
// Clients can define custom options in extensions of this message.
|
|
544
|
// See the documentation for the "Options" section above.
|
|
545
|
extensions 1000 to max;
|
|
546
|
|
|
547
|
reserved 38;
|
|
548
|
}
|
|
549
|
|
|
550
|
message MessageOptions {
|
|
551
|
// Set true to use the old proto1 MessageSet wire format for extensions.
|
|
552
|
// This is provided for backwards-compatibility with the MessageSet wire
|
|
553
|
// format. You should not use this for any other reason: It's less
|
|
554
|
// efficient, has fewer features, and is more complicated.
|
|
555
|
//
|
|
556
|
// The message must be defined exactly as follows:
|
|
557
|
// message Foo {
|
|
558
|
// option message_set_wire_format = true;
|
|
559
|
// extensions 4 to max;
|
|
560
|
// }
|
|
561
|
// Note that the message cannot have any defined fields; MessageSets only
|
|
562
|
// have extensions.
|
|
563
|
//
|
|
564
|
// All extensions of your type must be singular messages; e.g. they cannot
|
|
565
|
// be int32s, enums, or repeated messages.
|
|
566
|
//
|
|
567
|
// Because this is an option, the above two restrictions are not enforced by
|
|
568
|
// the protocol compiler.
|
|
569
|
optional bool message_set_wire_format = 1 [default = false];
|
|
570
|
|
|
571
|
// Disables the generation of the standard "descriptor()" accessor, which can
|
|
572
|
// conflict with a field of the same name. This is meant to make migration
|
|
573
|
// from proto1 easier; new code should avoid fields named "descriptor".
|
|
574
|
optional bool no_standard_descriptor_accessor = 2 [default = false];
|
|
575
|
|
|
576
|
// Is this message deprecated?
|
|
577
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
578
|
// for the message, or it will be completely ignored; in the very least,
|
|
579
|
// this is a formalization for deprecating messages.
|
|
580
|
optional bool deprecated = 3 [default = false];
|
|
581
|
|
|
582
|
reserved 4, 5, 6;
|
|
583
|
|
|
584
|
// Whether the message is an automatically generated map entry type for the
|
|
585
|
// maps field.
|
|
586
|
//
|
|
587
|
// For maps fields:
|
|
588
|
// map<KeyType, ValueType> map_field = 1;
|
|
589
|
// The parsed descriptor looks like:
|
|
590
|
// message MapFieldEntry {
|
|
591
|
// option map_entry = true;
|
|
592
|
// optional KeyType key = 1;
|
|
593
|
// optional ValueType value = 2;
|
|
863
|
// }
|
|
595
|
// repeated MapFieldEntry map_field = 1;
|
|
596
|
//
|
|
597
|
// Implementations may choose not to generate the map_entry=true message, but
|
|
598
|
// use a native map in the target language to hold the keys and values.
|
|
599
|
// The reflection APIs in such implementations still need to work as
|
|
600
|
// if the field is a repeated message field.
|
|
601
|
//
|
|
602
|
// NOTE: Do not set the option in .proto files. Always use the maps syntax
|
|
603
|
// instead. The option should only be implicitly set by the proto compiler
|
|
604
|
// parser.
|
|
605
|
optional bool map_entry = 7;
|
|
606
|
|
|
607
|
reserved 8; // javalite_serializable
|
|
608
|
reserved 9; // javanano_as_lite
|
|
609
|
|
|
610
|
// Enable the legacy handling of JSON field name conflicts. This lowercases
|
|
611
|
// and strips underscored from the fields before comparison in proto3 only.
|
|
612
|
// The new behavior takes `json_name` into account and applies to proto2 as
|
|
613
|
// well.
|
|
614
|
//
|
|
615
|
// This should only be used as a temporary measure against broken builds due
|
|
616
|
// to the change in behavior for JSON field name conflicts.
|
|
617
|
//
|
|
618
|
// TODO This is legacy behavior we plan to remove once downstream
|
|
619
|
// teams have had time to migrate.
|
|
620
|
optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true];
|
|
621
|
|
|
622
|
// Any features defined in the specific edition.
|
|
623
|
optional FeatureSet features = 12;
|
|
624
|
|
|
625
|
// The parser stores options it doesn't recognize here. See above.
|
|
626
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
627
|
|
|
628
|
// Clients can define custom options in extensions of this message. See above.
|
|
629
|
extensions 1000 to max;
|
|
630
|
}
|
|
631
|
|
|
632
|
message FieldOptions {
|
|
633
|
// The ctype option instructs the C code generator to use a different
|
|
634
|
// representation of the field than it normally would. See the specific
|
|
635
|
// options below. This option is only implemented to support use of
|
|
636
|
// [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of
|
|
637
|
// type "bytes" in the open source release -- sorry, we'll try to include
|
|
638
|
// other types in a future version!
|
|
639
|
optional CType ctype = 1 [default = STRING];
|
|
640
|
enum CType {
|
|
641
|
// Default mode.
|
|
642
|
STRING = 0;
|
|
643
|
|
|
644
|
// The option [ctype=CORD] may be applied to a non-repeated field of type
|
|
645
|
// "bytes". It indicates that in C , the data should be stored in a Cord
|
|
646
|
// instead of a string. For very large strings, this may reduce memory
|
|
647
|
// fragmentation. It may also allow better performance when parsing from a
|
|
648
|
// Cord, or when parsing with aliasing enabled, as the parsed Cord may then
|
|
649
|
// alias the original buffer.
|
|
650
|
CORD = 1;
|
|
651
|
|
|
652
|
STRING_PIECE = 2;
|
|
653
|
}
|
|
654
|
// The packed option can be enabled for repeated primitive fields to enable
|
|
655
|
// a more efficient representation on the wire. Rather than repeatedly
|
|
656
|
// writing the tag and type for each element, the entire array is encoded as
|
|
657
|
// a single length-delimited blob. In proto3, only explicit setting it to
|
|
658
|
// false will avoid using packed encoding. This option is prohibited in
|
|
659
|
// Editions, but the `repeated_field_encoding` feature can be used to control
|
|
660
|
// the behavior.
|
|
661
|
optional bool packed = 2;
|
|
662
|
|
|
663
|
// The jstype option determines the JavaScript type used for values of the
|
|
664
|
// field. The option is permitted only for 64 bit integral and fixed types
|
|
665
|
// (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
|
|
666
|
// is represented as JavaScript string, which avoids loss of precision that
|
|
667
|
// can happen when a large value is converted to a floating point JavaScript.
|
|
668
|
// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
|
|
669
|
// use the JavaScript "number" type. The behavior of the default option
|
|
670
|
// JS_NORMAL is implementation dependent.
|
|
671
|
//
|
|
672
|
// This option is an enum to permit additional types to be added, e.g.
|
|
673
|
// goog.math.Integer.
|
|
674
|
optional JSType jstype = 6 [default = JS_NORMAL];
|
|
675
|
enum JSType {
|
|
676
|
// Use the default type.
|
|
677
|
JS_NORMAL = 0;
|
|
678
|
|
|
679
|
// Use JavaScript strings.
|
|
680
|
JS_STRING = 1;
|
|
681
|
|
|
682
|
// Use JavaScript numbers.
|
|
683
|
JS_NUMBER = 2;
|
|
684
|
}
|
|
685
|
|
|
686
|
// Should this field be parsed lazily? Lazy applies only to message-type
|
|
687
|
// fields. It means that when the outer message is initially parsed, the
|
|
688
|
// inner message's contents will not be parsed but instead stored in encoded
|
|
689
|
// form. The inner message will actually be parsed when it is first accessed.
|
|
690
|
//
|
|
691
|
// This is only a hint. Implementations are free to choose whether to use
|
|
692
|
// eager or lazy parsing regardless of the value of this option. However,
|
|
693
|
// setting this option true suggests that the protocol author believes that
|
|
694
|
// using lazy parsing on this field is worth the additional bookkeeping
|
|
695
|
// overhead typically needed to implement it.
|
|
696
|
//
|
|
697
|
// This option does not affect the public interface of any generated code;
|
|
698
|
// all method signatures remain the same. Furthermore, thread-safety of the
|
|
699
|
// interface is not affected by this option; const methods remain safe to
|
|
700
|
// call from multiple threads concurrently, while non-const methods continue
|
|
701
|
// to require exclusive access.
|
|
702
|
//
|
|
703
|
// Note that lazy message fields are still eagerly verified to check
|
|
704
|
// ill-formed wireformat or missing required fields. Calling IsInitialized()
|
|
705
|
// on the outer message would fail if the inner message has missing required
|
|
706
|
// fields. Failed verification would result in parsing failure (except when
|
|
707
|
// uninitialized messages are acceptable).
|
|
708
|
optional bool lazy = 5 [default = false];
|
|
709
|
|
|
710
|
// unverified_lazy does no correctness checks on the byte stream. This should
|
|
711
|
// only be used where lazy with verification is prohibitive for performance
|
|
712
|
// reasons.
|
|
713
|
optional bool unverified_lazy = 15 [default = false];
|
|
714
|
|
|
715
|
// Is this field deprecated?
|
|
716
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
717
|
// for accessors, or it will be completely ignored; in the very least, this
|
|
718
|
// is a formalization for deprecating fields.
|
|
719
|
optional bool deprecated = 3 [default = false];
|
|
720
|
|
|
721
|
// For Google-internal migration only. Do not use.
|
|
722
|
optional bool weak = 10 [default = false];
|
|
723
|
|
|
724
|
// Indicate that the field value should not be printed out when using debug
|
|
725
|
// formats, e.g. when the field contains sensitive credentials.
|
|
726
|
optional bool debug_redact = 16 [default = false];
|
|
727
|
|
|
728
|
// If set to RETENTION_SOURCE, the option will be omitted from the binary.
|
|
729
|
// Note: as of January 2023, support for this is in progress and does not yet
|
|
730
|
// have an effect (b/264593489).
|
|
731
|
enum OptionRetention {
|
|
732
|
RETENTION_UNKNOWN = 0;
|
|
733
|
RETENTION_RUNTIME = 1;
|
|
734
|
RETENTION_SOURCE = 2;
|
|
735
|
}
|
|
736
|
|
|
737
|
optional OptionRetention retention = 17;
|
|
738
|
|
|
739
|
// This indicates the types of entities that the field may apply to when used
|
|
740
|
// as an option. If it is unset, then the field may be freely used as an
|
|
741
|
// option on any kind of entity. Note: as of January 2023, support for this is
|
|
742
|
// in progress and does not yet have an effect (b/264593489).
|
|
743
|
enum OptionTargetType {
|
|
744
|
TARGET_TYPE_UNKNOWN = 0;
|
|
745
|
TARGET_TYPE_FILE = 1;
|
|
746
|
TARGET_TYPE_EXTENSION_RANGE = 2;
|
|
747
|
TARGET_TYPE_MESSAGE = 3;
|
|
748
|
TARGET_TYPE_FIELD = 4;
|
|
749
|
TARGET_TYPE_ONEOF = 5;
|
|
750
|
TARGET_TYPE_ENUM = 6;
|
|
751
|
TARGET_TYPE_ENUM_ENTRY = 7;
|
|
752
|
TARGET_TYPE_SERVICE = 8;
|
|
753
|
TARGET_TYPE_METHOD = 9;
|
|
754
|
}
|
|
755
|
|
|
756
|
repeated OptionTargetType targets = 19;
|
|
757
|
|
|
758
|
message EditionDefault {
|
|
759
|
optional Edition edition = 3;
|
|
760
|
optional string value = 2; // Textproto value.
|
|
761
|
}
|
|
762
|
repeated EditionDefault edition_defaults = 20;
|
|
763
|
|
|
764
|
// Any features defined in the specific edition.
|
|
765
|
optional FeatureSet features = 21;
|
|
766
|
|
|
767
|
// The parser stores options it doesn't recognize here. See above.
|
|
768
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
769
|
|
|
770
|
// Clients can define custom options in extensions of this message. See above.
|
|
771
|
extensions 1000 to max;
|
|
772
|
|
|
773
|
reserved 4; // removed jtype
|
|
774
|
reserved 18; // reserve target, target_obsolete_do_not_use
|
|
775
|
}
|
|
776
|
|
|
777
|
message OneofOptions {
|
|
778
|
// Any features defined in the specific edition.
|
|
779
|
optional FeatureSet features = 1;
|
|
780
|
|
|
781
|
// The parser stores options it doesn't recognize here. See above.
|
|
782
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
783
|
|
|
784
|
// Clients can define custom options in extensions of this message. See above.
|
|
785
|
extensions 1000 to max;
|
|
786
|
}
|
|
787
|
|
|
788
|
message EnumOptions {
|
|
789
|
|
|
790
|
// Set this option to true to allow mapping different tag names to the same
|
|
791
|
// value.
|
|
792
|
optional bool allow_alias = 2;
|
|
793
|
|
|
794
|
// Is this enum deprecated?
|
|
795
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
796
|
// for the enum, or it will be completely ignored; in the very least, this
|
|
797
|
// is a formalization for deprecating enums.
|
|
798
|
optional bool deprecated = 3 [default = false];
|
|
799
|
|
|
800
|
reserved 5; // javanano_as_lite
|
|
801
|
|
|
802
|
// Enable the legacy handling of JSON field name conflicts. This lowercases
|
|
803
|
// and strips underscored from the fields before comparison in proto3 only.
|
|
804
|
// The new behavior takes `json_name` into account and applies to proto2 as
|
|
805
|
// well.
|
|
806
|
// TODO Remove this legacy behavior once downstream teams have
|
|
807
|
// had time to migrate.
|
|
808
|
optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true];
|
|
809
|
|
|
810
|
// Any features defined in the specific edition.
|
|
811
|
optional FeatureSet features = 7;
|
|
812
|
|
|
813
|
// The parser stores options it doesn't recognize here. See above.
|
|
814
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
815
|
|
|
816
|
// Clients can define custom options in extensions of this message. See above.
|
|
817
|
extensions 1000 to max;
|
|
818
|
}
|
|
819
|
|
|
820
|
message EnumValueOptions {
|
|
821
|
// Is this enum value deprecated?
|
|
822
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
823
|
// for the enum value, or it will be completely ignored; in the very least,
|
|
824
|
// this is a formalization for deprecating enum values.
|
|
825
|
optional bool deprecated = 1 [default = false];
|
|
826
|
|
|
827
|
// Any features defined in the specific edition.
|
|
828
|
optional FeatureSet features = 2;
|
|
829
|
|
|
830
|
// Indicate that fields annotated with this enum value should not be printed
|
|
831
|
// out when using debug formats, e.g. when the field contains sensitive
|
|
832
|
// credentials.
|
|
833
|
optional bool debug_redact = 3 [default = false];
|
|
834
|
|
|
835
|
// The parser stores options it doesn't recognize here. See above.
|
|
836
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
837
|
|
|
838
|
// Clients can define custom options in extensions of this message. See above.
|
|
839
|
extensions 1000 to max;
|
|
840
|
}
|
|
841
|
|
|
842
|
message ServiceOptions {
|
|
843
|
|
|
844
|
// Any features defined in the specific edition.
|
|
845
|
optional FeatureSet features = 34;
|
|
846
|
|
|
847
|
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
|
|
848
|
// framework. We apologize for hoarding these numbers to ourselves, but
|
|
849
|
// we were already using them long before we decided to release Protocol
|
|
850
|
// Buffers.
|
|
851
|
|
|
852
|
// Is this service deprecated?
|
|
853
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
854
|
// for the service, or it will be completely ignored; in the very least,
|
|
855
|
// this is a formalization for deprecating services.
|
|
856
|
optional bool deprecated = 33 [default = false];
|
|
857
|
|
|
858
|
// The parser stores options it doesn't recognize here. See above.
|
|
859
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
860
|
|
|
861
|
// Clients can define custom options in extensions of this message. See above.
|
|
862
|
extensions 1000 to max;
|
|
863
|
}
|
|
864
|
|
|
865
|
message MethodOptions {
|
|
866
|
|
|
867
|
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
|
|
868
|
// framework. We apologize for hoarding these numbers to ourselves, but
|
|
869
|
// we were already using them long before we decided to release Protocol
|
|
870
|
// Buffers.
|
|
871
|
|
|
872
|
// Is this method deprecated?
|
|
873
|
// Depending on the target platform, this can emit Deprecated annotations
|
|
874
|
// for the method, or it will be completely ignored; in the very least,
|
|
875
|
// this is a formalization for deprecating methods.
|
|
876
|
optional bool deprecated = 33 [default = false];
|
|
877
|
|
|
878
|
// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
|
|
879
|
// or neither? HTTP based RPC implementation may choose GET verb for safe
|
|
880
|
// methods, and PUT verb for idempotent methods instead of the default POST.
|
|
881
|
enum IdempotencyLevel {
|
|
882
|
IDEMPOTENCY_UNKNOWN = 0;
|
|
883
|
NO_SIDE_EFFECTS = 1; // implies idempotent
|
|
884
|
IDEMPOTENT = 2; // idempotent, but may have side effects
|
|
885
|
}
|
|
886
|
optional IdempotencyLevel idempotency_level = 34
|
|
887
|
[default = IDEMPOTENCY_UNKNOWN];
|
|
888
|
|
|
889
|
// Any features defined in the specific edition.
|
|
890
|
optional FeatureSet features = 35;
|
|
891
|
|
|
892
|
// The parser stores options it doesn't recognize here. See above.
|
|
893
|
repeated UninterpretedOption uninterpreted_option = 999;
|
|
894
|
|
|
895
|
// Clients can define custom options in extensions of this message. See above.
|
|
896
|
extensions 1000 to max;
|
|
897
|
}
|
|
898
|
|
|
899
|
// A message representing a option the parser does not recognize. This only
|
|
900
|
// appears in options protos created by the compiler::Parser class.
|
|
901
|
// DescriptorPool resolves these when building Descriptor objects. Therefore,
|
|
902
|
// options protos in descriptor objects (e.g. returned by Descriptor::options(),
|
|
903
|
// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
|
|
904
|
// in them.
|
|
905
|
message UninterpretedOption {
|
|
906
|
// The name of the uninterpreted option. Each string represents a segment in
|
|
907
|
// a dot-separated name. is_extension is true iff a segment represents an
|
|
908
|
// extension (denoted with parentheses in options specs in .proto files).
|
|
909
|
// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
|
|
910
|
// "foo.(bar.baz).moo".
|
|
911
|
message NamePart {
|
|
912
|
required string name_part = 1;
|
|
913
|
required bool is_extension = 2;
|
|
914
|
}
|
|
915
|
repeated NamePart name = 2;
|
|
916
|
|
|
917
|
// The value of the uninterpreted option, in whatever type the tokenizer
|
|
918
|
// identified it as during parsing. Exactly one of these should be set.
|
|
919
|
optional string identifier_value = 3;
|
|
920
|
optional uint64 positive_int_value = 4;
|
|
921
|
optional int64 negative_int_value = 5;
|
|
922
|
optional double double_value = 6;
|
|
923
|
optional bytes string_value = 7;
|
|
924
|
optional string aggregate_value = 8;
|
|
925
|
}
|
|
926
|
|
|
927
|
// ===================================================================
|
|
928
|
// Features
|
|
929
|
|
|
930
|
// TODO Enums in C gencode (and potentially other languages) are
|
|
931
|
// not well scoped. This means that each of the feature enums below can clash
|
|
932
|
// with each other. The short names we've chosen maximize call-site
|
|
933
|
// readability, but leave us very open to this scenario. A future feature will
|
|
934
|
// be designed and implemented to handle this, hopefully before we ever hit a
|
|
935
|
// conflict here.
|
|
936
|
message FeatureSet {
|
|
937
|
enum FieldPresence {
|
|
938
|
FIELD_PRESENCE_UNKNOWN = 0;
|
|
939
|
EXPLICIT = 1;
|
|
940
|
IMPLICIT = 2;
|
|
941
|
LEGACY_REQUIRED = 3;
|
|
942
|
}
|
|
943
|
optional FieldPresence field_presence = 1 [
|
|
944
|
retention = RETENTION_RUNTIME,
|
|
945
|
targets = TARGET_TYPE_FIELD,
|
|
946
|
targets = TARGET_TYPE_FILE,
|
|
947
|
edition_defaults = { edition: EDITION_PROTO2, value: "EXPLICIT" },
|
|
948
|
edition_defaults = { edition: EDITION_PROTO3, value: "IMPLICIT" },
|
|
949
|
edition_defaults = { edition: EDITION_2023, value: "EXPLICIT" }
|
|
950
|
];
|
|
951
|
|
|
952
|
enum EnumType {
|
|
953
|
ENUM_TYPE_UNKNOWN = 0;
|
|
954
|
OPEN = 1;
|
|
955
|
CLOSED = 2;
|
|
956
|
}
|
|
957
|
optional EnumType enum_type = 2 [
|
|
958
|
retention = RETENTION_RUNTIME,
|
|
959
|
targets = TARGET_TYPE_ENUM,
|
|
960
|
targets = TARGET_TYPE_FILE,
|
|
961
|
edition_defaults = { edition: EDITION_PROTO2, value: "CLOSED" },
|
|
962
|
edition_defaults = { edition: EDITION_PROTO3, value: "OPEN" }
|
|
963
|
];
|
|
964
|
|
|
965
|
enum RepeatedFieldEncoding {
|
|
966
|
REPEATED_FIELD_ENCODING_UNKNOWN = 0;
|
|
967
|
PACKED = 1;
|
|
968
|
EXPANDED = 2;
|
|
969
|
}
|
|
970
|
optional RepeatedFieldEncoding repeated_field_encoding = 3 [
|
|
971
|
retention = RETENTION_RUNTIME,
|
|
972
|
targets = TARGET_TYPE_FIELD,
|
|
973
|
targets = TARGET_TYPE_FILE,
|
|
974
|
edition_defaults = { edition: EDITION_PROTO2, value: "EXPANDED" },
|
|
975
|
edition_defaults = { edition: EDITION_PROTO3, value: "PACKED" }
|
|
976
|
];
|
|
977
|
|
|
978
|
enum Utf8Validation {
|
|
979
|
UTF8_VALIDATION_UNKNOWN = 0;
|
|
980
|
VERIFY = 2;
|
|
981
|
NONE = 3;
|
|
982
|
}
|
|
983
|
optional Utf8Validation utf8_validation = 4 [
|
|
984
|
retention = RETENTION_RUNTIME,
|
|
985
|
targets = TARGET_TYPE_FIELD,
|
|
986
|
targets = TARGET_TYPE_FILE,
|
|
987
|
edition_defaults = { edition: EDITION_PROTO2, value: "NONE" },
|
|
988
|
edition_defaults = { edition: EDITION_PROTO3, value: "VERIFY" }
|
|
989
|
];
|
|
990
|
|
|
991
|
enum MessageEncoding {
|
|
992
|
MESSAGE_ENCODING_UNKNOWN = 0;
|
|
993
|
LENGTH_PREFIXED = 1;
|
|
994
|
DELIMITED = 2;
|
|
995
|
}
|
|
996
|
optional MessageEncoding message_encoding = 5 [
|
|
997
|
retention = RETENTION_RUNTIME,
|
|
998
|
targets = TARGET_TYPE_FIELD,
|
|
999
|
targets = TARGET_TYPE_FILE,
|
|
1000
|
edition_defaults = { edition: EDITION_PROTO2, value: "LENGTH_PREFIXED" }
|
|
1001
|
];
|
|
1002
|
|
|
1003
|
enum JsonFormat {
|
|
1004
|
JSON_FORMAT_UNKNOWN = 0;
|
|
1005
|
ALLOW = 1;
|
|
1006
|
LEGACY_BEST_EFFORT = 2;
|
|
1007
|
}
|
|
1008
|
optional JsonFormat json_format = 6 [
|
|
1009
|
retention = RETENTION_RUNTIME,
|
|
1010
|
targets = TARGET_TYPE_MESSAGE,
|
|
1011
|
targets = TARGET_TYPE_ENUM,
|
|
1012
|
targets = TARGET_TYPE_FILE,
|
|
1013
|
edition_defaults = { edition: EDITION_PROTO2, value: "LEGACY_BEST_EFFORT" },
|
|
1014
|
edition_defaults = { edition: EDITION_PROTO3, value: "ALLOW" }
|
|
1015
|
];
|
|
1016
|
|
|
1017
|
reserved 999;
|
|
1018
|
|
|
1019
|
extensions 1000; // for Protobuf C
|
|
1020
|
extensions 1001; // for Protobuf Java
|
|
1021
|
extensions 1002; // for Protobuf Go
|
|
1022
|
|
|
1023
|
extensions 9995 to 9999; // For internal testing
|
|
1024
|
extensions 10000; // for https://github.com/bufbuild/protobuf-es
|
|
1025
|
}
|
|
1026
|
|
|
1027
|
// A compiled specification for the defaults of a set of features. These
|
|
1028
|
// messages are generated from FeatureSet extensions and can be used to seed
|
|
1029
|
// feature resolution. The resolution with this object becomes a simple search
|
|
1030
|
// for the closest matching edition, followed by proto merges.
|
|
1031
|
message FeatureSetDefaults {
|
|
1032
|
// A map from every known edition with a unique set of defaults to its
|
|
1033
|
// defaults. Not all editions may be contained here. For a given edition,
|
|
1034
|
// the defaults at the closest matching edition ordered at or before it should
|
|
1035
|
// be used. This field must be in strict ascending order by edition.
|
|
1036
|
message FeatureSetEditionDefault {
|
|
1037
|
optional Edition edition = 3;
|
|
1038
|
optional FeatureSet features = 2;
|
|
1039
|
}
|
|
1040
|
repeated FeatureSetEditionDefault defaults = 1;
|
|
1041
|
|
|
1042
|
// The minimum supported edition (inclusive) when this was constructed.
|
|
1043
|
// Editions before this will not have defaults.
|
|
1044
|
optional Edition minimum_edition = 4;
|
|
1045
|
|
|
1046
|
// The maximum known edition (inclusive) when this was constructed. Editions
|
|
1047
|
// after this will not have reliable defaults.
|
|
1048
|
optional Edition maximum_edition = 5;
|
|
1049
|
}
|
|
1050
|
|
|
1051
|
// ===================================================================
|
|
1052
|
// Optional source code info
|
|
1053
|
|
|
1054
|
// Encapsulates information about the original source file from which a
|
|
1055
|
// FileDescriptorProto was generated.
|
|
1056
|
message SourceCodeInfo {
|
|
1057
|
// A Location identifies a piece of source code in a .proto file which
|
|
1058
|
// corresponds to a particular definition. This information is intended
|
|
1059
|
// to be useful to IDEs, code indexers, documentation generators, and similar
|
|
1060
|
// tools.
|
|
1061
|
//
|
|
1062
|
// For example, say we have a file like:
|
|
1063
|
// message Foo {
|
|
1064
|
// optional string foo = 1;
|
|
1065
|
// }
|
|
1066
|
// Let's look at just the field definition:
|
|
1067
|
// optional string foo = 1;
|
|
1068
|
// ^ ^^ ^^ ^ ^^^
|
|
1069
|
// a bc de f ghi
|
|
1070
|
// We have the following locations:
|
|
1071
|
// span path represents
|
|
1072
|
// [a,i) [ 4, 0, 2, 0 ] The whole field definition.
|
|
1073
|
// [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
|
|
1074
|
// [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
|
|
1075
|
// [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
|
|
1076
|
// [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
|
|
1077
|
//
|
|
1078
|
// Notes:
|
|
1079
|
// - A location may refer to a repeated field itself (i.e. not to any
|
|
1080
|
// particular index within it). This is used whenever a set of elements are
|
|
1081
|
// logically enclosed in a single code segment. For example, an entire
|
|
1082
|
// extend block (possibly containing multiple extension definitions) will
|
|
1083
|
// have an outer location whose path refers to the "extensions" repeated
|
|
1084
|
// field without an index.
|
|
1085
|
// - Multiple locations may have the same path. This happens when a single
|
|
1086
|
// logical declaration is spread out across multiple places. The most
|
|
1087
|
// obvious example is the "extend" block again -- there may be multiple
|
|
1088
|
// extend blocks in the same scope, each of which will have the same path.
|
|
1089
|
// - A location's span is not always a subset of its parent's span. For
|
|
1090
|
// example, the "extendee" of an extension declaration appears at the
|
|
1091
|
// beginning of the "extend" block and is shared by all extensions within
|
|
1092
|
// the block.
|
|
1093
|
// - Just because a location's span is a subset of some other location's span
|
|
1094
|
// does not mean that it is a descendant. For example, a "group" defines
|
|
1095
|
// both a type and a field in a single declaration. Thus, the locations
|
|
1096
|
// corresponding to the type and field and their components will overlap.
|
|
1097
|
// - Code which tries to interpret locations should probably be designed to
|
|
1098
|
// ignore those that it doesn't understand, as more types of locations could
|
|
1099
|
// be recorded in the future.
|
|
1100
|
repeated Location location = 1;
|
|
1101
|
message Location {
|
|
1102
|
// Identifies which part of the FileDescriptorProto was defined at this
|
|
1103
|
// location.
|
|
1104
|
//
|
|
1105
|
// Each element is a field number or an index. They form a path from
|
|
1106
|
// the root FileDescriptorProto to the place where the definition appears.
|
|
1107
|
// For example, this path:
|
|
1108
|
// [ 4, 3, 2, 7, 1 ]
|
|
1109
|
// refers to:
|
|
1110
|
// file.message_type(3) // 4, 3
|
|
1111
|
// .field(7) // 2, 7
|
|
1112
|
// .name() // 1
|
|
1113
|
// This is because FileDescriptorProto.message_type has field number 4:
|
|
1114
|
// repeated DescriptorProto message_type = 4;
|
|
1115
|
// and DescriptorProto.field has field number 2:
|
|
1116
|
// repeated FieldDescriptorProto field = 2;
|
|
1117
|
// and FieldDescriptorProto.name has field number 1:
|
|
1118
|
// optional string name = 1;
|
|
1119
|
//
|
|
1120
|
// Thus, the above path gives the location of a field name. If we removed
|
|
1121
|
// the last element:
|
|
1122
|
// [ 4, 3, 2, 7 ]
|
|
1123
|
// this path refers to the whole field declaration (from the beginning
|
|
1124
|
// of the label to the terminating semicolon).
|
|
1125
|
repeated int32 path = 1 [packed = true];
|
|
1126
|
|
|
1127
|
// Always has exactly three or four elements: start line, start column,
|
|
1128
|
// end line (optional, otherwise assumed same as start line), end column.
|
|
1129
|
// These are packed into a single field for efficiency. Note that line
|
|
1130
|
// and column numbers are zero-based -- typically you will want to add
|
|
1131
|
// 1 to each before displaying to a user.
|
|
1132
|
repeated int32 span = 2 [packed = true];
|
|
1133
|
|
|
1134
|
// If this SourceCodeInfo represents a complete declaration, these are any
|
|
1135
|
// comments appearing before and after the declaration which appear to be
|
|
1136
|
// attached to the declaration.
|
|
1137
|
//
|
|
1138
|
// A series of line comments appearing on consecutive lines, with no other
|
|
1139
|
// tokens appearing on those lines, will be treated as a single comment.
|
|
1140
|
//
|
|
1141
|
// leading_detached_comments will keep paragraphs of comments that appear
|
|
1142
|
// before (but not connected to) the current element. Each paragraph,
|
|
1143
|
// separated by empty lines, will be one comment element in the repeated
|
|
1144
|
// field.
|
|
1145
|
//
|
|
1146
|
// Only the comment content is provided; comment markers (e.g. //) are
|
|
1147
|
// stripped out. For block comments, leading whitespace and an asterisk
|
|
1148
|
// will be stripped from the beginning of each line other than the first.
|
|
1149
|
// Newlines are included in the output.
|
|
1150
|
//
|
|
1151
|
// Examples:
|
|
1152
|
//
|
|
1153
|
// optional int32 foo = 1; // Comment attached to foo.
|
|
1154
|
// // Comment attached to bar.
|
|
1155
|
// optional int32 bar = 2;
|
|
1156
|
//
|
|
1157
|
// optional string baz = 3;
|
|
1158
|
// // Comment attached to baz.
|
|
1159
|
// // Another line attached to baz.
|
|
1160
|
//
|
|
1161
|
// // Comment attached to moo.
|
|
1162
|
// //
|
|
1163
|
// // Another line attached to moo.
|
|
1164
|
// optional double moo = 4;
|
|
1165
|
//
|
|
1166
|
// // Detached comment for corge. This is not leading or trailing comments
|
|
1167
|
// // to moo or corge because there are blank lines separating it from
|
|
1168
|
// // both.
|
|
1169
|
//
|
|
1170
|
// // Detached comment for corge paragraph 2.
|
|
1171
|
//
|
|
1172
|
// optional string corge = 5;
|
|
1173
|
// /* Block comment attached
|
|
1174
|
// * to corge. Leading asterisks
|
|
1175
|
// * will be removed. */
|
|
1176
|
// /* Block comment attached to
|
|
1177
|
// * grault. */
|
|
1178
|
// optional int32 grault = 6;
|
|
1179
|
//
|
|
1180
|
// // ignored detached comments.
|
|
1181
|
optional string leading_comments = 3;
|
|
1182
|
optional string trailing_comments = 4;
|
|
1183
|
repeated string leading_detached_comments = 6;
|
|
1184
|
}
|
|
1185
|
}
|
|
1186
|
|
|
1187
|
// Describes the relationship between generated code and its original source
|
|
1188
|
// file. A GeneratedCodeInfo message is associated with only one generated
|
|
1189
|
// source file, but may contain references to different source .proto files.
|
|
1190
|
message GeneratedCodeInfo {
|
|
1191
|
// An Annotation connects some span of text in generated code to an element
|
|
1192
|
// of its generating .proto file.
|
|
1193
|
repeated Annotation annotation = 1;
|
|
1194
|
message Annotation {
|
|
1195
|
// Identifies the element in the original source .proto file. This field
|
|
1196
|
// is formatted the same as SourceCodeInfo.Location.path.
|
|
1197
|
repeated int32 path = 1 [packed = true];
|
|
1198
|
|
|
1199
|
// Identifies the filesystem path to the original source .proto.
|
|
1200
|
optional string source_file = 2;
|
|
1201
|
|
|
1202
|
// Identifies the starting offset in bytes in the generated code
|
|
1203
|
// that relates to the identified object.
|
|
1204
|
optional int32 begin = 3;
|
|
1205
|
|
|
1206
|
// Identifies the ending offset in bytes in the generated code that
|
|
1207
|
// relates to the identified object. The end offset should be one past
|
|
1208
|
// the last relevant byte (so the length of the text = end - begin).
|
|
1209
|
optional int32 end = 4;
|
|
1210
|
|
|
1211
|
// Represents the identified object's effect on the element in the original
|
|
1212
|
// .proto file.
|
|
1213
|
enum Semantic {
|
|
1214
|
// There is no effect or the effect is indescribable.
|
|
1215
|
NONE = 0;
|
|
1216
|
// The element is set or otherwise mutated.
|
|
1217
|
SET = 1;
|
|
1218
|
// An alias to the element is returned.
|
|
1219
|
ALIAS = 2;
|
|
1220
|
}
|
|
1221
|
optional Semantic semantic = 5;
|
|
1222
|
}
|
|
1223
|
}
|
added
priv/protos/google/protobuf/duration.proto
|
|
@@ -0,0 1,115 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
36
|
option cc_enable_arenas = true;
|
|
37
|
option go_package = "google.golang.org/protobuf/types/known/durationpb";
|
|
38
|
option java_package = "com.google.protobuf";
|
|
39
|
option java_outer_classname = "DurationProto";
|
|
40
|
option java_multiple_files = true;
|
|
41
|
option objc_class_prefix = "GPB";
|
|
42
|
|
|
43
|
// A Duration represents a signed, fixed-length span of time represented
|
|
44
|
// as a count of seconds and fractions of seconds at nanosecond
|
|
45
|
// resolution. It is independent of any calendar and concepts like "day"
|
|
46
|
// or "month". It is related to Timestamp in that the difference between
|
|
47
|
// two Timestamp values is a Duration and it can be added or subtracted
|
|
48
|
// from a Timestamp. Range is approximately -10,000 years.
|
|
49
|
//
|
|
50
|
// # Examples
|
|
51
|
//
|
|
52
|
// Example 1: Compute Duration from two Timestamps in pseudo code.
|
|
53
|
//
|
|
54
|
// Timestamp start = ...;
|
|
55
|
// Timestamp end = ...;
|
|
56
|
// Duration duration = ...;
|
|
57
|
//
|
|
58
|
// duration.seconds = end.seconds - start.seconds;
|
|
59
|
// duration.nanos = end.nanos - start.nanos;
|
|
60
|
//
|
|
61
|
// if (duration.seconds < 0 && duration.nanos > 0) {
|
|
62
|
// duration.seconds = 1;
|
|
63
|
// duration.nanos -= 1000000000;
|
|
64
|
// } else if (duration.seconds > 0 && duration.nanos < 0) {
|
|
65
|
// duration.seconds -= 1;
|
|
66
|
// duration.nanos = 1000000000;
|
|
67
|
// }
|
|
68
|
//
|
|
69
|
// Example 2: Compute Timestamp from Timestamp Duration in pseudo code.
|
|
70
|
//
|
|
71
|
// Timestamp start = ...;
|
|
72
|
// Duration duration = ...;
|
|
73
|
// Timestamp end = ...;
|
|
74
|
//
|
|
75
|
// end.seconds = start.seconds duration.seconds;
|
|
76
|
// end.nanos = start.nanos duration.nanos;
|
|
77
|
//
|
|
78
|
// if (end.nanos < 0) {
|
|
79
|
// end.seconds -= 1;
|
|
80
|
// end.nanos = 1000000000;
|
|
81
|
// } else if (end.nanos >= 1000000000) {
|
|
82
|
// end.seconds = 1;
|
|
83
|
// end.nanos -= 1000000000;
|
|
84
|
// }
|
|
85
|
//
|
|
86
|
// Example 3: Compute Duration from datetime.timedelta in Python.
|
|
87
|
//
|
|
88
|
// td = datetime.timedelta(days=3, minutes=10)
|
|
89
|
// duration = Duration()
|
|
90
|
// duration.FromTimedelta(td)
|
|
91
|
//
|
|
92
|
// # JSON Mapping
|
|
93
|
//
|
|
94
|
// In JSON format, the Duration type is encoded as a string rather than an
|
|
95
|
// object, where the string ends in the suffix "s" (indicating seconds) and
|
|
96
|
// is preceded by the number of seconds, with nanoseconds expressed as
|
|
97
|
// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
|
|
98
|
// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
|
|
99
|
// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
|
|
100
|
// microsecond should be expressed in JSON format as "3.000001s".
|
|
101
|
//
|
|
102
|
message Duration {
|
|
103
|
// Signed seconds of the span of time. Must be from -315,576,000,000
|
|
104
|
// to 315,576,000,000 inclusive. Note: these bounds are computed from:
|
|
105
|
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
|
|
106
|
int64 seconds = 1;
|
|
107
|
|
|
108
|
// Signed fractions of a second at nanosecond resolution of the span
|
|
109
|
// of time. Durations less than one second are represented with a 0
|
|
110
|
// `seconds` field and a positive or negative `nanos` field. For durations
|
|
111
|
// of one second or more, a non-zero value for the `nanos` field must be
|
|
112
|
// of the same sign as the `seconds` field. Must be from -999,999,999
|
|
113
|
// to 999,999,999 inclusive.
|
|
114
|
int32 nanos = 2;
|
|
115
|
}
|
added
priv/protos/google/protobuf/empty.proto
|
|
@@ -0,0 1,51 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
36
|
option go_package = "google.golang.org/protobuf/types/known/emptypb";
|
|
37
|
option java_package = "com.google.protobuf";
|
|
38
|
option java_outer_classname = "EmptyProto";
|
|
39
|
option java_multiple_files = true;
|
|
40
|
option objc_class_prefix = "GPB";
|
|
41
|
option cc_enable_arenas = true;
|
|
42
|
|
|
43
|
// A generic empty message that you can re-use to avoid defining duplicated
|
|
44
|
// empty messages in your APIs. A typical example is to use it as the request
|
|
45
|
// or the response type of an API method. For instance:
|
|
46
|
//
|
|
47
|
// service Foo {
|
|
48
|
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
|
|
49
|
// }
|
|
50
|
//
|
|
51
|
message Empty {}
|
added
priv/protos/google/protobuf/field_mask.proto
|
|
@@ -0,0 1,245 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
option java_package = "com.google.protobuf";
|
|
36
|
option java_outer_classname = "FieldMaskProto";
|
|
37
|
option java_multiple_files = true;
|
|
38
|
option objc_class_prefix = "GPB";
|
|
39
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
40
|
option go_package = "google.golang.org/protobuf/types/known/fieldmaskpb";
|
|
41
|
option cc_enable_arenas = true;
|
|
42
|
|
|
43
|
// `FieldMask` represents a set of symbolic field paths, for example:
|
|
44
|
//
|
|
45
|
// paths: "f.a"
|
|
46
|
// paths: "f.b.d"
|
|
47
|
//
|
|
48
|
// Here `f` represents a field in some root message, `a` and `b`
|
|
49
|
// fields in the message found in `f`, and `d` a field found in the
|
|
50
|
// message in `f.b`.
|
|
51
|
//
|
|
52
|
// Field masks are used to specify a subset of fields that should be
|
|
53
|
// returned by a get operation or modified by an update operation.
|
|
54
|
// Field masks also have a custom JSON encoding (see below).
|
|
55
|
//
|
|
56
|
// # Field Masks in Projections
|
|
57
|
//
|
|
58
|
// When used in the context of a projection, a response message or
|
|
59
|
// sub-message is filtered by the API to only contain those fields as
|
|
60
|
// specified in the mask. For example, if the mask in the previous
|
|
61
|
// example is applied to a response message as follows:
|
|
62
|
//
|
|
63
|
// f {
|
|
64
|
// a : 22
|
|
65
|
// b {
|
|
66
|
// d : 1
|
|
67
|
// x : 2
|
|
68
|
// }
|
|
69
|
// y : 13
|
|
70
|
// }
|
|
71
|
// z: 8
|
|
72
|
//
|
|
73
|
// The result will not contain specific values for fields x,y and z
|
|
74
|
// (their value will be set to the default, and omitted in proto text
|
|
75
|
// output):
|
|
76
|
//
|
|
77
|
//
|
|
78
|
// f {
|
|
79
|
// a : 22
|
|
80
|
// b {
|
|
81
|
// d : 1
|
|
82
|
// }
|
|
83
|
// }
|
|
84
|
//
|
|
85
|
// A repeated field is not allowed except at the last position of a
|
|
86
|
// paths string.
|
|
87
|
//
|
|
88
|
// If a FieldMask object is not present in a get operation, the
|
|
89
|
// operation applies to all fields (as if a FieldMask of all fields
|
|
90
|
// had been specified).
|
|
91
|
//
|
|
92
|
// Note that a field mask does not necessarily apply to the
|
|
93
|
// top-level response message. In case of a REST get operation, the
|
|
94
|
// field mask applies directly to the response, but in case of a REST
|
|
95
|
// list operation, the mask instead applies to each individual message
|
|
96
|
// in the returned resource list. In case of a REST custom method,
|
|
97
|
// other definitions may be used. Where the mask applies will be
|
|
98
|
// clearly documented together with its declaration in the API. In
|
|
99
|
// any case, the effect on the returned resource/resources is required
|
|
100
|
// behavior for APIs.
|
|
101
|
//
|
|
102
|
// # Field Masks in Update Operations
|
|
103
|
//
|
|
104
|
// A field mask in update operations specifies which fields of the
|
|
105
|
// targeted resource are going to be updated. The API is required
|
|
106
|
// to only change the values of the fields as specified in the mask
|
|
107
|
// and leave the others untouched. If a resource is passed in to
|
|
108
|
// describe the updated values, the API ignores the values of all
|
|
109
|
// fields not covered by the mask.
|
|
110
|
//
|
|
111
|
// If a repeated field is specified for an update operation, new values will
|
|
112
|
// be appended to the existing repeated field in the target resource. Note that
|
|
113
|
// a repeated field is only allowed in the last position of a `paths` string.
|
|
114
|
//
|
|
115
|
// If a sub-message is specified in the last position of the field mask for an
|
|
116
|
// update operation, then new value will be merged into the existing sub-message
|
|
117
|
// in the target resource.
|
|
118
|
//
|
|
119
|
// For example, given the target message:
|
|
120
|
//
|
|
121
|
// f {
|
|
122
|
// b {
|
|
123
|
// d: 1
|
|
124
|
// x: 2
|
|
125
|
// }
|
|
126
|
// c: [1]
|
|
127
|
// }
|
|
128
|
//
|
|
129
|
// And an update message:
|
|
130
|
//
|
|
131
|
// f {
|
|
132
|
// b {
|
|
133
|
// d: 10
|
|
134
|
// }
|
|
135
|
// c: [2]
|
|
136
|
// }
|
|
137
|
//
|
|
138
|
// then if the field mask is:
|
|
139
|
//
|
|
140
|
// paths: ["f.b", "f.c"]
|
|
141
|
//
|
|
142
|
// then the result will be:
|
|
143
|
//
|
|
144
|
// f {
|
|
145
|
// b {
|
|
146
|
// d: 10
|
|
147
|
// x: 2
|
|
148
|
// }
|
|
149
|
// c: [1, 2]
|
|
150
|
// }
|
|
151
|
//
|
|
152
|
// An implementation may provide options to override this default behavior for
|
|
153
|
// repeated and message fields.
|
|
154
|
//
|
|
155
|
// In order to reset a field's value to the default, the field must
|
|
156
|
// be in the mask and set to the default value in the provided resource.
|
|
157
|
// Hence, in order to reset all fields of a resource, provide a default
|
|
158
|
// instance of the resource and set all fields in the mask, or do
|
|
159
|
// not provide a mask as described below.
|
|
160
|
//
|
|
161
|
// If a field mask is not present on update, the operation applies to
|
|
162
|
// all fields (as if a field mask of all fields has been specified).
|
|
163
|
// Note that in the presence of schema evolution, this may mean that
|
|
164
|
// fields the client does not know and has therefore not filled into
|
|
165
|
// the request will be reset to their default. If this is unwanted
|
|
166
|
// behavior, a specific service may require a client to always specify
|
|
167
|
// a field mask, producing an error if not.
|
|
168
|
//
|
|
169
|
// As with get operations, the location of the resource which
|
|
170
|
// describes the updated values in the request message depends on the
|
|
171
|
// operation kind. In any case, the effect of the field mask is
|
|
172
|
// required to be honored by the API.
|
|
173
|
//
|
|
174
|
// ## Considerations for HTTP REST
|
|
175
|
//
|
|
176
|
// The HTTP kind of an update operation which uses a field mask must
|
|
177
|
// be set to PATCH instead of PUT in order to satisfy HTTP semantics
|
|
178
|
// (PUT must only be used for full updates).
|
|
179
|
//
|
|
180
|
// # JSON Encoding of Field Masks
|
|
181
|
//
|
|
182
|
// In JSON, a field mask is encoded as a single string where paths are
|
|
183
|
// separated by a comma. Fields name in each path are converted
|
|
184
|
// to/from lower-camel naming conventions.
|
|
185
|
//
|
|
186
|
// As an example, consider the following message declarations:
|
|
187
|
//
|
|
188
|
// message Profile {
|
|
189
|
// User user = 1;
|
|
190
|
// Photo photo = 2;
|
|
191
|
// }
|
|
192
|
// message User {
|
|
193
|
// string display_name = 1;
|
|
194
|
// string address = 2;
|
|
195
|
// }
|
|
196
|
//
|
|
197
|
// In proto a field mask for `Profile` may look as such:
|
|
198
|
//
|
|
199
|
// mask {
|
|
200
|
// paths: "user.display_name"
|
|
201
|
// paths: "photo"
|
|
202
|
// }
|
|
203
|
//
|
|
204
|
// In JSON, the same mask is represented as below:
|
|
205
|
//
|
|
206
|
// {
|
|
207
|
// mask: "user.displayName,photo"
|
|
208
|
// }
|
|
209
|
//
|
|
210
|
// # Field Masks and Oneof Fields
|
|
211
|
//
|
|
212
|
// Field masks treat fields in oneofs just as regular fields. Consider the
|
|
213
|
// following message:
|
|
214
|
//
|
|
215
|
// message SampleMessage {
|
|
216
|
// oneof test_oneof {
|
|
217
|
// string name = 4;
|
|
218
|
// SubMessage sub_message = 9;
|
|
219
|
// }
|
|
220
|
// }
|
|
221
|
//
|
|
222
|
// The field mask can be:
|
|
223
|
//
|
|
224
|
// mask {
|
|
225
|
// paths: "name"
|
|
226
|
// }
|
|
227
|
//
|
|
228
|
// Or:
|
|
229
|
//
|
|
230
|
// mask {
|
|
231
|
// paths: "sub_message"
|
|
232
|
// }
|
|
233
|
//
|
|
234
|
// Note that oneof type names ("test_oneof" in this case) cannot be used in
|
|
235
|
// paths.
|
|
236
|
//
|
|
237
|
// ## Field Mask Verification
|
|
238
|
//
|
|
239
|
// The implementation of any API method which has a FieldMask type field in the
|
|
240
|
// request should verify the included field paths, and return an
|
|
241
|
// `INVALID_ARGUMENT` error if any path is unmappable.
|
|
242
|
message FieldMask {
|
|
243
|
// The set of field mask paths.
|
|
244
|
repeated string paths = 1;
|
|
245
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/google/protobuf/source_context.proto
|
|
@@ -0,0 1,48 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
option java_package = "com.google.protobuf";
|
|
36
|
option java_outer_classname = "SourceContextProto";
|
|
37
|
option java_multiple_files = true;
|
|
38
|
option objc_class_prefix = "GPB";
|
|
39
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
40
|
option go_package = "google.golang.org/protobuf/types/known/sourcecontextpb";
|
|
41
|
|
|
42
|
// `SourceContext` represents information about the source of a
|
|
43
|
// protobuf element, like the file in which it is defined.
|
|
44
|
message SourceContext {
|
|
45
|
// The path-qualified name of the .proto file that contained the associated
|
|
46
|
// protobuf element. For example: `"google/protobuf/source_context.proto"`.
|
|
47
|
string file_name = 1;
|
|
48
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/google/protobuf/struct.proto
|
|
@@ -0,0 1,95 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
option cc_enable_arenas = true;
|
|
36
|
option go_package = "google.golang.org/protobuf/types/known/structpb";
|
|
37
|
option java_package = "com.google.protobuf";
|
|
38
|
option java_outer_classname = "StructProto";
|
|
39
|
option java_multiple_files = true;
|
|
40
|
option objc_class_prefix = "GPB";
|
|
41
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
42
|
|
|
43
|
// `Struct` represents a structured data value, consisting of fields
|
|
44
|
// which map to dynamically typed values. In some languages, `Struct`
|
|
45
|
// might be supported by a native representation. For example, in
|
|
46
|
// scripting languages like JS a struct is represented as an
|
|
47
|
// object. The details of that representation are described together
|
|
48
|
// with the proto support for the language.
|
|
49
|
//
|
|
50
|
// The JSON representation for `Struct` is JSON object.
|
|
51
|
message Struct {
|
|
52
|
// Unordered map of dynamically typed values.
|
|
53
|
map<string, Value> fields = 1;
|
|
54
|
}
|
|
55
|
|
|
56
|
// `Value` represents a dynamically typed value which can be either
|
|
57
|
// null, a number, a string, a boolean, a recursive struct value, or a
|
|
58
|
// list of values. A producer of value is expected to set one of these
|
|
59
|
// variants. Absence of any variant indicates an error.
|
|
60
|
//
|
|
61
|
// The JSON representation for `Value` is JSON value.
|
|
62
|
message Value {
|
|
63
|
// The kind of value.
|
|
64
|
oneof kind {
|
|
65
|
// Represents a null value.
|
|
66
|
NullValue null_value = 1;
|
|
67
|
// Represents a double value.
|
|
68
|
double number_value = 2;
|
|
69
|
// Represents a string value.
|
|
70
|
string string_value = 3;
|
|
71
|
// Represents a boolean value.
|
|
72
|
bool bool_value = 4;
|
|
73
|
// Represents a structured value.
|
|
74
|
Struct struct_value = 5;
|
|
75
|
// Represents a repeated `Value`.
|
|
76
|
ListValue list_value = 6;
|
|
77
|
}
|
|
78
|
}
|
|
79
|
|
|
80
|
// `NullValue` is a singleton enumeration to represent the null value for the
|
|
81
|
// `Value` type union.
|
|
82
|
//
|
|
83
|
// The JSON representation for `NullValue` is JSON `null`.
|
|
84
|
enum NullValue {
|
|
85
|
// Null value.
|
|
86
|
NULL_VALUE = 0;
|
|
87
|
}
|
|
88
|
|
|
89
|
// `ListValue` is a wrapper around a repeated field of values.
|
|
90
|
//
|
|
91
|
// The JSON representation for `ListValue` is JSON array.
|
|
92
|
message ListValue {
|
|
93
|
// Repeated field of dynamically typed values.
|
|
94
|
repeated Value values = 1;
|
|
95
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/google/protobuf/timestamp.proto
|
|
@@ -0,0 1,144 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
36
|
option cc_enable_arenas = true;
|
|
37
|
option go_package = "google.golang.org/protobuf/types/known/timestamppb";
|
|
38
|
option java_package = "com.google.protobuf";
|
|
39
|
option java_outer_classname = "TimestampProto";
|
|
40
|
option java_multiple_files = true;
|
|
41
|
option objc_class_prefix = "GPB";
|
|
42
|
|
|
43
|
// A Timestamp represents a point in time independent of any time zone or local
|
|
44
|
// calendar, encoded as a count of seconds and fractions of seconds at
|
|
45
|
// nanosecond resolution. The count is relative to an epoch at UTC midnight on
|
|
46
|
// January 1, 1970, in the proleptic Gregorian calendar which extends the
|
|
47
|
// Gregorian calendar backwards to year one.
|
|
48
|
//
|
|
49
|
// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
|
|
50
|
// second table is needed for interpretation, using a [24-hour linear
|
|
51
|
// smear](https://developers.google.com/time/smear).
|
|
52
|
//
|
|
53
|
// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
|
|
54
|
// restricting to that range, we ensure that we can convert to and from [RFC
|
|
55
|
// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
|
|
56
|
//
|
|
57
|
// # Examples
|
|
58
|
//
|
|
59
|
// Example 1: Compute Timestamp from POSIX `time()`.
|
|
60
|
//
|
|
61
|
// Timestamp timestamp;
|
|
62
|
// timestamp.set_seconds(time(NULL));
|
|
63
|
// timestamp.set_nanos(0);
|
|
64
|
//
|
|
65
|
// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
|
|
66
|
//
|
|
67
|
// struct timeval tv;
|
|
68
|
// gettimeofday(&tv, NULL);
|
|
69
|
//
|
|
70
|
// Timestamp timestamp;
|
|
71
|
// timestamp.set_seconds(tv.tv_sec);
|
|
72
|
// timestamp.set_nanos(tv.tv_usec * 1000);
|
|
73
|
//
|
|
74
|
// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
|
|
75
|
//
|
|
76
|
// FILETIME ft;
|
|
77
|
// GetSystemTimeAsFileTime(&ft);
|
|
78
|
// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
|
|
79
|
//
|
|
80
|
// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
|
|
81
|
// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
|
|
82
|
// Timestamp timestamp;
|
|
83
|
// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
|
|
84
|
// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
|
|
85
|
//
|
|
86
|
// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
|
|
87
|
//
|
|
88
|
// long millis = System.currentTimeMillis();
|
|
89
|
//
|
|
90
|
// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
|
|
91
|
// .setNanos((int) ((millis % 1000) * 1000000)).build();
|
|
92
|
//
|
|
93
|
// Example 5: Compute Timestamp from Java `Instant.now()`.
|
|
94
|
//
|
|
95
|
// Instant now = Instant.now();
|
|
96
|
//
|
|
97
|
// Timestamp timestamp =
|
|
98
|
// Timestamp.newBuilder().setSeconds(now.getEpochSecond())
|
|
99
|
// .setNanos(now.getNano()).build();
|
|
100
|
//
|
|
101
|
// Example 6: Compute Timestamp from current time in Python.
|
|
102
|
//
|
|
103
|
// timestamp = Timestamp()
|
|
104
|
// timestamp.GetCurrentTime()
|
|
105
|
//
|
|
106
|
// # JSON Mapping
|
|
107
|
//
|
|
108
|
// In JSON format, the Timestamp type is encoded as a string in the
|
|
109
|
// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
|
|
110
|
// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
|
|
111
|
// where {year} is always expressed using four digits while {month}, {day},
|
|
112
|
// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
|
|
113
|
// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
|
|
114
|
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
|
|
115
|
// is required. A proto3 JSON serializer should always use UTC (as indicated by
|
|
116
|
// "Z") when printing the Timestamp type and a proto3 JSON parser should be
|
|
117
|
// able to accept both UTC and other timezones (as indicated by an offset).
|
|
118
|
//
|
|
119
|
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
|
|
120
|
// 01:30 UTC on January 15, 2017.
|
|
121
|
//
|
|
122
|
// In JavaScript, one can convert a Date object to this format using the
|
|
123
|
// standard
|
|
124
|
// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
|
|
125
|
// method. In Python, a standard `datetime.datetime` object can be converted
|
|
126
|
// to this format using
|
|
127
|
// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
|
|
128
|
// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
|
|
129
|
// the Joda Time's [`ISODateTimeFormat.dateTime()`](
|
|
130
|
// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
|
|
131
|
// ) to obtain a formatter capable of generating timestamps in this format.
|
|
132
|
//
|
|
133
|
message Timestamp {
|
|
134
|
// Represents seconds of UTC time since Unix epoch
|
|
135
|
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
|
|
136
|
// 9999-12-31T23:59:59Z inclusive.
|
|
137
|
int64 seconds = 1;
|
|
138
|
|
|
139
|
// Non-negative fractions of a second at nanosecond resolution. Negative
|
|
140
|
// second values with fractions must still have non-negative nanos values
|
|
141
|
// that count forward in time. Must be from 0 to 999,999,999
|
|
142
|
// inclusive.
|
|
143
|
int32 nanos = 2;
|
|
144
|
}
|
added
priv/protos/google/protobuf/type.proto
|
|
@@ -0,0 1,193 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
|
|
31
|
syntax = "proto3";
|
|
32
|
|
|
33
|
package google.protobuf;
|
|
34
|
|
|
35
|
import "google/protobuf/any.proto";
|
|
36
|
import "google/protobuf/source_context.proto";
|
|
37
|
|
|
38
|
option cc_enable_arenas = true;
|
|
39
|
option java_package = "com.google.protobuf";
|
|
40
|
option java_outer_classname = "TypeProto";
|
|
41
|
option java_multiple_files = true;
|
|
42
|
option objc_class_prefix = "GPB";
|
|
43
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
44
|
option go_package = "google.golang.org/protobuf/types/known/typepb";
|
|
45
|
|
|
46
|
// A protocol buffer message type.
|
|
47
|
message Type {
|
|
48
|
// The fully qualified message name.
|
|
49
|
string name = 1;
|
|
50
|
// The list of fields.
|
|
51
|
repeated Field fields = 2;
|
|
52
|
// The list of types appearing in `oneof` definitions in this type.
|
|
53
|
repeated string oneofs = 3;
|
|
54
|
// The protocol buffer options.
|
|
55
|
repeated Option options = 4;
|
|
56
|
// The source context.
|
|
57
|
SourceContext source_context = 5;
|
|
58
|
// The source syntax.
|
|
59
|
Syntax syntax = 6;
|
|
60
|
// The source edition string, only valid when syntax is SYNTAX_EDITIONS.
|
|
61
|
string edition = 7;
|
|
62
|
}
|
|
63
|
|
|
64
|
// A single field of a message type.
|
|
65
|
message Field {
|
|
66
|
// Basic field types.
|
|
67
|
enum Kind {
|
|
68
|
// Field type unknown.
|
|
69
|
TYPE_UNKNOWN = 0;
|
|
70
|
// Field type double.
|
|
71
|
TYPE_DOUBLE = 1;
|
|
72
|
// Field type float.
|
|
73
|
TYPE_FLOAT = 2;
|
|
74
|
// Field type int64.
|
|
75
|
TYPE_INT64 = 3;
|
|
76
|
// Field type uint64.
|
|
77
|
TYPE_UINT64 = 4;
|
|
78
|
// Field type int32.
|
|
79
|
TYPE_INT32 = 5;
|
|
80
|
// Field type fixed64.
|
|
81
|
TYPE_FIXED64 = 6;
|
|
82
|
// Field type fixed32.
|
|
83
|
TYPE_FIXED32 = 7;
|
|
84
|
// Field type bool.
|
|
85
|
TYPE_BOOL = 8;
|
|
86
|
// Field type string.
|
|
87
|
TYPE_STRING = 9;
|
|
88
|
// Field type group. Proto2 syntax only, and deprecated.
|
|
89
|
TYPE_GROUP = 10;
|
|
90
|
// Field type message.
|
|
91
|
TYPE_MESSAGE = 11;
|
|
92
|
// Field type bytes.
|
|
93
|
TYPE_BYTES = 12;
|
|
94
|
// Field type uint32.
|
|
95
|
TYPE_UINT32 = 13;
|
|
96
|
// Field type enum.
|
|
97
|
TYPE_ENUM = 14;
|
|
98
|
// Field type sfixed32.
|
|
99
|
TYPE_SFIXED32 = 15;
|
|
100
|
// Field type sfixed64.
|
|
101
|
TYPE_SFIXED64 = 16;
|
|
102
|
// Field type sint32.
|
|
103
|
TYPE_SINT32 = 17;
|
|
104
|
// Field type sint64.
|
|
105
|
TYPE_SINT64 = 18;
|
|
106
|
}
|
|
107
|
|
|
108
|
// Whether a field is optional, required, or repeated.
|
|
109
|
enum Cardinality {
|
|
110
|
// For fields with unknown cardinality.
|
|
111
|
CARDINALITY_UNKNOWN = 0;
|
|
112
|
// For optional fields.
|
|
113
|
CARDINALITY_OPTIONAL = 1;
|
|
114
|
// For required fields. Proto2 syntax only.
|
|
115
|
CARDINALITY_REQUIRED = 2;
|
|
116
|
// For repeated fields.
|
|
117
|
CARDINALITY_REPEATED = 3;
|
|
118
|
}
|
|
119
|
|
|
120
|
// The field type.
|
|
121
|
Kind kind = 1;
|
|
122
|
// The field cardinality.
|
|
123
|
Cardinality cardinality = 2;
|
|
124
|
// The field number.
|
|
125
|
int32 number = 3;
|
|
126
|
// The field name.
|
|
127
|
string name = 4;
|
|
128
|
// The field type URL, without the scheme, for message or enumeration
|
|
129
|
// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
|
|
130
|
string type_url = 6;
|
|
131
|
// The index of the field type in `Type.oneofs`, for message or enumeration
|
|
132
|
// types. The first type has index 1; zero means the type is not in the list.
|
|
133
|
int32 oneof_index = 7;
|
|
134
|
// Whether to use alternative packed wire representation.
|
|
135
|
bool packed = 8;
|
|
136
|
// The protocol buffer options.
|
|
137
|
repeated Option options = 9;
|
|
138
|
// The field JSON name.
|
|
139
|
string json_name = 10;
|
|
140
|
// The string value of the default value of this field. Proto2 syntax only.
|
|
141
|
string default_value = 11;
|
|
142
|
}
|
|
143
|
|
|
144
|
// Enum type definition.
|
|
145
|
message Enum {
|
|
146
|
// Enum type name.
|
|
147
|
string name = 1;
|
|
148
|
// Enum value definitions.
|
|
149
|
repeated EnumValue enumvalue = 2;
|
|
150
|
// Protocol buffer options.
|
|
151
|
repeated Option options = 3;
|
|
152
|
// The source context.
|
|
153
|
SourceContext source_context = 4;
|
|
154
|
// The source syntax.
|
|
155
|
Syntax syntax = 5;
|
|
156
|
// The source edition string, only valid when syntax is SYNTAX_EDITIONS.
|
|
157
|
string edition = 6;
|
|
158
|
}
|
|
159
|
|
|
160
|
// Enum value definition.
|
|
161
|
message EnumValue {
|
|
162
|
// Enum value name.
|
|
163
|
string name = 1;
|
|
164
|
// Enum value number.
|
|
165
|
int32 number = 2;
|
|
166
|
// Protocol buffer options.
|
|
167
|
repeated Option options = 3;
|
|
168
|
}
|
|
169
|
|
|
170
|
// A protocol buffer option, which can be attached to a message, field,
|
|
171
|
// enumeration, etc.
|
|
172
|
message Option {
|
|
173
|
// The option's name. For protobuf built-in options (options defined in
|
|
174
|
// descriptor.proto), this is the short name. For example, `"map_entry"`.
|
|
175
|
// For custom options, it should be the fully-qualified name. For example,
|
|
176
|
// `"google.api.http"`.
|
|
177
|
string name = 1;
|
|
178
|
// The option's value packed in an Any message. If the value is a primitive,
|
|
179
|
// the corresponding wrapper type defined in google/protobuf/wrappers.proto
|
|
180
|
// should be used. If the value is an enum, it should be stored as an int32
|
|
181
|
// value using the google.protobuf.Int32Value type.
|
|
182
|
Any value = 2;
|
|
183
|
}
|
|
184
|
|
|
185
|
// The syntax in which a protocol buffer element is defined.
|
|
186
|
enum Syntax {
|
|
187
|
// Syntax `proto2`.
|
|
188
|
SYNTAX_PROTO2 = 0;
|
|
189
|
// Syntax `proto3`.
|
|
190
|
SYNTAX_PROTO3 = 1;
|
|
191
|
// Syntax `editions`.
|
|
192
|
SYNTAX_EDITIONS = 2;
|
|
193
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/google/protobuf/wrappers.proto
|
|
@@ -0,0 1,123 @@
|
|
1
|
// Protocol Buffers - Google's data interchange format
|
|
2
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
3
|
// https://developers.google.com/protocol-buffers/
|
|
4
|
//
|
|
5
|
// Redistribution and use in source and binary forms, with or without
|
|
6
|
// modification, are permitted provided that the following conditions are
|
|
7
|
// met:
|
|
8
|
//
|
|
9
|
// * Redistributions of source code must retain the above copyright
|
|
10
|
// notice, this list of conditions and the following disclaimer.
|
|
11
|
// * Redistributions in binary form must reproduce the above
|
|
12
|
// copyright notice, this list of conditions and the following disclaimer
|
|
13
|
// in the documentation and/or other materials provided with the
|
|
14
|
// distribution.
|
|
15
|
// * Neither the name of Google Inc. nor the names of its
|
|
16
|
// contributors may be used to endorse or promote products derived from
|
|
17
|
// this software without specific prior written permission.
|
|
18
|
//
|
|
19
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
20
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
21
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
22
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
23
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
24
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
25
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
26
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
27
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
28
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
29
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
30
|
//
|
|
31
|
// Wrappers for primitive (non-message) types. These types are useful
|
|
32
|
// for embedding primitives in the `google.protobuf.Any` type and for places
|
|
33
|
// where we need to distinguish between the absence of a primitive
|
|
34
|
// typed field and its default value.
|
|
35
|
//
|
|
36
|
// These wrappers have no meaningful use within repeated fields as they lack
|
|
37
|
// the ability to detect presence on individual elements.
|
|
38
|
// These wrappers have no meaningful use within a map or a oneof since
|
|
39
|
// individual entries of a map or fields of a oneof can already detect presence.
|
|
40
|
|
|
41
|
syntax = "proto3";
|
|
42
|
|
|
43
|
package google.protobuf;
|
|
44
|
|
|
45
|
option cc_enable_arenas = true;
|
|
46
|
option go_package = "google.golang.org/protobuf/types/known/wrapperspb";
|
|
47
|
option java_package = "com.google.protobuf";
|
|
48
|
option java_outer_classname = "WrappersProto";
|
|
49
|
option java_multiple_files = true;
|
|
50
|
option objc_class_prefix = "GPB";
|
|
51
|
option csharp_namespace = "Google.Protobuf.WellKnownTypes";
|
|
52
|
|
|
53
|
// Wrapper message for `double`.
|
|
54
|
//
|
|
55
|
// The JSON representation for `DoubleValue` is JSON number.
|
|
56
|
message DoubleValue {
|
|
57
|
// The double value.
|
|
58
|
double value = 1;
|
|
59
|
}
|
|
60
|
|
|
61
|
// Wrapper message for `float`.
|
|
62
|
//
|
|
63
|
// The JSON representation for `FloatValue` is JSON number.
|
|
64
|
message FloatValue {
|
|
65
|
// The float value.
|
|
66
|
float value = 1;
|
|
67
|
}
|
|
68
|
|
|
69
|
// Wrapper message for `int64`.
|
|
70
|
//
|
|
71
|
// The JSON representation for `Int64Value` is JSON string.
|
|
72
|
message Int64Value {
|
|
73
|
// The int64 value.
|
|
74
|
int64 value = 1;
|
|
75
|
}
|
|
76
|
|
|
77
|
// Wrapper message for `uint64`.
|
|
78
|
//
|
|
79
|
// The JSON representation for `UInt64Value` is JSON string.
|
|
80
|
message UInt64Value {
|
|
81
|
// The uint64 value.
|
|
82
|
uint64 value = 1;
|
|
83
|
}
|
|
84
|
|
|
85
|
// Wrapper message for `int32`.
|
|
86
|
//
|
|
87
|
// The JSON representation for `Int32Value` is JSON number.
|
|
88
|
message Int32Value {
|
|
89
|
// The int32 value.
|
|
90
|
int32 value = 1;
|
|
91
|
}
|
|
92
|
|
|
93
|
// Wrapper message for `uint32`.
|
|
94
|
//
|
|
95
|
// The JSON representation for `UInt32Value` is JSON number.
|
|
96
|
message UInt32Value {
|
|
97
|
// The uint32 value.
|
|
98
|
uint32 value = 1;
|
|
99
|
}
|
|
100
|
|
|
101
|
// Wrapper message for `bool`.
|
|
102
|
//
|
|
103
|
// The JSON representation for `BoolValue` is JSON `true` and `false`.
|
|
104
|
message BoolValue {
|
|
105
|
// The bool value.
|
|
106
|
bool value = 1;
|
|
107
|
}
|
|
108
|
|
|
109
|
// Wrapper message for `string`.
|
|
110
|
//
|
|
111
|
// The JSON representation for `StringValue` is JSON string.
|
|
112
|
message StringValue {
|
|
113
|
// The string value.
|
|
114
|
string value = 1;
|
|
115
|
}
|
|
116
|
|
|
117
|
// Wrapper message for `bytes`.
|
|
118
|
//
|
|
119
|
// The JSON representation for `BytesValue` is JSON string.
|
|
120
|
message BytesValue {
|
|
121
|
// The bytes value.
|
|
122
|
bytes value = 1;
|
|
123
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/grpc/reflection/v1alpha/reflection.proto
|
|
@@ -0,0 1,136 @@
|
|
1
|
// Copyright 2016 gRPC authors.
|
|
2
|
//
|
|
3
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
4
|
// you may not use this file except in compliance with the License.
|
|
5
|
// You may obtain a copy of the License at
|
|
6
|
//
|
|
7
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
8
|
//
|
|
9
|
// Unless required by applicable law or agreed to in writing, software
|
|
10
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
11
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
12
|
// See the License for the specific language governing permissions and
|
|
13
|
// limitations under the License.
|
|
14
|
|
|
15
|
// Service exported by server reflection
|
|
16
|
|
|
17
|
syntax = "proto3";
|
|
18
|
|
|
19
|
package grpc.reflection.v1alpha;
|
|
20
|
|
|
21
|
service ServerReflection {
|
|
22
|
// The reflection service is structured as a bidirectional stream, ensuring
|
|
23
|
// all related requests go to a single server.
|
|
24
|
rpc ServerReflectionInfo(stream ServerReflectionRequest)
|
|
25
|
returns (stream ServerReflectionResponse);
|
|
26
|
}
|
|
27
|
|
|
28
|
// The message sent by the client when calling ServerReflectionInfo method.
|
|
29
|
message ServerReflectionRequest {
|
|
30
|
string host = 1;
|
|
31
|
// To use reflection service, the client should set one of the following
|
|
32
|
// fields in message_request. The server distinguishes requests by their
|
|
33
|
// defined field and then handles them using corresponding methods.
|
|
34
|
oneof message_request {
|
|
35
|
// Find a proto file by the file name.
|
|
36
|
string file_by_filename = 3;
|
|
37
|
|
|
38
|
// Find the proto file that declares the given fully-qualified symbol name.
|
|
39
|
// This field should be a fully-qualified symbol name
|
|
40
|
// (e.g. <package>.<service>[.<method>] or <package>.<type>).
|
|
41
|
string file_containing_symbol = 4;
|
|
42
|
|
|
43
|
// Find the proto file which defines an extension extending the given
|
|
44
|
// message type with the given field number.
|
|
45
|
ExtensionRequest file_containing_extension = 5;
|
|
46
|
|
|
47
|
// Finds the tag numbers used by all known extensions of the given message
|
|
48
|
// type, and appends them to ExtensionNumberResponse in an undefined order.
|
|
49
|
// Its corresponding method is best-effort: it's not guaranteed that the
|
|
50
|
// reflection service will implement this method, and it's not guaranteed
|
|
51
|
// that this method will provide all extensions. Returns
|
|
52
|
// StatusCode::UNIMPLEMENTED if it's not implemented.
|
|
53
|
// This field should be a fully-qualified type name. The format is
|
|
54
|
// <package>.<type>
|
|
55
|
string all_extension_numbers_of_type = 6;
|
|
56
|
|
|
57
|
// List the full names of registered services. The content will not be
|
|
58
|
// checked.
|
|
59
|
string list_services = 7;
|
|
60
|
}
|
|
61
|
}
|
|
62
|
|
|
63
|
// The type name and extension number sent by the client when requesting
|
|
64
|
// file_containing_extension.
|
|
65
|
message ExtensionRequest {
|
|
66
|
// Fully-qualified type name. The format should be <package>.<type>
|
|
67
|
string containing_type = 1;
|
|
68
|
int32 extension_number = 2;
|
|
69
|
}
|
|
70
|
|
|
71
|
// The message sent by the server to answer ServerReflectionInfo method.
|
|
72
|
message ServerReflectionResponse {
|
|
73
|
string valid_host = 1;
|
|
74
|
ServerReflectionRequest original_request = 2;
|
|
75
|
// The server set one of the following fields accroding to the message_request
|
|
76
|
// in the request.
|
|
77
|
oneof message_response {
|
|
78
|
// This message is used to answer file_by_filename, file_containing_symbol,
|
|
79
|
// file_containing_extension requests with transitive dependencies. As
|
|
80
|
// the repeated label is not allowed in oneof fields, we use a
|
|
81
|
// FileDescriptorResponse message to encapsulate the repeated fields.
|
|
82
|
// The reflection service is allowed to avoid sending FileDescriptorProtos
|
|
83
|
// that were previously sent in response to earlier requests in the stream.
|
|
84
|
FileDescriptorResponse file_descriptor_response = 4;
|
|
85
|
|
|
86
|
// This message is used to answer all_extension_numbers_of_type requst.
|
|
87
|
ExtensionNumberResponse all_extension_numbers_response = 5;
|
|
88
|
|
|
89
|
// This message is used to answer list_services request.
|
|
90
|
ListServiceResponse list_services_response = 6;
|
|
91
|
|
|
92
|
// This message is used when an error occurs.
|
|
93
|
ErrorResponse error_response = 7;
|
|
94
|
}
|
|
95
|
}
|
|
96
|
|
|
97
|
// Serialized FileDescriptorProto messages sent by the server answering
|
|
98
|
// a file_by_filename, file_containing_symbol, or file_containing_extension
|
|
99
|
// request.
|
|
100
|
message FileDescriptorResponse {
|
|
101
|
// Serialized FileDescriptorProto messages. We avoid taking a dependency on
|
|
102
|
// descriptor.proto, which uses proto2 only features, by making them opaque
|
|
103
|
// bytes instead.
|
|
104
|
repeated bytes file_descriptor_proto = 1;
|
|
105
|
}
|
|
106
|
|
|
107
|
// A list of extension numbers sent by the server answering
|
|
108
|
// all_extension_numbers_of_type request.
|
|
109
|
message ExtensionNumberResponse {
|
|
110
|
// Full name of the base type, including the package name. The format
|
|
111
|
// is <package>.<type>
|
|
112
|
string base_type_name = 1;
|
|
113
|
repeated int32 extension_number = 2;
|
|
114
|
}
|
|
115
|
|
|
116
|
// A list of ServiceResponse sent by the server answering list_services request.
|
|
117
|
message ListServiceResponse {
|
|
118
|
// The information of each service may be expanded in the future, so we use
|
|
119
|
// ServiceResponse message to encapsulate it.
|
|
120
|
repeated ServiceResponse service = 1;
|
|
121
|
}
|
|
122
|
|
|
123
|
// The information of a single service used by ListServiceResponse to answer
|
|
124
|
// list_services request.
|
|
125
|
message ServiceResponse {
|
|
126
|
// Full name of a registered service, including its package name. The format
|
|
127
|
// is <package>.<service>
|
|
128
|
string name = 1;
|
|
129
|
}
|
|
130
|
|
|
131
|
// The error code and error message sent by the server when an error occurs.
|
|
132
|
message ErrorResponse {
|
|
133
|
// This field uses the error codes defined in grpc::StatusCode.
|
|
134
|
int32 error_code = 1;
|
|
135
|
string error_message = 2;
|
|
136
|
}
|
|
|
\ No newline at end of file
|
added
priv/protos/modules/README.md
|
|
@@ -0,0 1 @@
|
|
1
|
# Temporary Module Files
|