From 6301ee43c54b0a2510a53b8c476a29067322346d Mon Sep 17 00:00:00 2001 From: Mike Nguyen Date: Mon, 19 Aug 2024 12:44:18 +0100 Subject: [PATCH] refactor!: dapr no longer requires protoc or tonic_build (#206) * refactor!: dapr no longer requires protoc or tonic_build The dapr crate no longer requires tonic_build or protoc to build. The examples have been moved into a separate crate. proto-gen is now compiling the dapr and example protos. Signed-off-by: mikeee * chore: fmt run Signed-off-by: mikeee * chore: update example names Signed-off-by: mikeee * fix: add a build step Signed-off-by: mikeee * test: remove ci build step and add it to the examples Signed-off-by: mikeee * fix: update validation workflows Signed-off-by: mikeee * tests: tweaks to timings Signed-off-by: mikeee --------- Signed-off-by: mikeee --- .github/workflows/ci.yml | 6 +- .github/workflows/validate-examples.yml | 3 - Cargo.toml | 116 +- build.rs | 15 - {macros => dapr-macros}/.gitignore | 0 {macros => dapr-macros}/Cargo.toml | 0 {macros => dapr-macros}/src/lib.rs | 4 +- dapr/Cargo.toml | 37 + {src => dapr/src}/appcallback.rs | 7 +- {src => dapr/src}/client.rs | 28 +- dapr/src/dapr/README.md | 3 + dapr/src/dapr/dapr.proto.common.v1.rs | 280 + dapr/src/dapr/dapr.proto.runtime.v1.rs | 8270 +++++++++++++++++ dapr/src/dapr/types.bin | Bin 0 -> 120951 bytes {src => dapr/src}/error.rs | 0 {src => dapr/src}/lib.rs | 17 +- .../src}/server/actor/context_client.rs | 2 +- {src => dapr/src}/server/actor/mod.rs | 0 {src => dapr/src}/server/actor/runtime/mod.rs | 0 {src => dapr/src}/server/actor/tests.rs | 0 {src => dapr/src}/server/appcallbackalpha.rs | 4 +- {src => dapr/src}/server/http.rs | 0 {src => dapr/src}/server/mod.rs | 0 {src => dapr/src}/server/models.rs | 0 {src => dapr/src}/server/utils.rs | 0 examples/Cargo.toml | 90 + examples/README.md | 4 +- .../helloworld}/helloworld.proto | 0 examples/{ => src}/actors/README.md | 21 +- examples/{ => src}/actors/client.rs | 0 examples/{ => src}/actors/dapr.yaml | 4 +- .../{ => src}/actors/resources/redis.yaml | 0 examples/{ => src}/actors/server.rs | 0 examples/{ => src}/bindings/README.md | 21 +- .../bindings/components/bindings.yml | 0 examples/{ => src}/bindings/dapr.yaml | 4 +- examples/{ => src}/bindings/input.rs | 6 +- examples/{ => src}/bindings/output.rs | 0 examples/{ => src}/client/README.md | 11 +- examples/{ => src}/client/client.rs | 0 .../{ => src}/client/resources/redis.yaml | 0 .../{ => src}/components/configstore.yaml | 0 examples/{ => src}/configuration/README.md | 9 + examples/{ => src}/configuration/main.rs | 0 examples/{ => src}/crypto/README.md | 25 +- .../crypto/components/local-storage.yml | 0 examples/{ => src}/crypto/dapr.yaml | 0 examples/{ => src}/crypto/image.png | Bin examples/{ => src}/crypto/main.rs | 0 .../{ => src}/invoke/grpc-proxying/README.md | 13 +- .../{ => src}/invoke/grpc-proxying/client.rs | 2 +- .../{ => src}/invoke/grpc-proxying/dapr.yaml | 0 .../grpc-proxying/resources/resiliency.yaml | 0 .../{ => src}/invoke/grpc-proxying/server.rs | 2 +- examples/{ => src}/invoke/grpc/README.md | 13 +- examples/{ => src}/invoke/grpc/client.rs | 6 +- examples/{ => src}/invoke/grpc/dapr.yaml | 0 .../invoke/grpc/resources/resiliency.yaml | 0 examples/{ => src}/invoke/grpc/server.rs | 7 +- examples/src/invoke/protos/helloworld.rs | 298 + examples/src/invoke/protos/types.bin | Bin 0 -> 458 bytes examples/{ => src}/jobs/README.md | 19 +- examples/{ => src}/jobs/dapr.yaml | 0 examples/{ => src}/jobs/jobs.rs | 7 +- examples/{ => src}/pubsub/README.md | 29 +- examples/{ => src}/pubsub/dapr.yaml | 4 +- examples/{ => src}/pubsub/publisher.rs | 5 + .../{ => src}/pubsub/resources/pubsub.yaml | 2 +- .../pubsub/resources/resiliency.yaml | 0 examples/{ => src}/pubsub/subscriber.rs | 5 +- examples/{ => src}/query_state/README.md | 13 +- examples/{ => src}/query_state/query1.rs | 0 examples/{ => src}/query_state/query2.rs | 0 .../query_state/statestore/dataset.json | 0 .../query_state/statestore/mongodb.yml | 0 examples/{ => src}/secrets-bulk/README.md | 11 +- examples/{ => src}/secrets-bulk/app.rs | 0 .../resources/local-secret-store.yaml | 0 examples/{ => src}/secrets-bulk/secrets.json | 0 examples/validate.sh | 2 +- proto-gen/Cargo.toml | 12 + proto-gen/src/main.rs | 74 + .../dapr}/proto/common/v1/common.proto | 0 .../dapr}/proto/runtime/v1/appcallback.proto | 0 .../dapr}/proto/runtime/v1/dapr.proto | 0 src/dapr.rs | 15 - 86 files changed, 9298 insertions(+), 228 deletions(-) delete mode 100644 build.rs rename {macros => dapr-macros}/.gitignore (100%) rename {macros => dapr-macros}/Cargo.toml (100%) rename {macros => dapr-macros}/src/lib.rs (99%) create mode 100644 dapr/Cargo.toml rename {src => dapr/src}/appcallback.rs (97%) rename {src => dapr/src}/client.rs (96%) create mode 100644 dapr/src/dapr/README.md create mode 100644 dapr/src/dapr/dapr.proto.common.v1.rs create mode 100644 dapr/src/dapr/dapr.proto.runtime.v1.rs create mode 100644 dapr/src/dapr/types.bin rename {src => dapr/src}/error.rs (100%) rename {src => dapr/src}/lib.rs (55%) rename {src => dapr/src}/server/actor/context_client.rs (99%) rename {src => dapr/src}/server/actor/mod.rs (100%) rename {src => dapr/src}/server/actor/runtime/mod.rs (100%) rename {src => dapr/src}/server/actor/tests.rs (100%) rename {src => dapr/src}/server/appcallbackalpha.rs (95%) rename {src => dapr/src}/server/http.rs (100%) rename {src => dapr/src}/server/mod.rs (100%) rename {src => dapr/src}/server/models.rs (100%) rename {src => dapr/src}/server/utils.rs (100%) create mode 100644 examples/Cargo.toml rename examples/{invoke/proto => proto/helloworld}/helloworld.proto (100%) rename examples/{ => src}/actors/README.md (93%) rename examples/{ => src}/actors/client.rs (100%) rename examples/{ => src}/actors/dapr.yaml (69%) rename examples/{ => src}/actors/resources/redis.yaml (100%) rename examples/{ => src}/actors/server.rs (100%) rename examples/{ => src}/bindings/README.md (89%) rename examples/{ => src}/bindings/components/bindings.yml (100%) rename examples/{ => src}/bindings/dapr.yaml (69%) rename examples/{ => src}/bindings/input.rs (92%) rename examples/{ => src}/bindings/output.rs (100%) rename examples/{ => src}/client/README.md (89%) rename examples/{ => src}/client/client.rs (100%) rename examples/{ => src}/client/resources/redis.yaml (100%) rename examples/{ => src}/components/configstore.yaml (100%) rename examples/{ => src}/configuration/README.md (95%) rename examples/{ => src}/configuration/main.rs (100%) rename examples/{ => src}/crypto/README.md (70%) rename examples/{ => src}/crypto/components/local-storage.yml (100%) rename examples/{ => src}/crypto/dapr.yaml (100%) rename examples/{ => src}/crypto/image.png (100%) rename examples/{ => src}/crypto/main.rs (100%) rename examples/{ => src}/invoke/grpc-proxying/README.md (91%) rename examples/{ => src}/invoke/grpc-proxying/client.rs (90%) rename examples/{ => src}/invoke/grpc-proxying/dapr.yaml (100%) rename examples/{ => src}/invoke/grpc-proxying/resources/resiliency.yaml (100%) rename examples/{ => src}/invoke/grpc-proxying/server.rs (91%) rename examples/{ => src}/invoke/grpc/README.md (96%) rename examples/{ => src}/invoke/grpc/client.rs (84%) rename examples/{ => src}/invoke/grpc/dapr.yaml (100%) rename examples/{ => src}/invoke/grpc/resources/resiliency.yaml (100%) rename examples/{ => src}/invoke/grpc/server.rs (94%) create mode 100644 examples/src/invoke/protos/helloworld.rs create mode 100644 examples/src/invoke/protos/types.bin rename examples/{ => src}/jobs/README.md (69%) rename examples/{ => src}/jobs/dapr.yaml (100%) rename examples/{ => src}/jobs/jobs.rs (95%) rename examples/{ => src}/pubsub/README.md (92%) rename examples/{ => src}/pubsub/dapr.yaml (68%) rename examples/{ => src}/pubsub/publisher.rs (95%) rename examples/{ => src}/pubsub/resources/pubsub.yaml (92%) rename examples/{ => src}/pubsub/resources/resiliency.yaml (100%) rename examples/{ => src}/pubsub/subscriber.rs (88%) rename examples/{ => src}/query_state/README.md (96%) rename examples/{ => src}/query_state/query1.rs (100%) rename examples/{ => src}/query_state/query2.rs (100%) rename examples/{ => src}/query_state/statestore/dataset.json (100%) rename examples/{ => src}/query_state/statestore/mongodb.yml (100%) rename examples/{ => src}/secrets-bulk/README.md (91%) rename examples/{ => src}/secrets-bulk/app.rs (100%) rename examples/{ => src}/secrets-bulk/resources/local-secret-store.yaml (100%) rename examples/{ => src}/secrets-bulk/secrets.json (100%) create mode 100644 proto-gen/Cargo.toml create mode 100644 proto-gen/src/main.rs rename {dapr => proto/dapr}/proto/common/v1/common.proto (100%) rename {dapr => proto/dapr}/proto/runtime/v1/appcallback.proto (100%) rename {dapr => proto/dapr}/proto/runtime/v1/dapr.proto (100%) delete mode 100644 src/dapr.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6e56cf41..2984f68d 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -82,7 +82,7 @@ jobs: with: version: ${{ env.PROTOC_VERSION }} - uses: actions/checkout@v2 - - name: cargo publish macros - run: cargo publish --manifest-path macros/Cargo.toml --token ${{ env.CARGO_TOKEN }} - - name: cargo publish + - name: cargo publish dapr-macros + run: cargo publish --manifest-path dapr-macros/Cargo.toml --token ${{ env.CARGO_TOKEN }} + - name: cargo publish dapr run: cargo publish --token ${{ env.CARGO_TOKEN }} diff --git a/.github/workflows/validate-examples.yml b/.github/workflows/validate-examples.yml index 2e9b3942..4af707a2 100644 --- a/.github/workflows/validate-examples.yml +++ b/.github/workflows/validate-examples.yml @@ -294,9 +294,6 @@ jobs: python -m pip install --upgrade pip pip install mechanical-markdown - - name: Cargo Build Examples - run: cargo build --examples - - name: Dapr version run: | dapr version diff --git a/Cargo.toml b/Cargo.toml index 6c7ebf71..a538c3d3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,108 +1,8 @@ -[package] -name = "dapr" -version = "0.15.0" -authors = ["dapr.io"] -edition = "2021" -license = "Apache-2.0" -repository = "https://github.com/dapr/rust-sdk" -description = "Rust SDK for dapr" -readme = "README.md" -keywords = ["microservices", "dapr"] - -[dependencies] -dapr-macros = { version = "0.15.0", path = "macros" } -futures = "0.3" -tonic = "0.11.0" -prost = "0.12.3" -bytes = "1" -prost-types = "0.12.3" -async-trait = "0.1" -env_logger = "0.11.2" -log = "0.4" -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -axum = "0.7.4" -tokio = { version = "1.29", features = ["sync"] } -tokio-util = { version = "0.7.10", features = ["io"] } -chrono = "0.4.38" -base64 = "0.22.1" - -[build-dependencies] -tonic-build = "0.11.0" - -[dev-dependencies] -axum-test = "15.0.1" -once_cell = "1.18.0" -tokio = { version = "1", features = ["full"] } -uuid = { version = "1.4.0", features = ["v4"] } -dapr = { path = "./" } -tokio-test = "0.4.2" -tokio-stream = { version = "0.1" } - -[[example]] -name = "actor-client" -path = "examples/actors/client.rs" - -[[example]] -name = "actor-server" -path = "examples/actors/server.rs" - -[[example]] -name = "client" -path = "examples/client/client.rs" - -[[example]] -name = "configuration" -path = "examples/configuration/main.rs" - -[[example]] -name = "crypto" -path = "examples/crypto/main.rs" - -[[example]] -name = "invoke-grpc-client" -path = "examples/invoke/grpc/client.rs" - -[[example]] -name = "invoke-grpc-server" -path = "examples/invoke/grpc/server.rs" - -[[example]] -name = "invoke-grpc-proxying-client" -path = "examples/invoke/grpc-proxying/client.rs" - -[[example]] -name = "invoke-grpc-proxying-server" -path = "examples/invoke/grpc-proxying/server.rs" - -[[example]] -name = "jobs" -path = "examples/jobs/jobs.rs" - -[[example]] -name = "publisher" -path = "examples/pubsub/publisher.rs" - -[[example]] -name = "subscriber" -path = "examples/pubsub/subscriber.rs" - -[[example]] -name = "output-bindings" -path = "examples/bindings/output.rs" - -[[example]] -name = "input-bindings" -path = "examples/bindings/input.rs" - -[[example]] -name = "query_state_q1" -path = "examples/query_state/query1.rs" - -[[example]] -name = "query_state_q2" -path = "examples/query_state/query2.rs" - -[[example]] -name = "secrets-bulk" -path = "examples/secrets-bulk/app.rs" +[workspace] +members = [ + "dapr", + "dapr-macros", + "examples", + "proto-gen", +] +resolver = "2" diff --git a/build.rs b/build.rs deleted file mode 100644 index 3215fafd..00000000 --- a/build.rs +++ /dev/null @@ -1,15 +0,0 @@ -// use std::env; - -fn main() -> Result<(), std::io::Error> { - // env::set_var("OUT_DIR", "src"); - tonic_build::configure().build_server(true).compile( - &[ - "dapr/proto/common/v1/common.proto", - "dapr/proto/runtime/v1/dapr.proto", - "dapr/proto/runtime/v1/appcallback.proto", - "examples/invoke/proto/helloworld.proto", - ], - &["."], - )?; - Ok(()) -} diff --git a/macros/.gitignore b/dapr-macros/.gitignore similarity index 100% rename from macros/.gitignore rename to dapr-macros/.gitignore diff --git a/macros/Cargo.toml b/dapr-macros/Cargo.toml similarity index 100% rename from macros/Cargo.toml rename to dapr-macros/Cargo.toml diff --git a/macros/src/lib.rs b/dapr-macros/src/lib.rs similarity index 99% rename from macros/src/lib.rs rename to dapr-macros/src/lib.rs index 00895196..a6e5a437 100644 --- a/macros/src/lib.rs +++ b/dapr-macros/src/lib.rs @@ -3,8 +3,8 @@ use std::iter; use proc_macro2::TokenTree; use quote::{format_ident, quote}; -use syn::{Ident, LitStr, parse_macro_input}; use syn::parse::{Parse, ParseStream}; +use syn::{parse_macro_input, Ident, LitStr}; macro_rules! derive_parse {( @derive_only @@ -236,4 +236,4 @@ pub fn topic(args: TokenStream, input: TokenStream) -> TokenStream { }; tokens.into() -} \ No newline at end of file +} diff --git a/dapr/Cargo.toml b/dapr/Cargo.toml new file mode 100644 index 00000000..dbdeae4d --- /dev/null +++ b/dapr/Cargo.toml @@ -0,0 +1,37 @@ +[package] +name = "dapr" +version = "0.15.0" +authors = ["dapr.io"] +edition = "2021" +license = "Apache-2.0" +repository = "https://github.com/dapr/rust-sdk" +description = "Rust SDK for dapr" +readme = "../README.md" +keywords = ["microservices", "dapr"] + +[dependencies] +dapr-macros = { version = "0.15.0", path = "../dapr-macros" } +futures = "0.3" +tonic = "0.11.0" +prost = "0.12.3" +bytes = "1" +prost-types = "0.12.3" +async-trait = "0.1" +env_logger = "0.11.2" +log = "0.4" +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" +axum = "0.7.4" +tokio = { version = "1.29", features = ["sync"] } +tokio-util = { version = "0.7.10", features = ["io"] } +chrono = "0.4.38" +base64 = "0.22.1" + +[dev-dependencies] +axum-test = "15.0.1" +once_cell = "1.18.0" +tokio = { version = "1", features = ["full"] } +uuid = { version = "1.4.0", features = ["v4"] } +dapr = { path = "./" } +tokio-test = "0.4.2" +tokio-stream = { version = "0.1" } \ No newline at end of file diff --git a/src/appcallback.rs b/dapr/src/appcallback.rs similarity index 97% rename from src/appcallback.rs rename to dapr/src/appcallback.rs index a60efcfe..87675ee5 100644 --- a/src/appcallback.rs +++ b/dapr/src/appcallback.rs @@ -1,10 +1,9 @@ +use crate::dapr; +use crate::dapr::proto::runtime::v1::app_callback_server::AppCallback; +use crate::dapr::proto::{common, runtime}; use std::collections::HashMap; use tonic::{Code, Request, Response, Status}; -use crate::dapr::dapr::proto::runtime::v1::app_callback_server::AppCallback; -use crate::dapr::dapr::proto::{common, runtime}; -use crate::dapr::*; - /// InvokeRequest is the message to invoke a method with the data. pub type InvokeRequest = dapr::proto::common::v1::InvokeRequest; diff --git a/src/client.rs b/dapr/src/client.rs similarity index 96% rename from src/client.rs rename to dapr/src/client.rs index dbd24e4e..0c34249f 100644 --- a/src/client.rs +++ b/dapr/src/client.rs @@ -1,5 +1,4 @@ use std::collections::HashMap; -use std::fmt::Debug; use async_trait::async_trait; use futures::StreamExt; @@ -11,7 +10,7 @@ use tonic::codegen::tokio_stream; use tonic::{transport::Channel as TonicChannel, Request}; use tonic::{Status, Streaming}; -use crate::dapr::dapr::proto::{common::v1 as common_v1, runtime::v1 as dapr_v1}; +use crate::dapr::proto::{common::v1 as common_v1, runtime::v1 as dapr_v1}; use crate::error::Error; #[derive(Clone)] @@ -876,39 +875,39 @@ pub type UnsubscribeConfigurationResponse = dapr_v1::UnsubscribeConfigurationRes pub type TonicClient = dapr_v1::dapr_client::DaprClient; /// Encryption gRPC request -pub type EncryptRequest = crate::dapr::dapr::proto::runtime::v1::EncryptRequest; +pub type EncryptRequest = crate::dapr::proto::runtime::v1::EncryptRequest; /// Decrypt gRPC request -pub type DecryptRequest = crate::dapr::dapr::proto::runtime::v1::DecryptRequest; +pub type DecryptRequest = crate::dapr::proto::runtime::v1::DecryptRequest; /// Encryption request options -pub type EncryptRequestOptions = crate::dapr::dapr::proto::runtime::v1::EncryptRequestOptions; +pub type EncryptRequestOptions = crate::dapr::proto::runtime::v1::EncryptRequestOptions; /// Decryption request options -pub type DecryptRequestOptions = crate::dapr::dapr::proto::runtime::v1::DecryptRequestOptions; +pub type DecryptRequestOptions = crate::dapr::proto::runtime::v1::DecryptRequestOptions; /// The basic job structure -pub type Job = crate::dapr::dapr::proto::runtime::v1::Job; +pub type Job = crate::dapr::proto::runtime::v1::Job; /// A request to schedule a job -pub type ScheduleJobRequest = crate::dapr::dapr::proto::runtime::v1::ScheduleJobRequest; +pub type ScheduleJobRequest = crate::dapr::proto::runtime::v1::ScheduleJobRequest; /// A response from a schedule job request -pub type ScheduleJobResponse = crate::dapr::dapr::proto::runtime::v1::ScheduleJobResponse; +pub type ScheduleJobResponse = crate::dapr::proto::runtime::v1::ScheduleJobResponse; /// A request to get a job -pub type GetJobRequest = crate::dapr::dapr::proto::runtime::v1::GetJobRequest; +pub type GetJobRequest = crate::dapr::proto::runtime::v1::GetJobRequest; /// A response from a get job request -pub type GetJobResponse = crate::dapr::dapr::proto::runtime::v1::GetJobResponse; +pub type GetJobResponse = crate::dapr::proto::runtime::v1::GetJobResponse; /// A request to delete a job -pub type DeleteJobRequest = crate::dapr::dapr::proto::runtime::v1::DeleteJobRequest; +pub type DeleteJobRequest = crate::dapr::proto::runtime::v1::DeleteJobRequest; /// A response from a delete job request -pub type DeleteJobResponse = crate::dapr::dapr::proto::runtime::v1::DeleteJobResponse; +pub type DeleteJobResponse = crate::dapr::proto::runtime::v1::DeleteJobResponse; -type StreamPayload = crate::dapr::dapr::proto::common::v1::StreamPayload; +type StreamPayload = crate::dapr::proto::common::v1::StreamPayload; impl From<(K, Vec)> for common_v1::StateItem where K: Into, @@ -930,7 +929,6 @@ impl ReaderStream { } } -#[derive(Debug)] pub struct JobBuilder { schedule: Option, data: Option, diff --git a/dapr/src/dapr/README.md b/dapr/src/dapr/README.md new file mode 100644 index 00000000..305267a5 --- /dev/null +++ b/dapr/src/dapr/README.md @@ -0,0 +1,3 @@ +# dapr + +These are compiled by running the proto-gen crate \ No newline at end of file diff --git a/dapr/src/dapr/dapr.proto.common.v1.rs b/dapr/src/dapr/dapr.proto.common.v1.rs new file mode 100644 index 00000000..a8657cd6 --- /dev/null +++ b/dapr/src/dapr/dapr.proto.common.v1.rs @@ -0,0 +1,280 @@ +// This file is @generated by prost-build. +/// HTTPExtension includes HTTP verb and querystring +/// when Dapr runtime delivers HTTP content. +/// +/// For example, when callers calls http invoke api +/// POST /method/?query1=value1&query2=value2> +/// +/// Dapr runtime will parse POST as a verb and extract querystring to quersytring map. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HttpExtension { + /// Required. HTTP verb. + #[prost(enumeration = "http_extension::Verb", tag = "1")] + pub verb: i32, + /// Optional. querystring represents an encoded HTTP url query string in the following format: name=value&name2=value2 + #[prost(string, tag = "2")] + pub querystring: ::prost::alloc::string::String, +} +/// Nested message and enum types in `HTTPExtension`. +pub mod http_extension { + /// Type of HTTP 1.1 Methods + /// RFC 7231: + /// RFC 5789: + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Verb { + None = 0, + Get = 1, + Head = 2, + Post = 3, + Put = 4, + Delete = 5, + Connect = 6, + Options = 7, + Trace = 8, + Patch = 9, + } + impl Verb { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Verb::None => "NONE", + Verb::Get => "GET", + Verb::Head => "HEAD", + Verb::Post => "POST", + Verb::Put => "PUT", + Verb::Delete => "DELETE", + Verb::Connect => "CONNECT", + Verb::Options => "OPTIONS", + Verb::Trace => "TRACE", + Verb::Patch => "PATCH", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "NONE" => Some(Self::None), + "GET" => Some(Self::Get), + "HEAD" => Some(Self::Head), + "POST" => Some(Self::Post), + "PUT" => Some(Self::Put), + "DELETE" => Some(Self::Delete), + "CONNECT" => Some(Self::Connect), + "OPTIONS" => Some(Self::Options), + "TRACE" => Some(Self::Trace), + "PATCH" => Some(Self::Patch), + _ => None, + } + } + } +} +/// InvokeRequest is the message to invoke a method with the data. +/// This message is used in InvokeService of Dapr gRPC Service and OnInvoke +/// of AppCallback gRPC service. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeRequest { + /// Required. method is a method name which will be invoked by caller. + #[prost(string, tag = "1")] + pub method: ::prost::alloc::string::String, + /// Required in unary RPCs. Bytes value or Protobuf message which caller sent. + /// Dapr treats Any.value as bytes type if Any.type_url is unset. + #[prost(message, optional, tag = "2")] + pub data: ::core::option::Option<::prost_types::Any>, + /// The type of data content. + /// + /// This field is required if data delivers http request body + /// Otherwise, this is optional. + #[prost(string, tag = "3")] + pub content_type: ::prost::alloc::string::String, + /// HTTP specific fields if request conveys http-compatible request. + /// + /// This field is required for http-compatible request. Otherwise, + /// this field is optional. + #[prost(message, optional, tag = "4")] + pub http_extension: ::core::option::Option, +} +/// InvokeResponse is the response message including data and its content type +/// from app callback. +/// This message is used in InvokeService of Dapr gRPC Service and OnInvoke +/// of AppCallback gRPC service. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeResponse { + /// Required in unary RPCs. The content body of InvokeService response. + #[prost(message, optional, tag = "1")] + pub data: ::core::option::Option<::prost_types::Any>, + /// Required. The type of data content. + #[prost(string, tag = "2")] + pub content_type: ::prost::alloc::string::String, +} +/// Chunk of data sent in a streaming request or response. +/// This is used in requests including InternalInvokeRequestStream. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StreamPayload { + /// Data sent in the chunk. + /// The amount of data included in each chunk is up to the discretion of the sender, and can be empty. + /// Additionally, the amount of data doesn't need to be fixed and subsequent messages can send more, or less, data. + /// Receivers must not make assumptions about the number of bytes they'll receive in each chunk. + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, + /// Sequence number. This is a counter that starts from 0 and increments by 1 on each chunk sent. + #[prost(uint64, tag = "2")] + pub seq: u64, +} +/// StateItem represents state key, value, and additional options to save state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StateItem { + /// Required. The state key + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + /// Required. The state data for key + #[prost(bytes = "vec", tag = "2")] + pub value: ::prost::alloc::vec::Vec, + /// The entity tag which represents the specific version of data. + /// The exact ETag format is defined by the corresponding data store. + #[prost(message, optional, tag = "3")] + pub etag: ::core::option::Option, + /// The metadata which will be passed to state store component. + #[prost(map = "string, string", tag = "4")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// Options for concurrency and consistency to save the state. + #[prost(message, optional, tag = "5")] + pub options: ::core::option::Option, +} +/// Etag represents a state item version +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Etag { + /// value sets the etag value + #[prost(string, tag = "1")] + pub value: ::prost::alloc::string::String, +} +/// StateOptions configures concurrency and consistency for state operations +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StateOptions { + #[prost(enumeration = "state_options::StateConcurrency", tag = "1")] + pub concurrency: i32, + #[prost(enumeration = "state_options::StateConsistency", tag = "2")] + pub consistency: i32, +} +/// Nested message and enum types in `StateOptions`. +pub mod state_options { + /// Enum describing the supported concurrency for state. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum StateConcurrency { + ConcurrencyUnspecified = 0, + ConcurrencyFirstWrite = 1, + ConcurrencyLastWrite = 2, + } + impl StateConcurrency { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + StateConcurrency::ConcurrencyUnspecified => "CONCURRENCY_UNSPECIFIED", + StateConcurrency::ConcurrencyFirstWrite => "CONCURRENCY_FIRST_WRITE", + StateConcurrency::ConcurrencyLastWrite => "CONCURRENCY_LAST_WRITE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CONCURRENCY_UNSPECIFIED" => Some(Self::ConcurrencyUnspecified), + "CONCURRENCY_FIRST_WRITE" => Some(Self::ConcurrencyFirstWrite), + "CONCURRENCY_LAST_WRITE" => Some(Self::ConcurrencyLastWrite), + _ => None, + } + } + } + /// Enum describing the supported consistency for state. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum StateConsistency { + ConsistencyUnspecified = 0, + ConsistencyEventual = 1, + ConsistencyStrong = 2, + } + impl StateConsistency { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + StateConsistency::ConsistencyUnspecified => "CONSISTENCY_UNSPECIFIED", + StateConsistency::ConsistencyEventual => "CONSISTENCY_EVENTUAL", + StateConsistency::ConsistencyStrong => "CONSISTENCY_STRONG", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CONSISTENCY_UNSPECIFIED" => Some(Self::ConsistencyUnspecified), + "CONSISTENCY_EVENTUAL" => Some(Self::ConsistencyEventual), + "CONSISTENCY_STRONG" => Some(Self::ConsistencyStrong), + _ => None, + } + } + } +} +/// ConfigurationItem represents all the configuration with its name(key). +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConfigurationItem { + /// Required. The value of configuration item. + #[prost(string, tag = "1")] + pub value: ::prost::alloc::string::String, + /// Version is response only and cannot be fetched. Store is not expected to keep all versions available + #[prost(string, tag = "2")] + pub version: ::prost::alloc::string::String, + /// the metadata which will be passed to/from configuration store component. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} diff --git a/dapr/src/dapr/dapr.proto.runtime.v1.rs b/dapr/src/dapr/dapr.proto.runtime.v1.rs new file mode 100644 index 00000000..1ec07647 --- /dev/null +++ b/dapr/src/dapr/dapr.proto.runtime.v1.rs @@ -0,0 +1,8270 @@ +// This file is @generated by prost-build. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JobEventRequest { + /// Job name. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Job data to be sent back to app. + #[prost(message, optional, tag = "2")] + pub data: ::core::option::Option<::prost_types::Any>, + /// Required. method is a method name which will be invoked by caller. + #[prost(string, tag = "3")] + pub method: ::prost::alloc::string::String, + /// The type of data content. + /// + /// This field is required if data delivers http request body + /// Otherwise, this is optional. + #[prost(string, tag = "4")] + pub content_type: ::prost::alloc::string::String, + /// HTTP specific fields if request conveys http-compatible request. + /// + /// This field is required for http-compatible request. Otherwise, + /// this field is optional. + #[prost(message, optional, tag = "5")] + pub http_extension: ::core::option::Option, +} +/// JobEventResponse is the response from the app when a job is triggered. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JobEventResponse {} +/// TopicEventRequest message is compatible with CloudEvent spec v1.0 +/// +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventRequest { + /// id identifies the event. Producers MUST ensure that source + id + /// is unique for each distinct event. If a duplicate event is re-sent + /// (e.g. due to a network error) it MAY have the same id. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// source identifies the context in which an event happened. + /// Often this will include information such as the type of the + /// event source, the organization publishing the event or the process + /// that produced the event. The exact syntax and semantics behind + /// the data encoded in the URI is defined by the event producer. + #[prost(string, tag = "2")] + pub source: ::prost::alloc::string::String, + /// The type of event related to the originating occurrence. + #[prost(string, tag = "3")] + pub r#type: ::prost::alloc::string::String, + /// The version of the CloudEvents specification. + #[prost(string, tag = "4")] + pub spec_version: ::prost::alloc::string::String, + /// The content type of data value. + #[prost(string, tag = "5")] + pub data_content_type: ::prost::alloc::string::String, + /// The content of the event. + #[prost(bytes = "vec", tag = "7")] + pub data: ::prost::alloc::vec::Vec, + /// The pubsub topic which publisher sent to. + #[prost(string, tag = "6")] + pub topic: ::prost::alloc::string::String, + /// The name of the pubsub the publisher sent to. + #[prost(string, tag = "8")] + pub pubsub_name: ::prost::alloc::string::String, + /// The matching path from TopicSubscription/routes (if specified) for this event. + /// This value is used by OnTopicEvent to "switch" inside the handler. + #[prost(string, tag = "9")] + pub path: ::prost::alloc::string::String, + /// The map of additional custom properties to be sent to the app. These are considered to be cloud event extensions. + #[prost(message, optional, tag = "10")] + pub extensions: ::core::option::Option<::prost_types::Struct>, +} +/// TopicEventResponse is response from app on published message +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventResponse { + /// The list of output bindings. + #[prost(enumeration = "topic_event_response::TopicEventResponseStatus", tag = "1")] + pub status: i32, +} +/// Nested message and enum types in `TopicEventResponse`. +pub mod topic_event_response { + /// TopicEventResponseStatus allows apps to have finer control over handling of the message. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum TopicEventResponseStatus { + /// SUCCESS is the default behavior: message is acknowledged and not retried or logged. + Success = 0, + /// RETRY status signals Dapr to retry the message as part of an expected scenario (no warning is logged). + Retry = 1, + /// DROP status signals Dapr to drop the message as part of an unexpected scenario (warning is logged). + Drop = 2, + } + impl TopicEventResponseStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TopicEventResponseStatus::Success => "SUCCESS", + TopicEventResponseStatus::Retry => "RETRY", + TopicEventResponseStatus::Drop => "DROP", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SUCCESS" => Some(Self::Success), + "RETRY" => Some(Self::Retry), + "DROP" => Some(Self::Drop), + _ => None, + } + } + } +} +/// TopicEventCERequest message is compatible with CloudEvent spec v1.0 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventCeRequest { + /// The unique identifier of this cloud event. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// source identifies the context in which an event happened. + #[prost(string, tag = "2")] + pub source: ::prost::alloc::string::String, + /// The type of event related to the originating occurrence. + #[prost(string, tag = "3")] + pub r#type: ::prost::alloc::string::String, + /// The version of the CloudEvents specification. + #[prost(string, tag = "4")] + pub spec_version: ::prost::alloc::string::String, + /// The content type of data value. + #[prost(string, tag = "5")] + pub data_content_type: ::prost::alloc::string::String, + /// The content of the event. + #[prost(bytes = "vec", tag = "6")] + pub data: ::prost::alloc::vec::Vec, + /// Custom attributes which includes cloud event extensions. + #[prost(message, optional, tag = "7")] + pub extensions: ::core::option::Option<::prost_types::Struct>, +} +/// TopicEventBulkRequestEntry represents a single message inside a bulk request +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventBulkRequestEntry { + /// Unique identifier for the message. + #[prost(string, tag = "1")] + pub entry_id: ::prost::alloc::string::String, + /// content type of the event contained. + #[prost(string, tag = "4")] + pub content_type: ::prost::alloc::string::String, + /// The metadata associated with the event. + #[prost(map = "string, string", tag = "5")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The content of the event. + #[prost(oneof = "topic_event_bulk_request_entry::Event", tags = "2, 3")] + pub event: ::core::option::Option, +} +/// Nested message and enum types in `TopicEventBulkRequestEntry`. +pub mod topic_event_bulk_request_entry { + /// The content of the event. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Event { + #[prost(bytes, tag = "2")] + Bytes(::prost::alloc::vec::Vec), + #[prost(message, tag = "3")] + CloudEvent(super::TopicEventCeRequest), + } +} +/// TopicEventBulkRequest represents request for bulk message +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventBulkRequest { + /// Unique identifier for the bulk request. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// The list of items inside this bulk request. + #[prost(message, repeated, tag = "2")] + pub entries: ::prost::alloc::vec::Vec, + /// The metadata associated with the this bulk request. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The pubsub topic which publisher sent to. + #[prost(string, tag = "4")] + pub topic: ::prost::alloc::string::String, + /// The name of the pubsub the publisher sent to. + #[prost(string, tag = "5")] + pub pubsub_name: ::prost::alloc::string::String, + /// The type of event related to the originating occurrence. + #[prost(string, tag = "6")] + pub r#type: ::prost::alloc::string::String, + /// The matching path from TopicSubscription/routes (if specified) for this event. + /// This value is used by OnTopicEvent to "switch" inside the handler. + #[prost(string, tag = "7")] + pub path: ::prost::alloc::string::String, +} +/// TopicEventBulkResponseEntry Represents single response, as part of TopicEventBulkResponse, to be +/// sent by subscibed App for the corresponding single message during bulk subscribe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventBulkResponseEntry { + /// Unique identifier associated the message. + #[prost(string, tag = "1")] + pub entry_id: ::prost::alloc::string::String, + /// The status of the response. + #[prost(enumeration = "topic_event_response::TopicEventResponseStatus", tag = "2")] + pub status: i32, +} +/// AppBulkResponse is response from app on published message +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicEventBulkResponse { + /// The list of all responses for the bulk request. + #[prost(message, repeated, tag = "1")] + pub statuses: ::prost::alloc::vec::Vec, +} +/// BindingEventRequest represents input bindings event. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BindingEventRequest { + /// Required. The name of the input binding component. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Required. The payload that the input bindings sent + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + /// The metadata set by the input binging components. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// BindingEventResponse includes operations to save state or +/// send data to output bindings optionally. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BindingEventResponse { + /// The name of state store where states are saved. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The state key values which will be stored in store_name. + #[prost(message, repeated, tag = "2")] + pub states: ::prost::alloc::vec::Vec, + /// The list of output bindings. + #[prost(string, repeated, tag = "3")] + pub to: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The content which will be sent to "to" output bindings. + #[prost(bytes = "vec", tag = "4")] + pub data: ::prost::alloc::vec::Vec, + /// The concurrency of output bindings to send data to + /// "to" output bindings list. The default is SEQUENTIAL. + #[prost(enumeration = "binding_event_response::BindingEventConcurrency", tag = "5")] + pub concurrency: i32, +} +/// Nested message and enum types in `BindingEventResponse`. +pub mod binding_event_response { + /// BindingEventConcurrency is the kind of concurrency + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum BindingEventConcurrency { + /// SEQUENTIAL sends data to output bindings specified in "to" sequentially. + Sequential = 0, + /// PARALLEL sends data to output bindings specified in "to" in parallel. + Parallel = 1, + } + impl BindingEventConcurrency { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + BindingEventConcurrency::Sequential => "SEQUENTIAL", + BindingEventConcurrency::Parallel => "PARALLEL", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SEQUENTIAL" => Some(Self::Sequential), + "PARALLEL" => Some(Self::Parallel), + _ => None, + } + } + } +} +/// ListTopicSubscriptionsResponse is the message including the list of the subscribing topics. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListTopicSubscriptionsResponse { + /// The list of topics. + #[prost(message, repeated, tag = "1")] + pub subscriptions: ::prost::alloc::vec::Vec, +} +/// TopicSubscription represents topic and metadata. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicSubscription { + /// Required. The name of the pubsub containing the topic below to subscribe to. + #[prost(string, tag = "1")] + pub pubsub_name: ::prost::alloc::string::String, + /// Required. The name of topic which will be subscribed + #[prost(string, tag = "2")] + pub topic: ::prost::alloc::string::String, + /// The optional properties used for this topic's subscription e.g. session id + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The optional routing rules to match against. In the gRPC interface, OnTopicEvent + /// is still invoked but the matching path is sent in the TopicEventRequest. + #[prost(message, optional, tag = "5")] + pub routes: ::core::option::Option, + /// The optional dead letter queue for this topic to send events to. + #[prost(string, tag = "6")] + pub dead_letter_topic: ::prost::alloc::string::String, + /// The optional bulk subscribe settings for this topic. + #[prost(message, optional, tag = "7")] + pub bulk_subscribe: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicRoutes { + /// The list of rules for this topic. + #[prost(message, repeated, tag = "1")] + pub rules: ::prost::alloc::vec::Vec, + /// The default path for this topic. + #[prost(string, tag = "2")] + pub default: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicRule { + /// The optional CEL expression used to match the event. + /// If the match is not specified, then the route is considered + /// the default. + #[prost(string, tag = "1")] + pub r#match: ::prost::alloc::string::String, + /// The path used to identify matches for this subscription. + /// This value is passed in TopicEventRequest and used by OnTopicEvent to "switch" + /// inside the handler. + #[prost(string, tag = "2")] + pub path: ::prost::alloc::string::String, +} +/// BulkSubscribeConfig is the message to pass settings for bulk subscribe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BulkSubscribeConfig { + /// Required. Flag to enable/disable bulk subscribe + #[prost(bool, tag = "1")] + pub enabled: bool, + /// Optional. Max number of messages to be sent in a single bulk request + #[prost(int32, tag = "2")] + pub max_messages_count: i32, + /// Optional. Max duration to wait for messages to be sent in a single bulk request + #[prost(int32, tag = "3")] + pub max_await_duration_ms: i32, +} +/// ListInputBindingsResponse is the message including the list of input bindings. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListInputBindingsResponse { + /// The list of input bindings. + #[prost(string, repeated, tag = "1")] + pub bindings: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// HealthCheckResponse is the message with the response to the health check. +/// This message is currently empty as used as placeholder. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HealthCheckResponse {} +/// Generated client implementations. +pub mod app_callback_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// AppCallback V1 allows user application to interact with Dapr runtime. + /// User application needs to implement AppCallback service if it needs to + /// receive message from dapr runtime. + #[derive(Debug, Clone)] + pub struct AppCallbackClient { + inner: tonic::client::Grpc, + } + impl AppCallbackClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AppCallbackClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AppCallbackClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AppCallbackClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Invokes service method with InvokeRequest. + pub async fn on_invoke( + &mut self, + request: impl tonic::IntoRequest< + super::super::super::common::v1::InvokeRequest, + >, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallback/OnInvoke", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.AppCallback", "OnInvoke"), + ); + self.inner.unary(req, path, codec).await + } + /// Lists all topics subscribed by this app. + pub async fn list_topic_subscriptions( + &mut self, + request: impl tonic::IntoRequest<()>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallback/ListTopicSubscriptions", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.AppCallback", + "ListTopicSubscriptions", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Subscribes events from Pubsub + pub async fn on_topic_event( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallback/OnTopicEvent", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.AppCallback", "OnTopicEvent"), + ); + self.inner.unary(req, path, codec).await + } + /// Lists all input bindings subscribed by this app. + pub async fn list_input_bindings( + &mut self, + request: impl tonic::IntoRequest<()>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallback/ListInputBindings", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.AppCallback", + "ListInputBindings", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Listens events from the input bindings + /// + /// User application can save the states or send the events to the output + /// bindings optionally by returning BindingEventResponse. + pub async fn on_binding_event( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallback/OnBindingEvent", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.AppCallback", + "OnBindingEvent", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated client implementations. +pub mod app_callback_health_check_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// AppCallbackHealthCheck V1 is an optional extension to AppCallback V1 to implement + /// the HealthCheck method. + #[derive(Debug, Clone)] + pub struct AppCallbackHealthCheckClient { + inner: tonic::client::Grpc, + } + impl AppCallbackHealthCheckClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AppCallbackHealthCheckClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AppCallbackHealthCheckClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AppCallbackHealthCheckClient::new( + InterceptedService::new(inner, interceptor), + ) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Health check. + pub async fn health_check( + &mut self, + request: impl tonic::IntoRequest<()>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallbackHealthCheck/HealthCheck", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.AppCallbackHealthCheck", + "HealthCheck", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated client implementations. +pub mod app_callback_alpha_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// AppCallbackAlpha V1 is an optional extension to AppCallback V1 to opt + /// for Alpha RPCs. + #[derive(Debug, Clone)] + pub struct AppCallbackAlphaClient { + inner: tonic::client::Grpc, + } + impl AppCallbackAlphaClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AppCallbackAlphaClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AppCallbackAlphaClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + AppCallbackAlphaClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Subscribes bulk events from Pubsub + pub async fn on_bulk_topic_event_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallbackAlpha/OnBulkTopicEventAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.AppCallbackAlpha", + "OnBulkTopicEventAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Sends job back to the app's endpoint at trigger time. + pub async fn on_job_event_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.AppCallbackAlpha/OnJobEventAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.AppCallbackAlpha", + "OnJobEventAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod app_callback_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AppCallbackServer. + #[async_trait] + pub trait AppCallback: Send + Sync + 'static { + /// Invokes service method with InvokeRequest. + async fn on_invoke( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Lists all topics subscribed by this app. + async fn list_topic_subscriptions( + &self, + request: tonic::Request<()>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Subscribes events from Pubsub + async fn on_topic_event( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Lists all input bindings subscribed by this app. + async fn list_input_bindings( + &self, + request: tonic::Request<()>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Listens events from the input bindings + /// + /// User application can save the states or send the events to the output + /// bindings optionally by returning BindingEventResponse. + async fn on_binding_event( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// AppCallback V1 allows user application to interact with Dapr runtime. + /// User application needs to implement AppCallback service if it needs to + /// receive message from dapr runtime. + #[derive(Debug)] + pub struct AppCallbackServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl AppCallbackServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AppCallbackServer + where + T: AppCallback, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/dapr.proto.runtime.v1.AppCallback/OnInvoke" => { + #[allow(non_camel_case_types)] + struct OnInvokeSvc(pub Arc); + impl< + T: AppCallback, + > tonic::server::UnaryService< + super::super::super::common::v1::InvokeRequest, + > for OnInvokeSvc { + type Response = super::super::super::common::v1::InvokeResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::super::super::common::v1::InvokeRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::on_invoke(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = OnInvokeSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.AppCallback/ListTopicSubscriptions" => { + #[allow(non_camel_case_types)] + struct ListTopicSubscriptionsSvc(pub Arc); + impl tonic::server::UnaryService<()> + for ListTopicSubscriptionsSvc { + type Response = super::ListTopicSubscriptionsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call(&mut self, request: tonic::Request<()>) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_topic_subscriptions( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ListTopicSubscriptionsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.AppCallback/OnTopicEvent" => { + #[allow(non_camel_case_types)] + struct OnTopicEventSvc(pub Arc); + impl< + T: AppCallback, + > tonic::server::UnaryService + for OnTopicEventSvc { + type Response = super::TopicEventResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::on_topic_event(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = OnTopicEventSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.AppCallback/ListInputBindings" => { + #[allow(non_camel_case_types)] + struct ListInputBindingsSvc(pub Arc); + impl tonic::server::UnaryService<()> + for ListInputBindingsSvc { + type Response = super::ListInputBindingsResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call(&mut self, request: tonic::Request<()>) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::list_input_bindings(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ListInputBindingsSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.AppCallback/OnBindingEvent" => { + #[allow(non_camel_case_types)] + struct OnBindingEventSvc(pub Arc); + impl< + T: AppCallback, + > tonic::server::UnaryService + for OnBindingEventSvc { + type Response = super::BindingEventResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::on_binding_event(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = OnBindingEventSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AppCallbackServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for AppCallbackServer { + const NAME: &'static str = "dapr.proto.runtime.v1.AppCallback"; + } +} +/// Generated server implementations. +pub mod app_callback_health_check_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AppCallbackHealthCheckServer. + #[async_trait] + pub trait AppCallbackHealthCheck: Send + Sync + 'static { + /// Health check. + async fn health_check( + &self, + request: tonic::Request<()>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// AppCallbackHealthCheck V1 is an optional extension to AppCallback V1 to implement + /// the HealthCheck method. + #[derive(Debug)] + pub struct AppCallbackHealthCheckServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl AppCallbackHealthCheckServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> + for AppCallbackHealthCheckServer + where + T: AppCallbackHealthCheck, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/dapr.proto.runtime.v1.AppCallbackHealthCheck/HealthCheck" => { + #[allow(non_camel_case_types)] + struct HealthCheckSvc(pub Arc); + impl tonic::server::UnaryService<()> + for HealthCheckSvc { + type Response = super::HealthCheckResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call(&mut self, request: tonic::Request<()>) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::health_check(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = HealthCheckSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AppCallbackHealthCheckServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService + for AppCallbackHealthCheckServer { + const NAME: &'static str = "dapr.proto.runtime.v1.AppCallbackHealthCheck"; + } +} +/// Generated server implementations. +pub mod app_callback_alpha_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AppCallbackAlphaServer. + #[async_trait] + pub trait AppCallbackAlpha: Send + Sync + 'static { + /// Subscribes bulk events from Pubsub + async fn on_bulk_topic_event_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Sends job back to the app's endpoint at trigger time. + async fn on_job_event_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// AppCallbackAlpha V1 is an optional extension to AppCallback V1 to opt + /// for Alpha RPCs. + #[derive(Debug)] + pub struct AppCallbackAlphaServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl AppCallbackAlphaServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AppCallbackAlphaServer + where + T: AppCallbackAlpha, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/dapr.proto.runtime.v1.AppCallbackAlpha/OnBulkTopicEventAlpha1" => { + #[allow(non_camel_case_types)] + struct OnBulkTopicEventAlpha1Svc(pub Arc); + impl< + T: AppCallbackAlpha, + > tonic::server::UnaryService + for OnBulkTopicEventAlpha1Svc { + type Response = super::TopicEventBulkResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::on_bulk_topic_event_alpha1( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = OnBulkTopicEventAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.AppCallbackAlpha/OnJobEventAlpha1" => { + #[allow(non_camel_case_types)] + struct OnJobEventAlpha1Svc(pub Arc); + impl< + T: AppCallbackAlpha, + > tonic::server::UnaryService + for OnJobEventAlpha1Svc { + type Response = super::JobEventResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::on_job_event_alpha1( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = OnJobEventAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for AppCallbackAlphaServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for AppCallbackAlphaServer { + const NAME: &'static str = "dapr.proto.runtime.v1.AppCallbackAlpha"; + } +} +/// InvokeServiceRequest represents the request message for Service invocation. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeServiceRequest { + /// Required. Callee's app id. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// Required. message which will be delivered to callee. + #[prost(message, optional, tag = "3")] + pub message: ::core::option::Option, +} +/// GetStateRequest is the message to get key-value states from specific state store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetStateRequest { + /// The name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The key of the desired state + #[prost(string, tag = "2")] + pub key: ::prost::alloc::string::String, + /// The read consistency of the state store. + #[prost( + enumeration = "super::super::common::v1::state_options::StateConsistency", + tag = "3" + )] + pub consistency: i32, + /// The metadata which will be sent to state store components. + #[prost(map = "string, string", tag = "4")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetBulkStateRequest is the message to get a list of key-value states from specific state store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetBulkStateRequest { + /// The name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The keys to get. + #[prost(string, repeated, tag = "2")] + pub keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The number of parallel operations executed on the state store for a get operation. + #[prost(int32, tag = "3")] + pub parallelism: i32, + /// The metadata which will be sent to state store components. + #[prost(map = "string, string", tag = "4")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetBulkStateResponse is the response conveying the list of state values. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetBulkStateResponse { + /// The list of items containing the keys to get values for. + #[prost(message, repeated, tag = "1")] + pub items: ::prost::alloc::vec::Vec, +} +/// BulkStateItem is the response item for a bulk get operation. +/// Return values include the item key, data and etag. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BulkStateItem { + /// state item key + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + /// The byte array data + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + /// The entity tag which represents the specific version of data. + /// ETag format is defined by the corresponding data store. + #[prost(string, tag = "3")] + pub etag: ::prost::alloc::string::String, + /// The error that was returned from the state store in case of a failed get operation. + #[prost(string, tag = "4")] + pub error: ::prost::alloc::string::String, + /// The metadata which will be sent to app. + #[prost(map = "string, string", tag = "5")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetStateResponse is the response conveying the state value and etag. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetStateResponse { + /// The byte array data + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, + /// The entity tag which represents the specific version of data. + /// ETag format is defined by the corresponding data store. + #[prost(string, tag = "2")] + pub etag: ::prost::alloc::string::String, + /// The metadata which will be sent to app. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// DeleteStateRequest is the message to delete key-value states in the specific state store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteStateRequest { + /// The name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The key of the desired state + #[prost(string, tag = "2")] + pub key: ::prost::alloc::string::String, + /// The entity tag which represents the specific version of data. + /// The exact ETag format is defined by the corresponding data store. + #[prost(message, optional, tag = "3")] + pub etag: ::core::option::Option, + /// State operation options which includes concurrency/ + /// consistency/retry_policy. + #[prost(message, optional, tag = "4")] + pub options: ::core::option::Option, + /// The metadata which will be sent to state store components. + #[prost(map = "string, string", tag = "5")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// DeleteBulkStateRequest is the message to delete a list of key-value states from specific state store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteBulkStateRequest { + /// The name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The array of the state key values. + #[prost(message, repeated, tag = "2")] + pub states: ::prost::alloc::vec::Vec, +} +/// SaveStateRequest is the message to save multiple states into state store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SaveStateRequest { + /// The name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The array of the state key values. + #[prost(message, repeated, tag = "2")] + pub states: ::prost::alloc::vec::Vec, +} +/// QueryStateRequest is the message to query state store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStateRequest { + /// The name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The query in JSON format. + #[prost(string, tag = "2")] + pub query: ::prost::alloc::string::String, + /// The metadata which will be sent to state store components. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStateItem { + /// The object key. + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + /// The object value. + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + /// The entity tag which represents the specific version of data. + /// ETag format is defined by the corresponding data store. + #[prost(string, tag = "3")] + pub etag: ::prost::alloc::string::String, + /// The error message indicating an error in processing of the query result. + #[prost(string, tag = "4")] + pub error: ::prost::alloc::string::String, +} +/// QueryStateResponse is the response conveying the query results. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryStateResponse { + /// An array of query results. + #[prost(message, repeated, tag = "1")] + pub results: ::prost::alloc::vec::Vec, + /// Pagination token. + #[prost(string, tag = "2")] + pub token: ::prost::alloc::string::String, + /// The metadata which will be sent to app. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// PublishEventRequest is the message to publish event data to pubsub topic +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublishEventRequest { + /// The name of the pubsub component + #[prost(string, tag = "1")] + pub pubsub_name: ::prost::alloc::string::String, + /// The pubsub topic + #[prost(string, tag = "2")] + pub topic: ::prost::alloc::string::String, + /// The data which will be published to topic. + #[prost(bytes = "vec", tag = "3")] + pub data: ::prost::alloc::vec::Vec, + /// The content type for the data (optional). + #[prost(string, tag = "4")] + pub data_content_type: ::prost::alloc::string::String, + /// The metadata passing to pub components + /// + /// metadata property: + /// - key : the key of the message. + #[prost(map = "string, string", tag = "5")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// BulkPublishRequest is the message to bulk publish events to pubsub topic +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BulkPublishRequest { + /// The name of the pubsub component + #[prost(string, tag = "1")] + pub pubsub_name: ::prost::alloc::string::String, + /// The pubsub topic + #[prost(string, tag = "2")] + pub topic: ::prost::alloc::string::String, + /// The entries which contain the individual events and associated details to be published + #[prost(message, repeated, tag = "3")] + pub entries: ::prost::alloc::vec::Vec, + /// The request level metadata passing to to the pubsub components + #[prost(map = "string, string", tag = "4")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// BulkPublishRequestEntry is the message containing the event to be bulk published +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BulkPublishRequestEntry { + /// The request scoped unique ID referring to this message. Used to map status in response + #[prost(string, tag = "1")] + pub entry_id: ::prost::alloc::string::String, + /// The event which will be pulished to the topic + #[prost(bytes = "vec", tag = "2")] + pub event: ::prost::alloc::vec::Vec, + /// The content type for the event + #[prost(string, tag = "3")] + pub content_type: ::prost::alloc::string::String, + /// The event level metadata passing to the pubsub component + #[prost(map = "string, string", tag = "4")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// BulkPublishResponse is the message returned from a BulkPublishEvent call +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BulkPublishResponse { + /// The entries for different events that failed publish in the BulkPublishEvent call + #[prost(message, repeated, tag = "1")] + pub failed_entries: ::prost::alloc::vec::Vec, +} +/// BulkPublishResponseFailedEntry is the message containing the entryID and error of a failed event in BulkPublishEvent call +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BulkPublishResponseFailedEntry { + /// The response scoped unique ID referring to this message + #[prost(string, tag = "1")] + pub entry_id: ::prost::alloc::string::String, + /// The error message if any on failure + #[prost(string, tag = "2")] + pub error: ::prost::alloc::string::String, +} +/// SubscribeTopicEventsRequestAlpha1 is a message containing the details for +/// subscribing to a topic via streaming. +/// The first message must always be the initial request. All subsequent +/// messages must be event processed responses. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeTopicEventsRequestAlpha1 { + #[prost( + oneof = "subscribe_topic_events_request_alpha1::SubscribeTopicEventsRequestType", + tags = "1, 2" + )] + pub subscribe_topic_events_request_type: ::core::option::Option< + subscribe_topic_events_request_alpha1::SubscribeTopicEventsRequestType, + >, +} +/// Nested message and enum types in `SubscribeTopicEventsRequestAlpha1`. +pub mod subscribe_topic_events_request_alpha1 { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum SubscribeTopicEventsRequestType { + #[prost(message, tag = "1")] + InitialRequest(super::SubscribeTopicEventsRequestInitialAlpha1), + #[prost(message, tag = "2")] + EventProcessed(super::SubscribeTopicEventsRequestProcessedAlpha1), + } +} +/// SubscribeTopicEventsRequestInitialAlpha1 is the initial message containing +/// the details for subscribing to a topic via streaming. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeTopicEventsRequestInitialAlpha1 { + /// The name of the pubsub component + #[prost(string, tag = "1")] + pub pubsub_name: ::prost::alloc::string::String, + /// The pubsub topic + #[prost(string, tag = "2")] + pub topic: ::prost::alloc::string::String, + /// The metadata passing to pub components + /// + /// metadata property: + /// - key : the key of the message. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// dead_letter_topic is the topic to which messages that fail to be processed + /// are sent. + #[prost(string, optional, tag = "4")] + pub dead_letter_topic: ::core::option::Option<::prost::alloc::string::String>, +} +/// SubscribeTopicEventsRequestProcessedAlpha1 is the message containing the +/// subscription to a topic. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeTopicEventsRequestProcessedAlpha1 { + /// id is the unique identifier for the subscription request. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// status is the result of the subscription request. + #[prost(message, optional, tag = "2")] + pub status: ::core::option::Option, +} +/// SubscribeTopicEventsResponseAlpha1 is a message returned from daprd +/// when subscribing to a topic via streaming. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeTopicEventsResponseAlpha1 { + #[prost( + oneof = "subscribe_topic_events_response_alpha1::SubscribeTopicEventsResponseType", + tags = "1, 2" + )] + pub subscribe_topic_events_response_type: ::core::option::Option< + subscribe_topic_events_response_alpha1::SubscribeTopicEventsResponseType, + >, +} +/// Nested message and enum types in `SubscribeTopicEventsResponseAlpha1`. +pub mod subscribe_topic_events_response_alpha1 { + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum SubscribeTopicEventsResponseType { + #[prost(message, tag = "1")] + InitialResponse(super::SubscribeTopicEventsResponseInitialAlpha1), + #[prost(message, tag = "2")] + EventMessage(super::TopicEventRequest), + } +} +/// SubscribeTopicEventsResponseInitialAlpha1 is the initial response from daprd +/// when subscribing to a topic. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeTopicEventsResponseInitialAlpha1 {} +/// InvokeBindingRequest is the message to send data to output bindings +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeBindingRequest { + /// The name of the output binding to invoke. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The data which will be sent to output binding. + #[prost(bytes = "vec", tag = "2")] + pub data: ::prost::alloc::vec::Vec, + /// The metadata passing to output binding components + /// + /// Common metadata property: + /// - ttlInSeconds : the time to live in seconds for the message. + /// + /// If set in the binding definition will cause all messages to + /// have a default time to live. The message ttl overrides any value + /// in the binding definition. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The name of the operation type for the binding to invoke + #[prost(string, tag = "4")] + pub operation: ::prost::alloc::string::String, +} +/// InvokeBindingResponse is the message returned from an output binding invocation +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeBindingResponse { + /// The data which will be sent to output binding. + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, + /// The metadata returned from an external system + #[prost(map = "string, string", tag = "2")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetSecretRequest is the message to get secret from secret store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetSecretRequest { + /// The name of secret store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The name of secret key. + #[prost(string, tag = "2")] + pub key: ::prost::alloc::string::String, + /// The metadata which will be sent to secret store components. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetSecretResponse is the response message to convey the requested secret. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetSecretResponse { + /// data is the secret value. Some secret store, such as kubernetes secret + /// store, can save multiple secrets for single secret key. + #[prost(map = "string, string", tag = "1")] + pub data: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetBulkSecretRequest is the message to get the secrets from secret store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetBulkSecretRequest { + /// The name of secret store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The metadata which will be sent to secret store components. + #[prost(map = "string, string", tag = "2")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// SecretResponse is a map of decrypted string/string values +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SecretResponse { + #[prost(map = "string, string", tag = "1")] + pub secrets: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetBulkSecretResponse is the response message to convey the requested secrets. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetBulkSecretResponse { + /// data hold the secret values. Some secret store, such as kubernetes secret + /// store, can save multiple secrets for single secret key. + #[prost(map = "string, message", tag = "1")] + pub data: ::std::collections::HashMap< + ::prost::alloc::string::String, + SecretResponse, + >, +} +/// TransactionalStateOperation is the message to execute a specified operation with a key-value pair. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TransactionalStateOperation { + /// The type of operation to be executed + #[prost(string, tag = "1")] + pub operation_type: ::prost::alloc::string::String, + /// State values to be operated on + #[prost(message, optional, tag = "2")] + pub request: ::core::option::Option, +} +/// ExecuteStateTransactionRequest is the message to execute multiple operations on a specified store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecuteStateTransactionRequest { + /// Required. name of state store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// Required. transactional operation list. + #[prost(message, repeated, tag = "2")] + pub operations: ::prost::alloc::vec::Vec, + /// The metadata used for transactional operations. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// RegisterActorTimerRequest is the message to register a timer for an actor of a given type and id. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisterActorTimerRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub due_time: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub period: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub callback: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "7")] + pub data: ::prost::alloc::vec::Vec, + #[prost(string, tag = "8")] + pub ttl: ::prost::alloc::string::String, +} +/// UnregisterActorTimerRequest is the message to unregister an actor timer +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnregisterActorTimerRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub name: ::prost::alloc::string::String, +} +/// RegisterActorReminderRequest is the message to register a reminder for an actor of a given type and id. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisterActorReminderRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub due_time: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub period: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "6")] + pub data: ::prost::alloc::vec::Vec, + #[prost(string, tag = "7")] + pub ttl: ::prost::alloc::string::String, +} +/// UnregisterActorReminderRequest is the message to unregister an actor reminder. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnregisterActorReminderRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub name: ::prost::alloc::string::String, +} +/// GetActorStateRequest is the message to get key-value states from specific actor. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetActorStateRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub key: ::prost::alloc::string::String, +} +/// GetActorStateResponse is the response conveying the actor's state value. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetActorStateResponse { + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, + /// The metadata which will be sent to app. + #[prost(map = "string, string", tag = "2")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// ExecuteActorStateTransactionRequest is the message to execute multiple operations on a specified actor. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecuteActorStateTransactionRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "3")] + pub operations: ::prost::alloc::vec::Vec, +} +/// TransactionalActorStateOperation is the message to execute a specified operation with a key-value pair. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TransactionalActorStateOperation { + #[prost(string, tag = "1")] + pub operation_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub key: ::prost::alloc::string::String, + #[prost(message, optional, tag = "3")] + pub value: ::core::option::Option<::prost_types::Any>, + /// The metadata used for transactional operations. + /// + /// Common metadata property: + /// - ttlInSeconds : the time to live in seconds for the stored value. + #[prost(map = "string, string", tag = "4")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// InvokeActorRequest is the message to call an actor. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeActorRequest { + #[prost(string, tag = "1")] + pub actor_type: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub actor_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub method: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "4")] + pub data: ::prost::alloc::vec::Vec, + #[prost(map = "string, string", tag = "5")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// InvokeActorResponse is the method that returns an actor invocation response. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvokeActorResponse { + #[prost(bytes = "vec", tag = "1")] + pub data: ::prost::alloc::vec::Vec, +} +/// GetMetadataRequest is the message for the GetMetadata request. +/// +/// Empty +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetMetadataRequest {} +/// GetMetadataResponse is a message that is returned on GetMetadata rpc call. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetMetadataResponse { + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// Deprecated alias for actor_runtime.active_actors. + #[deprecated] + #[prost(message, repeated, tag = "2")] + pub active_actors_count: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "3")] + pub registered_components: ::prost::alloc::vec::Vec, + #[prost(map = "string, string", tag = "4")] + pub extended_metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + #[prost(message, repeated, tag = "5")] + pub subscriptions: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "6")] + pub http_endpoints: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "7")] + pub app_connection_properties: ::core::option::Option, + #[prost(string, tag = "8")] + pub runtime_version: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "9")] + pub enabled_features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// TODO: Cassie: probably add scheduler runtime status + #[prost(message, optional, tag = "10")] + pub actor_runtime: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActorRuntime { + /// Contains an enum indicating whether the actor runtime has been initialized. + #[prost(enumeration = "actor_runtime::ActorRuntimeStatus", tag = "1")] + pub runtime_status: i32, + /// Count of active actors per type. + #[prost(message, repeated, tag = "2")] + pub active_actors: ::prost::alloc::vec::Vec, + /// Indicates whether the actor runtime is ready to host actors. + #[prost(bool, tag = "3")] + pub host_ready: bool, + /// Custom message from the placement provider. + #[prost(string, tag = "4")] + pub placement: ::prost::alloc::string::String, +} +/// Nested message and enum types in `ActorRuntime`. +pub mod actor_runtime { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum ActorRuntimeStatus { + /// Indicates that the actor runtime is still being initialized. + Initializing = 0, + /// Indicates that the actor runtime is disabled. + /// This normally happens when Dapr is started without "placement-host-address" + Disabled = 1, + /// Indicates the actor runtime is running, either as an actor host or client. + Running = 2, + } + impl ActorRuntimeStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ActorRuntimeStatus::Initializing => "INITIALIZING", + ActorRuntimeStatus::Disabled => "DISABLED", + ActorRuntimeStatus::Running => "RUNNING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "INITIALIZING" => Some(Self::Initializing), + "DISABLED" => Some(Self::Disabled), + "RUNNING" => Some(Self::Running), + _ => None, + } + } + } +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActiveActorsCount { + #[prost(string, tag = "1")] + pub r#type: ::prost::alloc::string::String, + #[prost(int32, tag = "2")] + pub count: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisteredComponents { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub r#type: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub version: ::prost::alloc::string::String, + #[prost(string, repeated, tag = "4")] + pub capabilities: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MetadataHttpEndpoint { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AppConnectionProperties { + #[prost(int32, tag = "1")] + pub port: i32, + #[prost(string, tag = "2")] + pub protocol: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub channel_address: ::prost::alloc::string::String, + #[prost(int32, tag = "4")] + pub max_concurrency: i32, + #[prost(message, optional, tag = "5")] + pub health: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AppConnectionHealthProperties { + #[prost(string, tag = "1")] + pub health_check_path: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub health_probe_interval: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub health_probe_timeout: ::prost::alloc::string::String, + #[prost(int32, tag = "4")] + pub health_threshold: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PubsubSubscription { + #[prost(string, tag = "1")] + pub pubsub_name: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub topic: ::prost::alloc::string::String, + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + #[prost(message, optional, tag = "4")] + pub rules: ::core::option::Option, + #[prost(string, tag = "5")] + pub dead_letter_topic: ::prost::alloc::string::String, + #[prost(enumeration = "PubsubSubscriptionType", tag = "6")] + pub r#type: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PubsubSubscriptionRules { + #[prost(message, repeated, tag = "1")] + pub rules: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PubsubSubscriptionRule { + #[prost(string, tag = "1")] + pub r#match: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub path: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SetMetadataRequest { + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub value: ::prost::alloc::string::String, +} +/// GetConfigurationRequest is the message to get a list of key-value configuration from specified configuration store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetConfigurationRequest { + /// Required. The name of configuration store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// Optional. The key of the configuration item to fetch. + /// If set, only query for the specified configuration items. + /// Empty list means fetch all. + #[prost(string, repeated, tag = "2")] + pub keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Optional. The metadata which will be sent to configuration store components. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// GetConfigurationResponse is the response conveying the list of configuration values. +/// It should be the FULL configuration of specified application which contains all of its configuration items. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetConfigurationResponse { + #[prost(map = "string, message", tag = "1")] + pub items: ::std::collections::HashMap< + ::prost::alloc::string::String, + super::super::common::v1::ConfigurationItem, + >, +} +/// SubscribeConfigurationRequest is the message to get a list of key-value configuration from specified configuration store. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeConfigurationRequest { + /// The name of configuration store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// Optional. The key of the configuration item to fetch. + /// If set, only query for the specified configuration items. + /// Empty list means fetch all. + #[prost(string, repeated, tag = "2")] + pub keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The metadata which will be sent to configuration store components. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// UnSubscribeConfigurationRequest is the message to stop watching the key-value configuration. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnsubscribeConfigurationRequest { + /// The name of configuration store. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// The id to unsubscribe. + #[prost(string, tag = "2")] + pub id: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeConfigurationResponse { + /// Subscribe id, used to stop subscription. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// The list of items containing configuration values + #[prost(map = "string, message", tag = "2")] + pub items: ::std::collections::HashMap< + ::prost::alloc::string::String, + super::super::common::v1::ConfigurationItem, + >, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnsubscribeConfigurationResponse { + #[prost(bool, tag = "1")] + pub ok: bool, + #[prost(string, tag = "2")] + pub message: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TryLockRequest { + /// Required. The lock store name,e.g. `redis`. + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// Required. resource_id is the lock key. e.g. `order_id_111` + /// It stands for "which resource I want to protect" + #[prost(string, tag = "2")] + pub resource_id: ::prost::alloc::string::String, + /// Required. lock_owner indicate the identifier of lock owner. + /// You can generate a uuid as lock_owner.For example,in golang: + /// + /// req.LockOwner = uuid.New().String() + /// + /// This field is per request,not per process,so it is different for each request, + /// which aims to prevent multi-thread in the same process trying the same lock concurrently. + /// + /// The reason why we don't make it automatically generated is: + /// 1. If it is automatically generated,there must be a 'my_lock_owner_id' field in the response. + /// This name is so weird that we think it is inappropriate to put it into the api spec + /// 2. If we change the field 'my_lock_owner_id' in the response to 'lock_owner',which means the current lock owner of this lock, + /// we find that in some lock services users can't get the current lock owner.Actually users don't need it at all. + /// 3. When reentrant lock is needed,the existing lock_owner is required to identify client and check "whether this client can reenter this lock". + /// So this field in the request shouldn't be removed. + #[prost(string, tag = "3")] + pub lock_owner: ::prost::alloc::string::String, + /// Required. The time before expiry.The time unit is second. + #[prost(int32, tag = "4")] + pub expiry_in_seconds: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TryLockResponse { + #[prost(bool, tag = "1")] + pub success: bool, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnlockRequest { + #[prost(string, tag = "1")] + pub store_name: ::prost::alloc::string::String, + /// resource_id is the lock key. + #[prost(string, tag = "2")] + pub resource_id: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub lock_owner: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnlockResponse { + #[prost(enumeration = "unlock_response::Status", tag = "1")] + pub status: i32, +} +/// Nested message and enum types in `UnlockResponse`. +pub mod unlock_response { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Status { + Success = 0, + LockDoesNotExist = 1, + LockBelongsToOthers = 2, + InternalError = 3, + } + impl Status { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Status::Success => "SUCCESS", + Status::LockDoesNotExist => "LOCK_DOES_NOT_EXIST", + Status::LockBelongsToOthers => "LOCK_BELONGS_TO_OTHERS", + Status::InternalError => "INTERNAL_ERROR", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SUCCESS" => Some(Self::Success), + "LOCK_DOES_NOT_EXIST" => Some(Self::LockDoesNotExist), + "LOCK_BELONGS_TO_OTHERS" => Some(Self::LockBelongsToOthers), + "INTERNAL_ERROR" => Some(Self::InternalError), + _ => None, + } + } + } +} +/// SubtleGetKeyRequest is the request object for SubtleGetKeyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleGetKeyRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Name (or name/version) of the key to use in the key vault + #[prost(string, tag = "2")] + pub name: ::prost::alloc::string::String, + /// Response format + #[prost(enumeration = "subtle_get_key_request::KeyFormat", tag = "3")] + pub format: i32, +} +/// Nested message and enum types in `SubtleGetKeyRequest`. +pub mod subtle_get_key_request { + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum KeyFormat { + /// PEM (PKIX) (default) + Pem = 0, + /// JSON (JSON Web Key) as string + Json = 1, + } + impl KeyFormat { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + KeyFormat::Pem => "PEM", + KeyFormat::Json => "JSON", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "PEM" => Some(Self::Pem), + "JSON" => Some(Self::Json), + _ => None, + } + } + } +} +/// SubtleGetKeyResponse is the response for SubtleGetKeyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleGetKeyResponse { + /// Name (or name/version) of the key. + /// This is returned as response too in case there is a version. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Public key, encoded in the requested format + #[prost(string, tag = "2")] + pub public_key: ::prost::alloc::string::String, +} +/// SubtleEncryptRequest is the request for SubtleEncryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleEncryptRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Message to encrypt. + #[prost(bytes = "vec", tag = "2")] + pub plaintext: ::prost::alloc::vec::Vec, + /// Algorithm to use, as in the JWA standard. + #[prost(string, tag = "3")] + pub algorithm: ::prost::alloc::string::String, + /// Name (or name/version) of the key. + #[prost(string, tag = "4")] + pub key_name: ::prost::alloc::string::String, + /// Nonce / initialization vector. + /// Ignored with asymmetric ciphers. + #[prost(bytes = "vec", tag = "5")] + pub nonce: ::prost::alloc::vec::Vec, + /// Associated Data when using AEAD ciphers (optional). + #[prost(bytes = "vec", tag = "6")] + pub associated_data: ::prost::alloc::vec::Vec, +} +/// SubtleEncryptResponse is the response for SubtleEncryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleEncryptResponse { + /// Encrypted ciphertext. + #[prost(bytes = "vec", tag = "1")] + pub ciphertext: ::prost::alloc::vec::Vec, + /// Authentication tag. + /// This is nil when not using an authenticated cipher. + #[prost(bytes = "vec", tag = "2")] + pub tag: ::prost::alloc::vec::Vec, +} +/// SubtleDecryptRequest is the request for SubtleDecryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleDecryptRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Message to decrypt. + #[prost(bytes = "vec", tag = "2")] + pub ciphertext: ::prost::alloc::vec::Vec, + /// Algorithm to use, as in the JWA standard. + #[prost(string, tag = "3")] + pub algorithm: ::prost::alloc::string::String, + /// Name (or name/version) of the key. + #[prost(string, tag = "4")] + pub key_name: ::prost::alloc::string::String, + /// Nonce / initialization vector. + /// Ignored with asymmetric ciphers. + #[prost(bytes = "vec", tag = "5")] + pub nonce: ::prost::alloc::vec::Vec, + /// Authentication tag. + /// This is nil when not using an authenticated cipher. + #[prost(bytes = "vec", tag = "6")] + pub tag: ::prost::alloc::vec::Vec, + /// Associated Data when using AEAD ciphers (optional). + #[prost(bytes = "vec", tag = "7")] + pub associated_data: ::prost::alloc::vec::Vec, +} +/// SubtleDecryptResponse is the response for SubtleDecryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleDecryptResponse { + /// Decrypted plaintext. + #[prost(bytes = "vec", tag = "1")] + pub plaintext: ::prost::alloc::vec::Vec, +} +/// SubtleWrapKeyRequest is the request for SubtleWrapKeyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleWrapKeyRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Key to wrap + #[prost(bytes = "vec", tag = "2")] + pub plaintext_key: ::prost::alloc::vec::Vec, + /// Algorithm to use, as in the JWA standard. + #[prost(string, tag = "3")] + pub algorithm: ::prost::alloc::string::String, + /// Name (or name/version) of the key. + #[prost(string, tag = "4")] + pub key_name: ::prost::alloc::string::String, + /// Nonce / initialization vector. + /// Ignored with asymmetric ciphers. + #[prost(bytes = "vec", tag = "5")] + pub nonce: ::prost::alloc::vec::Vec, + /// Associated Data when using AEAD ciphers (optional). + #[prost(bytes = "vec", tag = "6")] + pub associated_data: ::prost::alloc::vec::Vec, +} +/// SubtleWrapKeyResponse is the response for SubtleWrapKeyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleWrapKeyResponse { + /// Wrapped key. + #[prost(bytes = "vec", tag = "1")] + pub wrapped_key: ::prost::alloc::vec::Vec, + /// Authentication tag. + /// This is nil when not using an authenticated cipher. + #[prost(bytes = "vec", tag = "2")] + pub tag: ::prost::alloc::vec::Vec, +} +/// SubtleUnwrapKeyRequest is the request for SubtleUnwrapKeyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleUnwrapKeyRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Wrapped key. + #[prost(bytes = "vec", tag = "2")] + pub wrapped_key: ::prost::alloc::vec::Vec, + /// Algorithm to use, as in the JWA standard. + #[prost(string, tag = "3")] + pub algorithm: ::prost::alloc::string::String, + /// Name (or name/version) of the key. + #[prost(string, tag = "4")] + pub key_name: ::prost::alloc::string::String, + /// Nonce / initialization vector. + /// Ignored with asymmetric ciphers. + #[prost(bytes = "vec", tag = "5")] + pub nonce: ::prost::alloc::vec::Vec, + /// Authentication tag. + /// This is nil when not using an authenticated cipher. + #[prost(bytes = "vec", tag = "6")] + pub tag: ::prost::alloc::vec::Vec, + /// Associated Data when using AEAD ciphers (optional). + #[prost(bytes = "vec", tag = "7")] + pub associated_data: ::prost::alloc::vec::Vec, +} +/// SubtleUnwrapKeyResponse is the response for SubtleUnwrapKeyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleUnwrapKeyResponse { + /// Key in plaintext + #[prost(bytes = "vec", tag = "1")] + pub plaintext_key: ::prost::alloc::vec::Vec, +} +/// SubtleSignRequest is the request for SubtleSignAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleSignRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Digest to sign. + #[prost(bytes = "vec", tag = "2")] + pub digest: ::prost::alloc::vec::Vec, + /// Algorithm to use, as in the JWA standard. + #[prost(string, tag = "3")] + pub algorithm: ::prost::alloc::string::String, + /// Name (or name/version) of the key. + #[prost(string, tag = "4")] + pub key_name: ::prost::alloc::string::String, +} +/// SubtleSignResponse is the response for SubtleSignAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleSignResponse { + /// The signature that was computed + #[prost(bytes = "vec", tag = "1")] + pub signature: ::prost::alloc::vec::Vec, +} +/// SubtleVerifyRequest is the request for SubtleVerifyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleVerifyRequest { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Digest of the message. + #[prost(bytes = "vec", tag = "2")] + pub digest: ::prost::alloc::vec::Vec, + /// Algorithm to use, as in the JWA standard. + #[prost(string, tag = "3")] + pub algorithm: ::prost::alloc::string::String, + /// Name (or name/version) of the key. + #[prost(string, tag = "4")] + pub key_name: ::prost::alloc::string::String, + /// Signature to verify. + #[prost(bytes = "vec", tag = "5")] + pub signature: ::prost::alloc::vec::Vec, +} +/// SubtleVerifyResponse is the response for SubtleVerifyAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubtleVerifyResponse { + /// True if the signature is valid. + #[prost(bool, tag = "1")] + pub valid: bool, +} +/// EncryptRequest is the request for EncryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptRequest { + /// Request details. Must be present in the first message only. + #[prost(message, optional, tag = "1")] + pub options: ::core::option::Option, + /// Chunk of data of arbitrary size. + #[prost(message, optional, tag = "2")] + pub payload: ::core::option::Option, +} +/// EncryptRequestOptions contains options for the first message in the EncryptAlpha1 request. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptRequestOptions { + /// Name of the component. Required. + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Name (or name/version) of the key. Required. + #[prost(string, tag = "2")] + pub key_name: ::prost::alloc::string::String, + /// Key wrapping algorithm to use. Required. + /// Supported options include: A256KW (alias: AES), A128CBC, A192CBC, A256CBC, RSA-OAEP-256 (alias: RSA). + #[prost(string, tag = "3")] + pub key_wrap_algorithm: ::prost::alloc::string::String, + /// Cipher used to encrypt data (optional): "aes-gcm" (default) or "chacha20-poly1305" + #[prost(string, tag = "10")] + pub data_encryption_cipher: ::prost::alloc::string::String, + /// If true, the encrypted document does not contain a key reference. + /// In that case, calls to the Decrypt method must provide a key reference (name or name/version). + /// Defaults to false. + #[prost(bool, tag = "11")] + pub omit_decryption_key_name: bool, + /// Key reference to embed in the encrypted document (name or name/version). + /// This is helpful if the reference of the key used to decrypt the document is different from the one used to encrypt it. + /// If unset, uses the reference of the key used to encrypt the document (this is the default behavior). + /// This option is ignored if omit_decryption_key_name is true. + #[prost(string, tag = "12")] + pub decryption_key_name: ::prost::alloc::string::String, +} +/// EncryptResponse is the response for EncryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptResponse { + /// Chunk of data. + #[prost(message, optional, tag = "1")] + pub payload: ::core::option::Option, +} +/// DecryptRequest is the request for DecryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecryptRequest { + /// Request details. Must be present in the first message only. + #[prost(message, optional, tag = "1")] + pub options: ::core::option::Option, + /// Chunk of data of arbitrary size. + #[prost(message, optional, tag = "2")] + pub payload: ::core::option::Option, +} +/// DecryptRequestOptions contains options for the first message in the DecryptAlpha1 request. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecryptRequestOptions { + /// Name of the component + #[prost(string, tag = "1")] + pub component_name: ::prost::alloc::string::String, + /// Name (or name/version) of the key to decrypt the message. + /// Overrides any key reference included in the message if present. + /// This is required if the message doesn't include a key reference (i.e. was created with omit_decryption_key_name set to true). + #[prost(string, tag = "12")] + pub key_name: ::prost::alloc::string::String, +} +/// DecryptResponse is the response for DecryptAlpha1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecryptResponse { + /// Chunk of data. + #[prost(message, optional, tag = "1")] + pub payload: ::core::option::Option, +} +/// GetWorkflowRequest is the request for GetWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetWorkflowRequest { + /// ID of the workflow instance to query. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, +} +/// GetWorkflowResponse is the response for GetWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetWorkflowResponse { + /// ID of the workflow instance. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow. + #[prost(string, tag = "2")] + pub workflow_name: ::prost::alloc::string::String, + /// The time at which the workflow instance was created. + #[prost(message, optional, tag = "3")] + pub created_at: ::core::option::Option<::prost_types::Timestamp>, + /// The last time at which the workflow instance had its state changed. + #[prost(message, optional, tag = "4")] + pub last_updated_at: ::core::option::Option<::prost_types::Timestamp>, + /// The current status of the workflow instance, for example, "PENDING", "RUNNING", "SUSPENDED", "COMPLETED", "FAILED", and "TERMINATED". + #[prost(string, tag = "5")] + pub runtime_status: ::prost::alloc::string::String, + /// Additional component-specific properties of the workflow instance. + #[prost(map = "string, string", tag = "6")] + pub properties: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// StartWorkflowRequest is the request for StartWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StartWorkflowRequest { + /// The ID to assign to the started workflow instance. If empty, a random ID is generated. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, + /// Name of the workflow. + #[prost(string, tag = "3")] + pub workflow_name: ::prost::alloc::string::String, + /// Additional component-specific options for starting the workflow instance. + #[prost(map = "string, string", tag = "4")] + pub options: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// Input data for the workflow instance. + #[prost(bytes = "vec", tag = "5")] + pub input: ::prost::alloc::vec::Vec, +} +/// StartWorkflowResponse is the response for StartWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StartWorkflowResponse { + /// ID of the started workflow instance. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, +} +/// TerminateWorkflowRequest is the request for TerminateWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TerminateWorkflowRequest { + /// ID of the workflow instance to terminate. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, +} +/// PauseWorkflowRequest is the request for PauseWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PauseWorkflowRequest { + /// ID of the workflow instance to pause. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, +} +/// ResumeWorkflowRequest is the request for ResumeWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ResumeWorkflowRequest { + /// ID of the workflow instance to resume. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, +} +/// RaiseEventWorkflowRequest is the request for RaiseEventWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RaiseEventWorkflowRequest { + /// ID of the workflow instance to raise an event for. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, + /// Name of the event. + #[prost(string, tag = "3")] + pub event_name: ::prost::alloc::string::String, + /// Data associated with the event. + #[prost(bytes = "vec", tag = "4")] + pub event_data: ::prost::alloc::vec::Vec, +} +/// PurgeWorkflowRequest is the request for PurgeWorkflowBeta1. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PurgeWorkflowRequest { + /// ID of the workflow instance to purge. + #[prost(string, tag = "1")] + pub instance_id: ::prost::alloc::string::String, + /// Name of the workflow component. + #[prost(string, tag = "2")] + pub workflow_component: ::prost::alloc::string::String, +} +/// ShutdownRequest is the request for Shutdown. +/// +/// Empty +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ShutdownRequest {} +/// Job is the definition of a job. At least one of schedule or due_time must be +/// provided but can also be provided together. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Job { + /// The unique name for the job. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// schedule is an optional schedule at which the job is to be run. + /// Accepts both systemd timer style cron expressions, as well as human + /// readable '@' prefixed period strings as defined below. + /// + /// Systemd timer style cron accepts 6 fields: + /// seconds | minutes | hours | day of month | month | day of week + /// 0-59 | 0-59 | 0-23 | 1-31 | 1-12/jan-dec | 0-7/sun-sat + /// + /// "0 30 * * * *" - every hour on the half hour + /// "0 15 3 * * *" - every day at 03:15 + /// + /// Period string expressions: + /// Entry | Description | Equivalent To + /// ----- | ----------- | ------------- + /// @every | Run every (e.g. '@every 1h30m') | N/A + /// @yearly (or @annually) | Run once a year, midnight, Jan. 1st | 0 0 0 1 1 * + /// @monthly | Run once a month, midnight, first of month | 0 0 0 1 * * + /// @weekly | Run once a week, midnight on Sunday | 0 0 0 * * 0 + /// @daily (or @midnight) | Run once a day, midnight | 0 0 0 * * * + /// @hourly | Run once an hour, beginning of hour | 0 0 * * * * + #[prost(string, optional, tag = "2")] + pub schedule: ::core::option::Option<::prost::alloc::string::String>, + /// repeats is the optional number of times in which the job should be + /// triggered. If not set, the job will run indefinitely or until expiration. + #[prost(uint32, optional, tag = "3")] + pub repeats: ::core::option::Option, + /// due_time is the optional time at which the job should be active, or the + /// "one shot" time if other scheduling type fields are not provided. Accepts + /// a "point in time" string in the format of RFC3339, Go duration string + /// (calculated from job creation time), or non-repeating ISO8601. + #[prost(string, optional, tag = "4")] + pub due_time: ::core::option::Option<::prost::alloc::string::String>, + /// ttl is the optional time to live or expiration of the job. Accepts a + /// "point in time" string in the format of RFC3339, Go duration string + /// (calculated from job creation time), or non-repeating ISO8601. + #[prost(string, optional, tag = "5")] + pub ttl: ::core::option::Option<::prost::alloc::string::String>, + /// payload is the serialized job payload that will be sent to the recipient + /// when the job is triggered. + #[prost(message, optional, tag = "6")] + pub data: ::core::option::Option<::prost_types::Any>, +} +/// ScheduleJobRequest is the message to create/schedule the job. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScheduleJobRequest { + /// The job details. + #[prost(message, optional, tag = "1")] + pub job: ::core::option::Option, +} +/// ScheduleJobResponse is the message response to create/schedule the job. +/// +/// Empty +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScheduleJobResponse {} +/// GetJobRequest is the message to retrieve a job. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetJobRequest { + /// The name of the job. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// GetJobResponse is the message's response for a job retrieved. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetJobResponse { + /// The job details. + #[prost(message, optional, tag = "1")] + pub job: ::core::option::Option, +} +/// DeleteJobRequest is the message to delete the job by name. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteJobRequest { + /// The name of the job. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// DeleteJobResponse is the message response to delete the job by name. +/// +/// Empty +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DeleteJobResponse {} +/// PubsubSubscriptionType indicates the type of subscription +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum PubsubSubscriptionType { + /// UNKNOWN is the default value for the subscription type. + Unknown = 0, + /// Declarative subscription (k8s CRD) + Declarative = 1, + /// Programmatically created subscription + Programmatic = 2, + /// Bidirectional Streaming subscription + Streaming = 3, +} +impl PubsubSubscriptionType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + PubsubSubscriptionType::Unknown => "UNKNOWN", + PubsubSubscriptionType::Declarative => "DECLARATIVE", + PubsubSubscriptionType::Programmatic => "PROGRAMMATIC", + PubsubSubscriptionType::Streaming => "STREAMING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNKNOWN" => Some(Self::Unknown), + "DECLARATIVE" => Some(Self::Declarative), + "PROGRAMMATIC" => Some(Self::Programmatic), + "STREAMING" => Some(Self::Streaming), + _ => None, + } + } +} +/// Generated client implementations. +pub mod dapr_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + /// Dapr service provides APIs to user application to access Dapr building blocks. + #[derive(Debug, Clone)] + pub struct DaprClient { + inner: tonic::client::Grpc, + } + impl DaprClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl DaprClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> DaprClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + DaprClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + /// Invokes a method on a remote Dapr app. + /// Deprecated: Use proxy mode service invocation instead. + pub async fn invoke_service( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/InvokeService", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "InvokeService")); + self.inner.unary(req, path, codec).await + } + /// Gets the state for a specific key. + pub async fn get_state( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetState", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetState")); + self.inner.unary(req, path, codec).await + } + /// Gets a bulk of state items for a list of keys + pub async fn get_bulk_state( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetBulkState", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetBulkState")); + self.inner.unary(req, path, codec).await + } + /// Saves the state for a specific key. + pub async fn save_state( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SaveState", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SaveState")); + self.inner.unary(req, path, codec).await + } + /// Queries the state. + pub async fn query_state_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/QueryStateAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "QueryStateAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Deletes the state for a specific key. + pub async fn delete_state( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/DeleteState", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "DeleteState")); + self.inner.unary(req, path, codec).await + } + /// Deletes a bulk of state items for a list of keys + pub async fn delete_bulk_state( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/DeleteBulkState", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "DeleteBulkState"), + ); + self.inner.unary(req, path, codec).await + } + /// Executes transactions for a specified store + pub async fn execute_state_transaction( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/ExecuteStateTransaction", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "ExecuteStateTransaction", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Publishes events to the specific topic. + pub async fn publish_event( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/PublishEvent", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "PublishEvent")); + self.inner.unary(req, path, codec).await + } + /// Bulk Publishes multiple events to the specified topic. + pub async fn bulk_publish_event_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/BulkPublishEventAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "BulkPublishEventAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// SubscribeTopicEventsAlpha1 subscribes to a PubSub topic and receives topic + /// events from it. + pub async fn subscribe_topic_events_alpha1( + &mut self, + request: impl tonic::IntoStreamingRequest< + Message = super::SubscribeTopicEventsRequestAlpha1, + >, + ) -> std::result::Result< + tonic::Response< + tonic::codec::Streaming, + >, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubscribeTopicEventsAlpha1", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "SubscribeTopicEventsAlpha1", + ), + ); + self.inner.streaming(req, path, codec).await + } + /// Invokes binding data to specific output bindings + pub async fn invoke_binding( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/InvokeBinding", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "InvokeBinding")); + self.inner.unary(req, path, codec).await + } + /// Gets secrets from secret stores. + pub async fn get_secret( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetSecret", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetSecret")); + self.inner.unary(req, path, codec).await + } + /// Gets a bulk of secrets + pub async fn get_bulk_secret( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetBulkSecret", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetBulkSecret")); + self.inner.unary(req, path, codec).await + } + /// Register an actor timer. + pub async fn register_actor_timer( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/RegisterActorTimer", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "RegisterActorTimer"), + ); + self.inner.unary(req, path, codec).await + } + /// Unregister an actor timer. + pub async fn unregister_actor_timer( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/UnregisterActorTimer", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "UnregisterActorTimer"), + ); + self.inner.unary(req, path, codec).await + } + /// Register an actor reminder. + pub async fn register_actor_reminder( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/RegisterActorReminder", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "RegisterActorReminder", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Unregister an actor reminder. + pub async fn unregister_actor_reminder( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/UnregisterActorReminder", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "UnregisterActorReminder", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Gets the state for a specific actor. + pub async fn get_actor_state( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetActorState", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetActorState")); + self.inner.unary(req, path, codec).await + } + /// Executes state transactions for a specified actor + pub async fn execute_actor_state_transaction( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/ExecuteActorStateTransaction", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "ExecuteActorStateTransaction", + ), + ); + self.inner.unary(req, path, codec).await + } + /// InvokeActor calls a method on an actor. + pub async fn invoke_actor( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/InvokeActor", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "InvokeActor")); + self.inner.unary(req, path, codec).await + } + /// GetConfiguration gets configuration from configuration store. + pub async fn get_configuration_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetConfigurationAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "GetConfigurationAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// GetConfiguration gets configuration from configuration store. + pub async fn get_configuration( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetConfiguration", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetConfiguration"), + ); + self.inner.unary(req, path, codec).await + } + /// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + pub async fn subscribe_configuration_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response< + tonic::codec::Streaming, + >, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubscribeConfigurationAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "SubscribeConfigurationAlpha1", + ), + ); + self.inner.server_streaming(req, path, codec).await + } + /// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + pub async fn subscribe_configuration( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response< + tonic::codec::Streaming, + >, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubscribeConfiguration", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "SubscribeConfiguration", + ), + ); + self.inner.server_streaming(req, path, codec).await + } + /// UnSubscribeConfiguration unsubscribe the subscription of configuration + pub async fn unsubscribe_configuration_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfigurationAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "UnsubscribeConfigurationAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// UnSubscribeConfiguration unsubscribe the subscription of configuration + pub async fn unsubscribe_configuration( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfiguration", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "UnsubscribeConfiguration", + ), + ); + self.inner.unary(req, path, codec).await + } + /// TryLockAlpha1 tries to get a lock with an expiry. + pub async fn try_lock_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/TryLockAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "TryLockAlpha1")); + self.inner.unary(req, path, codec).await + } + /// UnlockAlpha1 unlocks a lock. + pub async fn unlock_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/UnlockAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "UnlockAlpha1")); + self.inner.unary(req, path, codec).await + } + /// EncryptAlpha1 encrypts a message using the Dapr encryption scheme and a key stored in the vault. + pub async fn encrypt_alpha1( + &mut self, + request: impl tonic::IntoStreamingRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/EncryptAlpha1", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "EncryptAlpha1")); + self.inner.streaming(req, path, codec).await + } + /// DecryptAlpha1 decrypts a message using the Dapr encryption scheme and a key stored in the vault. + pub async fn decrypt_alpha1( + &mut self, + request: impl tonic::IntoStreamingRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/DecryptAlpha1", + ); + let mut req = request.into_streaming_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "DecryptAlpha1")); + self.inner.streaming(req, path, codec).await + } + /// Gets metadata of the sidecar + pub async fn get_metadata( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetMetadata", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetMetadata")); + self.inner.unary(req, path, codec).await + } + /// Sets value in extended metadata of the sidecar + pub async fn set_metadata( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SetMetadata", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SetMetadata")); + self.inner.unary(req, path, codec).await + } + /// SubtleGetKeyAlpha1 returns the public part of an asymmetric key stored in the vault. + pub async fn subtle_get_key_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleGetKeyAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SubtleGetKeyAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// SubtleEncryptAlpha1 encrypts a small message using a key stored in the vault. + pub async fn subtle_encrypt_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleEncryptAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SubtleEncryptAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// SubtleDecryptAlpha1 decrypts a small message using a key stored in the vault. + pub async fn subtle_decrypt_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleDecryptAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SubtleDecryptAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// SubtleWrapKeyAlpha1 wraps a key using a key stored in the vault. + pub async fn subtle_wrap_key_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleWrapKeyAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SubtleWrapKeyAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// SubtleUnwrapKeyAlpha1 unwraps a key using a key stored in the vault. + pub async fn subtle_unwrap_key_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleUnwrapKeyAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "SubtleUnwrapKeyAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// SubtleSignAlpha1 signs a message using a key stored in the vault. + pub async fn subtle_sign_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleSignAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SubtleSignAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// SubtleVerifyAlpha1 verifies the signature of a message using a key stored in the vault. + pub async fn subtle_verify_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/SubtleVerifyAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "SubtleVerifyAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Starts a new instance of a workflow + pub async fn start_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/StartWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "StartWorkflowAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Gets details about a started workflow instance + pub async fn get_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetWorkflowAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Purge Workflow + pub async fn purge_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "PurgeWorkflowAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Terminates a running workflow instance + pub async fn terminate_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "TerminateWorkflowAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Pauses a running workflow instance + pub async fn pause_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/PauseWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "PauseWorkflowAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Resumes a paused workflow instance + pub async fn resume_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "ResumeWorkflowAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Raise an event to a running workflow instance + pub async fn raise_event_workflow_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "RaiseEventWorkflowAlpha1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Starts a new instance of a workflow + pub async fn start_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/StartWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "StartWorkflowBeta1"), + ); + self.inner.unary(req, path, codec).await + } + /// Gets details about a started workflow instance + pub async fn get_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetWorkflowBeta1"), + ); + self.inner.unary(req, path, codec).await + } + /// Purge Workflow + pub async fn purge_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "PurgeWorkflowBeta1"), + ); + self.inner.unary(req, path, codec).await + } + /// Terminates a running workflow instance + pub async fn terminate_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "TerminateWorkflowBeta1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Pauses a running workflow instance + pub async fn pause_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/PauseWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "PauseWorkflowBeta1"), + ); + self.inner.unary(req, path, codec).await + } + /// Resumes a paused workflow instance + pub async fn resume_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "ResumeWorkflowBeta1"), + ); + self.inner.unary(req, path, codec).await + } + /// Raise an event to a running workflow instance + pub async fn raise_event_workflow_beta1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowBeta1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "dapr.proto.runtime.v1.Dapr", + "RaiseEventWorkflowBeta1", + ), + ); + self.inner.unary(req, path, codec).await + } + /// Shutdown the sidecar + pub async fn shutdown( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/Shutdown", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "Shutdown")); + self.inner.unary(req, path, codec).await + } + /// Create and schedule a job + pub async fn schedule_job_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/ScheduleJobAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "ScheduleJobAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + /// Gets a scheduled job + pub async fn get_job_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/GetJobAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "GetJobAlpha1")); + self.inner.unary(req, path, codec).await + } + /// Delete a job + pub async fn delete_job_alpha1( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/dapr.proto.runtime.v1.Dapr/DeleteJobAlpha1", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("dapr.proto.runtime.v1.Dapr", "DeleteJobAlpha1"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod dapr_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with DaprServer. + #[async_trait] + pub trait Dapr: Send + Sync + 'static { + /// Invokes a method on a remote Dapr app. + /// Deprecated: Use proxy mode service invocation instead. + async fn invoke_service( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets the state for a specific key. + async fn get_state( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets a bulk of state items for a list of keys + async fn get_bulk_state( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Saves the state for a specific key. + async fn save_state( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Queries the state. + async fn query_state_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Deletes the state for a specific key. + async fn delete_state( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Deletes a bulk of state items for a list of keys + async fn delete_bulk_state( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Executes transactions for a specified store + async fn execute_state_transaction( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Publishes events to the specific topic. + async fn publish_event( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Bulk Publishes multiple events to the specified topic. + async fn bulk_publish_event_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the SubscribeTopicEventsAlpha1 method. + type SubscribeTopicEventsAlpha1Stream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::SubscribeTopicEventsResponseAlpha1, + tonic::Status, + >, + > + + Send + + 'static; + /// SubscribeTopicEventsAlpha1 subscribes to a PubSub topic and receives topic + /// events from it. + async fn subscribe_topic_events_alpha1( + &self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Invokes binding data to specific output bindings + async fn invoke_binding( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets secrets from secret stores. + async fn get_secret( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets a bulk of secrets + async fn get_bulk_secret( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Register an actor timer. + async fn register_actor_timer( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Unregister an actor timer. + async fn unregister_actor_timer( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Register an actor reminder. + async fn register_actor_reminder( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Unregister an actor reminder. + async fn unregister_actor_reminder( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Gets the state for a specific actor. + async fn get_actor_state( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Executes state transactions for a specified actor + async fn execute_actor_state_transaction( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// InvokeActor calls a method on an actor. + async fn invoke_actor( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// GetConfiguration gets configuration from configuration store. + async fn get_configuration_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// GetConfiguration gets configuration from configuration store. + async fn get_configuration( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the SubscribeConfigurationAlpha1 method. + type SubscribeConfigurationAlpha1Stream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::SubscribeConfigurationResponse, + tonic::Status, + >, + > + + Send + + 'static; + /// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + async fn subscribe_configuration_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the SubscribeConfiguration method. + type SubscribeConfigurationStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result< + super::SubscribeConfigurationResponse, + tonic::Status, + >, + > + + Send + + 'static; + /// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream + async fn subscribe_configuration( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// UnSubscribeConfiguration unsubscribe the subscription of configuration + async fn unsubscribe_configuration_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// UnSubscribeConfiguration unsubscribe the subscription of configuration + async fn unsubscribe_configuration( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// TryLockAlpha1 tries to get a lock with an expiry. + async fn try_lock_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// UnlockAlpha1 unlocks a lock. + async fn unlock_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Server streaming response type for the EncryptAlpha1 method. + type EncryptAlpha1Stream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /// EncryptAlpha1 encrypts a message using the Dapr encryption scheme and a key stored in the vault. + async fn encrypt_alpha1( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Server streaming response type for the DecryptAlpha1 method. + type DecryptAlpha1Stream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /// DecryptAlpha1 decrypts a message using the Dapr encryption scheme and a key stored in the vault. + async fn decrypt_alpha1( + &self, + request: tonic::Request>, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets metadata of the sidecar + async fn get_metadata( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Sets value in extended metadata of the sidecar + async fn set_metadata( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// SubtleGetKeyAlpha1 returns the public part of an asymmetric key stored in the vault. + async fn subtle_get_key_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// SubtleEncryptAlpha1 encrypts a small message using a key stored in the vault. + async fn subtle_encrypt_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// SubtleDecryptAlpha1 decrypts a small message using a key stored in the vault. + async fn subtle_decrypt_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// SubtleWrapKeyAlpha1 wraps a key using a key stored in the vault. + async fn subtle_wrap_key_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// SubtleUnwrapKeyAlpha1 unwraps a key using a key stored in the vault. + async fn subtle_unwrap_key_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// SubtleSignAlpha1 signs a message using a key stored in the vault. + async fn subtle_sign_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// SubtleVerifyAlpha1 verifies the signature of a message using a key stored in the vault. + async fn subtle_verify_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Starts a new instance of a workflow + async fn start_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets details about a started workflow instance + async fn get_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Purge Workflow + async fn purge_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Terminates a running workflow instance + async fn terminate_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Pauses a running workflow instance + async fn pause_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Resumes a paused workflow instance + async fn resume_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Raise an event to a running workflow instance + async fn raise_event_workflow_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Starts a new instance of a workflow + async fn start_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets details about a started workflow instance + async fn get_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Purge Workflow + async fn purge_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Terminates a running workflow instance + async fn terminate_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Pauses a running workflow instance + async fn pause_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Resumes a paused workflow instance + async fn resume_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Raise an event to a running workflow instance + async fn raise_event_workflow_beta1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Shutdown the sidecar + async fn shutdown( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Create and schedule a job + async fn schedule_job_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + /// Gets a scheduled job + async fn get_job_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + /// Delete a job + async fn delete_job_alpha1( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + /// Dapr service provides APIs to user application to access Dapr building blocks. + #[derive(Debug)] + pub struct DaprServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl DaprServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for DaprServer + where + T: Dapr, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/dapr.proto.runtime.v1.Dapr/InvokeService" => { + #[allow(non_camel_case_types)] + struct InvokeServiceSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for InvokeServiceSvc { + type Response = super::super::super::common::v1::InvokeResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::invoke_service(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = InvokeServiceSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetState" => { + #[allow(non_camel_case_types)] + struct GetStateSvc(pub Arc); + impl tonic::server::UnaryService + for GetStateSvc { + type Response = super::GetStateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_state(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetStateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetBulkState" => { + #[allow(non_camel_case_types)] + struct GetBulkStateSvc(pub Arc); + impl tonic::server::UnaryService + for GetBulkStateSvc { + type Response = super::GetBulkStateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_bulk_state(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetBulkStateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SaveState" => { + #[allow(non_camel_case_types)] + struct SaveStateSvc(pub Arc); + impl tonic::server::UnaryService + for SaveStateSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::save_state(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SaveStateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/QueryStateAlpha1" => { + #[allow(non_camel_case_types)] + struct QueryStateAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for QueryStateAlpha1Svc { + type Response = super::QueryStateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::query_state_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = QueryStateAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/DeleteState" => { + #[allow(non_camel_case_types)] + struct DeleteStateSvc(pub Arc); + impl tonic::server::UnaryService + for DeleteStateSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_state(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = DeleteStateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/DeleteBulkState" => { + #[allow(non_camel_case_types)] + struct DeleteBulkStateSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for DeleteBulkStateSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_bulk_state(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = DeleteBulkStateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/ExecuteStateTransaction" => { + #[allow(non_camel_case_types)] + struct ExecuteStateTransactionSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for ExecuteStateTransactionSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::ExecuteStateTransactionRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::execute_state_transaction(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ExecuteStateTransactionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/PublishEvent" => { + #[allow(non_camel_case_types)] + struct PublishEventSvc(pub Arc); + impl tonic::server::UnaryService + for PublishEventSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::publish_event(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PublishEventSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/BulkPublishEventAlpha1" => { + #[allow(non_camel_case_types)] + struct BulkPublishEventAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for BulkPublishEventAlpha1Svc { + type Response = super::BulkPublishResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::bulk_publish_event_alpha1(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = BulkPublishEventAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubscribeTopicEventsAlpha1" => { + #[allow(non_camel_case_types)] + struct SubscribeTopicEventsAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::StreamingService< + super::SubscribeTopicEventsRequestAlpha1, + > for SubscribeTopicEventsAlpha1Svc { + type Response = super::SubscribeTopicEventsResponseAlpha1; + type ResponseStream = T::SubscribeTopicEventsAlpha1Stream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subscribe_topic_events_alpha1(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubscribeTopicEventsAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/InvokeBinding" => { + #[allow(non_camel_case_types)] + struct InvokeBindingSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for InvokeBindingSvc { + type Response = super::InvokeBindingResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::invoke_binding(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = InvokeBindingSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetSecret" => { + #[allow(non_camel_case_types)] + struct GetSecretSvc(pub Arc); + impl tonic::server::UnaryService + for GetSecretSvc { + type Response = super::GetSecretResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_secret(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetSecretSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetBulkSecret" => { + #[allow(non_camel_case_types)] + struct GetBulkSecretSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for GetBulkSecretSvc { + type Response = super::GetBulkSecretResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_bulk_secret(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetBulkSecretSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/RegisterActorTimer" => { + #[allow(non_camel_case_types)] + struct RegisterActorTimerSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for RegisterActorTimerSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::register_actor_timer(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = RegisterActorTimerSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/UnregisterActorTimer" => { + #[allow(non_camel_case_types)] + struct UnregisterActorTimerSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for UnregisterActorTimerSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::unregister_actor_timer(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UnregisterActorTimerSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/RegisterActorReminder" => { + #[allow(non_camel_case_types)] + struct RegisterActorReminderSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for RegisterActorReminderSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::register_actor_reminder(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = RegisterActorReminderSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/UnregisterActorReminder" => { + #[allow(non_camel_case_types)] + struct UnregisterActorReminderSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for UnregisterActorReminderSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::UnregisterActorReminderRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::unregister_actor_reminder(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UnregisterActorReminderSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetActorState" => { + #[allow(non_camel_case_types)] + struct GetActorStateSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for GetActorStateSvc { + type Response = super::GetActorStateResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_actor_state(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetActorStateSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/ExecuteActorStateTransaction" => { + #[allow(non_camel_case_types)] + struct ExecuteActorStateTransactionSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService< + super::ExecuteActorStateTransactionRequest, + > for ExecuteActorStateTransactionSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::ExecuteActorStateTransactionRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::execute_actor_state_transaction( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ExecuteActorStateTransactionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/InvokeActor" => { + #[allow(non_camel_case_types)] + struct InvokeActorSvc(pub Arc); + impl tonic::server::UnaryService + for InvokeActorSvc { + type Response = super::InvokeActorResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::invoke_actor(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = InvokeActorSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetConfigurationAlpha1" => { + #[allow(non_camel_case_types)] + struct GetConfigurationAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for GetConfigurationAlpha1Svc { + type Response = super::GetConfigurationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_configuration_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetConfigurationAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetConfiguration" => { + #[allow(non_camel_case_types)] + struct GetConfigurationSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for GetConfigurationSvc { + type Response = super::GetConfigurationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_configuration(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetConfigurationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubscribeConfigurationAlpha1" => { + #[allow(non_camel_case_types)] + struct SubscribeConfigurationAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::ServerStreamingService< + super::SubscribeConfigurationRequest, + > for SubscribeConfigurationAlpha1Svc { + type Response = super::SubscribeConfigurationResponse; + type ResponseStream = T::SubscribeConfigurationAlpha1Stream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subscribe_configuration_alpha1(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubscribeConfigurationAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubscribeConfiguration" => { + #[allow(non_camel_case_types)] + struct SubscribeConfigurationSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::ServerStreamingService< + super::SubscribeConfigurationRequest, + > for SubscribeConfigurationSvc { + type Response = super::SubscribeConfigurationResponse; + type ResponseStream = T::SubscribeConfigurationStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subscribe_configuration(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubscribeConfigurationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfigurationAlpha1" => { + #[allow(non_camel_case_types)] + struct UnsubscribeConfigurationAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for UnsubscribeConfigurationAlpha1Svc { + type Response = super::UnsubscribeConfigurationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::UnsubscribeConfigurationRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::unsubscribe_configuration_alpha1( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UnsubscribeConfigurationAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfiguration" => { + #[allow(non_camel_case_types)] + struct UnsubscribeConfigurationSvc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for UnsubscribeConfigurationSvc { + type Response = super::UnsubscribeConfigurationResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::UnsubscribeConfigurationRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::unsubscribe_configuration(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UnsubscribeConfigurationSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/TryLockAlpha1" => { + #[allow(non_camel_case_types)] + struct TryLockAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for TryLockAlpha1Svc { + type Response = super::TryLockResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::try_lock_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TryLockAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/UnlockAlpha1" => { + #[allow(non_camel_case_types)] + struct UnlockAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for UnlockAlpha1Svc { + type Response = super::UnlockResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::unlock_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UnlockAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/EncryptAlpha1" => { + #[allow(non_camel_case_types)] + struct EncryptAlpha1Svc(pub Arc); + impl tonic::server::StreamingService + for EncryptAlpha1Svc { + type Response = super::EncryptResponse; + type ResponseStream = T::EncryptAlpha1Stream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::encrypt_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = EncryptAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/DecryptAlpha1" => { + #[allow(non_camel_case_types)] + struct DecryptAlpha1Svc(pub Arc); + impl tonic::server::StreamingService + for DecryptAlpha1Svc { + type Response = super::DecryptResponse; + type ResponseStream = T::DecryptAlpha1Stream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + tonic::Streaming, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::decrypt_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = DecryptAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetMetadata" => { + #[allow(non_camel_case_types)] + struct GetMetadataSvc(pub Arc); + impl tonic::server::UnaryService + for GetMetadataSvc { + type Response = super::GetMetadataResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_metadata(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetMetadataSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SetMetadata" => { + #[allow(non_camel_case_types)] + struct SetMetadataSvc(pub Arc); + impl tonic::server::UnaryService + for SetMetadataSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::set_metadata(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SetMetadataSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleGetKeyAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleGetKeyAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for SubtleGetKeyAlpha1Svc { + type Response = super::SubtleGetKeyResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_get_key_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleGetKeyAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleEncryptAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleEncryptAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for SubtleEncryptAlpha1Svc { + type Response = super::SubtleEncryptResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_encrypt_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleEncryptAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleDecryptAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleDecryptAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for SubtleDecryptAlpha1Svc { + type Response = super::SubtleDecryptResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_decrypt_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleDecryptAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleWrapKeyAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleWrapKeyAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for SubtleWrapKeyAlpha1Svc { + type Response = super::SubtleWrapKeyResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_wrap_key_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleWrapKeyAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleUnwrapKeyAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleUnwrapKeyAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for SubtleUnwrapKeyAlpha1Svc { + type Response = super::SubtleUnwrapKeyResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_unwrap_key_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleUnwrapKeyAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleSignAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleSignAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for SubtleSignAlpha1Svc { + type Response = super::SubtleSignResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_sign_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleSignAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/SubtleVerifyAlpha1" => { + #[allow(non_camel_case_types)] + struct SubtleVerifyAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for SubtleVerifyAlpha1Svc { + type Response = super::SubtleVerifyResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::subtle_verify_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SubtleVerifyAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/StartWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct StartWorkflowAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for StartWorkflowAlpha1Svc { + type Response = super::StartWorkflowResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::start_workflow_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = StartWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct GetWorkflowAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for GetWorkflowAlpha1Svc { + type Response = super::GetWorkflowResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_workflow_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct PurgeWorkflowAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for PurgeWorkflowAlpha1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::purge_workflow_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PurgeWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct TerminateWorkflowAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for TerminateWorkflowAlpha1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::terminate_workflow_alpha1(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TerminateWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/PauseWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct PauseWorkflowAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for PauseWorkflowAlpha1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::pause_workflow_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PauseWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct ResumeWorkflowAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for ResumeWorkflowAlpha1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::resume_workflow_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ResumeWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowAlpha1" => { + #[allow(non_camel_case_types)] + struct RaiseEventWorkflowAlpha1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for RaiseEventWorkflowAlpha1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::raise_event_workflow_alpha1(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = RaiseEventWorkflowAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/StartWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct StartWorkflowBeta1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for StartWorkflowBeta1Svc { + type Response = super::StartWorkflowResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::start_workflow_beta1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = StartWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct GetWorkflowBeta1Svc(pub Arc); + impl tonic::server::UnaryService + for GetWorkflowBeta1Svc { + type Response = super::GetWorkflowResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_workflow_beta1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct PurgeWorkflowBeta1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for PurgeWorkflowBeta1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::purge_workflow_beta1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PurgeWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct TerminateWorkflowBeta1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for TerminateWorkflowBeta1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::terminate_workflow_beta1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = TerminateWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/PauseWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct PauseWorkflowBeta1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for PauseWorkflowBeta1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::pause_workflow_beta1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = PauseWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct ResumeWorkflowBeta1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for ResumeWorkflowBeta1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::resume_workflow_beta1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ResumeWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowBeta1" => { + #[allow(non_camel_case_types)] + struct RaiseEventWorkflowBeta1Svc(pub Arc); + impl< + T: Dapr, + > tonic::server::UnaryService + for RaiseEventWorkflowBeta1Svc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::raise_event_workflow_beta1(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = RaiseEventWorkflowBeta1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/Shutdown" => { + #[allow(non_camel_case_types)] + struct ShutdownSvc(pub Arc); + impl tonic::server::UnaryService + for ShutdownSvc { + type Response = (); + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::shutdown(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ShutdownSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/ScheduleJobAlpha1" => { + #[allow(non_camel_case_types)] + struct ScheduleJobAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for ScheduleJobAlpha1Svc { + type Response = super::ScheduleJobResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::schedule_job_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = ScheduleJobAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/GetJobAlpha1" => { + #[allow(non_camel_case_types)] + struct GetJobAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for GetJobAlpha1Svc { + type Response = super::GetJobResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_job_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = GetJobAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/dapr.proto.runtime.v1.Dapr/DeleteJobAlpha1" => { + #[allow(non_camel_case_types)] + struct DeleteJobAlpha1Svc(pub Arc); + impl tonic::server::UnaryService + for DeleteJobAlpha1Svc { + type Response = super::DeleteJobResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_job_alpha1(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = DeleteJobAlpha1Svc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for DaprServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for DaprServer { + const NAME: &'static str = "dapr.proto.runtime.v1.Dapr"; + } +} diff --git a/dapr/src/dapr/types.bin b/dapr/src/dapr/types.bin new file mode 100644 index 0000000000000000000000000000000000000000..12b13302707a3de906d8c9a1ea5baa77cb0bedf8 GIT binary patch literal 120951 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 F{{yx5`>, diff --git a/src/server/http.rs b/dapr/src/server/http.rs similarity index 100% rename from src/server/http.rs rename to dapr/src/server/http.rs diff --git a/src/server/mod.rs b/dapr/src/server/mod.rs similarity index 100% rename from src/server/mod.rs rename to dapr/src/server/mod.rs diff --git a/src/server/models.rs b/dapr/src/server/models.rs similarity index 100% rename from src/server/models.rs rename to dapr/src/server/models.rs diff --git a/src/server/utils.rs b/dapr/src/server/utils.rs similarity index 100% rename from src/server/utils.rs rename to dapr/src/server/utils.rs diff --git a/examples/Cargo.toml b/examples/Cargo.toml new file mode 100644 index 00000000..ec106b9a --- /dev/null +++ b/examples/Cargo.toml @@ -0,0 +1,90 @@ +[package] +name = "examples" +authors = ["Mike Nguyen "] +license = "Apache-2.0" +edition = "2021" +publish = false +version = "0.0.1" + +[dependencies] +dapr = { path = "../dapr" } +dapr-macros = { path = "../dapr-macros" } +serde = { version = "1.0.208", features = ["derive"] } +tokio = { version = "1.39.2", features = ["full"] } +tokio-stream = "0.1.15" +async-trait = "0.1.81" +env_logger = "0.11.5" +log = "0.4.22" +tonic = "0.11.0" +prost = "0.12.3" +prost-types = "0.12.3" +base64 = "0.21.7" +serde_json = "1.0.125" + +[[example]] +name = "actors-client" +path = "src/actors/client.rs" + +[[example]] +name = "actors-server" +path = "src/actors/server.rs" + +[[example]] +name = "bindings-input" +path = "src/bindings/input.rs" + +[[example]] +name = "bindings-output" +path = "src/bindings/output.rs" + +[[example]] +name = "client" +path = "src/client/client.rs" + +[[example]] +name = "configuration" +path = "src/configuration/main.rs" + +[[example]] +name = "crypto" +path = "src/crypto/main.rs" + +[[example]] +name = "invoke-grpc-client" +path = "src/invoke/grpc/client.rs" + +[[example]] +name = "invoke-grpc-server" +path = "src/invoke/grpc/server.rs" + +[[example]] +name = "invoke-grpc-proxying-client" +path = "src/invoke/grpc-proxying/client.rs" + +[[example]] +name = "invoke-grpc-proxying-server" +path = "src/invoke/grpc-proxying/server.rs" + +[[example]] +name = "jobs" +path = "src/jobs/jobs.rs" + +[[example]] +name = "pubsub-publisher" +path = "src/pubsub/publisher.rs" + +[[example]] +name = "pubsub-subscriber" +path = "src/pubsub/subscriber.rs" + +[[example]] +name = "query-state-1" +path = "src/query_state/query1.rs" + +[[example]] +name = "query-state-2" +path = "src/query_state/query2.rs" + +[[example]] +name = "secrets-bulk" +path = "src/secrets-bulk/app.rs" diff --git a/examples/README.md b/examples/README.md index f2c39e43..37f43619 100644 --- a/examples/README.md +++ b/examples/README.md @@ -2,9 +2,9 @@ These examples demonstrates how to use Dapr rust sdk. -* [client](./client) +* [client](src/client) * Simple dapr client example that saves, gets, and deletes state from the state stores -* [pubsub](./pubsub) +* [pubsub](src/pubsub) * Publishes and subscribes to events ## Adding new examples diff --git a/examples/invoke/proto/helloworld.proto b/examples/proto/helloworld/helloworld.proto similarity index 100% rename from examples/invoke/proto/helloworld.proto rename to examples/proto/helloworld/helloworld.proto diff --git a/examples/actors/README.md b/examples/src/actors/README.md similarity index 93% rename from examples/actors/README.md rename to examples/src/actors/README.md index b9364d68..c9cbb86d 100644 --- a/examples/actors/README.md +++ b/examples/src/actors/README.md @@ -88,7 +88,22 @@ Use the `DaprJson` extractor to deserialize the request from Json coming from a > docker ps > ``` -To run this example (using the multi-app run): +1. To run the example we need to first build the examples using the following command: + + + +```bash +cargo build --examples +``` + + + +2. Run this example (using the multi-app run): + +```bash +cargo build --examples +``` + + + +2Run a kafka container -2. Run the multi-app run template (`dapr.yaml`) +3. Run the multi-app run template (`dapr.yaml`) ```bash diff --git a/examples/bindings/components/bindings.yml b/examples/src/bindings/components/bindings.yml similarity index 100% rename from examples/bindings/components/bindings.yml rename to examples/src/bindings/components/bindings.yml diff --git a/examples/bindings/dapr.yaml b/examples/src/bindings/dapr.yaml similarity index 69% rename from examples/bindings/dapr.yaml rename to examples/src/bindings/dapr.yaml index aa984e7e..0f2c3807 100644 --- a/examples/bindings/dapr.yaml +++ b/examples/src/bindings/dapr.yaml @@ -8,9 +8,9 @@ apps: appProtocol: grpc appPort: 50051 logLevel: debug - command: ["cargo", "run", "--example", "input-bindings"] + command: ["cargo", "run", "--example", "bindings-input"] - appID: rust-output-b appDirPath: ./ appProtocol: grpc logLevel: debug - command: ["cargo", "run", "--example", "output-bindings"] \ No newline at end of file + command: ["cargo", "run", "--example", "bindings-output"] \ No newline at end of file diff --git a/examples/bindings/input.rs b/examples/src/bindings/input.rs similarity index 92% rename from examples/bindings/input.rs rename to examples/src/bindings/input.rs index 0e582000..f305fd61 100644 --- a/examples/bindings/input.rs +++ b/examples/src/bindings/input.rs @@ -1,8 +1,8 @@ use tonic::{transport::Server, Request, Response, Status}; -use dapr::dapr::dapr::proto::common::v1::{InvokeRequest, InvokeResponse}; -use dapr::dapr::dapr::proto::runtime::v1::app_callback_server::{AppCallback, AppCallbackServer}; -use dapr::dapr::dapr::proto::runtime::v1::{ +use dapr::dapr::proto::common::v1::{InvokeRequest, InvokeResponse}; +use dapr::dapr::proto::runtime::v1::{ + app_callback_server::{AppCallback, AppCallbackServer}, BindingEventRequest, BindingEventResponse, ListInputBindingsResponse, ListTopicSubscriptionsResponse, TopicEventRequest, TopicEventResponse, }; diff --git a/examples/bindings/output.rs b/examples/src/bindings/output.rs similarity index 100% rename from examples/bindings/output.rs rename to examples/src/bindings/output.rs diff --git a/examples/client/README.md b/examples/src/client/README.md similarity index 89% rename from examples/client/README.md rename to examples/src/client/README.md index e6d57615..fe61b7cb 100644 --- a/examples/client/README.md +++ b/examples/src/client/README.md @@ -5,10 +5,19 @@ docker ps 1. To run the example we need to first build the examples using the following command: -``` + + +```bash cargo build --examples ``` + + 2. Run the example with dapr using the following command: + ```bash cargo build --examples ``` + + 2. Insert a key with the value `hello` to redis using the following command: diff --git a/examples/configuration/main.rs b/examples/src/configuration/main.rs similarity index 100% rename from examples/configuration/main.rs rename to examples/src/configuration/main.rs diff --git a/examples/crypto/README.md b/examples/src/crypto/README.md similarity index 70% rename from examples/crypto/README.md rename to examples/src/crypto/README.md index 7b00a5cd..23288c56 100644 --- a/examples/crypto/README.md +++ b/examples/src/crypto/README.md @@ -6,15 +6,30 @@ This is a simple example that demonstrates Dapr's Cryptography capabilities. ## Running -To run this example: +1. To run the example we need to first build the examples using the following command: + + + +```bash +cargo build --examples +``` + + + +2. Generate keys in examples/crypto/keys directory: -1. Generate keys in examples/crypto/keys directory: + ```bash mkdir -p keys # Generate a private RSA key, 4096-bit keys @@ -25,7 +40,7 @@ openssl rand -out keys/symmetric-key-256 32 -2. Run the multi-app run template: +3. Run the multi-app run template: ```bash @@ -45,4 +60,4 @@ dapr run -f . -2. Stop with `ctrl + c` +4. Stop with `ctrl + c` diff --git a/examples/crypto/components/local-storage.yml b/examples/src/crypto/components/local-storage.yml similarity index 100% rename from examples/crypto/components/local-storage.yml rename to examples/src/crypto/components/local-storage.yml diff --git a/examples/crypto/dapr.yaml b/examples/src/crypto/dapr.yaml similarity index 100% rename from examples/crypto/dapr.yaml rename to examples/src/crypto/dapr.yaml diff --git a/examples/crypto/image.png b/examples/src/crypto/image.png similarity index 100% rename from examples/crypto/image.png rename to examples/src/crypto/image.png diff --git a/examples/crypto/main.rs b/examples/src/crypto/main.rs similarity index 100% rename from examples/crypto/main.rs rename to examples/src/crypto/main.rs diff --git a/examples/invoke/grpc-proxying/README.md b/examples/src/invoke/grpc-proxying/README.md similarity index 91% rename from examples/invoke/grpc-proxying/README.md rename to examples/src/invoke/grpc-proxying/README.md index 3c2c4c8b..1c718dac 100644 --- a/examples/invoke/grpc-proxying/README.md +++ b/examples/src/invoke/grpc-proxying/README.md @@ -5,10 +5,19 @@ docker ps 1. To run the example we need to first build the examples using the following command: -``` + + +```bash cargo build --examples ``` + + 2. Run the example with dapr using the following command: ```bash diff --git a/examples/invoke/grpc-proxying/client.rs b/examples/src/invoke/grpc-proxying/client.rs similarity index 90% rename from examples/invoke/grpc-proxying/client.rs rename to examples/src/invoke/grpc-proxying/client.rs index 99172962..3cdd49a5 100644 --- a/examples/invoke/grpc-proxying/client.rs +++ b/examples/src/invoke/grpc-proxying/client.rs @@ -5,7 +5,7 @@ use hello_world::{greeter_client::GreeterClient, HelloRequest}; use tonic::metadata::MetadataValue; pub mod hello_world { - tonic::include_proto!("helloworld"); // The string specified here must match the proto package name + include!("../protos/helloworld.rs"); } #[tokio::main] diff --git a/examples/invoke/grpc-proxying/dapr.yaml b/examples/src/invoke/grpc-proxying/dapr.yaml similarity index 100% rename from examples/invoke/grpc-proxying/dapr.yaml rename to examples/src/invoke/grpc-proxying/dapr.yaml diff --git a/examples/invoke/grpc-proxying/resources/resiliency.yaml b/examples/src/invoke/grpc-proxying/resources/resiliency.yaml similarity index 100% rename from examples/invoke/grpc-proxying/resources/resiliency.yaml rename to examples/src/invoke/grpc-proxying/resources/resiliency.yaml diff --git a/examples/invoke/grpc-proxying/server.rs b/examples/src/invoke/grpc-proxying/server.rs similarity index 91% rename from examples/invoke/grpc-proxying/server.rs rename to examples/src/invoke/grpc-proxying/server.rs index 4c50beab..b0ceadf4 100644 --- a/examples/invoke/grpc-proxying/server.rs +++ b/examples/src/invoke/grpc-proxying/server.rs @@ -3,7 +3,7 @@ use crate::hello_world::{HelloReply, HelloRequest}; use tonic::{transport::Server, Request, Response, Status}; pub mod hello_world { - tonic::include_proto!("helloworld"); // The string specified here must match the proto package name + include!("../protos/helloworld.rs"); } #[derive(Debug, Default)] diff --git a/examples/invoke/grpc/README.md b/examples/src/invoke/grpc/README.md similarity index 96% rename from examples/invoke/grpc/README.md rename to examples/src/invoke/grpc/README.md index ac716f50..cd28653e 100644 --- a/examples/invoke/grpc/README.md +++ b/examples/src/invoke/grpc/README.md @@ -5,10 +5,19 @@ docker ps 1. To run the example we need to first build the examples using the following command: -``` + + +```bash cargo build --examples ``` + + 2. Run the example with dapr using the following command to start the multi-app run: == APP - invoke-grpc-server == Method: say_hello == APP - invoke-grpc-server == Name: "Test" diff --git a/examples/invoke/grpc/client.rs b/examples/src/invoke/grpc/client.rs similarity index 84% rename from examples/invoke/grpc/client.rs rename to examples/src/invoke/grpc/client.rs index d3d3cff2..bda11d8b 100644 --- a/examples/invoke/grpc/client.rs +++ b/examples/src/invoke/grpc/client.rs @@ -1,10 +1,10 @@ +use crate::hello_world::HelloReply; use std::{thread, time::Duration}; -use hello_world::{HelloReply, HelloRequest}; use prost::Message; pub mod hello_world { - tonic::include_proto!("helloworld"); // The string specified here must match the proto package name + include!("../protos/helloworld.rs"); } type DaprClient = dapr::Client; @@ -19,7 +19,7 @@ async fn main() -> Result<(), Box> { let mut client = DaprClient::connect(address).await?; - let request = HelloRequest { + let request = hello_world::HelloRequest { name: "Test".to_string(), }; let data = request.encode_to_vec(); diff --git a/examples/invoke/grpc/dapr.yaml b/examples/src/invoke/grpc/dapr.yaml similarity index 100% rename from examples/invoke/grpc/dapr.yaml rename to examples/src/invoke/grpc/dapr.yaml diff --git a/examples/invoke/grpc/resources/resiliency.yaml b/examples/src/invoke/grpc/resources/resiliency.yaml similarity index 100% rename from examples/invoke/grpc/resources/resiliency.yaml rename to examples/src/invoke/grpc/resources/resiliency.yaml diff --git a/examples/invoke/grpc/server.rs b/examples/src/invoke/grpc/server.rs similarity index 94% rename from examples/invoke/grpc/server.rs rename to examples/src/invoke/grpc/server.rs index 7d61c032..1f5bd006 100644 --- a/examples/invoke/grpc/server.rs +++ b/examples/src/invoke/grpc/server.rs @@ -1,14 +1,15 @@ use dapr::{ appcallback::*, - dapr::dapr::proto::runtime::v1::app_callback_server::{AppCallback, AppCallbackServer}, + dapr::proto::runtime::v1::app_callback_server::{AppCallback, AppCallbackServer}, }; -use prost::Message; use tonic::{transport::Server, Request, Response, Status}; +use prost::Message; + use hello_world::{HelloReply, HelloRequest}; pub mod hello_world { - tonic::include_proto!("helloworld"); // The string specified here must match the proto package name + include!("../protos/helloworld.rs"); } pub struct AppCallbackService {} diff --git a/examples/src/invoke/protos/helloworld.rs b/examples/src/invoke/protos/helloworld.rs new file mode 100644 index 00000000..c02e50fd --- /dev/null +++ b/examples/src/invoke/protos/helloworld.rs @@ -0,0 +1,298 @@ +// This file is @generated by prost-build. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HelloRequest { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HelloReply { + #[prost(string, tag = "1")] + pub message: ::prost::alloc::string::String, +} +/// Generated client implementations. +pub mod greeter_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct GreeterClient { + inner: tonic::client::Grpc, + } + impl GreeterClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl GreeterClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> GreeterClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + GreeterClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn say_hello( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/helloworld.Greeter/SayHello", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("helloworld.Greeter", "SayHello")); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod greeter_server { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with GreeterServer. + #[async_trait] + pub trait Greeter: Send + Sync + 'static { + async fn say_hello( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct GreeterServer { + inner: _Inner, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + struct _Inner(Arc); + impl GreeterServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + let inner = _Inner(inner); + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for GreeterServer + where + T: Greeter, + B: Body + Send + 'static, + B::Error: Into + Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + let inner = self.inner.clone(); + match req.uri().path() { + "/helloworld.Greeter/SayHello" => { + #[allow(non_camel_case_types)] + struct SayHelloSvc(pub Arc); + impl tonic::server::UnaryService + for SayHelloSvc { + type Response = super::HelloReply; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::say_hello(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = SayHelloSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + Ok( + http::Response::builder() + .status(200) + .header("grpc-status", "12") + .header("content-type", "application/grpc") + .body(empty_body()) + .unwrap(), + ) + }) + } + } + } + } + impl Clone for GreeterServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + impl Clone for _Inner { + fn clone(&self) -> Self { + Self(Arc::clone(&self.0)) + } + } + impl std::fmt::Debug for _Inner { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self.0) + } + } + impl tonic::server::NamedService for GreeterServer { + const NAME: &'static str = "helloworld.Greeter"; + } +} diff --git a/examples/src/invoke/protos/types.bin b/examples/src/invoke/protos/types.bin new file mode 100644 index 0000000000000000000000000000000000000000..b5e7258cb610de194e00880e273ca410380b532e GIT binary patch literal 458 zcmZvZ!A`?442F~1Yg0GC@L*IN5b6Q3OAk!kxDRn0Pf$bzhmMZ62<;JgGF}TOA{qy7 z{^H-CErq^;rmwDTyU(s~pX+VkjUCherK-r@`~KR!f4E^}CVXo)uGE+MI$wvnx+40` zY}*}|lx^HFG%qm}@n%KYs&{U5J>QXeY<6La%X+`B{=4ja{!d3%JbWdTGAebT$&j`T zO0lmJ2CZg9l%$Fg)I>`SsnQH!j;J6^RiYRWZ^_ccgS600BZ&a{A`%EKmR^UV%Tyk8 z=w~u>;&m8w24;T5!-T;=9!Y|R4kL-q9COfV#=>7O*P)hFVL0ftzs}-W7!eSiMT#Ur QTW}=N+0*$`8vbng19n?QNdN!< literal 0 HcmV?d00001 diff --git a/examples/jobs/README.md b/examples/src/jobs/README.md similarity index 69% rename from examples/jobs/README.md rename to examples/src/jobs/README.md index 6a4809b5..722f5ff2 100644 --- a/examples/jobs/README.md +++ b/examples/src/jobs/README.md @@ -6,7 +6,22 @@ This is a simple example that demonstrates Dapr's job scheduling capabilities. To run this example: -1. Run the multi-app run template: +1. To run the example we need to first build the examples using the following command: + + + +```bash +cargo build --examples +``` + + + +2. Run the multi-app run template: -2. Stop with `ctrl + c` +3. Stop with `ctrl + c` diff --git a/examples/jobs/dapr.yaml b/examples/src/jobs/dapr.yaml similarity index 100% rename from examples/jobs/dapr.yaml rename to examples/src/jobs/dapr.yaml diff --git a/examples/jobs/jobs.rs b/examples/src/jobs/jobs.rs similarity index 95% rename from examples/jobs/jobs.rs rename to examples/src/jobs/jobs.rs index aa5aa49a..6f724e1e 100644 --- a/examples/jobs/jobs.rs +++ b/examples/src/jobs/jobs.rs @@ -1,11 +1,12 @@ use std::time::Duration; use base64::prelude::*; -use dapr::add_job_handler_alpha; use dapr::client::JobBuilder; -use dapr::dapr::dapr::proto::runtime::v1::app_callback_alpha_server::AppCallbackAlphaServer; -use dapr::dapr::dapr::proto::runtime::v1::{JobEventRequest, JobEventResponse}; +use dapr::dapr::proto::runtime::v1::{ + app_callback_alpha_server::AppCallbackAlphaServer, JobEventRequest, JobEventResponse, +}; use dapr::server::appcallbackalpha::{AppCallbackServiceAlpha, JobHandlerMethod}; +use dapr::{add_job_handler_alpha, serde_json}; use prost_types::Any; use serde::{Deserialize, Serialize}; use tokio::time::sleep; diff --git a/examples/pubsub/README.md b/examples/src/pubsub/README.md similarity index 92% rename from examples/pubsub/README.md rename to examples/src/pubsub/README.md index e7a459d1..5d01c414 100644 --- a/examples/pubsub/README.md +++ b/examples/src/pubsub/README.md @@ -14,12 +14,25 @@ This is a simple example that demonstrates Dapr's pub/sub capabilities. To imple > docker ps > ``` -To run this example: +1. To run the example we need to first build the examples using the following command: -1. Run the multi-app run template: + + +```bash +cargo build --examples +``` + + + +2. Run the multi-app run template: @@ -116,16 +129,16 @@ dapr run -f . -2. Stop with `ctrl + c` +3. Stop with `ctrl + c` ### Running without multi-app 1. Run the subscriber with dapr ```bash -dapr run --app-id rust-subscriber --app-protocol grpc --app-port 50051 cargo run -- --example subscriber +dapr run --app-id rust-subscriber --app-protocol grpc --app-port 50051 cargo run -- --example pubsub-subscriber ``` 2. Run the publisher with dapr ```bash -dapr run --app-id rust-publisher --app-protocol grpc cargo run -- --example publisher +dapr run --app-id rust-publisher --app-protocol grpc cargo run -- --example pubsub-publisher ``` diff --git a/examples/pubsub/dapr.yaml b/examples/src/pubsub/dapr.yaml similarity index 68% rename from examples/pubsub/dapr.yaml rename to examples/src/pubsub/dapr.yaml index e70f122e..f8376e31 100644 --- a/examples/pubsub/dapr.yaml +++ b/examples/src/pubsub/dapr.yaml @@ -8,9 +8,9 @@ apps: appProtocol: grpc appPort: 50051 logLevel: debug - command: ["cargo", "run", "--example", "subscriber"] + command: ["cargo", "run", "--example", "pubsub-subscriber"] - appID: rust-publisher appDirPath: ./ appProtocol: grpc logLevel: debug - command: ["cargo", "run", "--example", "publisher"] + command: ["cargo", "run", "--example", "pubsub-publisher"] diff --git a/examples/pubsub/publisher.rs b/examples/src/pubsub/publisher.rs similarity index 95% rename from examples/pubsub/publisher.rs rename to examples/src/pubsub/publisher.rs index 543e6b28..71086a15 100644 --- a/examples/pubsub/publisher.rs +++ b/examples/src/pubsub/publisher.rs @@ -1,5 +1,7 @@ use std::{collections::HashMap, thread, time::Duration}; +use tokio::time; + use dapr::serde::{Deserialize, Serialize}; use dapr::serde_json; @@ -37,6 +39,9 @@ async fn main() -> Result<(), Box> { let topic = "A".to_string(); let topic_b = "B".to_string(); + // Delay to wait for the subscriber to fully start + time::sleep(Duration::from_secs(5)).await; + for count in 0..10 { let order = Order { order_number: count, diff --git a/examples/pubsub/resources/pubsub.yaml b/examples/src/pubsub/resources/pubsub.yaml similarity index 92% rename from examples/pubsub/resources/pubsub.yaml rename to examples/src/pubsub/resources/pubsub.yaml index 953c26f3..8d476c95 100644 --- a/examples/pubsub/resources/pubsub.yaml +++ b/examples/src/pubsub/resources/pubsub.yaml @@ -9,4 +9,4 @@ spec: - name: redisHost value: localhost:6379 - name: redisPassword - value: "" + value: "" \ No newline at end of file diff --git a/examples/pubsub/resources/resiliency.yaml b/examples/src/pubsub/resources/resiliency.yaml similarity index 100% rename from examples/pubsub/resources/resiliency.yaml rename to examples/src/pubsub/resources/resiliency.yaml diff --git a/examples/pubsub/subscriber.rs b/examples/src/pubsub/subscriber.rs similarity index 88% rename from examples/pubsub/subscriber.rs rename to examples/src/pubsub/subscriber.rs index a149e5c5..3383041e 100644 --- a/examples/pubsub/subscriber.rs +++ b/examples/src/pubsub/subscriber.rs @@ -1,11 +1,8 @@ use dapr_macros::topic; use tonic::transport::Server; -use dapr::appcallback::AppCallbackService; use dapr::serde::{Deserialize, Serialize}; -use dapr::{ - appcallback::*, dapr::dapr::proto::runtime::v1::app_callback_server::AppCallbackServer, -}; +use dapr::{appcallback::*, dapr::proto::runtime::v1::app_callback_server::AppCallbackServer}; #[derive(Serialize, Deserialize, Debug)] struct Order { diff --git a/examples/query_state/README.md b/examples/src/query_state/README.md similarity index 96% rename from examples/query_state/README.md rename to examples/src/query_state/README.md index a7348de5..fcf0fa6b 100644 --- a/examples/query_state/README.md +++ b/examples/src/query_state/README.md @@ -50,10 +50,19 @@ curl -X POST -H "Content-Type: application/json" http://localhost:3500/v1.0/stat 1. To run the example we need to first build the examples using the following command: + + ```bash cargo build --examples ``` + + 2. Executing the first query Query: ```json @@ -83,7 +92,7 @@ sleep: 15 timeout_seconds: 30 --> ```bash -dapr run --app-id=rustapp --dapr-grpc-port 3501 --resources-path statestore/ cargo run -- --example query_state_q1 +dapr run --app-id=rustapp --dapr-grpc-port 3501 --resources-path statestore/ cargo run -- --example query-state-1 ``` @@ -117,7 +126,7 @@ sleep: 15 timeout_seconds: 30 --> ```bash -dapr run --app-id=rustapp --dapr-grpc-port 3501 --resources-path statestore/ cargo run -- --example query_state_q2 +dapr run --app-id=rustapp --dapr-grpc-port 3501 --resources-path statestore/ cargo run -- --example query-state-2 ``` diff --git a/examples/query_state/query1.rs b/examples/src/query_state/query1.rs similarity index 100% rename from examples/query_state/query1.rs rename to examples/src/query_state/query1.rs diff --git a/examples/query_state/query2.rs b/examples/src/query_state/query2.rs similarity index 100% rename from examples/query_state/query2.rs rename to examples/src/query_state/query2.rs diff --git a/examples/query_state/statestore/dataset.json b/examples/src/query_state/statestore/dataset.json similarity index 100% rename from examples/query_state/statestore/dataset.json rename to examples/src/query_state/statestore/dataset.json diff --git a/examples/query_state/statestore/mongodb.yml b/examples/src/query_state/statestore/mongodb.yml similarity index 100% rename from examples/query_state/statestore/mongodb.yml rename to examples/src/query_state/statestore/mongodb.yml diff --git a/examples/secrets-bulk/README.md b/examples/src/secrets-bulk/README.md similarity index 91% rename from examples/secrets-bulk/README.md rename to examples/src/secrets-bulk/README.md index ca070f6a..d05eaedb 100644 --- a/examples/secrets-bulk/README.md +++ b/examples/src/secrets-bulk/README.md @@ -5,10 +5,19 @@ docker ps 1. To run the example we need to first build the examples using the following command: -``` + + +```bash cargo build --examples ``` + + 2. Run the example with dapr using the following command: