code
stringlengths 0
56.1M
| repo_name
stringclasses 515
values | path
stringlengths 2
147
| language
stringclasses 447
values | license
stringclasses 7
values | size
int64 0
56.8M
|
|---|---|---|---|---|---|
package operator
import (
"context"
"fmt"
"time"
"go.uber.org/ratelimit"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/selection"
"k8s.io/apimachinery/pkg/types"
"sigs.k8s.io/controller-runtime/pkg/client"
injectorConsts "github.com/dapr/dapr/pkg/injector/consts"
operatorConsts "github.com/dapr/dapr/pkg/operator/meta"
"github.com/dapr/kit/utils"
)
const (
sidecarContainerName = "daprd"
daprEnabledAnnotationKey = "dapr.io/enabled"
)
// service timers, using var to be able to mock their values in tests
var (
// minimum amount of time that interval should be to not execute this only once
singleIterationDurationThreshold = time.Second
// How long to wait for the sidecar injector deployment to be up and running before retrying
sidecarInjectorWaitInterval = 5 * time.Second
)
// DaprWatchdog is a controller that periodically polls all pods and ensures that they are in the correct state.
// This controller only runs on the cluster's leader.
// Currently, this ensures that the sidecar is injected in each pod, otherwise it kills the pod, so it can be restarted.
type DaprWatchdog struct {
interval time.Duration
maxRestartsPerMin int
client client.Client
restartLimiter ratelimit.Limiter
canPatchPodLabels bool
podSelector labels.Selector
}
// NeedLeaderElection makes it so the controller runs on the leader node only.
// Implements sigs.k8s.io/controller-runtime/pkg/manager.LeaderElectionRunnable .
func (dw *DaprWatchdog) NeedLeaderElection() bool {
return true
}
// Start the controller. This method blocks until the context is canceled.
// Implements sigs.k8s.io/controller-runtime/pkg/manager.Runnable .
func (dw *DaprWatchdog) Start(parentCtx context.Context) error {
log.Infof("DaprWatchdog worker starting")
ctx, cancel := context.WithCancel(parentCtx)
defer cancel()
if dw.maxRestartsPerMin > 0 {
dw.restartLimiter = ratelimit.New(
dw.maxRestartsPerMin,
ratelimit.Per(time.Minute),
ratelimit.WithoutSlack,
)
} else {
dw.restartLimiter = ratelimit.NewUnlimited()
}
// Use a buffered channel to make sure that there's at most one iteration at a given time
// and if an iteration isn't done by the time the next one is scheduled to start, no more iterations are added to the queue
workCh := make(chan struct{}, 1)
defer close(workCh)
firstCompleteCh := make(chan struct{})
go func() {
defer log.Infof("DaprWatchdog worker stopped")
firstCompleted := false
for {
select {
case <-ctx.Done():
return
case _, ok := <-workCh:
if !ok {
continue
}
ok = dw.listPods(ctx)
if !firstCompleted {
if ok {
close(firstCompleteCh)
firstCompleted = true
} else {
// Ensure that there's at least one successful run
// If it failed, retry after a bit
time.Sleep(sidecarInjectorWaitInterval)
workCh <- struct{}{}
}
}
}
}
}()
log.Infof("DaprWatchdog worker started")
// Start an iteration right away, at startup
workCh <- struct{}{}
// Wait for completion of first iteration
select {
case <-ctx.Done(): // in case context Done, as first iteration can get stuck, and the channel would not be closed
return nil
case <-firstCompleteCh:
// nop
}
// If we only run once, exit when it's done
if dw.interval < singleIterationDurationThreshold {
return nil
}
// Repeat on interval
t := time.NewTicker(dw.interval)
defer t.Stop()
forloop:
for {
select {
case <-ctx.Done():
break forloop
case <-t.C:
log.Debugf("DaprWatchdog worker tick")
select {
case workCh <- struct{}{}:
// Successfully queued another iteration
log.Debugf("Added listPods iteration to the queue")
default:
// Do nothing - there's already an iteration in the queue
log.Debugf("There's already an iteration in the listPods queue-not adding another one")
}
}
}
log.Infof("DaprWatchdog worker stopping")
return nil
}
// getSideCarInjectedNotExistsSelector creates a selector that matches pod without the injector patched label
func getSideCarInjectedNotExistsSelector() labels.Selector {
sel := labels.NewSelector()
req, err := labels.NewRequirement(injectorConsts.SidecarInjectedLabel, selection.DoesNotExist, []string{})
if err != nil {
log.Fatalf("Unable to add label requirement to find pods with Injector created label , err: %s", err)
}
sel = sel.Add(*req)
req, err = labels.NewRequirement(operatorConsts.WatchdogPatchedLabel, selection.DoesNotExist, []string{})
if err != nil {
log.Fatalf("Unable to add label requirement to find pods with Watchdog created label , err: %s", err)
}
return sel.Add(*req)
}
func (dw *DaprWatchdog) listPods(ctx context.Context) bool {
log.Infof("DaprWatchdog started checking pods")
// Look for the dapr-sidecar-injector deployment first and ensure it's running
// Otherwise, the pods would come back up without the sidecar again
deployment := &appsv1.DeploymentList{}
err := dw.client.List(ctx, deployment, &client.ListOptions{
LabelSelector: labels.SelectorFromSet(
map[string]string{"app": operatorConsts.SidecarInjectorDeploymentName},
),
})
if err != nil {
log.Errorf("Failed to list pods to get dapr-sidecar-injector. Error: %v", err)
return false
}
if len(deployment.Items) == 0 || deployment.Items[0].Status.ReadyReplicas < 1 {
log.Warnf("Could not find a running dapr-sidecar-injector; will retry later")
return false
}
log.Debugf("Found running dapr-sidecar-injector container")
// We are splitting the process of finding the potential pods by first querying only for the metadata of the pods
// to verify the annotation. If we find some with dapr enabled annotation we will subsequently query those further.
podListOpts := &client.ListOptions{
LabelSelector: dw.podSelector,
}
podList := &corev1.PodList{}
err = dw.client.List(ctx, podList, podListOpts)
if err != nil {
log.Errorf("Failed to list pods. Error: %v", err)
return false
}
for i := range podList.Items {
pod := podList.Items[i]
// Skip invalid pods
if pod.Name == "" {
continue
}
logName := pod.Namespace + "/" + pod.Name
// Filter for pods with the dapr.io/enabled annotation
if daprEnabled, ok := pod.Annotations[daprEnabledAnnotationKey]; !(ok && utils.IsTruthy(daprEnabled)) {
log.Debugf("Skipping pod %s: %s is not true", logName, daprEnabledAnnotationKey)
continue
}
// Check if the sidecar container is running
hasSidecar := false
for _, c := range pod.Spec.Containers {
if c.Name == sidecarContainerName {
hasSidecar = true
break
}
}
if hasSidecar {
if dw.canPatchPodLabels {
log.Debugf("Found Dapr sidecar in pod %s, will patch the pod labels", logName)
err = patchPodLabel(ctx, dw.client, &pod)
if err != nil {
log.Errorf("problems patching pod %s, err: %s", logName, err)
}
} else {
log.Debugf("Found Dapr sidecar in pod %s", logName)
}
continue
}
// Pod doesn't have a sidecar, so we need to delete it, so it can be restarted and have the sidecar injected
log.Warnf("Pod %s does not have the Dapr sidecar and will be deleted", logName)
err = dw.client.Delete(ctx, &pod)
if err != nil {
log.Errorf("Failed to delete pod %s. Error: %v", logName, err)
continue
}
log.Infof("Deleted pod %s", logName)
log.Debugf("Taking a pod restart token")
before := time.Now()
_ = dw.restartLimiter.Take()
log.Debugf("Resumed after pausing for %v", time.Since(before))
}
log.Infof("DaprWatchdog completed checking pods")
return true
}
func patchPodLabel(ctx context.Context, cl client.Client, pod *corev1.Pod) error {
// in case this has been already patched just return
if _, ok := pod.GetLabels()[operatorConsts.WatchdogPatchedLabel]; ok {
return nil
}
mergePatch := []byte(fmt.Sprintf(`{"metadata":{"labels":{"%s":"true"}}}`, operatorConsts.WatchdogPatchedLabel))
return cl.Patch(ctx, pod, client.RawPatch(types.MergePatchType, mergePatch))
}
|
mikeee/dapr
|
pkg/operator/watchdog.go
|
GO
|
mit
| 8,037 |
package operator
import (
"context"
"fmt"
"testing"
"time"
"github.com/stretchr/testify/require"
"go.uber.org/ratelimit"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/client/fake"
"github.com/dapr/dapr/pkg/injector/annotations"
injectorConsts "github.com/dapr/dapr/pkg/injector/consts"
operatorconsts "github.com/dapr/dapr/pkg/operator/meta"
"github.com/dapr/kit/ptr"
)
func createMockInjectorDeployment(replicas int32) *appsv1.Deployment {
return &appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{
Name: "injector",
Namespace: "dapr-system",
Labels: map[string]string{"app": operatorconsts.SidecarInjectorDeploymentName},
},
Spec: appsv1.DeploymentSpec{
Replicas: ptr.Of(replicas),
},
Status: appsv1.DeploymentStatus{
ReadyReplicas: replicas,
},
}
}
func createMockPods(n, daprized, injected, daprdPresent int) (pods []*corev1.Pod) {
pods = make([]*corev1.Pod, n)
for i := 0; i < n; i++ {
pods[i] = &corev1.Pod{
ObjectMeta: metav1.ObjectMeta{
Name: fmt.Sprintf("pod-%d", i),
Namespace: "dapr-system",
Labels: make(map[string]string),
Annotations: make(map[string]string),
},
Spec: corev1.PodSpec{
Containers: []corev1.Container{{Name: "my-app", Image: "quay.io/prometheus/busybox-linux-arm64", Args: []string{"sh", "-c", "sleep 3600"}}},
TerminationGracePeriodSeconds: ptr.Of(int64(0)),
Tolerations: []corev1.Toleration{
{
Key: "kwok.x-k8s.io/node",
Operator: corev1.TolerationOpEqual,
Value: "fake",
Effect: corev1.TaintEffectNoSchedule,
},
},
NodeSelector: map[string]string{
"type": "kwok",
},
},
Status: corev1.PodStatus{},
}
if i < daprized {
pods[i].Annotations[annotations.KeyEnabled] = "true"
}
if i < injected {
pods[i].Labels[injectorConsts.SidecarInjectedLabel] = "true"
}
if i < daprdPresent {
pods[i].Spec.Containers = append(pods[i].Spec.Containers, corev1.Container{
Name: sidecarContainerName,
Image: "quay.io/prometheus/busybox-linux-arm64", Args: []string{"sh", "-c", "sleep 3600"},
},
)
}
}
return pods
}
func TestDaprWatchdog_listPods(t *testing.T) {
ctx := context.Background()
rl := ratelimit.NewUnlimited()
t.Run("injectorNotPresent", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects().Build()
dw := &DaprWatchdog{client: ctlClient}
require.False(t, dw.listPods(ctx))
})
t.Run("injectorPresentNoReplicas", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(0)).Build()
dw := &DaprWatchdog{client: ctlClient}
require.False(t, dw.listPods(ctx))
})
t.Run("noPods", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{client: ctlClient, podSelector: getSideCarInjectedNotExistsSelector()}
require.True(t, dw.listPods(ctx))
})
t.Run("noPodsWithAnnotations", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{client: ctlClient, podSelector: getSideCarInjectedNotExistsSelector()}
pods := createMockPods(10, 0, 0, 0)
for _, pod := range pods {
require.NoError(t, ctlClient.Create(ctx, pod))
}
require.True(t, dw.listPods(ctx))
t.Log("all pods should be present")
for _, pod := range pods {
require.NoError(t, ctlClient.Get(ctx, client.ObjectKeyFromObject(pod), &corev1.Pod{}))
}
})
t.Run("noInjectedPods", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{client: ctlClient, restartLimiter: rl, podSelector: getSideCarInjectedNotExistsSelector()}
daprized := 5
var injected, running int
pods := createMockPods(10, daprized, injected, running)
for _, pod := range pods {
require.NoError(t, ctlClient.Create(ctx, pod))
}
require.True(t, dw.listPods(ctx))
t.Log("daprized pods should be deleted")
assertExpectedPodsDeleted(t, pods, ctlClient, ctx, daprized, running, injected)
})
t.Run("noInjectedPodsSomeRunning", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{client: ctlClient, restartLimiter: rl, podSelector: getSideCarInjectedNotExistsSelector()}
daprized := 5
running := 2
var injected int
pods := createMockPods(10, daprized, injected, running)
for _, pod := range pods {
require.NoError(t, ctlClient.Create(ctx, pod))
}
require.True(t, dw.listPods(ctx))
t.Log("daprized pods should be deleted except those running")
assertExpectedPodsDeleted(t, pods, ctlClient, ctx, daprized, running, injected)
})
t.Run("someInjectedPodsWatchdogCannotPatch", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{client: ctlClient, restartLimiter: rl, podSelector: getSideCarInjectedNotExistsSelector()}
daprized := 5
running := 1
injected := 3
pods := createMockPods(10, daprized, injected, running)
for _, pod := range pods {
require.NoError(t, ctlClient.Create(ctx, pod))
}
require.True(t, dw.listPods(ctx))
t.Log("daprized pods should be deleted except those running")
assertExpectedPodsDeleted(t, pods, ctlClient, ctx, daprized, running, injected)
assertExpectedPodsPatched(t, ctlClient, ctx, 0) // not expecting any patched pods as all pods with sidecar already have the injected label
})
t.Run("someInjectedPodsWatchdogCanPatch", func(t *testing.T) {
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{client: ctlClient, restartLimiter: rl, canPatchPodLabels: true, podSelector: getSideCarInjectedNotExistsSelector()}
daprized := 5
running := 3
injected := 1
pods := createMockPods(10, daprized, injected, running)
for _, pod := range pods {
require.NoError(t, ctlClient.Create(ctx, pod))
}
require.True(t, dw.listPods(ctx))
t.Log("daprized pods should be deleted except those running")
assertExpectedPodsDeleted(t, pods, ctlClient, ctx, daprized, running, injected)
assertExpectedPodsPatched(t, ctlClient, ctx, 2) // expecting 2, as we have 3 with sidecar but only one with label injected
})
}
// assertExpectedPodsPatched check that we have patched the pods that did not have the label when the watchdog can patch pods
func assertExpectedPodsPatched(t *testing.T, ctlClient client.Reader, ctx context.Context, expectedPatchPods int) {
objList := corev1.PodList{}
require.NoError(t, ctlClient.List(ctx, &objList, client.MatchingLabels{operatorconsts.WatchdogPatchedLabel: "true"}))
require.Len(t, objList.Items, expectedPatchPods)
}
// assertExpectedPodsDeleted
func assertExpectedPodsDeleted(t *testing.T, pods []*corev1.Pod, ctlClient client.Reader, ctx context.Context, daprized int, running int, injected int) {
for i, pod := range pods {
err := ctlClient.Get(ctx, client.ObjectKeyFromObject(pod), &corev1.Pod{})
injectedOrRunning := running
if injected > injectedOrRunning {
injectedOrRunning = injected
}
if i < daprized && i >= injectedOrRunning {
require.Error(t, err)
require.True(t, apierrors.IsNotFound(err))
} else {
require.NoError(t, err)
}
}
}
func Test_patchPodLabel(t *testing.T) {
tests := []struct {
name string
pod *corev1.Pod
wantLabels map[string]string
wantErr bool
}{
{
name: "nilLabels",
pod: &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "test"}},
wantLabels: map[string]string{operatorconsts.WatchdogPatchedLabel: "true"},
},
{
name: "emptyLabels",
pod: &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "test", Labels: map[string]string{}}},
wantLabels: map[string]string{operatorconsts.WatchdogPatchedLabel: "true"},
},
{
name: "nonEmptyLabels",
pod: &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "test", Labels: map[string]string{"app": "name"}}},
wantLabels: map[string]string{operatorconsts.WatchdogPatchedLabel: "true", "app": "name"},
},
{
name: "noName",
pod: &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"app": "name"}}},
wantErr: true,
},
{
name: "alreadyPresent",
pod: &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"app": "name", operatorconsts.WatchdogPatchedLabel: "true"}}},
wantLabels: map[string]string{operatorconsts.WatchdogPatchedLabel: "true", "app": "name"},
},
}
for _, tc := range tests {
ctlClient := fake.NewClientBuilder().WithObjects(tc.pod).Build()
t.Run(tc.name, func(t *testing.T) {
if err := patchPodLabel(context.TODO(), ctlClient, tc.pod); (err != nil) != tc.wantErr {
t.Fatalf("patchPodLabel() error = %v, wantErr %v", err, tc.wantErr)
}
if !tc.wantErr {
require.Equal(t, tc.wantLabels, tc.pod.Labels)
}
})
}
}
func TestDaprWatchdog_Start(t *testing.T) {
// simple test of start
ctx, cancel := context.WithCancel(context.Background())
cancelled := false
defer func() {
if !cancelled {
cancel()
}
}()
singleIterationDurationThreshold = 100 * time.Millisecond
defer func() {
singleIterationDurationThreshold = time.Second
sidecarInjectorWaitInterval = 100 * time.Millisecond
}()
ctlClient := fake.NewClientBuilder().WithObjects(createMockInjectorDeployment(1)).Build()
dw := &DaprWatchdog{
client: ctlClient,
maxRestartsPerMin: 0,
canPatchPodLabels: true,
interval: 200 * time.Millisecond,
podSelector: getSideCarInjectedNotExistsSelector(),
}
daprized := 5
running := 3
injected := 1
pods := createMockPods(10, daprized, injected, running)
for _, pod := range pods {
require.NoError(t, ctlClient.Create(ctx, pod))
}
startDone := make(chan struct{}, 1)
go func() {
require.NoError(t, dw.Start(ctx))
startDone <- struct{}{}
}()
// let it run a few cycles
time.Sleep(time.Second)
cancel()
cancelled = true
<-startDone
t.Log("daprized pods should be deleted except those running")
assertExpectedPodsDeleted(t, pods, ctlClient, ctx, daprized, running, injected)
t.Log("daprized pods with sidecar should have been patched")
assertExpectedPodsPatched(t, ctlClient, ctx, 2)
}
|
mikeee/dapr
|
pkg/operator/watchdog_test.go
|
GO
|
mit
| 10,512 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package fake
import (
"context"
"github.com/dapr/components-contrib/state"
"github.com/dapr/dapr/pkg/apis/components/v1alpha1"
)
type Fake struct {
addOrUpdateOutboxFn func(stateStore v1alpha1.Component)
enabledFn func(stateStore string) bool
publishInternalFn func(ctx context.Context, stateStore string, states []state.TransactionalStateOperation, source, traceID, traceState string) ([]state.TransactionalStateOperation, error)
subscribeToInternalTopicsFn func(ctx context.Context, appID string) error
}
func New() *Fake {
return &Fake{
addOrUpdateOutboxFn: func(stateStore v1alpha1.Component) {},
enabledFn: func(stateStore string) bool { return false },
publishInternalFn: func(ctx context.Context, stateStore string, states []state.TransactionalStateOperation, source, traceID, traceState string) ([]state.TransactionalStateOperation, error) {
return nil, nil
},
subscribeToInternalTopicsFn: func(ctx context.Context, appID string) error { return nil },
}
}
func (f *Fake) WithAddOrUpdateOutbox(fn func(stateStore v1alpha1.Component)) *Fake {
f.addOrUpdateOutboxFn = fn
return f
}
func (f *Fake) WithEnabled(fn func(stateStore string) bool) *Fake {
f.enabledFn = fn
return f
}
func (f *Fake) WithPublishInternal(fn func(ctx context.Context, stateStore string, states []state.TransactionalStateOperation, source, traceID, traceState string) ([]state.TransactionalStateOperation, error)) *Fake {
f.publishInternalFn = fn
return f
}
func (f *Fake) WithSubscribeToInternalTopics(fn func(ctx context.Context, appID string) error) *Fake {
f.subscribeToInternalTopicsFn = fn
return f
}
func (f *Fake) AddOrUpdateOutbox(stateStore v1alpha1.Component) {
f.addOrUpdateOutboxFn(stateStore)
}
func (f *Fake) Enabled(stateStore string) bool {
return f.enabledFn(stateStore)
}
func (f *Fake) PublishInternal(ctx context.Context, stateStore string, states []state.TransactionalStateOperation, source, traceID, traceState string) ([]state.TransactionalStateOperation, error) {
return f.publishInternalFn(ctx, stateStore, states, source, traceID, traceState)
}
func (f *Fake) SubscribeToInternalTopics(ctx context.Context, appID string) error {
return f.subscribeToInternalTopicsFn(ctx, appID)
}
|
mikeee/dapr
|
pkg/outbox/fake/fake.go
|
GO
|
mit
| 2,838 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package fake
import (
"testing"
"github.com/dapr/dapr/pkg/outbox"
)
func Test_Fake(t *testing.T) {
var _ outbox.Outbox = New()
}
|
mikeee/dapr
|
pkg/outbox/fake/fake_test.go
|
GO
|
mit
| 696 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package outbox
import (
"context"
"github.com/dapr/components-contrib/state"
"github.com/dapr/dapr/pkg/apis/components/v1alpha1"
)
// Outbox defines the interface for all Outbox pattern operations combining state and pubsub.
type Outbox interface {
AddOrUpdateOutbox(stateStore v1alpha1.Component)
Enabled(stateStore string) bool
PublishInternal(ctx context.Context, stateStore string, states []state.TransactionalStateOperation, source, traceID, traceState string) ([]state.TransactionalStateOperation, error)
SubscribeToInternalTopics(ctx context.Context, appID string) error
}
|
mikeee/dapr
|
pkg/outbox/outbox.go
|
GO
|
mit
| 1,151 |
package placement
import (
"context"
"errors"
"fmt"
"testing"
"time"
hcraft "github.com/hashicorp/raft"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
clocktesting "k8s.io/utils/clock/testing"
"github.com/dapr/dapr/pkg/placement/raft"
"github.com/dapr/dapr/pkg/security/fake"
daprtesting "github.com/dapr/dapr/pkg/testing"
"github.com/dapr/kit/logger"
)
func init() {
logger.ApplyOptionsToLoggers(&logger.Options{
OutputLevel: "debug",
})
}
func TestPlacementHA(t *testing.T) {
// Get 3 ports
ports, err := daprtesting.GetFreePorts(3)
if err != nil {
log.Fatalf("failed to get 3 ports: %v", err)
return
}
// Note that ports below are unused (i.e. no service is started on those ports), they are just used as identifiers with the IP address
testMembers := []*raft.DaprHostMember{
{
Name: "127.0.0.1:3031",
Namespace: "ns1",
AppID: "testmember1",
Entities: []string{"red"},
},
{
Name: "127.0.0.1:3032",
Namespace: "ns1",
AppID: "testmember2",
Entities: []string{"blue"},
},
{
Name: "127.0.0.1:3033",
Namespace: "ns2",
AppID: "testmember3",
Entities: []string{"red", "blue"},
},
}
// Create 3 raft servers
raftServers := make([]*raft.Server, 3)
ready := make([]<-chan struct{}, 3)
raftServerCancel := make([]context.CancelFunc, 3)
peers := make([]raft.PeerInfo, 3)
for i := 0; i < 3; i++ {
peers[i] = raft.PeerInfo{
ID: fmt.Sprintf("mynode-%d", i),
Address: fmt.Sprintf("127.0.0.1:%d", ports[i]),
}
}
for i := 0; i < 3; i++ {
raftServers[i], ready[i], raftServerCancel[i] = createRaftServer(t, i, peers)
}
for i := 0; i < 3; i++ {
select {
case <-ready[i]:
// nop
case <-time.After(time.Second):
t.Fatalf("raft server %d did not start in time", i)
}
}
// Run tests
t.Run("elects leader with 3 nodes", func(t *testing.T) {
// It is painful that we have to include a `time.Sleep` here, but due to
// the non-deterministic behaviour of the raft library we are using we will
// later fail on slower test runner machines. A clock timer wait means we
// have a _better_ chance of being in the right spot in the state machine
// and the network has died down. Ideally we should move to a different
// raft library that is more deterministic and reliable for our use case.
time.Sleep(time.Second * 3)
require.NotEqual(t, -1, findLeader(t, raftServers))
})
t.Run("set and retrieve state in leader", func(t *testing.T) {
assert.Eventually(t, func() bool {
lead := findLeader(t, raftServers)
_, err := raftServers[lead].ApplyCommand(raft.MemberUpsert, *testMembers[0])
if errors.Is(err, hcraft.ErrLeadershipLost) || errors.Is(err, hcraft.ErrNotLeader) {
// If leadership is lost, we should retry
return false
}
require.NoError(t, err)
retrieveValidState(t, raftServers[lead], testMembers[0])
return true
}, time.Second*10, time.Millisecond*300)
})
t.Run("retrieve state in follower", func(t *testing.T) {
var follower, oldLeader int
oldLeader = findLeader(t, raftServers)
follower = (oldLeader + 1) % 3
retrieveValidState(t, raftServers[follower], testMembers[0])
t.Run("new leader after leader fails", func(t *testing.T) {
raftServerCancel[oldLeader]()
raftServers[oldLeader] = nil
// It is painful that we have to include a `time.Sleep` here, but due to
// the non-deterministic behaviour of the raft library we are using we will
// later fail on slower test runner machines. A clock timer wait means we
// have a _better_ chance of being in the right spot in the state machine
// and the network has died down. Ideally we should move to a different
// raft library that is more deterministic and reliable for our use case.
time.Sleep(time.Second * 3)
require.Eventually(t, func() bool {
return oldLeader != findLeader(t, raftServers)
}, time.Second*10, time.Millisecond*100)
})
})
t.Run("set and retrieve state in leader after re-election", func(t *testing.T) {
assert.Eventually(t, func() bool {
_, err := raftServers[findLeader(t, raftServers)].ApplyCommand(raft.MemberUpsert, *testMembers[1])
if errors.Is(err, hcraft.ErrLeadershipLost) || errors.Is(err, hcraft.ErrNotLeader) {
// If leadership is lost, we should retry
return false
}
require.NoError(t, err)
retrieveValidState(t, raftServers[findLeader(t, raftServers)], testMembers[1])
return true
}, time.Second*10, time.Millisecond*300)
})
t.Run("leave only leader node running", func(t *testing.T) {
// It is painful that we have to include a `time.Sleep` here, but due to
// the non-deterministic behaviour of the raft library we are using we will
// fail in a few lines on slower test runner machines. A clock timer wait
// means we have a _better_ chance of being in the right spot in the state
// machine. Ideally we should move to a different raft library that is more
// deterministic and reliable.
time.Sleep(time.Second * 3)
leader := findLeader(t, raftServers)
for i := range raftServers {
if i != leader {
raftServerCancel[i]()
raftServers[i] = nil
}
}
var running int
for i := 0; i < 3; i++ {
if raftServers[i] != nil {
running++
}
}
assert.Equal(t, 1, running, "only single server should be running")
// There should be no leader
assert.Eventually(t, func() bool {
for _, srv := range raftServers {
if srv != nil && srv.IsLeader() {
return false
}
}
return true
}, time.Second*5, time.Millisecond*100, "leader did not step down")
})
// It is painful that we have to include a `time.Sleep` here, but due to
// the non-deterministic behaviour of the raft library we are using we will
// fail in a few lines on slower test runner machines. A clock timer wait
// means we have a _better_ chance of being in the right spot in the state
// machine. Ideally we should move to a different raft library that is more
// deterministic and reliable.
time.Sleep(time.Second * 3)
t.Run("leader elected when second node comes up", func(t *testing.T) {
var oldSvr int
for oldSvr = 0; oldSvr < 3; oldSvr++ {
if raftServers[oldSvr] == nil {
break
}
}
raftServers[oldSvr], ready[oldSvr], raftServerCancel[oldSvr] = createRaftServer(t, oldSvr, peers)
select {
case <-ready[oldSvr]:
// nop
case <-time.After(time.Second * 5):
t.Fatalf("raft server %d did not start in time", oldSvr)
}
var running int
for i := 0; i < 3; i++ {
if raftServers[i] != nil {
running++
}
}
assert.Equal(t, 2, running, "only two servers should be running")
findLeader(t, raftServers)
})
t.Run("state is preserved", func(t *testing.T) {
for _, srv := range raftServers {
if srv != nil {
retrieveValidState(t, srv, testMembers[0])
retrieveValidState(t, srv, testMembers[1])
}
}
})
t.Run("leave only follower node running", func(t *testing.T) {
leader := findLeader(t, raftServers)
for i, srv := range raftServers {
if i != leader && srv != nil {
raftServerCancel[i]()
raftServers[i] = nil
}
}
assert.Eventually(t, func() bool {
// There should be no leader
for _, srv := range raftServers {
if srv != nil {
return !srv.IsLeader()
}
}
return false
}, time.Second*5, time.Millisecond*100, "leader did not step down")
})
t.Run("shutdown and restart all nodes", func(t *testing.T) {
// Shutdown all nodes
for i, srv := range raftServers {
if srv != nil {
raftServerCancel[i]()
}
}
// It is painful that we have to include a `time.Sleep` here, but due to
// the non-deterministic behaviour of the raft library we are using we will
// later fail on slower test runner machines. A clock timer wait means we
// have a _better_ chance of being in the right spot in the state machine
// and the network has died down. Ideally we should move to a different
// raft library that is more deterministic and reliable for our use case.
time.Sleep(time.Second * 3)
// Restart all nodes
for i := 0; i < 3; i++ {
raftServers[i], ready[i], raftServerCancel[i] = createRaftServer(t, i, peers)
}
for i := 0; i < 3; i++ {
select {
case <-ready[i]:
// nop
case <-time.After(time.Second * 5):
t.Fatalf("raft server %d did not start in time", i)
}
}
})
t.Run("leader is elected", func(t *testing.T) {
findLeader(t, raftServers)
})
// Shutdown all servers
for i, srv := range raftServers {
if srv != nil {
raftServerCancel[i]()
}
}
}
func createRaftServer(t *testing.T, nodeID int, peers []raft.PeerInfo) (*raft.Server, <-chan struct{}, context.CancelFunc) {
clock := clocktesting.NewFakeClock(time.Now())
srv := raft.New(raft.Options{
ID: fmt.Sprintf("mynode-%d", nodeID),
InMem: true,
Peers: peers,
LogStorePath: "",
Clock: clock,
})
ctx, cancel := context.WithCancel(context.Background())
stopped := make(chan struct{})
go func() {
defer close(stopped)
require.NoError(t, srv.StartRaft(ctx, fake.New(), &hcraft.Config{
ProtocolVersion: hcraft.ProtocolVersionMax,
HeartbeatTimeout: 2 * time.Second,
ElectionTimeout: 2 * time.Second,
CommitTimeout: 2 * time.Second,
MaxAppendEntries: 64,
ShutdownOnRemove: true,
TrailingLogs: 10240,
SnapshotInterval: 120 * time.Second,
SnapshotThreshold: 8192,
LeaderLeaseTimeout: time.Second,
BatchApplyCh: true,
}))
}()
ready := make(chan struct{})
go func() {
defer close(ready)
for {
timeoutCtx, timeoutCancel := context.WithTimeout(ctx, time.Second*5)
defer timeoutCancel()
r, err := srv.Raft(timeoutCtx)
require.NoError(t, err)
if r.State() == hcraft.Follower || r.State() == hcraft.Leader {
return
}
}
}()
go func() {
for {
select {
case <-ready:
case <-time.After(time.Millisecond):
clock.Step(time.Second * 2)
}
}
}()
return srv, ready, func() {
cancel()
select {
case <-stopped:
case <-time.After(time.Second * 5):
require.Fail(t, "server didn't stop in time")
}
}
}
func findLeader(t *testing.T, raftServers []*raft.Server) int {
// Ensure that one node became leader
n := -1
require.Eventually(t, func() bool {
for i, srv := range raftServers {
if srv != nil && srv.IsLeader() {
n = i
break
}
}
if n == -1 {
return false
}
// Ensure there is only a single leader.
for i, srv := range raftServers {
if i != n && srv != nil && srv.IsLeader() {
require.Fail(t, "more than one leader")
}
}
return true
}, time.Second*30, time.Second, "no leader elected")
return n
}
func retrieveValidState(t *testing.T, srv *raft.Server, expect *raft.DaprHostMember) {
t.Helper()
var actual *raft.DaprHostMember
assert.Eventuallyf(t, func() bool {
state := srv.FSM().State()
assert.NotNil(t, state)
var ok bool
state.ForEachHostInNamespace(expect.Namespace, func(member *raft.DaprHostMember) bool {
if member.Name == expect.Name {
actual = member
ok = true
}
return true
})
return ok && expect.Name == actual.Name &&
expect.AppID == actual.AppID && expect.Namespace == actual.Namespace
}, time.Second*5, time.Millisecond*300, "%v != %v", expect, actual)
require.NotNil(t, actual)
assert.EqualValues(t, expect.Entities, actual.Entities)
}
|
mikeee/dapr
|
pkg/placement/ha_test.go
|
GO
|
mit
| 11,376 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Package placement is an implementation of Consistent Hashing and
// Consistent Hashing With Bounded Loads.
//
// https://en.wikipedia.org/wiki/Consistent_hashing
//
// https://research.googleblog.com/2017/04/consistent-hashing-with-bounded-loads.html
//
// https://github.com/lafikl/consistent/blob/master/consistent.go
package hashing
import (
"encoding/binary"
"errors"
"fmt"
"math"
"sort"
"strconv"
"sync"
"sync/atomic"
"golang.org/x/crypto/blake2b"
)
// ErrNoHosts is an error for no hosts.
var ErrNoHosts = errors.New("no hosts added")
// ConsistentHashTables is a table holding a map of consistent hashes with a given version.
type ConsistentHashTables struct {
Version string
Entries map[string]*Consistent
}
// Host represents a host of stateful entities with a given name, id, port and load.
type Host struct {
Name string
Port int64
Load int64
AppID string
}
// Consistent represents a data structure for consistent hashing.
type Consistent struct {
hosts map[uint64]string
sortedSet []uint64
loadMap map[string]*Host
totalLoad int64
replicationFactor int64
sync.RWMutex
}
// NewHost returns a new host.
func NewHost(name, id string, load int64, port int64) *Host {
return &Host{
Name: name,
Load: load,
Port: port,
AppID: id,
}
}
// NewConsistentHash returns a new consistent hash.
func NewConsistentHash(replicationFactory int64) *Consistent {
return &Consistent{
hosts: map[uint64]string{},
sortedSet: []uint64{},
loadMap: map[string]*Host{},
replicationFactor: replicationFactory,
}
}
// NewFromExisting creates a new consistent hash from existing values.
func NewFromExisting(loadMap map[string]*Host, replicationFactor int64, virtualNodesCache *VirtualNodesCache) *Consistent {
newHash := &Consistent{
hosts: map[uint64]string{},
sortedSet: []uint64{},
loadMap: loadMap,
replicationFactor: replicationFactor,
}
for hostName := range loadMap {
hashes := virtualNodesCache.GetHashes(replicationFactor, hostName)
for _, h := range hashes {
newHash.hosts[h] = hostName
}
newHash.sortedSet = append(newHash.sortedSet, hashes...)
}
// sort hashes in ascending order
sort.Slice(newHash.sortedSet, func(i int, j int) bool {
return newHash.sortedSet[i] < newHash.sortedSet[j]
})
return newHash
}
// VirtualNodesCache data example:
//
// 100 -> (the replication factor)
// "192.168.1.89:62362" -> ["10056481384176189962", "10100244799470048543"...] (100 elements)
// "192.168.1.89:62362" -> ["10056481384176189962", "10100244799470048543"...]
// 200 ->
// "192.168.1.89:62362" -> ["10056481384176189962", "10100244799470048543"...] (200 elements)
// "192.168.1.89:62362" -> ["10056481384176189962", "10100244799470048543"...]
type VirtualNodesCache struct {
sync.RWMutex
data map[int64]*hashMap
}
// hashMap represents a mapping of IP addresses to their hashes.
type hashMap struct {
hashes map[string][]uint64
}
func newHashMap() *hashMap {
return &hashMap{
hashes: make(map[string][]uint64),
}
}
func NewVirtualNodesCache() *VirtualNodesCache {
return &VirtualNodesCache{
data: make(map[int64]*hashMap),
}
}
// GetHashes retrieves the hashes for the given replication factor and IP address.
func (hc *VirtualNodesCache) GetHashes(replicationFactor int64, host string) []uint64 {
hc.RLock()
if hashMap, exists := hc.data[replicationFactor]; exists {
if hashes, found := hashMap.hashes[host]; found {
hc.RUnlock()
return hashes
}
}
hc.RUnlock()
return hc.setHashes(replicationFactor, host)
}
// SetHashes sets the hashes for the given replication factor and IP address.
func (hc *VirtualNodesCache) setHashes(replicationFactor int64, host string) []uint64 {
hc.Lock()
defer hc.Unlock()
// We have to check once again if the hash map exists, because by this point
// we already released the previous lock (in getHashes) and another goroutine might have
// created the hash map in the meantime.
if hashMap, exists := hc.data[replicationFactor]; exists {
if hashes, found := hashMap.hashes[host]; found {
return hashes
}
}
hashMap := newHashMap()
hashMap.hashes[host] = make([]uint64, replicationFactor)
for i := 0; i < int(replicationFactor); i++ {
hashMap.hashes[host][i] = hash(host + strconv.Itoa(i))
}
hc.data[replicationFactor] = hashMap
return hashMap.hashes[host]
}
// NewFromExistingWithVirtNodes creates a new consistent hash from existing values with vnodes
// It's a legacy function needed for backwards compatibility (daprd >= 1.13 with placement < 1.13)
// TODO: @elena in v1.15 remove this function
func NewFromExistingWithVirtNodes(hosts map[uint64]string, sortedSet []uint64, loadMap map[string]*Host) *Consistent {
return &Consistent{
hosts: hosts,
sortedSet: sortedSet,
loadMap: loadMap,
}
}
// ReadInternals returns the internal data structure of the consistent hash.
func (c *Consistent) ReadInternals(reader func(map[uint64]string, []uint64, map[string]*Host, int64)) {
c.RLock()
defer c.RUnlock()
reader(c.hosts, c.sortedSet, c.loadMap, c.totalLoad)
}
// Add adds a host with port to the table.
func (c *Consistent) Add(host, id string, port int64) bool {
c.Lock()
defer c.Unlock()
if _, ok := c.loadMap[host]; ok {
return true
}
c.loadMap[host] = &Host{Name: host, AppID: id, Load: 0, Port: port}
// TODO: @elena in v1.15
// The optimisation of not disseminating vnodes with the placement table was introduced
// in 1.13, and the API level was increased to 20, but we still have to support sidecars
// running on 1.12 with placement services on 1.13. That's why we are keeping the
// vhosts in the store in v1.13.
// This should be removed in 1.15.
// --Start remove--
for i := 0; i < int(c.replicationFactor); i++ {
h := hash(host + strconv.Itoa(i))
c.hosts[h] = host
c.sortedSet = append(c.sortedSet, h)
}
// sort hashes in ascending order
sort.Slice(c.sortedSet, func(i int, j int) bool {
return c.sortedSet[i] < c.sortedSet[j]
})
// --End remove--
return false
}
// Get returns the host that owns `key`.
//
// As described in https://en.wikipedia.org/wiki/Consistent_hashing
//
// It returns ErrNoHosts if the ring has no hosts in it.
func (c *Consistent) Get(key string) (string, error) {
c.RLock()
defer c.RUnlock()
if len(c.hosts) == 0 {
return "", ErrNoHosts
}
h := hash(key)
idx := c.search(h)
return c.hosts[c.sortedSet[idx]], nil
}
// GetHost gets a host.
func (c *Consistent) GetHost(key string) (*Host, error) {
h, err := c.Get(key)
if err != nil {
return nil, err
}
return c.loadMap[h], nil
}
// GetLeast uses Consistent Hashing With Bounded loads
//
// https://research.googleblog.com/2017/04/consistent-hashing-with-bounded-loads.html
//
// to pick the least loaded host that can serve the key
//
// It returns ErrNoHosts if the ring has no hosts in it.
func (c *Consistent) GetLeast(key string) (string, error) {
c.RLock()
defer c.RUnlock()
if len(c.hosts) == 0 {
return "", ErrNoHosts
}
h := hash(key)
idx := c.search(h)
i := idx
for {
host := c.hosts[c.sortedSet[i]]
if c.loadOK(host) {
return host, nil
}
i++
if i >= len(c.hosts) {
i = 0
}
}
}
func (c *Consistent) search(key uint64) int {
idx := sort.Search(len(c.sortedSet), func(i int) bool {
return c.sortedSet[i] >= key
})
if idx >= len(c.sortedSet) {
idx = 0
}
return idx
}
// UpdateLoad sets the load of `host` to the given `load`.
func (c *Consistent) UpdateLoad(host string, load int64) {
c.Lock()
defer c.Unlock()
if _, ok := c.loadMap[host]; !ok {
return
}
c.totalLoad -= c.loadMap[host].Load
c.loadMap[host].Load = load
c.totalLoad += load
}
// Inc increments the load of host by 1
//
// should only be used with if you obtained a host with GetLeast.
func (c *Consistent) Inc(host string) {
c.Lock()
defer c.Unlock()
atomic.AddInt64(&c.loadMap[host].Load, 1)
atomic.AddInt64(&c.totalLoad, 1)
}
// Done decrements the load of host by 1
//
// should only be used with if you obtained a host with GetLeast.
func (c *Consistent) Done(host string) {
c.Lock()
defer c.Unlock()
if _, ok := c.loadMap[host]; !ok {
return
}
atomic.AddInt64(&c.loadMap[host].Load, -1)
atomic.AddInt64(&c.totalLoad, -1)
}
// Remove deletes host from the ring.
func (c *Consistent) Remove(host string) bool {
c.Lock()
defer c.Unlock()
for i := 0; i < int(c.replicationFactor); i++ {
h := hash(host + strconv.Itoa(i))
delete(c.hosts, h)
c.delSlice(h)
}
delete(c.loadMap, host)
return true
}
// Hosts return the list of hosts in the ring.
func (c *Consistent) Hosts() (hosts []string) {
c.RLock()
defer c.RUnlock()
for k := range c.loadMap {
hosts = append(hosts, k)
}
return hosts
}
// GetLoads returns the loads of all the hosts.
func (c *Consistent) GetLoads() map[string]int64 {
loads := map[string]int64{}
for k, v := range c.loadMap {
loads[k] = v.Load
}
return loads
}
// MaxLoad returns the maximum load of the single host
// which is:
// (total_load/number_of_hosts)*1.25
// total_load = is the total number of active requests served by hosts
// for more info:
// https://research.googleblog.com/2017/04/consistent-hashing-with-bounded-loads.html
func (c *Consistent) MaxLoad() int64 {
if c.totalLoad == 0 {
c.totalLoad = 1
}
var avgLoadPerNode float64
avgLoadPerNode = float64(c.totalLoad / int64(len(c.loadMap)))
if avgLoadPerNode == 0 {
avgLoadPerNode = 1
}
avgLoadPerNode = math.Ceil(avgLoadPerNode * 1.25)
return int64(avgLoadPerNode)
}
func (c *Consistent) loadOK(host string) bool {
// a safety check if someone performed c.Done more than needed
if c.totalLoad < 0 {
c.totalLoad = 0
}
var avgLoadPerNode float64
avgLoadPerNode = float64((c.totalLoad + 1) / int64(len(c.loadMap)))
if avgLoadPerNode == 0 {
avgLoadPerNode = 1
}
avgLoadPerNode = math.Ceil(avgLoadPerNode * 1.25)
bhost, ok := c.loadMap[host]
if !ok {
panic(fmt.Sprintf("given host(%s) not in loadsMap", bhost.Name))
}
if float64(bhost.Load)+1 <= avgLoadPerNode {
return true
}
return false
}
func (c *Consistent) delSlice(val uint64) {
idx := -1
l := 0
r := len(c.sortedSet) - 1
for l <= r {
m := (l + r) / 2
if c.sortedSet[m] == val {
idx = m
break
} else if c.sortedSet[m] < val {
l = m + 1
} else if c.sortedSet[m] > val {
r = m - 1
}
}
if idx != -1 {
c.sortedSet = append(c.sortedSet[:idx], c.sortedSet[idx+1:]...)
}
}
func (c *Consistent) VirtualNodes() map[uint64]string {
c.RLock()
defer c.RUnlock()
virtualNodes := make(map[uint64]string, len(c.hosts))
for vn, h := range c.hosts {
virtualNodes[vn] = h
}
return virtualNodes
}
func (c *Consistent) SortedSet() (sortedSet []uint64) {
c.RLock()
defer c.RUnlock()
return c.sortedSet
}
func hash(key string) uint64 {
out := blake2b.Sum512([]byte(key))
return binary.LittleEndian.Uint64(out[:])
}
|
mikeee/dapr
|
pkg/placement/hashing/consistent_hash.go
|
GO
|
mit
| 11,487 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package hashing
import (
"strconv"
"sync"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
var nodes = []string{"node1", "node2", "node3", "node4", "node5"}
func TestReplicationFactor(t *testing.T) {
keys := []string{}
for i := 0; i < 100; i++ {
keys = append(keys, strconv.Itoa(i))
}
t.Run("varying replication factors, no movement", func(t *testing.T) {
factors := []int64{1, 100, 1000, 10000}
for _, f := range factors {
h := NewConsistentHash(f)
for _, n := range nodes {
s := h.Add(n, n, 1)
assert.False(t, s)
}
k1 := map[string]string{}
for _, k := range keys {
h, err := h.Get(k)
require.NoError(t, err)
k1[k] = h
}
nodeToRemove := "node3"
h.Remove(nodeToRemove)
for _, k := range keys {
h, err := h.Get(k)
require.NoError(t, err)
orgS := k1[k]
if orgS != nodeToRemove {
assert.Equal(t, h, orgS)
}
}
}
})
}
func TestGetAndSetVirtualNodeCacheHashes(t *testing.T) {
cache := NewVirtualNodesCache()
// Test GetHashes and SetHashes for a specific replication factor and host
replicationFactor := int64(5)
host := "192.168.1.83:60992"
hashes := cache.GetHashes(replicationFactor, host)
assert.Len(t, hashes, 5)
assert.Equal(t, uint64(11414427053803968138), hashes[0])
assert.Equal(t, uint64(6110756290993384529), hashes[1])
assert.Equal(t, uint64(13876541546109691082), hashes[2])
assert.Equal(t, uint64(12165331075625862737), hashes[3])
assert.Equal(t, uint64(9528020266818944582), hashes[4])
// Test GetHashes and SetHashes for a different replication factor and host
replicationFactor = int64(3)
host = "192.168.1.89:62362"
hashes = cache.GetHashes(replicationFactor, host)
assert.Len(t, hashes, 3)
assert.Equal(t, uint64(13384490355354205375), hashes[0])
assert.Equal(t, uint64(11281728843146723001), hashes[1])
assert.Equal(t, uint64(694935339057032644), hashes[2])
}
func TestGetAndSetVirtualNodeCacheHashesConcurrently(t *testing.T) {
cache := NewVirtualNodesCache()
replicationFactor := int64(5)
host := "192.168.1.83:60992"
// Run multiple goroutines concurrently to test SetHashes and GetHashes
const goroutines = 10
var wg sync.WaitGroup
for i := 0; i < goroutines; i++ {
wg.Add(1)
go func() {
defer wg.Done()
hashes := cache.GetHashes(replicationFactor, host)
assert.Len(t, hashes, 5)
}()
}
wg.Wait()
}
|
mikeee/dapr
|
pkg/placement/hashing/consistent_hash_test.go
|
GO
|
mit
| 2,971 |
/*
Copyright 2024 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import (
"context"
"errors"
"sync/atomic"
"time"
)
// barrierWriteTimeout is the maximum duration to wait for the barrier command
// to be applied to the FSM. A barrier is used to ensure that all preceding
// operations have been committed to the FSM, guaranteeing
// that the FSM state reflects all queued writes.
const barrierWriteTimeout = 2 * time.Minute
// MonitorLeadership is used to monitor if we acquire or lose our role
// as the leader in the Raft cluster. There is some work the leader is
// expected to do, so we must react to changes
//
// reference: https://github.com/hashicorp/consul/blob/master/agent/consul/leader.go
func (p *Service) MonitorLeadership(parentCtx context.Context) error {
if p.closed.Load() {
return errors.New("placement is closed")
}
ctx, cancel := context.WithCancel(parentCtx)
p.wg.Add(1)
go func() {
defer p.wg.Done()
defer cancel()
select {
case <-parentCtx.Done():
case <-p.closedCh:
}
}()
raft, err := p.raftNode.Raft(ctx)
if err != nil {
return err
}
var (
leaderCh = raft.LeaderCh()
leaderLoopRunning atomic.Bool
loopNotRunning = make(chan struct{})
leaderCtx, leaderLoopCancel = context.WithCancel(ctx)
)
close(loopNotRunning)
defer func() {
leaderLoopCancel()
<-loopNotRunning
}()
for {
select {
case <-ctx.Done():
return nil
case isLeader := <-leaderCh:
if isLeader {
if leaderLoopRunning.CompareAndSwap(false, true) {
loopNotRunning = make(chan struct{})
p.wg.Add(1)
go func() {
defer p.wg.Done()
defer close(loopNotRunning)
defer leaderLoopRunning.Store(false)
log.Info("Cluster leadership acquired")
p.leaderLoop(leaderCtx)
}()
}
} else {
select {
case <-loopNotRunning:
log.Error("Attempted to stop leader loop when it was not running")
continue
default:
}
log.Info("Shutting down leader loop")
leaderLoopCancel()
select {
case <-loopNotRunning:
case <-ctx.Done():
return nil
}
log.Info("Cluster leadership lost")
}
}
}
}
func (p *Service) leaderLoop(ctx context.Context) error {
// This loop is to ensure the FSM reflects all queued writes by applying Barrier
// and completes leadership establishment before becoming a leader.
for !p.hasLeadership.Load() {
// for earlier stop
select {
case <-ctx.Done():
return nil
default:
// nop
}
raft, err := p.raftNode.Raft(ctx)
if err != nil {
return err
}
barrier := raft.Barrier(barrierWriteTimeout)
if err := barrier.Error(); err != nil {
log.Error("failed to wait for barrier", "error", err)
continue
}
if !p.hasLeadership.Load() {
p.establishLeadership()
log.Info("leader is established.")
// revoke leadership process must be done before leaderLoop() ends.
defer p.revokeLeadership()
}
}
p.membershipChangeWorker(ctx)
return nil
}
func (p *Service) establishLeadership() {
// Give more time to let each runtime to find the leader and connect to the leader.
p.membershipCh = make(chan hostMemberChange, membershipChangeChSize)
p.hasLeadership.Store(true)
}
func (p *Service) revokeLeadership() {
p.hasLeadership.Store(false)
log.Info("Waiting until all connections are drained")
p.streamConnGroup.Wait()
log.Info("Connections are drained")
p.streamConnPool.streamIndex.Store(0)
p.disseminateLocks.Clear()
p.disseminateNextTime.Clear()
p.memberUpdateCount.Clear()
p.cleanupHeartbeats()
}
func (p *Service) cleanupHeartbeats() {
p.lastHeartBeat.Range(func(key, value interface{}) bool {
p.lastHeartBeat.Delete(key)
return true
})
}
|
mikeee/dapr
|
pkg/placement/leadership.go
|
GO
|
mit
| 4,230 |
/*
Copyright 2024 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import (
"fmt"
"testing"
"github.com/stretchr/testify/require"
"github.com/dapr/dapr/pkg/placement/tests"
)
func TestCleanupHeartBeats(t *testing.T) {
testRaftServer := tests.Raft(t)
_, testServer, clock, cleanup := newTestPlacementServer(t, testRaftServer)
testServer.hasLeadership.Store(true)
maxClients := 3
for i := 0; i < maxClients; i++ {
testServer.lastHeartBeat.Store(fmt.Sprintf("ns-10.0.0.%d:1001", i), clock.Now().UnixNano())
}
getCount := func() int {
cnt := 0
testServer.lastHeartBeat.Range(func(k, v any) bool {
cnt++
return true
})
return cnt
}
require.Equal(t, maxClients, getCount())
testServer.cleanupHeartbeats()
require.Equal(t, 0, getCount())
cleanup()
}
|
mikeee/dapr
|
pkg/placement/leadership_test.go
|
GO
|
mit
| 1,295 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import (
"context"
"errors"
"fmt"
"sync/atomic"
"time"
"google.golang.org/grpc/peer"
"github.com/dapr/dapr/pkg/placement/monitoring"
"github.com/dapr/dapr/pkg/placement/raft"
v1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
"github.com/dapr/kit/retry"
)
const (
// raftApplyCommandMaxConcurrency is the max concurrency to apply command log to raft.
raftApplyCommandMaxConcurrency = 10
GRPCContextKeyAcceptVNodes = "dapr-accept-vnodes"
)
// membershipChangeWorker is the worker to change the state of membership
// and update the consistent hashing tables for actors.
func (p *Service) membershipChangeWorker(ctx context.Context) {
baselineHeartbeatTimestamp := p.clock.Now().UnixNano()
log.Infof("Baseline membership heartbeat timestamp: %v", baselineHeartbeatTimestamp)
disseminateTimer := p.clock.NewTicker(disseminateTimerInterval)
defer disseminateTimer.Stop()
// Reset memberUpdateCount to zero for every namespace when leadership is acquired.
p.streamConnPool.forEachNamespace(func(ns string, _ map[uint32]*daprdStream) {
val, _ := p.memberUpdateCount.GetOrSet(ns, &atomic.Uint32{})
val.Store(0)
})
p.wg.Add(1)
go func() {
defer p.wg.Done()
p.processMembershipCommands(ctx)
}()
faultyHostDetectCh := time.After(faultyHostDetectDuration)
for {
select {
case <-ctx.Done():
return
case <-faultyHostDetectCh:
// This only runs once when the placement service acquires leadership
// It loops through all the members in the raft store that have been connected to the
// previous leader and checks if they have already sent a heartbeat. If they haven't,
// they're removed from the raft store and the updated table is disseminated
p.raftNode.FSM().State().ForEachHost(func(h *raft.DaprHostMember) bool {
if !p.hasLeadership.Load() {
return false
}
// We only care about the hosts that haven't connected to the new leader
// The ones that have connected at some point, but have expired, will be handled
// through the disconnect mechanism in ReportDaprStatus
_, ok := p.lastHeartBeat.Load(h.NamespaceAndName())
if !ok {
log.Debugf("Try to remove outdated host: %s, no heartbeat record", h.Name)
p.membershipCh <- hostMemberChange{
cmdType: raft.MemberRemove,
host: raft.DaprHostMember{Name: h.Name, Namespace: h.Namespace},
}
}
return true
})
faultyHostDetectCh = nil
case t := <-disseminateTimer.C():
// Earlier stop when leadership is lost.
if !p.hasLeadership.Load() {
continue
}
now := t.UnixNano()
// Check if there are actor runtime member changes per namespace.
p.disseminateNextTime.ForEach(func(ns string, disseminateTime *atomic.Int64) bool {
if disseminateTime.Load() > now {
return true // Continue to the next namespace
}
cnt, ok := p.memberUpdateCount.Get(ns)
if !ok {
return true
}
c := cnt.Load()
if c == 0 {
return true
}
if len(p.membershipCh) == 0 {
log.Debugf("Add raft.TableDisseminate to membershipCh. memberUpdateCountTotal count for namespace %s: %d", ns, c)
p.membershipCh <- hostMemberChange{cmdType: raft.TableDisseminate, host: raft.DaprHostMember{Namespace: ns}}
}
return true
})
}
}
}
// processMembershipCommands is the worker loop that
// - applies membership change commands to the raft state
// - disseminates the latest hashing table to the connected dapr runtimes
func (p *Service) processMembershipCommands(ctx context.Context) {
// logApplyConcurrency is the buffered channel to limit the concurrency
// of raft apply command.
logApplyConcurrency := make(chan struct{}, raftApplyCommandMaxConcurrency)
for {
select {
case <-ctx.Done():
return
case op := <-p.membershipCh:
switch op.cmdType {
case raft.MemberUpsert, raft.MemberRemove:
// MemberUpsert updates the state of dapr runtime host whenever
// Dapr runtime sends heartbeats every X seconds.
// MemberRemove will be queued by faultHostDetectTimer.
// Even if ApplyCommand is failed, both commands will retry
// until the state is consistent.
logApplyConcurrency <- struct{}{}
p.wg.Add(1)
go func() {
defer p.wg.Done()
// We lock dissemination to ensure the updates can complete before the table is disseminated.
p.disseminateLocks.Lock(op.host.Namespace)
defer p.disseminateLocks.Unlock(op.host.Namespace)
updateCount, raftErr := p.raftNode.ApplyCommand(op.cmdType, op.host)
if raftErr != nil {
log.Errorf("fail to apply command: %v", raftErr)
} else {
if op.cmdType == raft.MemberRemove {
updateCount = p.handleDisconnectedMember(op, updateCount)
}
// ApplyCommand returns true only if the command changes the hashing table.
if updateCount {
c, _ := p.memberUpdateCount.GetOrSet(op.host.Namespace, &atomic.Uint32{})
c.Add(1)
// disseminateNextTime will be updated whenever apply is done, so that
// it will keep moving the time to disseminate the table, which will
// reduce the unnecessary table dissemination.
val, _ := p.disseminateNextTime.GetOrSet(op.host.Namespace, &atomic.Int64{})
val.Store(p.clock.Now().Add(disseminateTimeout).UnixNano())
}
}
<-logApplyConcurrency
}()
case raft.TableDisseminate:
// TableDisseminate will be triggered by disseminateTimer.
// This disseminates the latest consistent hashing tables to Dapr runtime.
if err := p.performTableDissemination(ctx, op.host.Namespace); err != nil {
log.Errorf("fail to perform table dissemination. Details: %v", err)
}
}
}
}
}
func (p *Service) handleDisconnectedMember(op hostMemberChange, updated bool) bool {
p.lastHeartBeat.Delete(op.host.NamespaceAndName())
// If this is the last host in the namespace, we should:
// - remove namespace-specific data structures to prevent memory-leaks
// - prevent next dissemination, because there are no more hosts in the namespace
if p.raftNode.FSM().State().MemberCountInNamespace(op.host.Namespace) == 0 {
p.disseminateLocks.Delete(op.host.Namespace)
p.disseminateNextTime.Del(op.host.Namespace)
p.memberUpdateCount.Del(op.host.Namespace)
updated = false
}
return updated
}
func (p *Service) performTableDissemination(ctx context.Context, ns string) error {
nStreamConnPool := p.streamConnPool.getStreamCount(ns)
if nStreamConnPool == 0 {
return nil
}
nTargetConns := p.raftNode.FSM().State().MemberCountInNamespace(ns)
monitoring.RecordRuntimesCount(nStreamConnPool, ns)
monitoring.RecordActorRuntimesCount(nTargetConns, ns)
// Ignore dissemination if there is no member update
ac, _ := p.memberUpdateCount.GetOrSet(ns, &atomic.Uint32{})
cnt := ac.Load()
if cnt == 0 {
return nil
}
p.disseminateLocks.Lock(ns)
defer p.disseminateLocks.Unlock(ns)
// Get a snapshot copy of the current streams, so we don't have to
// lock them while we're doing the dissemination (long operation)
streams := make([]daprdStream, 0, p.streamConnPool.getStreamCount(ns))
p.streamConnPool.forEachInNamespace(ns, func(_ uint32, stream *daprdStream) {
streams = append(streams, *stream)
})
// Check if the cluster has daprd hosts that expect vnodes;
// older daprd versions (pre 1.13) do expect them, and newer versions (1.13+) do not.
req := &tablesUpdateRequest{
hosts: streams,
}
// Loop through all streams and check what kind of tables to disseminate (with/without vnodes)
for _, stream := range streams {
if stream.needsVNodes && req.tablesWithVNodes == nil {
req.tablesWithVNodes = p.raftNode.FSM().PlacementState(true, ns)
}
if !stream.needsVNodes && req.tables == nil {
req.tables = p.raftNode.FSM().PlacementState(false, ns)
}
if req.tablesWithVNodes != nil && req.tables != nil {
break
}
}
log.Infof(
"Start disseminating tables for namespace %s. memberUpdateCount: %d, streams: %d, targets: %d, table generation: %s",
ns, cnt, nStreamConnPool, nTargetConns, req.GetVersion())
if err := p.performTablesUpdate(ctx, req); err != nil {
return err
}
log.Infof(
"Completed dissemination for namespace %s. memberUpdateCount: %d, streams: %d, targets: %d, table generation: %s",
ns, cnt, nStreamConnPool, nTargetConns, req.GetVersion())
if val, ok := p.memberUpdateCount.Get(ns); ok {
val.Store(0)
}
return nil
}
// performTablesUpdate updates the connected dapr runtimes using a 3 stage commit.
// It first locks so no further dapr can be taken it. Once placement table is locked
// in runtime, it proceeds to update new table to Dapr runtimes and then unlock
// once all runtimes have been updated.
func (p *Service) performTablesUpdate(ctx context.Context, req *tablesUpdateRequest) error {
// TODO: error from disseminationOperation needs to be handled properly.
// Otherwise, each Dapr runtime will have inconsistent hashing table.
startedAt := p.clock.Now()
// Enforce maximum API level
if req.tablesWithVNodes != nil || req.tables != nil {
req.SetAPILevel(p.minAPILevel, p.maxAPILevel)
}
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
// Perform each update on all hosts in sequence
err := p.disseminateOperationOnHosts(ctx, req, lockOperation)
if err != nil {
return fmt.Errorf("dissemination of 'lock' failed: %v", err)
}
err = p.disseminateOperationOnHosts(ctx, req, updateOperation)
if err != nil {
return fmt.Errorf("dissemination of 'update' failed: %v", err)
}
err = p.disseminateOperationOnHosts(ctx, req, unlockOperation)
if err != nil {
return fmt.Errorf("dissemination of 'unlock' failed: %v", err)
}
log.Debugf("performTablesUpdate succeed in %v", p.clock.Since(startedAt))
return nil
}
func (p *Service) disseminateOperationOnHosts(ctx context.Context, req *tablesUpdateRequest, operation string) error {
errCh := make(chan error)
for i := 0; i < len(req.hosts); i++ {
go func(i int) {
var tableToSend *v1pb.PlacementTables
if req.hosts[i].needsVNodes && req.tablesWithVNodes != nil {
tableToSend = req.tablesWithVNodes
} else if !req.hosts[i].needsVNodes && req.tables != nil {
tableToSend = req.tables
}
errCh <- p.disseminateOperation(ctx, req.hosts[i], operation, tableToSend)
}(i)
}
var errs []error
for i := 0; i < len(req.hosts); i++ {
err := <-errCh
if err != nil {
errs = append(errs, err)
}
}
return errors.Join(errs...)
}
func (p *Service) disseminateOperation(ctx context.Context, target daprdStream, operation string, tables *v1pb.PlacementTables) error {
o := &v1pb.PlacementOrder{
Operation: operation,
}
if operation == updateOperation {
o.Tables = tables
}
config := retry.DefaultConfig()
config.MaxRetries = 3
backoff := config.NewBackOffWithContext(ctx)
return retry.NotifyRecover(func() error {
// Check stream in stream pool, if stream is not available, skip to next.
if _, ok := p.streamConnPool.getStream(target.stream); !ok {
remoteAddr := "n/a"
if p, ok := peer.FromContext(target.stream.Context()); ok {
remoteAddr = p.Addr.String()
}
log.Debugf("Runtime host %q is disconnected from server; go with next dissemination (operation: %s)", remoteAddr, operation)
return nil
}
if err := target.stream.Send(o); err != nil {
remoteAddr := "n/a"
if p, ok := peer.FromContext(target.stream.Context()); ok {
remoteAddr = p.Addr.String()
}
log.Errorf("Error updating runtime host %q on %q operation: %v", remoteAddr, operation, err)
return err
}
return nil
},
backoff,
func(err error, d time.Duration) { log.Debugf("Attempting to disseminate again after error: %v", err) },
func() { log.Debug("Dissemination successful after failure") },
)
}
|
mikeee/dapr
|
pkg/placement/membership.go
|
GO
|
mit
| 12,307 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
//nolint:forbidigo,nosnakecase
package placement
import (
"context"
"fmt"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
clocktesting "k8s.io/utils/clock/testing"
"github.com/dapr/dapr/pkg/placement/raft"
"github.com/dapr/dapr/pkg/placement/tests"
v1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
)
func cleanupStates(testRaftServer *raft.Server) {
state := testRaftServer.FSM().State()
state.ForEachHost(func(host *raft.DaprHostMember) bool {
testRaftServer.ApplyCommand(raft.MemberRemove, raft.DaprHostMember{
Name: host.Name,
Namespace: host.Namespace,
})
return true
})
}
func TestMembershipChangeWorker(t *testing.T) {
var (
serverAddress string
testServer *Service
clock *clocktesting.FakeClock
)
setupEach := func(t *testing.T) context.CancelFunc {
ctx, cancel := context.WithCancel(context.Background())
var cancelServer context.CancelFunc
testRaftServer := tests.Raft(t)
serverAddress, testServer, clock, cancelServer = newTestPlacementServer(t, testRaftServer)
testServer.hasLeadership.Store(true)
membershipStopCh := make(chan struct{})
cleanupStates(testRaftServer)
state := testRaftServer.FSM().State()
require.Equal(t, 0, state.MemberCount())
go func() {
defer close(membershipStopCh)
testServer.membershipChangeWorker(ctx)
}()
time.Sleep(time.Second * 2)
return func() {
cancel()
cancelServer()
select {
case <-membershipStopCh:
case <-time.After(time.Second):
t.Error("membershipChangeWorker did not stop in time")
}
}
}
t.Run("successful dissemination", func(t *testing.T) {
t.Cleanup(setupEach(t))
conn1, _, stream1 := newTestClient(t, serverAddress)
conn2, _, stream2 := newTestClient(t, serverAddress)
conn3, _, stream3 := newTestClient(t, serverAddress)
ch := make(chan struct{}, 3)
var operations1 []string
go func() {
require.EventuallyWithT(t, func(c *assert.CollectT) {
placementOrder, streamErr := stream1.Recv()
//nolint:testifylint
assert.NoError(c, streamErr)
if placementOrder.GetOperation() == lockOperation {
operations1 = append(operations1, lockOperation)
}
if placementOrder.GetOperation() == updateOperation {
tables := placementOrder.GetTables()
assert.Len(c, tables.GetEntries(), 2)
assert.Contains(c, tables.GetEntries(), "actor1")
assert.Contains(c, tables.GetEntries(), "actor2")
operations1 = append(operations1, updateOperation)
}
if placementOrder.GetOperation() == unlockOperation {
operations1 = append(operations1, unlockOperation)
}
if assert.Len(c, operations1, 3) {
require.Equal(c, lockOperation, operations1[0])
require.Equal(c, updateOperation, operations1[1])
require.Equal(c, unlockOperation, operations1[2])
}
}, 20*time.Second, 100*time.Millisecond)
ch <- struct{}{}
}()
var operations2 []string
go func() {
require.EventuallyWithT(t, func(c *assert.CollectT) {
placementOrder, streamErr := stream2.Recv()
//nolint:testifylint
assert.NoError(c, streamErr)
if placementOrder.GetOperation() == lockOperation {
operations2 = append(operations2, lockOperation)
}
if placementOrder.GetOperation() == updateOperation {
entries := placementOrder.GetTables().GetEntries()
if !assert.Len(c, entries, 2) {
return
}
if !assert.Contains(c, entries, "actor3") {
return
}
if !assert.Contains(c, entries, "actor4") {
return
}
operations2 = append(operations2, updateOperation)
}
if placementOrder.GetOperation() == unlockOperation {
operations2 = append(operations2, unlockOperation)
}
// Depending on the timing of the host 3 registration
// we may receive one or two update messages
assert.GreaterOrEqual(c, len(operations2), 3)
}, 20*time.Second, 100*time.Millisecond)
ch <- struct{}{}
}()
var operations3 []string
go func() {
require.EventuallyWithT(t, func(c *assert.CollectT) {
placementOrder, streamErr := stream3.Recv()
//nolint:testifylint
assert.NoError(c, streamErr)
if placementOrder.GetOperation() == lockOperation {
operations3 = append(operations3, lockOperation)
}
if placementOrder.GetOperation() == updateOperation {
entries := placementOrder.GetTables().GetEntries()
if !assert.Len(c, entries, 2) {
return
}
if !assert.Contains(c, entries, "actor3") {
return
}
if !assert.Contains(c, entries, "actor4") {
return
}
operations3 = append(operations3, updateOperation)
}
if placementOrder.GetOperation() == unlockOperation {
operations3 = append(operations3, unlockOperation)
}
// Depending on the timing of the host 3 registration
// we may receive one or two update messages
if assert.GreaterOrEqual(c, len(operations3), 3) {
require.Equal(c, lockOperation, operations3[0])
require.Equal(c, updateOperation, operations3[1])
require.Equal(c, unlockOperation, operations3[2])
}
}, 20*time.Second, 100*time.Millisecond)
ch <- struct{}{}
}()
host1 := &v1pb.Host{
Name: "127.0.0.1:50100",
Namespace: "ns1",
Entities: []string{"actor1", "actor2"},
Id: "testAppID",
Load: 1,
}
host2 := &v1pb.Host{
Name: "127.0.0.1:50101",
Namespace: "ns2",
Entities: []string{"actor3"},
Id: "testAppID2",
Load: 1,
}
host3 := &v1pb.Host{
Name: "127.0.0.1:50102",
Namespace: "ns2",
Entities: []string{"actor4"},
Id: "testAppID3",
Load: 1,
}
require.NoError(t, stream1.Send(host1))
require.NoError(t, stream2.Send(host2))
require.NoError(t, stream3.Send(host3))
require.EventuallyWithT(t, func(c *assert.CollectT) {
assert.Equal(c, 1, testServer.streamConnPool.getStreamCount("ns1"))
assert.Equal(c, 2, testServer.streamConnPool.getStreamCount("ns2"))
assert.Equal(c, uint32(3), testServer.streamConnPool.streamIndex.Load())
assert.Len(c, testServer.streamConnPool.reverseLookup, 3)
// This indicates the member has been added to the dissemination queue and is
// going to be disseminated in the next tick
ts1, ok := testServer.disseminateNextTime.Get("ns1")
if assert.True(c, ok) {
assert.Equal(c, clock.Now().Add(disseminateTimeout).UnixNano(), ts1.Load())
}
ts2, ok := testServer.disseminateNextTime.Get("ns2")
if assert.True(c, ok) {
assert.Equal(c, clock.Now().Add(disseminateTimeout).UnixNano(), ts2.Load())
}
}, 10*time.Second, 100*time.Millisecond)
// Move the clock forward so dissemination is triggered
clock.Step(disseminateTimeout)
// Wait for all three hosts to receive the updates
updateMsgCnt := 0
require.Eventually(t, func() bool {
select {
case <-ch:
updateMsgCnt++
}
return updateMsgCnt == 3
}, 20*time.Second, 100*time.Millisecond)
// Ignore the next disseminateTimeout.
val, _ := testServer.disseminateNextTime.GetOrSet("ns1", &atomic.Int64{})
val.Store(0)
// Check members has been saved correctly in the raft store
require.EventuallyWithT(t, func(c *assert.CollectT) {
state := testServer.raftNode.FSM().State()
cnt := 0
state.ForEachHostInNamespace("ns1", func(host *raft.DaprHostMember) bool {
assert.Equal(c, "127.0.0.1:50100", host.Name)
assert.Equal(c, "ns1", host.Namespace)
assert.Contains(c, host.Entities, "actor1", "actor2")
cnt++
return true
})
assert.Equal(t, 1, cnt)
cnt = 0
state.ForEachHostInNamespace("ns2", func(host *raft.DaprHostMember) bool {
if host.Name == "127.0.0.1:50101" {
assert.Equal(c, "127.0.0.1:50101", host.Name)
assert.Equal(c, "ns2", host.Namespace)
assert.Contains(c, host.Entities, "actor3")
cnt++
}
if host.Name == "127.0.0.1:50102" {
assert.Equal(c, "127.0.0.1:50102", host.Name)
assert.Equal(c, "ns2", host.Namespace)
assert.Contains(c, host.Entities, "actor4")
cnt++
}
return true
})
assert.Equal(t, 2, cnt)
}, 10*time.Second, time.Millisecond, "the member hasn't been saved in the raft store")
// Wait until next table dissemination and check there haven't been any updates
clock.Step(disseminateTimerInterval)
require.Eventually(t, func() bool {
cnt, ok := testServer.memberUpdateCount.Get("ns1")
if !ok {
return false
}
return cnt.Load() == 0
}, 10*time.Second, time.Millisecond, "flushed all member updates")
// Disconnect the host in ns1
conn1.Close()
require.EventuallyWithT(t, func(c *assert.CollectT) {
assert.Equal(c, 2, testServer.raftNode.FSM().State().MemberCount())
// Disseminate locks have been deleted for ns1, but not ns2
assert.Equal(c, 1, testServer.disseminateLocks.ItemCount())
// Disseminate timers have been deleted for ns1, but not ns2
_, ok := testServer.disseminateNextTime.Get("ns1")
assert.False(c, ok)
_, ok = testServer.disseminateNextTime.Get("ns2")
assert.True(c, ok)
// Member update counts have been deleted for ns1, but not ns2
_, ok = testServer.memberUpdateCount.Get("ns1")
assert.False(c, ok)
_, ok = testServer.memberUpdateCount.Get("ns2")
assert.True(c, ok)
assert.Equal(c, 0, testServer.streamConnPool.getStreamCount("ns1"))
assert.Equal(c, 2, testServer.streamConnPool.getStreamCount("ns2"))
assert.Equal(c, uint32(3), testServer.streamConnPool.streamIndex.Load())
testServer.streamConnPool.lock.RLock()
assert.Len(c, testServer.streamConnPool.reverseLookup, 2)
testServer.streamConnPool.lock.RUnlock()
}, 20*time.Second, 100*time.Millisecond)
// // Disconnect one host in ns2
conn2.Close()
require.EventuallyWithT(t, func(c *assert.CollectT) {
assert.Equal(c, 1, testServer.raftNode.FSM().State().MemberCount())
// Disseminate lock for ns2 hasn't been deleted
assert.Equal(c, 1, testServer.disseminateLocks.ItemCount())
// Disseminate timer for ns2 hasn't been deleted,
// because there's still streams in the namespace
_, ok := testServer.disseminateNextTime.Get("ns1")
assert.False(c, ok)
_, ok = testServer.disseminateNextTime.Get("ns2")
assert.True(c, ok)
// Member update count for ns2 hasn't been deleted,
// because there's still streams in the namespace
_, ok = testServer.memberUpdateCount.Get("ns2")
assert.True(c, ok)
assert.Equal(c, 0, testServer.streamConnPool.getStreamCount("ns1"))
assert.Equal(c, 1, testServer.streamConnPool.getStreamCount("ns2"))
assert.Equal(c, uint32(3), testServer.streamConnPool.streamIndex.Load())
testServer.streamConnPool.lock.RLock()
assert.Len(c, testServer.streamConnPool.reverseLookup, 1)
testServer.streamConnPool.lock.RUnlock()
}, 20*time.Second, 100*time.Millisecond)
// Last host is disconnected
conn3.Close()
require.EventuallyWithT(t, func(c *assert.CollectT) {
assert.Equal(c, 0, testServer.raftNode.FSM().State().MemberCount())
// Disseminate locks have been deleted
assert.Equal(c, 0, testServer.disseminateLocks.ItemCount())
// Disseminate timers have been deleted
_, ok := testServer.disseminateNextTime.Get("ns1")
assert.False(c, ok)
_, ok = testServer.disseminateNextTime.Get("ns2")
assert.False(c, ok)
// Member update counts have been deleted
_, ok = testServer.memberUpdateCount.Get("ns1")
assert.False(c, ok)
_, ok = testServer.memberUpdateCount.Get("ns2")
assert.False(c, ok)
assert.Equal(c, 0, testServer.streamConnPool.getStreamCount("ns1"))
assert.Equal(c, 0, testServer.streamConnPool.getStreamCount("ns2"))
testServer.streamConnPool.lock.RLock()
assert.Empty(c, testServer.streamConnPool.reverseLookup)
testServer.streamConnPool.lock.RUnlock()
}, 20*time.Second, 100*time.Millisecond)
})
}
func PerformTableUpdateCostTime(t *testing.T) (wastedTime int64) {
const testClients = 10
serverAddress, testServer, _, cleanup := newTestPlacementServer(t, tests.Raft(t))
testServer.hasLeadership.Store(true)
var (
overArr [testClients]int64
overArrLock sync.RWMutex
clientConns []*grpc.ClientConn
clientStreams []v1pb.Placement_ReportDaprStatusClient
wg sync.WaitGroup
)
startFlag := atomic.Bool{}
startFlag.Store(false)
wg.Add(testClients)
for i := 0; i < testClients; i++ {
conn, _, stream := newTestClient(t, serverAddress)
clientConns = append(clientConns, conn)
clientStreams = append(clientStreams, stream)
go func(clientID int, clientStream v1pb.Placement_ReportDaprStatusClient) {
defer wg.Done()
var start time.Time
for {
placementOrder, streamErr := clientStream.Recv()
if streamErr != nil {
return
}
if placementOrder != nil {
if placementOrder.GetOperation() == lockOperation {
if startFlag.Load() {
start = time.Now()
if clientID == 1 {
t.Log("client 1 lock", start)
}
}
}
if placementOrder.GetOperation() == updateOperation {
continue
}
if placementOrder.GetOperation() == unlockOperation {
if startFlag.Load() {
if clientID == 1 {
t.Log("client 1 unlock", time.Now())
}
overArrLock.Lock()
overArr[clientID] = time.Since(start).Nanoseconds()
overArrLock.Unlock()
}
}
}
}
}(i, stream)
}
// register
for i := 0; i < testClients; i++ {
host := &v1pb.Host{
Name: fmt.Sprintf("127.0.0.1:5010%d", i),
Entities: []string{"DogActor", "CatActor"},
Id: "testAppID",
Load: 1, // Not used yet.
}
require.NoError(t, clientStreams[i].Send(host))
}
// Wait until clientStreams[clientID].Recv() in client go routine received new table.
ns := "" // The client didn't send any namespace
require.Eventually(t, func() bool {
return testServer.streamConnPool.getStreamCount(ns) == testClients
}, 15*time.Second, 100*time.Millisecond)
streamConnPool := make([]daprdStream, 0)
testServer.streamConnPool.forEachInNamespace(ns, func(streamId uint32, val *daprdStream) {
streamConnPool = append(streamConnPool, *val)
})
startFlag.Store(true)
mockMessage := &v1pb.PlacementTables{Version: "demo"}
for _, host := range streamConnPool {
require.NoError(t, testServer.disseminateOperation(context.Background(), host, lockOperation, mockMessage))
require.NoError(t, testServer.disseminateOperation(context.Background(), host, updateOperation, mockMessage))
require.NoError(t, testServer.disseminateOperation(context.Background(), host, unlockOperation, mockMessage))
}
startFlag.Store(false)
var max int64
overArrLock.RLock()
for i := range overArr {
if overArr[i] > max {
max = overArr[i]
}
}
overArrLock.RUnlock()
// clean up resources.
for i := 0; i < testClients; i++ {
require.NoError(t, clientConns[i].Close())
}
cleanup()
return max
}
func TestPerformTableUpdatePerf(t *testing.T) {
for i := 0; i < 3; i++ {
fmt.Println("max cost time(ns)", PerformTableUpdateCostTime(t))
}
}
// MockPlacementGRPCStream simulates the behavior of placementv1pb.Placement_ReportDaprStatusServer
type MockPlacementGRPCStream struct {
v1pb.Placement_ReportDaprStatusServer
ctx context.Context
}
func (m MockPlacementGRPCStream) Context() context.Context {
return m.ctx
}
// Utility function to create metadata and context for testing
func createContextWithMetadata(key, value string) context.Context {
md := metadata.Pairs(key, value)
return metadata.NewIncomingContext(context.Background(), md)
}
func TestExpectsVNodes(t *testing.T) {
tests := []struct {
name string
ctx context.Context
expected bool
}{
{
name: "Without metadata",
ctx: context.Background(),
expected: true,
},
{
name: "With metadata expectsVNodes true",
ctx: createContextWithMetadata(GRPCContextKeyAcceptVNodes, "true"),
expected: true,
},
{
name: "With metadata expectsVNodes false",
ctx: createContextWithMetadata(GRPCContextKeyAcceptVNodes, "false"),
expected: false,
},
{
name: "With invalid metadata value",
ctx: createContextWithMetadata(GRPCContextKeyAcceptVNodes, "invalid"),
expected: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
stream := MockPlacementGRPCStream{ctx: tt.ctx}
result := hostNeedsVNodes(stream)
if result != tt.expected {
t.Errorf("expectsVNodes() for %s: expected %v, got %v", tt.name, tt.expected, result)
}
})
}
}
|
mikeee/dapr
|
pkg/placement/membership_test.go
|
GO
|
mit
| 17,133 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package monitoring
import (
"context"
"time"
"go.opencensus.io/stats"
"go.opencensus.io/stats/view"
"go.opencensus.io/tag"
diagUtils "github.com/dapr/dapr/pkg/diagnostics/utils"
)
var (
runtimesTotal = stats.Int64(
"placement/runtimes_total",
"The total number of runtimes reported to placement service.",
stats.UnitDimensionless)
actorRuntimesTotal = stats.Int64(
"placement/actor_runtimes_total",
"The total number of actor runtimes reported to placement service.",
stats.UnitDimensionless)
actorHeartbeatTimestamp = stats.Int64(
"placement/actor_heartbeat_timestamp",
"The actor's heartbeat timestamp (in seconds) was last reported to the placement service.",
stats.UnitDimensionless)
// Metrics tags
appIDKey = tag.MustNewKey("app_id")
actorTypeKey = tag.MustNewKey("actor_type")
hostNameKey = tag.MustNewKey("host_name")
namespaceKey = tag.MustNewKey("host_namespace")
podNameKey = tag.MustNewKey("pod_name")
)
// RecordRuntimesCount records the number of connected runtimes.
func RecordRuntimesCount(count int, ns string) {
stats.RecordWithTags(
context.Background(),
diagUtils.WithTags(actorHeartbeatTimestamp.Name(), namespaceKey, ns),
runtimesTotal.M(int64(count)),
)
}
// RecordActorRuntimesCount records the number of valid actor runtimes.
func RecordActorRuntimesCount(count int, ns string) {
stats.RecordWithTags(
context.Background(),
diagUtils.WithTags(actorHeartbeatTimestamp.Name(), namespaceKey, ns),
actorRuntimesTotal.M(int64(count)),
)
}
// RecordActorHeartbeat records the actor heartbeat, in seconds since epoch, with actor type, host and pod name.
func RecordActorHeartbeat(appID, actorType, host, namespace, pod string, heartbeatTime time.Time) {
stats.RecordWithTags(
context.Background(),
diagUtils.WithTags(actorHeartbeatTimestamp.Name(), appIDKey, appID, actorTypeKey, actorType, hostNameKey, host, namespaceKey, namespace, podNameKey, pod),
actorHeartbeatTimestamp.M(heartbeatTime.Unix()))
}
// InitMetrics initialize the placement service metrics.
func InitMetrics() error {
err := view.Register(
diagUtils.NewMeasureView(runtimesTotal, []tag.Key{namespaceKey}, view.LastValue()),
diagUtils.NewMeasureView(actorRuntimesTotal, []tag.Key{namespaceKey}, view.LastValue()),
diagUtils.NewMeasureView(actorHeartbeatTimestamp, []tag.Key{appIDKey, actorTypeKey, hostNameKey, namespaceKey, podNameKey}, view.LastValue()),
)
return err
}
|
mikeee/dapr
|
pkg/placement/monitoring/metrics.go
|
GO
|
mit
| 3,003 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import (
"context"
"errors"
"fmt"
"io"
"net"
"sync"
"sync/atomic"
"time"
"github.com/alphadose/haxmap"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/keepalive"
"google.golang.org/grpc/status"
"k8s.io/utils/clock"
"github.com/dapr/dapr/pkg/placement/monitoring"
"github.com/dapr/dapr/pkg/placement/raft"
placementv1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
"github.com/dapr/dapr/pkg/security"
"github.com/dapr/dapr/pkg/security/spiffe"
"github.com/dapr/kit/concurrency"
"github.com/dapr/kit/logger"
)
var log = logger.NewLogger("dapr.placement")
const (
// membershipChangeChSize is the channel size of membership change request from Dapr runtime.
// MembershipChangeWorker will process actor host member change request.
membershipChangeChSize = 100
// disseminateTimerInterval is the interval to disseminate the latest consistent hashing table.
disseminateTimerInterval = 500 * time.Millisecond
// disseminateTimeout is the timeout to disseminate hashing tables after the membership change.
// When the multiple actor service pods are deployed first, a few pods are deployed in the beginning
// and the rest of pods will be deployed gradually. disseminateNextTime is maintained to decide when
// the hashing table is disseminated. disseminateNextTime is updated whenever membership change
// is applied to raft state or each pod is deployed. If we increase disseminateTimeout, it will
// reduce the frequency of dissemination, but it will delay the table dissemination.
disseminateTimeout = 2 * time.Second
// faultyHostDetectDuration is the maximum duration after which a host is considered faulty.
// Dapr runtime sends a heartbeat (stored in lastHeartBeat) every second.
// When placement failover occurs, the new leader will wait for faultyHostDetectDuration, then
// it will loop through all the members in the state and remove the ones that
// have not sent a heartbeat
faultyHostDetectDuration = 6 * time.Second
lockOperation = "lock"
unlockOperation = "unlock"
updateOperation = "update"
)
type hostMemberChange struct {
cmdType raft.CommandType
host raft.DaprHostMember
}
type tablesUpdateRequest struct {
hosts []daprdStream
tables *placementv1pb.PlacementTables
tablesWithVNodes *placementv1pb.PlacementTables // Temporary. Will be removed in 1.15
}
// GetVersion is used only for logs in membership.go
func (r *tablesUpdateRequest) GetVersion() string {
if r.tables != nil {
return r.tables.GetVersion()
}
if r.tablesWithVNodes != nil {
return r.tablesWithVNodes.GetVersion()
}
return ""
}
func (r *tablesUpdateRequest) SetAPILevel(minAPILevel uint32, maxAPILevel *uint32) {
setAPILevel := func(tables *placementv1pb.PlacementTables) {
if tables != nil {
if tables.GetApiLevel() < minAPILevel {
tables.ApiLevel = minAPILevel
}
if maxAPILevel != nil && tables.GetApiLevel() > *maxAPILevel {
tables.ApiLevel = *maxAPILevel
}
}
}
setAPILevel(r.tablesWithVNodes)
setAPILevel(r.tables)
}
// Service updates the Dapr runtimes with distributed hash tables for stateful entities.
type Service struct {
streamConnPool *streamConnPool
// raftNode is the raft server instance.
raftNode *raft.Server
// lastHeartBeat represents the last time stamp when runtime sent heartbeat.
lastHeartBeat sync.Map
// membershipCh is the channel to maintain Dapr runtime host membership update.
membershipCh chan hostMemberChange
// disseminateLocks is a map of lock per namespace for disseminating the hashing tables
disseminateLocks concurrency.MutexMap[string]
// disseminateNextTime is the time when the hashing tables for a namespace are disseminated.
disseminateNextTime haxmap.Map[string, *atomic.Int64]
// memberUpdateCount represents how many dapr runtimes needs to change in a namespace.
// Only actor runtime's heartbeat can increase this.
memberUpdateCount haxmap.Map[string, *atomic.Uint32]
// Maximum API level to return.
// If nil, there's no limit.
maxAPILevel *uint32
// Minimum API level to return
minAPILevel uint32
// hasLeadership indicates the state for leadership.
hasLeadership atomic.Bool
// streamConnGroup represents the number of stream connections.
// This waits until all stream connections are drained when revoking leadership.
streamConnGroup sync.WaitGroup
// clock keeps time. Mocked in tests.
clock clock.WithTicker
sec security.Provider
running atomic.Bool
closed atomic.Bool
closedCh chan struct{}
wg sync.WaitGroup
}
// PlacementServiceOpts contains options for the NewPlacementService method.
type PlacementServiceOpts struct {
RaftNode *raft.Server
MaxAPILevel *uint32
MinAPILevel uint32
SecProvider security.Provider
}
// NewPlacementService returns a new placement service.
func NewPlacementService(opts PlacementServiceOpts) *Service {
return &Service{
streamConnPool: newStreamConnPool(),
membershipCh: make(chan hostMemberChange, membershipChangeChSize),
raftNode: opts.RaftNode,
maxAPILevel: opts.MaxAPILevel,
minAPILevel: opts.MinAPILevel,
clock: &clock.RealClock{},
closedCh: make(chan struct{}),
sec: opts.SecProvider,
disseminateLocks: concurrency.NewMutexMap[string](),
memberUpdateCount: *haxmap.New[string, *atomic.Uint32](),
disseminateNextTime: *haxmap.New[string, *atomic.Int64](),
}
}
// Run starts the placement service gRPC server.
// Blocks until the service is closed and all connections are drained.
func (p *Service) Run(ctx context.Context, listenAddress, port string) error {
if p.closed.Load() {
return errors.New("placement service is closed")
}
if !p.running.CompareAndSwap(false, true) {
return errors.New("placement service is already running")
}
sec, err := p.sec.Handler(ctx)
if err != nil {
return err
}
serverListener, err := net.Listen("tcp", fmt.Sprintf("%s:%s", listenAddress, port))
if err != nil {
return fmt.Errorf("failed to listen: %w", err)
}
keepaliveParams := keepalive.ServerParameters{
Time: 2 * time.Second,
Timeout: 3 * time.Second,
}
grpcServer := grpc.NewServer(sec.GRPCServerOptionMTLS(), grpc.KeepaliveParams(keepaliveParams))
placementv1pb.RegisterPlacementServer(grpcServer, p)
log.Infof("Placement service started on port %d", serverListener.Addr().(*net.TCPAddr).Port)
errCh := make(chan error)
go func() {
errCh <- grpcServer.Serve(serverListener)
log.Info("Placement service stopped")
}()
<-ctx.Done()
if p.closed.CompareAndSwap(false, true) {
close(p.closedCh)
}
grpcServer.GracefulStop()
p.wg.Wait()
return <-errCh
}
// ReportDaprStatus gets a heartbeat report from different Dapr hosts.
func (p *Service) ReportDaprStatus(stream placementv1pb.Placement_ReportDaprStatusServer) error { //nolint:nosnakecase
registeredMemberID := ""
isActorRuntime := false
clientID, err := p.validateClient(stream)
if err != nil {
return err
}
firstMessage, err := p.receiveAndValidateFirstMessage(stream, clientID)
if err != nil {
return err
}
// Older versions won't be sending the namespace in subsequent messages either,
// so we'll save this one in a separate variable
namespace := firstMessage.GetNamespace()
daprStream := newDaprdStream(firstMessage, stream)
p.streamConnGroup.Add(1)
p.streamConnPool.add(daprStream)
defer func() {
// Runs when a stream is disconnected or when the placement service loses leadership
p.streamConnGroup.Done()
p.streamConnPool.delete(daprStream)
}()
for p.hasLeadership.Load() {
var req *placementv1pb.Host
if firstMessage != nil {
req, err = firstMessage, nil
firstMessage = nil
} else {
req, err = stream.Recv()
}
switch err {
case nil:
if clientID != nil && req.GetId() != clientID.AppID() {
return status.Errorf(codes.PermissionDenied, "client ID %s is not allowed", req.GetId())
}
if registeredMemberID == "" {
registeredMemberID, err = p.handleNewConnection(req, daprStream, namespace)
if err != nil {
return err
}
}
// Ensure that the incoming runtime is actor instance.
isActorRuntime = len(req.GetEntities()) > 0
if !isActorRuntime {
// we already disseminated the existing tables to this member,
// so we can ignore the rest if it's a non-actor.
continue
}
now := p.clock.Now()
for _, entity := range req.GetEntities() {
monitoring.RecordActorHeartbeat(req.GetId(), entity, req.GetName(), req.GetNamespace(), req.GetPod(), now)
}
// Record the heartbeat timestamp. Used for metrics and for disconnecting faulty hosts
// on placement fail-over by comparing the member list in raft with the heartbeats
p.lastHeartBeat.Store(req.GetNamespace()+"||"+req.GetName(), now.UnixNano())
// Upsert incoming member only if the existing member info
// doesn't match with the incoming member info.
if p.raftNode.FSM().State().UpsertRequired(namespace, req) {
p.membershipCh <- hostMemberChange{
cmdType: raft.MemberUpsert,
host: raft.DaprHostMember{
Name: req.GetName(),
AppID: req.GetId(),
Namespace: namespace,
Entities: req.GetEntities(),
UpdatedAt: now.UnixNano(),
APILevel: req.GetApiLevel(),
},
}
log.Debugf("Member changed; upserting appid %s in namespace %s with entities %v", req.GetId(), namespace, req.GetEntities())
}
default:
if registeredMemberID == "" {
log.Error("Stream is disconnected before member is added ", err)
return nil
}
if errors.Is(err, io.EOF) || errors.Is(err, context.Canceled) {
log.Debugf("Stream connection is disconnected gracefully: %s", registeredMemberID)
} else {
log.Debugf("Stream connection is disconnected with the error: %v", err)
}
if isActorRuntime {
p.membershipCh <- hostMemberChange{
cmdType: raft.MemberRemove,
host: raft.DaprHostMember{Name: registeredMemberID, Namespace: namespace},
}
}
return nil
}
}
return status.Error(codes.FailedPrecondition, "only leader can serve the request")
}
func (p *Service) validateClient(stream placementv1pb.Placement_ReportDaprStatusServer) (*spiffe.Parsed, error) {
sec, err := p.sec.Handler(stream.Context())
if err != nil {
return nil, status.Errorf(codes.Internal, "")
}
if !sec.MTLSEnabled() {
return nil, nil
}
clientID, ok, err := spiffe.FromGRPCContext(stream.Context())
if err != nil || !ok {
log.Debugf("failed to get client ID from context: err=%v, ok=%t", err, ok)
return nil, status.Errorf(codes.Unauthenticated, "failed to get client ID from context")
}
return clientID, nil
}
func (p *Service) receiveAndValidateFirstMessage(stream placementv1pb.Placement_ReportDaprStatusServer, clientID *spiffe.Parsed) (*placementv1pb.Host, error) {
firstMessage, err := stream.Recv()
if err != nil {
return nil, status.Errorf(codes.Internal, "failed to receive the first message: %v", err)
}
if clientID != nil && firstMessage.GetId() != clientID.AppID() {
return nil, status.Errorf(codes.PermissionDenied, "provided app ID %s doesn't match the one in the Spiffe ID (%s)", firstMessage.GetId(), clientID.AppID())
}
// For older versions that are not sending their namespace as part of the message
// we will use the namespace from the Spiffe clientID
if clientID != nil && firstMessage.GetNamespace() == "" {
firstMessage.Namespace = clientID.Namespace()
}
if clientID != nil && firstMessage.GetNamespace() != clientID.Namespace() {
return nil, status.Errorf(codes.PermissionDenied, "provided client namespace %s doesn't match the one in the Spiffe ID (%s)", firstMessage.GetNamespace(), clientID.Namespace())
}
return firstMessage, nil
}
func (p *Service) handleNewConnection(req *placementv1pb.Host, daprStream *daprdStream, namespace string) (string, error) {
err := p.checkAPILevel(req)
if err != nil {
return "", err
}
registeredMemberID := req.GetName()
// If the member is not an actor runtime (len(req.GetEntities()) == 0) we disseminate the tables
// If it is, we'll disseminate in the next disseminate interval
if len(req.GetEntities()) == 0 {
updateReq := &tablesUpdateRequest{
hosts: []daprdStream{*daprStream},
}
if daprStream.needsVNodes {
updateReq.tablesWithVNodes = p.raftNode.FSM().PlacementState(false, namespace)
} else {
updateReq.tables = p.raftNode.FSM().PlacementState(true, namespace)
}
err = p.performTablesUpdate(context.Background(), updateReq)
if err != nil {
return registeredMemberID, err
}
}
return registeredMemberID, nil
}
func (p *Service) checkAPILevel(req *placementv1pb.Host) error {
clusterAPILevel := max(p.minAPILevel, p.raftNode.FSM().State().APILevel())
if p.maxAPILevel != nil && clusterAPILevel > *p.maxAPILevel {
clusterAPILevel = *p.maxAPILevel
}
// Ensure that the reported API level is at least equal to the current one in the cluster
if req.GetApiLevel() < clusterAPILevel {
return status.Errorf(codes.FailedPrecondition, "The cluster's Actor API level is %d, which is higher than the reported API level %d", clusterAPILevel, req.GetApiLevel())
}
return nil
}
|
mikeee/dapr
|
pkg/placement/placement.go
|
GO
|
mit
| 13,778 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import (
"context"
"errors"
"net"
"strconv"
"testing"
"time"
"github.com/phayes/freeport"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/status"
clocktesting "k8s.io/utils/clock/testing"
"github.com/dapr/dapr/pkg/placement/raft"
"github.com/dapr/dapr/pkg/placement/tests"
v1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
securityfake "github.com/dapr/dapr/pkg/security/fake"
)
const testStreamSendLatency = time.Second
func newTestPlacementServer(t *testing.T, raftServer *raft.Server) (string, *Service, *clocktesting.FakeClock, context.CancelFunc) {
t.Helper()
testServer := NewPlacementService(PlacementServiceOpts{
RaftNode: raftServer,
SecProvider: securityfake.New(),
})
clock := clocktesting.NewFakeClock(time.Now())
testServer.clock = clock
port, err := freeport.GetFreePort()
require.NoError(t, err)
serverStopped := make(chan struct{})
ctx, cancel := context.WithCancel(context.Background())
go func() {
defer close(serverStopped)
err := testServer.Run(ctx, "127.0.0.1", strconv.Itoa(port))
if !errors.Is(err, grpc.ErrServerStopped) {
require.NoError(t, err)
}
}()
require.Eventually(t, func() bool {
conn, err := net.Dial("tcp", ":"+strconv.Itoa(port))
if err == nil {
conn.Close()
}
return err == nil
}, time.Second*5, time.Millisecond, "server did not start in time")
cleanUpFn := func() {
cancel()
select {
case <-serverStopped:
case <-time.After(time.Second * 5):
t.Error("server did not stop in time")
}
}
serverAddress := "127.0.0.1:" + strconv.Itoa(port)
return serverAddress, testServer, clock, cleanUpFn
}
func newTestClient(t *testing.T, serverAddress string) (*grpc.ClientConn, *net.TCPConn, v1pb.Placement_ReportDaprStatusClient) { //nolint:nosnakecase
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
tcpConn, err := net.Dial("tcp", serverAddress)
require.NoError(t, err)
conn, err := grpc.DialContext(ctx, "",
grpc.WithContextDialer(func(ctx context.Context, s string) (net.Conn, error) {
return tcpConn, nil
}),
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithBlock(),
)
require.NoError(t, err)
client := v1pb.NewPlacementClient(conn)
stream, err := client.ReportDaprStatus(context.Background())
require.NoError(t, err)
return conn, tcpConn.(*net.TCPConn), stream
}
func TestMemberRegistration_NoLeadership(t *testing.T) {
serverAddress, testServer, _, cleanup := newTestPlacementServer(t, tests.Raft(t))
t.Cleanup(cleanup)
testServer.hasLeadership.Store(false)
conn, _, stream := newTestClient(t, serverAddress)
host := &v1pb.Host{
Name: "127.0.0.1:50102",
Namespace: "ns1",
Entities: []string{"DogActor", "CatActor"},
Id: "testAppID",
Load: 1, // Not used yet
// Port is redundant because Name should include port number
}
stream.Send(host)
_, err := stream.Recv()
s, ok := status.FromError(err)
require.True(t, ok)
require.Equal(t, codes.FailedPrecondition, s.Code())
stream.CloseSend()
conn.Close()
}
func TestMemberRegistration_Leadership(t *testing.T) {
serverAddress, testServer, clock, cleanup := newTestPlacementServer(t, tests.Raft(t))
t.Cleanup(cleanup)
testServer.hasLeadership.Store(true)
t.Run("Connect server and disconnect it gracefully", func(t *testing.T) {
// arrange
conn, _, stream := newTestClient(t, serverAddress)
host := &v1pb.Host{
Name: "127.0.0.1:50102",
Namespace: "ns1",
Entities: []string{"DogActor", "CatActor"},
Id: "testAppID",
Load: 1, // Not used yet
// Port is redundant because Name should include port number
}
require.NoError(t, stream.Send(host))
require.Eventually(t, func() bool {
clock.Step(disseminateTimerInterval)
select {
case memberChange := <-testServer.membershipCh:
assert.Equal(t, raft.MemberUpsert, memberChange.cmdType)
assert.Equal(t, host.GetName(), memberChange.host.Name)
assert.Equal(t, host.GetNamespace(), memberChange.host.Namespace)
assert.Equal(t, host.GetId(), memberChange.host.AppID)
assert.EqualValues(t, host.GetEntities(), memberChange.host.Entities)
assert.Equal(t, 1, testServer.streamConnPool.getStreamCount("ns1"))
return true
default:
return false
}
}, testStreamSendLatency+3*time.Second, time.Millisecond, "no membership change")
// Runtime needs to close stream gracefully which will let placement remove runtime host from hashing ring
// in the next flush time window.
stream.CloseSend()
clock.Step(disseminateTimerInterval)
select {
case memberChange := <-testServer.membershipCh:
require.Equal(t, raft.MemberRemove, memberChange.cmdType)
require.Equal(t, host.GetName(), memberChange.host.Name)
case <-time.After(testStreamSendLatency):
require.Fail(t, "no membership change")
}
conn.Close()
})
// this test verifies that the placement service will work for pre 1.14 sidecars
// that do not send a namespace
t.Run("Connect server and disconnect it gracefully - no namespace sent", func(t *testing.T) {
// arrange
conn, _, stream := newTestClient(t, serverAddress)
host := &v1pb.Host{
Name: "127.0.0.1:50102",
Entities: []string{"DogActor", "CatActor"},
Id: "testAppID",
Load: 1, // Not used yet
// Port is redundant because Name should include port number
}
require.NoError(t, stream.Send(host))
require.Eventually(t, func() bool {
clock.Step(disseminateTimerInterval)
select {
case memberChange := <-testServer.membershipCh:
assert.Equal(t, raft.MemberUpsert, memberChange.cmdType)
assert.Equal(t, host.GetName(), memberChange.host.Name)
assert.Equal(t, host.GetNamespace(), memberChange.host.Namespace)
assert.Equal(t, host.GetId(), memberChange.host.AppID)
assert.EqualValues(t, host.GetEntities(), memberChange.host.Entities)
assert.Equal(t, 1, testServer.streamConnPool.getStreamCount(""))
return true
default:
return false
}
}, testStreamSendLatency+3*time.Second, time.Millisecond, "no membership change")
// Runtime needs to close stream gracefully which will let placement remove runtime host from hashing ring
// in the next flush time window.
stream.CloseSend()
select {
case memberChange := <-testServer.membershipCh:
require.Equal(t, raft.MemberRemove, memberChange.cmdType)
require.Equal(t, host.GetName(), memberChange.host.Name)
case <-time.After(testStreamSendLatency):
require.Fail(t, "no membership change")
}
conn.Close()
})
t.Run("Connect server and disconnect it forcefully", func(t *testing.T) {
// arrange
_, tcpConn, stream := newTestClient(t, serverAddress)
host := &v1pb.Host{
Name: "127.0.0.1:50103",
Namespace: "ns1",
Entities: []string{"DogActor", "CatActor"},
Id: "testAppID",
Load: 1, // Not used yet
// Port is redundant because Name should include port number
}
stream.Send(host)
require.EventuallyWithT(t, func(t *assert.CollectT) {
clock.Step(disseminateTimerInterval)
select {
case memberChange := <-testServer.membershipCh:
assert.Equal(t, raft.MemberUpsert, memberChange.cmdType)
assert.Equal(t, host.GetName(), memberChange.host.Name)
assert.Equal(t, host.GetNamespace(), memberChange.host.Namespace)
assert.Equal(t, host.GetId(), memberChange.host.AppID)
assert.EqualValues(t, host.GetEntities(), memberChange.host.Entities)
l := testServer.streamConnPool.getStreamCount("ns1")
assert.Equal(t, 1, l)
default:
assert.Fail(t, "No member change")
}
}, testStreamSendLatency+3*time.Second, time.Millisecond, "no membership change")
// Close tcp connection before closing stream, which simulates the scenario
// where dapr runtime disconnects the connection from placement service unexpectedly.
// Use SetLinger to forcefully close the TCP connection.
tcpConn.SetLinger(0)
tcpConn.Close()
select {
case memberChange := <-testServer.membershipCh:
require.Equal(t, raft.MemberRemove, memberChange.cmdType)
require.Equal(t, host.GetName(), memberChange.host.Name)
case <-time.After(testStreamSendLatency):
require.Fail(t, "no membership change")
}
})
t.Run("non actor host", func(t *testing.T) {
conn, _, stream := newTestClient(t, serverAddress)
host := &v1pb.Host{
Name: "127.0.0.1:50104",
Entities: []string{},
Id: "testAppID",
Load: 1, // Not used yet
// Port is redundant because Name should include port number
}
stream.Send(host)
select {
case <-testServer.membershipCh:
require.Fail(t, "should not have any membership change")
case <-time.After(testStreamSendLatency):
// All good
}
// Close tcp connection before closing stream, which simulates the scenario
// where dapr runtime disconnects the connection from placement service unexpectedly.
require.NoError(t, conn.Close())
})
}
|
mikeee/dapr
|
pkg/placement/placement_test.go
|
GO
|
mit
| 9,657 |
/*
Copyright 2024 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import (
"strings"
"sync"
"sync/atomic"
"google.golang.org/grpc/metadata"
placementv1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
)
type daprdStream struct {
id uint32
hostName string
hostID string
hostNamespace string
needsVNodes bool
stream placementv1pb.Placement_ReportDaprStatusServer
}
func newDaprdStream(host *placementv1pb.Host, stream placementv1pb.Placement_ReportDaprStatusServer) *daprdStream {
return &daprdStream{
hostID: host.GetId(),
hostName: host.GetName(),
hostNamespace: host.GetNamespace(),
stream: stream,
needsVNodes: hostNeedsVNodes(stream),
}
}
// streamConnPool has the stream connections established between the placement gRPC server
// and the Dapr runtime grouped by namespace, with an assigned id for faster lookup/deletion
// The id is a simple auto-incrementing number, for efficiency.
type streamConnPool struct {
// locks the streams map itself
lock sync.RWMutex
streams map[string]map[uint32]*daprdStream
// streamIndex assigns an index to streams in the streamConnPool.
// Its reset to zero every time a placement service loses leadership (thus clears all streams).
streamIndex atomic.Uint32
// reverseLookup is a reverse index of streams to their daprdStream object.
// (so we don't have to loop through all streams to find a specific one)
reverseLookup map[placementv1pb.Placement_ReportDaprStatusServer]*daprdStream
}
func newStreamConnPool() *streamConnPool {
return &streamConnPool{
streams: make(map[string]map[uint32]*daprdStream),
reverseLookup: make(map[placementv1pb.Placement_ReportDaprStatusServer]*daprdStream),
}
}
// add adds stream connection between runtime and placement to the namespaced dissemination pool.
func (s *streamConnPool) add(stream *daprdStream) {
id := s.streamIndex.Add(1)
stream.id = id
s.lock.Lock()
defer s.lock.Unlock()
if _, ok := s.streams[stream.hostNamespace]; !ok {
s.streams[stream.hostNamespace] = make(map[uint32]*daprdStream)
}
s.streams[stream.hostNamespace][id] = stream
s.reverseLookup[stream.stream] = stream
}
// delete removes a stream connection between runtime and placement
// from the namespaced dissemination pool.
// Returns true if the stream is the last one in a namespace
func (s *streamConnPool) delete(stream *daprdStream) {
s.lock.Lock()
defer s.lock.Unlock()
if streams, ok := s.streams[stream.hostNamespace]; ok {
delete(streams, stream.id)
delete(s.reverseLookup, stream.stream)
if len(streams) == 0 {
delete(s.streams, stream.hostNamespace)
}
}
}
func (s *streamConnPool) getStreamCount(namespace string) int {
s.lock.RLock()
defer s.lock.RUnlock()
return len(s.streams[namespace])
}
func (s *streamConnPool) forEachNamespace(fn func(namespace string, val map[uint32]*daprdStream)) {
s.lock.RLock()
defer s.lock.RUnlock()
for ns, val := range s.streams {
fn(ns, val)
}
}
func (s *streamConnPool) forEachInNamespace(namespace string, fn func(key uint32, val *daprdStream)) {
s.lock.RLock()
defer s.lock.RUnlock()
for key, val := range s.streams[namespace] {
fn(key, val)
}
}
func (s *streamConnPool) getStream(stream placementv1pb.Placement_ReportDaprStatusServer) (*daprdStream, bool) {
s.lock.RLock()
defer s.lock.RUnlock()
daprdStream, ok := s.reverseLookup[stream]
return daprdStream, ok
}
func hostNeedsVNodes(stream placementv1pb.Placement_ReportDaprStatusServer) bool {
md, ok := metadata.FromIncomingContext(stream.Context())
if !ok {
// default to older versions that need vnodes
return true
}
// Extract apiLevel from metadata
vmd := md.Get(GRPCContextKeyAcceptVNodes)
return !(len(vmd) > 0 && strings.EqualFold(vmd[0], "false"))
}
|
mikeee/dapr
|
pkg/placement/pool.go
|
GO
|
mit
| 4,302 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"errors"
"io"
"strconv"
"sync"
"github.com/hashicorp/raft"
"github.com/dapr/dapr/pkg/placement/hashing"
v1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
)
// CommandType is the type of raft command in log entry.
type CommandType uint8
const (
// MemberUpsert is the command to update or insert new or existing member info.
MemberUpsert CommandType = 0
// MemberRemove is the command to remove member from actor host member state.
MemberRemove CommandType = 1
// TableDisseminate is the reserved command for dissemination loop.
TableDisseminate CommandType = 100
)
// FSM implements a finite state machine that is used
// along with Raft to provide strong consistency. We implement
// this outside the Server to avoid exposing it outside the package.
type FSM struct {
// stateLock is only used to protect outside callers to State() from
// racing with Restore(), which is called by Raft (it puts in a totally
// new state store). Everything internal here is synchronized by the
// Raft side, so doesn't need to Lock this.
stateLock sync.RWMutex
state *DaprHostMemberState
config DaprHostMemberStateConfig
}
func newFSM(config DaprHostMemberStateConfig) *FSM {
return &FSM{
state: newDaprHostMemberState(config),
config: config,
}
}
// State is used to return a handle to the current state.
func (c *FSM) State() *DaprHostMemberState {
c.stateLock.RLock()
defer c.stateLock.RUnlock()
return c.state
}
// PlacementState returns the current placement tables.
// the withVirtualNodes parameter is here for backwards compatibility and should be removed in 1.15
// TODO in v1.15 remove the withVirtualNodes parameter
func (c *FSM) PlacementState(withVirtualNodes bool, namespace string) *v1pb.PlacementTables {
c.stateLock.RLock()
defer c.stateLock.RUnlock()
newTable := &v1pb.PlacementTables{
Version: strconv.FormatUint(c.state.TableGeneration(), 10),
Entries: make(map[string]*v1pb.PlacementTable),
ApiLevel: c.state.APILevel(),
ReplicationFactor: c.config.replicationFactor,
}
totalHostSize := 0
totalSortedSet := 0
totalLoadMap := 0
entries, err := c.state.hashingTableMap(namespace)
if err != nil {
return newTable
}
for k, v := range entries {
var table v1pb.PlacementTable
v.ReadInternals(func(hosts map[uint64]string, sortedSet []uint64, loadMap map[string]*hashing.Host, totalLoad int64) {
sortedSetLen := 0
if withVirtualNodes {
sortedSetLen = len(sortedSet)
}
table = v1pb.PlacementTable{
Hosts: make(map[uint64]string),
SortedSet: make([]uint64, sortedSetLen),
TotalLoad: totalLoad,
LoadMap: make(map[string]*v1pb.Host),
}
if withVirtualNodes {
for lk, lv := range hosts {
table.GetHosts()[lk] = lv
}
copy(table.GetSortedSet(), sortedSet)
}
for lk, lv := range loadMap {
h := v1pb.Host{
Name: lv.Name,
Load: lv.Load,
Port: lv.Port,
Id: lv.AppID,
}
table.LoadMap[lk] = &h
}
})
newTable.Entries[k] = &table
if withVirtualNodes {
totalHostSize += len(table.GetHosts())
totalSortedSet += len(table.GetSortedSet())
}
totalLoadMap += len(table.GetLoadMap())
}
if withVirtualNodes {
logging.Debugf("PlacementTable Size, Hosts: %d, SortedSet: %d, LoadMap: %d", totalHostSize, totalSortedSet, totalLoadMap)
} else {
logging.Debugf("PlacementTable LoadMapCount=%d ApiLevel=%d ReplicationFactor=%d", totalLoadMap, newTable.GetApiLevel(), newTable.GetReplicationFactor())
}
return newTable
}
func (c *FSM) upsertMember(cmdData []byte) (bool, error) {
var host DaprHostMember
if err := unmarshalMsgPack(cmdData, &host); err != nil {
return false, err
}
c.stateLock.RLock()
defer c.stateLock.RUnlock()
return c.state.upsertMember(&host), nil
}
func (c *FSM) removeMember(cmdData []byte) (bool, error) {
var host DaprHostMember
if err := unmarshalMsgPack(cmdData, &host); err != nil {
return false, err
}
c.stateLock.RLock()
defer c.stateLock.RUnlock()
return c.state.removeMember(&host), nil
}
// Apply log is invoked once a log entry is committed.
func (c *FSM) Apply(log *raft.Log) interface{} {
var (
err error
updated bool
)
if log.Index < c.state.Index() {
logging.Warnf("old: %d, new index: %d. skip apply", c.state.Index, log.Index)
return false
}
if len(log.Data) < 2 {
logging.Warnf("too short log data in raft logs: %v", log.Data)
return false
}
switch CommandType(log.Data[0]) {
case MemberUpsert:
updated, err = c.upsertMember(log.Data[1:])
case MemberRemove:
updated, err = c.removeMember(log.Data[1:])
default:
err = errors.New("unimplemented command")
}
if err != nil {
logging.Errorf("fsm apply entry log failed. data: %s, error: %s",
string(log.Data), err.Error())
return false
}
return updated
}
// Snapshot is used to support log compaction. This call should
// return an FSMSnapshot which can be used to save a point-in-time
// snapshot of the FSM.
func (c *FSM) Snapshot() (raft.FSMSnapshot, error) {
return &snapshot{
state: c.state.clone(),
}, nil
}
// Restore streams in the snapshot and replaces the current state store with a
// new one based on the snapshot if all goes OK during the restore.
func (c *FSM) Restore(old io.ReadCloser) error {
defer old.Close()
members := newDaprHostMemberState(c.config)
if err := members.restore(old); err != nil {
return err
}
c.stateLock.Lock()
c.state = members
c.stateLock.Unlock()
return nil
}
|
mikeee/dapr
|
pkg/placement/raft/fsm.go
|
GO
|
mit
| 6,069 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"bytes"
"io"
"testing"
"github.com/hashicorp/raft"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestFSMApply(t *testing.T) {
fsm := newFSM(DaprHostMemberStateConfig{
replicationFactor: 100,
minAPILevel: 0,
maxAPILevel: 100,
})
t.Run("upsertMember", func(t *testing.T) {
cmdLog, err := makeRaftLogCommand(MemberUpsert, DaprHostMember{
Name: "127.0.0.1:3030",
Namespace: "ns1",
AppID: "fakeAppID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
})
require.NoError(t, err)
raftLog := &raft.Log{
Index: 1,
Term: 1,
Type: raft.LogCommand,
Data: cmdLog,
}
resp := fsm.Apply(raftLog)
updated, ok := resp.(bool)
require.True(t, ok)
require.True(t, updated)
require.Equal(t, uint64(1), fsm.state.TableGeneration())
require.Equal(t, 1, fsm.state.NamespaceCount())
var containsNamespace bool
fsm.state.ForEachNamespace(func(ns string, _ *daprNamespace) bool {
containsNamespace = ns == "ns1"
return true
})
require.True(t, containsNamespace)
fsm.state.lock.RLock()
defer fsm.state.lock.RUnlock()
members, err := fsm.state.members("ns1")
require.NoError(t, err)
assert.Len(t, members, 1)
})
t.Run("removeMember", func(t *testing.T) {
cmdLog, err := makeRaftLogCommand(MemberRemove, DaprHostMember{
Name: "127.0.0.1:3030",
Namespace: "ns1",
})
require.NoError(t, err)
raftLog := &raft.Log{
Index: 2,
Term: 1,
Type: raft.LogCommand,
Data: cmdLog,
}
resp := fsm.Apply(raftLog)
updated, ok := resp.(bool)
assert.True(t, ok)
assert.True(t, updated)
assert.Equal(t, uint64(2), fsm.state.TableGeneration())
require.Equal(t, 0, fsm.state.MemberCountInNamespace("ns1"))
})
}
func TestRestore(t *testing.T) {
fsm := newFSM(DaprHostMemberStateConfig{
replicationFactor: 100,
minAPILevel: 0,
maxAPILevel: 100,
})
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 100,
minAPILevel: 0,
maxAPILevel: 100,
})
s.upsertMember(&DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
})
buf := bytes.NewBuffer(make([]byte, 0, 256))
err := s.persist(buf)
require.NoError(t, err)
err = fsm.Restore(io.NopCloser(buf))
require.NoError(t, err)
require.Equal(t, 1, fsm.state.MemberCountInNamespace("ns1"))
hashingTable, err := fsm.State().hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, hashingTable, 2)
}
func TestPlacementStateWithVirtualNodes(t *testing.T) {
fsm := newFSM(DaprHostMemberStateConfig{
replicationFactor: 5,
})
m := DaprHostMember{
Name: "127.0.0.1:3030",
Namespace: "ns1",
AppID: "fakeAppID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
APILevel: 10,
}
cmdLog, err := makeRaftLogCommand(MemberUpsert, m)
require.NoError(t, err)
fsm.Apply(&raft.Log{
Index: 1,
Term: 1,
Type: raft.LogCommand,
Data: cmdLog,
})
newTable := fsm.PlacementState(true, "ns1")
assert.Equal(t, "1", newTable.GetVersion())
assert.Len(t, newTable.GetEntries(), 2)
assert.Equal(t, int64(5), newTable.GetReplicationFactor())
for _, host := range newTable.GetEntries() {
assert.Len(t, host.GetHosts(), 5)
assert.Len(t, host.GetSortedSet(), 5)
assert.Len(t, host.GetLoadMap(), 1)
assert.Contains(t, host.GetLoadMap(), "127.0.0.1:3030")
}
}
func TestPlacementState(t *testing.T) {
fsm := newFSM(DaprHostMemberStateConfig{
replicationFactor: 5,
})
m := DaprHostMember{
Name: "127.0.0.1:3030",
Namespace: "ns1",
AppID: "fakeAppID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
}
cmdLog, err := makeRaftLogCommand(MemberUpsert, m)
require.NoError(t, err)
fsm.Apply(&raft.Log{
Index: 1,
Term: 1,
Type: raft.LogCommand,
Data: cmdLog,
})
newTable := fsm.PlacementState(false, "ns1")
assert.Equal(t, "1", newTable.GetVersion())
assert.Len(t, newTable.GetEntries(), 2)
assert.Equal(t, int64(5), newTable.GetReplicationFactor())
for _, host := range newTable.GetEntries() {
assert.Empty(t, host.GetHosts())
assert.Empty(t, host.GetSortedSet())
assert.Len(t, host.GetLoadMap(), 1)
assert.Contains(t, host.GetLoadMap(), "127.0.0.1:3030")
}
}
|
mikeee/dapr
|
pkg/placement/raft/fsm_test.go
|
GO
|
mit
| 4,900 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"io"
"log"
"strings"
"github.com/hashicorp/go-hclog"
"github.com/spf13/cast"
"github.com/dapr/kit/logger"
)
var logging = logger.NewLogger("dapr.placement.raft")
func newLoggerAdapter() hclog.Logger {
return &loggerAdapter{}
}
// loggerAdapter is the adapter to integrate with dapr logger.
type loggerAdapter struct{}
func (l *loggerAdapter) printLog(msg string, args ...any) {
if len(args) > 0 {
fields := strings.Builder{}
for i, f := range args {
if i%2 == 1 {
fields.WriteRune('=')
} else {
fields.WriteRune(',')
}
fields.WriteString(cast.ToString(f))
}
logging.Debug(msg + fields.String())
return
}
logging.Debug(msg)
}
func (l *loggerAdapter) Log(level hclog.Level, msg string, args ...interface{}) {
switch level {
case hclog.Debug:
l.printLog(msg, args...)
case hclog.Warn:
l.printLog(msg, args...)
case hclog.Error:
l.printLog(msg, args...)
default:
l.printLog(msg, args...)
}
}
func (l *loggerAdapter) Trace(msg string, args ...interface{}) {
l.printLog(msg, args...)
}
func (l *loggerAdapter) Debug(msg string, args ...interface{}) {
l.printLog(msg, args...)
}
func (l *loggerAdapter) Info(msg string, args ...interface{}) {
l.printLog(msg, args...)
}
func (l *loggerAdapter) Warn(msg string, args ...interface{}) {
l.printLog(msg, args...)
}
func (l *loggerAdapter) Error(msg string, args ...interface{}) {
l.printLog(msg, args...)
}
func (l *loggerAdapter) IsTrace() bool { return false }
func (l *loggerAdapter) IsDebug() bool { return true }
func (l *loggerAdapter) IsInfo() bool { return false }
func (l *loggerAdapter) IsWarn() bool { return false }
func (l *loggerAdapter) IsError() bool { return false }
func (l *loggerAdapter) ImpliedArgs() []interface{} { return []interface{}{} }
func (l *loggerAdapter) With(args ...interface{}) hclog.Logger { return l }
func (l *loggerAdapter) Name() string { return "dapr" }
func (l *loggerAdapter) Named(name string) hclog.Logger { return l }
func (l *loggerAdapter) ResetNamed(name string) hclog.Logger { return l }
func (l *loggerAdapter) SetLevel(level hclog.Level) {}
func (l *loggerAdapter) GetLevel() hclog.Level {
return hclog.Info
}
func (l *loggerAdapter) StandardLogger(opts *hclog.StandardLoggerOptions) *log.Logger {
return log.New(l.StandardWriter(opts), "placement-raft", log.LstdFlags)
}
func (l *loggerAdapter) StandardWriter(opts *hclog.StandardLoggerOptions) io.Writer {
return io.Discard
}
|
mikeee/dapr
|
pkg/placement/raft/logger.go
|
GO
|
mit
| 3,042 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"context"
"errors"
"fmt"
"net"
"path/filepath"
"sync"
"time"
"github.com/hashicorp/raft"
raftboltdb "github.com/hashicorp/raft-boltdb"
"github.com/spiffe/go-spiffe/v2/spiffeid"
"k8s.io/utils/clock"
"github.com/dapr/dapr/pkg/security"
)
const (
// Bump version number of the log prefix if there are breaking changes to Raft logs' schema.
logStorePrefix = "log-v2-"
snapshotsRetained = 2
// raftLogCacheSize is the maximum number of logs to cache in-memory.
// This is used to reduce disk I/O for the recently committed entries.
raftLogCacheSize = 512
commandTimeout = 1 * time.Second
nameResolveRetryInterval = 2 * time.Second
nameResolveMaxRetry = 120
NoVirtualNodesInPlacementTablesAPILevel = 20
)
// PeerInfo represents raft peer node information.
type PeerInfo struct {
ID string
Address string
}
// Server is Raft server implementation.
type Server struct {
id string
fsm *FSM
inMem bool
raftBind string
peers []PeerInfo
config *raft.Config
raft *raft.Raft
lock sync.RWMutex
raftReady chan struct{}
raftStore *raftboltdb.BoltStore
raftTransport *raft.NetworkTransport
logStore raft.LogStore
stableStore raft.StableStore
snapStore raft.SnapshotStore
raftLogStorePath string
clock clock.Clock
}
type Options struct {
ID string
InMem bool
Peers []PeerInfo
LogStorePath string
Clock clock.Clock
ReplicationFactor int64
MinAPILevel uint32
MaxAPILevel uint32
}
// New creates Raft server node.
func New(opts Options) *Server {
raftBind := raftAddressForID(opts.ID, opts.Peers)
if raftBind == "" {
return nil
}
cl := opts.Clock
if cl == nil {
cl = &clock.RealClock{}
}
return &Server{
id: opts.ID,
inMem: opts.InMem,
raftBind: raftBind,
peers: opts.Peers,
raftLogStorePath: opts.LogStorePath,
clock: cl,
raftReady: make(chan struct{}),
fsm: newFSM(DaprHostMemberStateConfig{
replicationFactor: opts.ReplicationFactor,
minAPILevel: opts.MinAPILevel,
maxAPILevel: opts.MaxAPILevel,
}),
}
}
func (s *Server) tryResolveRaftAdvertiseAddr(ctx context.Context, bindAddr string) (*net.TCPAddr, error) {
// HACKHACK: Kubernetes POD DNS A record population takes some time
// to look up the address after StatefulSet POD is deployed.
var err error
var addr *net.TCPAddr
for retry := 0; retry < nameResolveMaxRetry; retry++ {
addr, err = net.ResolveTCPAddr("tcp", bindAddr)
if err == nil {
return addr, nil
}
select {
case <-ctx.Done():
return nil, err
case <-s.clock.After(nameResolveRetryInterval):
// nop
}
}
return nil, err
}
type spiffeStreamLayer struct {
placeID spiffeid.ID
ctx context.Context
sec security.Handler
net.Listener
}
// Dial implements the StreamLayer interface.
func (s *spiffeStreamLayer) Dial(address raft.ServerAddress, timeout time.Duration) (net.Conn, error) {
return s.sec.NetDialerID(s.ctx, s.placeID, timeout)("tcp", string(address))
}
// StartRaft starts Raft node with Raft protocol configuration. if config is nil,
// the default config will be used.
func (s *Server) StartRaft(ctx context.Context, sec security.Handler, config *raft.Config) error {
// If we have an unclean exit then attempt to close the Raft store.
defer func() {
s.lock.RLock()
defer s.lock.RUnlock()
if s.raft == nil && s.raftStore != nil {
if err := s.raftStore.Close(); err != nil {
logging.Errorf("failed to close log storage: %v", err)
}
}
}()
addr, err := s.tryResolveRaftAdvertiseAddr(ctx, s.raftBind)
if err != nil {
return err
}
loggerAdapter := newLoggerAdapter()
listener, err := net.Listen("tcp", addr.String())
if err != nil {
return fmt.Errorf("failed to create raft listener: %w", err)
}
placeID, err := spiffeid.FromSegments(sec.ControlPlaneTrustDomain(), "ns", sec.ControlPlaneNamespace(), "dapr-placement")
if err != nil {
return err
}
s.raftTransport = raft.NewNetworkTransportWithLogger(&spiffeStreamLayer{
Listener: sec.NetListenerID(listener, placeID),
placeID: placeID,
sec: sec,
ctx: ctx,
}, 3, 10*time.Second, loggerAdapter)
// Build an all in-memory setup for dev mode, otherwise prepare a full
// disk-based setup.
if s.inMem {
raftInmem := raft.NewInmemStore()
s.stableStore = raftInmem
s.logStore = raftInmem
s.snapStore = raft.NewInmemSnapshotStore()
} else {
if err = ensureDir(s.raftStorePath()); err != nil {
return fmt.Errorf("failed to create log store directory: %w", err)
}
// Create the backend raft store for logs and stable storage.
s.raftStore, err = raftboltdb.NewBoltStore(filepath.Join(s.raftStorePath(), "raft.db"))
if err != nil {
return err
}
s.stableStore = s.raftStore
// Wrap the store in a LogCache to improve performance.
s.logStore, err = raft.NewLogCache(raftLogCacheSize, s.raftStore)
if err != nil {
return err
}
// Create the snapshot store.
s.snapStore, err = raft.NewFileSnapshotStoreWithLogger(s.raftStorePath(), snapshotsRetained, loggerAdapter)
if err != nil {
return err
}
}
// Setup Raft configuration.
if config == nil {
// Set default configuration for raft
if len(s.peers) == 1 {
s.config = &raft.Config{
ProtocolVersion: raft.ProtocolVersionMax,
HeartbeatTimeout: 5 * time.Millisecond,
ElectionTimeout: 5 * time.Millisecond,
CommitTimeout: 5 * time.Millisecond,
MaxAppendEntries: 64,
ShutdownOnRemove: true,
TrailingLogs: 10240,
SnapshotInterval: 120 * time.Second,
SnapshotThreshold: 8192,
LeaderLeaseTimeout: 5 * time.Millisecond,
}
} else {
s.config = &raft.Config{
ProtocolVersion: raft.ProtocolVersionMax,
HeartbeatTimeout: 2 * time.Second,
ElectionTimeout: 2 * time.Second,
CommitTimeout: 100 * time.Millisecond,
MaxAppendEntries: 64,
ShutdownOnRemove: true,
TrailingLogs: 10240,
SnapshotInterval: 120 * time.Second,
SnapshotThreshold: 8192,
LeaderLeaseTimeout: 2 * time.Second,
}
}
} else {
s.config = config
}
// Use LoggerAdapter to integrate with Dapr logger. Log level relies on placement log level.
s.config.Logger = loggerAdapter
s.config.LocalID = raft.ServerID(s.id)
// If we are in bootstrap or dev mode and the state is clean then we can
// bootstrap now.
bootstrapConf, err := s.bootstrapConfig(s.peers)
if err != nil {
return err
}
if bootstrapConf != nil {
if err = raft.BootstrapCluster(
s.config, s.logStore, s.stableStore,
s.snapStore, s.raftTransport, *bootstrapConf); err != nil {
return err
}
}
s.lock.Lock()
s.raft, err = raft.NewRaft(s.config, s.fsm, s.logStore, s.stableStore, s.snapStore, s.raftTransport)
s.lock.Unlock()
if err != nil {
return err
}
close(s.raftReady)
logging.Infof("Raft server is starting on %s...", s.raftBind)
<-ctx.Done()
logging.Info("Raft server is shutting down ...")
closeErr := s.raftTransport.Close()
s.lock.RLock()
defer s.lock.RUnlock()
if s.raftStore != nil {
closeErr = errors.Join(closeErr, s.raftStore.Close())
}
closeErr = errors.Join(closeErr, s.raft.Shutdown().Error())
if closeErr != nil {
return fmt.Errorf("error shutting down raft server: %w", closeErr)
}
logging.Info("Raft server shutdown")
return nil
}
func (s *Server) bootstrapConfig(peers []PeerInfo) (*raft.Configuration, error) {
hasState, err := raft.HasExistingState(s.logStore, s.stableStore, s.snapStore)
if err != nil {
return nil, err
}
if !hasState {
raftConfig := &raft.Configuration{
Servers: make([]raft.Server, len(peers)),
}
for i, p := range peers {
raftConfig.Servers[i] = raft.Server{
ID: raft.ServerID(p.ID),
Address: raft.ServerAddress(p.Address),
}
}
return raftConfig, nil
}
// return nil for raft.Configuration to use the existing log store files.
return nil, nil
}
func (s *Server) raftStorePath() string {
if s.raftLogStorePath == "" {
return logStorePrefix + s.id
}
return s.raftLogStorePath
}
// FSM returns fsm.
func (s *Server) FSM() *FSM {
return s.fsm
}
// Raft returns raft node.
func (s *Server) Raft(ctx context.Context) (*raft.Raft, error) {
select {
case <-s.raftReady:
case <-ctx.Done():
return nil, errors.New("raft server is not ready in time")
}
s.lock.RLock()
defer s.lock.RUnlock()
return s.raft, nil
}
// IsLeader returns true if the current node is leader.
func (s *Server) IsLeader() bool {
s.lock.RLock()
defer s.lock.RUnlock()
return s.raft != nil && s.raft.State() == raft.Leader
}
// ApplyCommand applies command log to state machine to upsert or remove members.
func (s *Server) ApplyCommand(cmdType CommandType, data DaprHostMember) (bool, error) {
if !s.IsLeader() {
return false, errors.New("this is not the leader node")
}
s.lock.RLock()
defer s.lock.RUnlock()
cmdLog, err := makeRaftLogCommand(cmdType, data)
if err != nil {
return false, err
}
future := s.raft.Apply(cmdLog, commandTimeout)
if err := future.Error(); err != nil {
return false, err
}
resp := future.Response()
return resp.(bool), nil
}
|
mikeee/dapr
|
pkg/placement/raft/server.go
|
GO
|
mit
| 9,837 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"github.com/hashicorp/raft"
)
// snapshot is used to provide a snapshot of the current
// state in a way that can be accessed concurrently with operations
// that may modify the live state.
type snapshot struct {
state *DaprHostMemberState
}
// Persist saves the FSM snapshot out to the given sink.
func (s *snapshot) Persist(sink raft.SnapshotSink) error {
if err := s.state.persist(sink); err != nil {
sink.Cancel()
}
return sink.Close()
}
// Release releases the state storage resource. No-Ops because we use the
// in-memory state.
func (s *snapshot) Release() {}
|
mikeee/dapr
|
pkg/placement/raft/snapshot.go
|
GO
|
mit
| 1,163 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"bytes"
"testing"
"github.com/hashicorp/raft"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type MockSnapShotSink struct {
*bytes.Buffer
cancel bool
}
func (m *MockSnapShotSink) ID() string {
return "Mock"
}
func (m *MockSnapShotSink) Cancel() error {
m.cancel = true
return nil
}
func (m *MockSnapShotSink) Close() error {
return nil
}
func TestPersist(t *testing.T) {
// arrange
fsm := newFSM(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
testMember := DaprHostMember{
Name: "127.0.0.1:3030",
Namespace: "ns1",
AppID: "fakeAppID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
}
cmdLog, _ := makeRaftLogCommand(MemberUpsert, testMember)
raftLog := &raft.Log{
Index: 1,
Term: 1,
Type: raft.LogCommand,
Data: cmdLog,
}
fsm.Apply(raftLog)
buf := bytes.NewBuffer(nil)
fakeSink := &MockSnapShotSink{buf, false}
// act
snap, err := fsm.Snapshot()
require.NoError(t, err)
snap.Persist(fakeSink)
// assert
restoredState := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
err = restoredState.restore(buf)
require.NoError(t, err)
members, err := fsm.State().members("ns1")
require.NoError(t, err)
expectedMember := members[testMember.Name]
restoredMembers, err := restoredState.members("ns1")
require.NoError(t, err)
restoredMember := restoredMembers[testMember.Name]
assert.Equal(t, fsm.State().Index(), restoredState.Index())
assert.Equal(t, expectedMember.Name, restoredMember.Name)
assert.Equal(t, expectedMember.AppID, restoredMember.AppID)
assert.EqualValues(t, expectedMember.Entities, restoredMember.Entities)
}
|
mikeee/dapr
|
pkg/placement/raft/snapshot_test.go
|
GO
|
mit
| 2,352 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"fmt"
"io"
"sync"
"github.com/google/go-cmp/cmp"
"github.com/hashicorp/go-msgpack/v2/codec"
"github.com/dapr/dapr/pkg/placement/hashing"
placementv1pb "github.com/dapr/dapr/pkg/proto/placement/v1"
)
var ErrNamespaceNotFound = fmt.Errorf("namespace not found")
// DaprHostMember represents Dapr runtime actor host member which serve actor types.
type DaprHostMember struct {
// Name is the unique name of Dapr runtime host.
Name string
// AppID is Dapr runtime app ID.
AppID string
// Namespace is the namespace of the Dapr runtime host.
Namespace string
// Entities is the list of Actor Types which this Dapr runtime supports.
Entities []string
// UpdatedAt is the last time when this host member info is updated.
UpdatedAt int64
// Version of the Actor APIs supported by the Dapr runtime
APILevel uint32
}
func (d *DaprHostMember) NamespaceAndName() string {
return d.Namespace + "||" + d.Name
}
// daprNamespace represents Dapr runtime namespace that can contain multiple DaprHostMembers
type daprNamespace struct {
// Members includes Dapr runtime hosts.
Members map[string]*DaprHostMember
// hashingTableMap is the map for storing consistent hashing data
// per Actor types. This will be generated when log entries are replayed.
// While snapshotting the state, this member will not be saved. Instead,
// hashingTableMap will be recovered in snapshot recovery process.
hashingTableMap map[string]*hashing.Consistent
}
// DaprHostMemberStateData is the state that stores Dapr namespace, runtime host and
// consistent hashing tables data
type DaprHostMemberStateData struct {
// Index is the index number of raft log.
Index uint64
// Version of the actor APIs for the cluster
APILevel uint32
// TableGeneration is the generation of hashingTableMap.
// This is increased whenever hashingTableMap is updated.
TableGeneration uint64
Namespace map[string]*daprNamespace
}
func newDaprHostMemberStateData() DaprHostMemberStateData {
return DaprHostMemberStateData{
Namespace: make(map[string]*daprNamespace),
}
}
// DaprHostMemberState is the wrapper over DaprHostMemberStateData that includes
// the cluster config and lock
type DaprHostMemberState struct {
lock sync.RWMutex
config DaprHostMemberStateConfig
data DaprHostMemberStateData
}
// DaprHostMemberStateConfig contains the placement cluster configuration data
// that needs to be consistent across leader changes
type DaprHostMemberStateConfig struct {
replicationFactor int64
minAPILevel uint32
maxAPILevel uint32
}
func newDaprHostMemberState(config DaprHostMemberStateConfig) *DaprHostMemberState {
return &DaprHostMemberState{
config: config,
data: newDaprHostMemberStateData(),
}
}
func (s *DaprHostMemberState) Index() uint64 {
s.lock.RLock()
defer s.lock.RUnlock()
return s.data.Index
}
// APILevel returns the current API level of the cluster.
func (s *DaprHostMemberState) APILevel() uint32 {
s.lock.RLock()
defer s.lock.RUnlock()
return s.data.APILevel
}
// NamespaceCount returns the number of namespaces in the store
func (s *DaprHostMemberState) NamespaceCount() int {
s.lock.RLock()
defer s.lock.RUnlock()
return len(s.data.Namespace)
}
// ForEachNamespace loops through all namespaces and runs the provided function
// Early exit can be achieved by returning false from the provided function
func (s *DaprHostMemberState) ForEachNamespace(fn func(string, *daprNamespace) bool) {
s.lock.Lock()
defer s.lock.Unlock()
for namespace, namespaceData := range s.data.Namespace {
if !fn(namespace, namespaceData) {
break
}
}
}
// ForEachHost loops through hosts across all namespaces and runs the provided function
// Early exit can be achieved by returning false from the provided function
func (s *DaprHostMemberState) ForEachHost(fn func(*DaprHostMember) bool) {
s.lock.Lock()
defer s.lock.Unlock()
outer:
for _, ns := range s.data.Namespace {
for _, host := range ns.Members {
if !fn(host) {
break outer
}
}
}
}
// ForEachHostInNamespace loops through all hosts in a namespace and runs the provided function
// Early exit can be achieved by returning false from the provided function
func (s *DaprHostMemberState) ForEachHostInNamespace(ns string, fn func(*DaprHostMember) bool) {
s.lock.Lock()
defer s.lock.Unlock()
n, ok := s.data.Namespace[ns]
if !ok {
return
}
for _, host := range n.Members {
if !fn(host) {
break
}
}
}
// MemberCount returns number of hosts in a namespace
func (s *DaprHostMemberState) MemberCount() int {
s.lock.RLock()
defer s.lock.RUnlock()
count := 0
for _, ns := range s.data.Namespace {
count += len(ns.Members)
}
return count
}
// MemberCountInNamespace returns number of hosts in a namespace
func (s *DaprHostMemberState) MemberCountInNamespace(ns string) int {
s.lock.RLock()
defer s.lock.RUnlock()
n, ok := s.data.Namespace[ns]
if !ok {
return 0
}
return len(n.Members)
}
// UpsertRequired checks if the newly reported data matches the saved state, or needs to be updated
func (s *DaprHostMemberState) UpsertRequired(ns string, new *placementv1pb.Host) bool {
s.lock.RLock()
defer s.lock.RUnlock()
n, ok := s.data.Namespace[ns]
if !ok {
return true // If the member doesn't exist, we need to upsert
}
if m, ok := n.Members[new.GetName()]; ok {
// If all attributes match, no upsert is required
return !(m.AppID == new.GetId() && m.Name == new.GetName() && cmp.Equal(m.Entities, new.GetEntities()))
}
return true
}
func (s *DaprHostMemberState) TableGeneration() uint64 {
s.lock.RLock()
defer s.lock.RUnlock()
return s.data.TableGeneration
}
// members requires a lock to be held by the caller.
func (s *DaprHostMemberState) members(ns string) (map[string]*DaprHostMember, error) {
n, ok := s.data.Namespace[ns]
if !ok {
return nil, fmt.Errorf("namespace %s not found", ns)
}
return n.Members, nil
}
// allMembers requires a lock to be held by the caller.
func (s *DaprHostMemberState) allMembers() map[string]*DaprHostMember {
members := make(map[string]*DaprHostMember)
for _, ns := range s.data.Namespace {
for k, v := range ns.Members {
members[k] = v
}
}
return members
}
// Internal function that updates the API level in the object.
// The API level can only be increased.
// Make sure you have a Lock before calling this method.
func (s *DaprHostMemberState) updateAPILevel() {
var observedMinLevel uint32
// Loop through all namespaces and members to find the minimum API level
for _, m := range s.allMembers() {
apiLevel := m.APILevel
if apiLevel <= 0 {
apiLevel = 0
}
if observedMinLevel == 0 || observedMinLevel > apiLevel {
observedMinLevel = apiLevel
}
}
// Only enforce minAPILevel if value > 0
// 0 is the default value of the struct.
// -1 is the default value of the CLI flag.
if s.config.minAPILevel >= uint32(0) && observedMinLevel < s.config.minAPILevel {
observedMinLevel = s.config.minAPILevel
}
// Only enforce maxAPILevel if value > 0
// 0 is the default value of the struct.
// -1 is the default value of the CLI flag.
if s.config.maxAPILevel > uint32(0) && observedMinLevel > s.config.maxAPILevel {
observedMinLevel = s.config.maxAPILevel
}
if observedMinLevel > s.data.APILevel {
s.data.APILevel = observedMinLevel
}
}
func (s *DaprHostMemberState) hashingTableMap(ns string) (map[string]*hashing.Consistent, error) {
s.lock.RLock()
defer s.lock.RUnlock()
n, ok := s.data.Namespace[ns]
if !ok {
return nil, ErrNamespaceNotFound
}
return n.hashingTableMap, nil
}
func (s *DaprHostMemberState) clone() *DaprHostMemberState {
s.lock.RLock()
defer s.lock.RUnlock()
newMembers := &DaprHostMemberState{
config: s.config,
data: DaprHostMemberStateData{
Index: s.data.Index,
Namespace: make(map[string]*daprNamespace, len(s.data.Namespace)),
TableGeneration: s.data.TableGeneration,
APILevel: s.data.APILevel,
},
}
for nsName, nsData := range s.data.Namespace {
newMembers.data.Namespace[nsName] = &daprNamespace{
Members: make(map[string]*DaprHostMember, len(nsData.Members)),
// hashingTableMap: make(map[string]*hashing.Consistent, len(nsData.hashingTableMap)),
}
for k, v := range nsData.Members {
m := &DaprHostMember{
Name: v.Name,
Namespace: v.Namespace,
AppID: v.AppID,
Entities: make([]string, len(v.Entities)),
UpdatedAt: v.UpdatedAt,
APILevel: v.APILevel,
}
copy(m.Entities, v.Entities)
newMembers.data.Namespace[nsName].Members[k] = m
}
}
return newMembers
}
// caller should hold Lock.
func (s *DaprHostMemberState) updateHashingTables(host *DaprHostMember) {
if _, ok := s.data.Namespace[host.Namespace]; !ok {
s.data.Namespace[host.Namespace] = &daprNamespace{
Members: make(map[string]*DaprHostMember),
hashingTableMap: make(map[string]*hashing.Consistent),
}
}
for _, e := range host.Entities {
if s.data.Namespace[host.Namespace].hashingTableMap == nil {
s.data.Namespace[host.Namespace].hashingTableMap = make(map[string]*hashing.Consistent)
}
if _, ok := s.data.Namespace[host.Namespace].hashingTableMap[e]; !ok {
s.data.Namespace[host.Namespace].hashingTableMap[e] = hashing.NewConsistentHash(s.config.replicationFactor)
}
s.data.Namespace[host.Namespace].hashingTableMap[e].Add(host.Name, host.AppID, 0)
}
}
// removeHashingTables caller should hold Lock.
func (s *DaprHostMemberState) removeHashingTables(host *DaprHostMember) {
ns, ok := s.data.Namespace[host.Namespace]
if !ok {
return
}
for _, e := range host.Entities {
if t, ok := ns.hashingTableMap[e]; ok {
t.Remove(host.Name)
// if no there are no other actor service instance for the particular actor type
// we should delete the hashing table map element to avoid memory leaks.
if len(t.Hosts()) == 0 {
delete(ns.hashingTableMap, e)
}
}
}
}
// upsertMember upserts member host info to the FSM state and returns true
// if the hashing table update happens.
func (s *DaprHostMemberState) upsertMember(host *DaprHostMember) bool {
if !s.isActorHost(host) {
return false
}
s.lock.Lock()
defer s.lock.Unlock()
ns, ok := s.data.Namespace[host.Namespace]
if !ok {
s.data.Namespace[host.Namespace] = &daprNamespace{
Members: make(map[string]*DaprHostMember),
}
ns = s.data.Namespace[host.Namespace]
}
if m, ok := ns.Members[host.Name]; ok {
// No need to update consistent hashing table if the same dapr host member exists
if m.AppID == host.AppID && m.Name == host.Name && cmp.Equal(m.Entities, host.Entities) {
m.UpdatedAt = host.UpdatedAt
return false
}
// Remove hashing table because the existing member is invalid
// and needs to be updated by new member info.
s.removeHashingTables(m)
}
ns.Members[host.Name] = &DaprHostMember{
Name: host.Name,
Namespace: host.Namespace,
AppID: host.AppID,
UpdatedAt: host.UpdatedAt,
APILevel: host.APILevel,
}
ns.Members[host.Name].Entities = make([]string, len(host.Entities))
copy(ns.Members[host.Name].Entities, host.Entities)
// Update hashing table only when host reports actor types
s.updateHashingTables(ns.Members[host.Name])
s.updateAPILevel()
// Increase hashing table generation version. Runtime will compare the table generation
// version with its own and then update it if it is new.
s.data.TableGeneration++
return true
}
// removeMember removes members from membership and update hashing table and returns true
// if hashing table update happens.
func (s *DaprHostMemberState) removeMember(host *DaprHostMember) bool {
s.lock.Lock()
defer s.lock.Unlock()
ns, ok := s.data.Namespace[host.Namespace]
if !ok {
return false
}
if m, ok := ns.Members[host.Name]; ok {
s.removeHashingTables(m)
s.data.TableGeneration++
delete(ns.Members, host.Name)
s.updateAPILevel()
return true
}
return false
}
func (s *DaprHostMemberState) isActorHost(host *DaprHostMember) bool {
return len(host.Entities) > 0
}
// caller should hold Lock.
func (s *DaprHostMemberState) restoreHashingTables() {
for _, ns := range s.data.Namespace {
if ns.hashingTableMap == nil {
ns.hashingTableMap = map[string]*hashing.Consistent{}
}
for _, m := range ns.Members {
s.updateHashingTables(m)
}
}
}
func (s *DaprHostMemberState) restore(r io.Reader) error {
dec := codec.NewDecoder(r, &codec.MsgpackHandle{})
var data DaprHostMemberStateData
if err := dec.Decode(&data); err != nil {
return err
}
s.lock.Lock()
defer s.lock.Unlock()
s.data = data
s.restoreHashingTables()
s.updateAPILevel()
return nil
}
func (s *DaprHostMemberState) persist(w io.Writer) error {
s.lock.RLock()
defer s.lock.RUnlock()
b, err := marshalMsgPack(s.data)
if err != nil {
return err
}
if _, err := w.Write(b); err != nil {
return err
}
return nil
}
|
mikeee/dapr
|
pkg/placement/raft/state.go
|
GO
|
mit
| 13,445 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"testing"
"github.com/stretchr/testify/require"
)
func TestNewDaprHostMemberState(t *testing.T) {
// act
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
require.Equal(t, uint64(0), s.Index())
require.Equal(t, 0, s.NamespaceCount())
require.Equal(t, 0, s.MemberCount())
}
func TestClone(t *testing.T) {
// arrange
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
s.upsertMember(&DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
})
// act
newState := s.clone()
require.NotSame(t, s, newState)
table, err := newState.hashingTableMap("ns1")
require.NoError(t, err)
require.Nil(t, table)
require.Equal(t, s.Index(), newState.Index())
members, err := s.members("ns1")
require.NoError(t, err)
clonedMembers, err := newState.members("ns1")
require.NoError(t, err)
require.EqualValues(t, members, clonedMembers)
}
func TestUpsertRemoveMembers(t *testing.T) {
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
hostMember := &DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
UpdatedAt: 1,
}
updated := s.upsertMember(hostMember)
m, err := s.members("ns1")
require.NoError(t, err)
ht, err := s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, m, 1)
require.Len(t, m["127.0.0.1:8080"].Entities, 2)
require.Len(t, ht, 2)
require.True(t, updated)
// An existing host starts serving new actor types
hostMember.Entities = []string{"actorTypeThree"}
updated = s.upsertMember(hostMember)
require.True(t, updated)
m, err = s.members("ns1")
require.NoError(t, err)
require.Len(t, m, 1)
require.Len(t, m["127.0.0.1:8080"].Entities, 1)
ht, err = s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, ht, 1)
updated = s.removeMember(hostMember)
m, err = s.members("ns1")
require.NoError(t, err)
require.Empty(t, m)
require.True(t, updated)
ht, err = s.hashingTableMap("ns1")
require.NoError(t, err)
require.Empty(t, ht)
updated = s.removeMember(&DaprHostMember{
Name: "127.0.0.1:8080",
})
require.False(t, updated)
}
func TestUpsertMemberNoHashingTable(t *testing.T) {
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
updated := s.upsertMember(&DaprHostMember{
Name: "127.0.0.1:8081",
Namespace: "ns1",
AppID: "FakeID_2",
Entities: []string{"actorTypeOne", "actorTypeTwo", "actorTypeThree"},
UpdatedAt: 1,
})
m, err := s.members("ns1")
require.NoError(t, err)
ht, err := s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, m, 1)
require.Len(t, ht, 3)
require.True(t, updated)
updated = s.upsertMember(&DaprHostMember{
Name: "127.0.0.1:8081",
Namespace: "ns1",
AppID: "FakeID_2",
Entities: []string{"actorTypeOne", "actorTypeTwo", "actorTypeThree"},
UpdatedAt: 2,
})
require.False(t, updated)
}
func TestUpsertMemberNonActorHost(t *testing.T) {
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
testMember := &DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID",
Entities: []string{},
UpdatedAt: 100,
}
// act
updated := s.upsertMember(testMember)
require.False(t, updated)
}
func TestUpdateHashingTable(t *testing.T) {
// each subtest has dependency on the state
// arrange
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
t.Run("add new hashing table per actor types", func(t *testing.T) {
testMember := &DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
}
// act
s.updateHashingTables(testMember)
ht, err := s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, ht, 2)
require.NotNil(t, ht["actorTypeOne"])
require.NotNil(t, ht["actorTypeTwo"])
})
t.Run("update new hashing table per actor types", func(t *testing.T) {
testMember := &DaprHostMember{
Name: "127.0.0.1:8081",
Namespace: "ns1",
AppID: "FakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo", "actorTypeThree"},
}
s.updateHashingTables(testMember)
ht, err := s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, ht, 3)
require.NotNil(t, ht["actorTypeOne"])
require.NotNil(t, ht["actorTypeTwo"])
require.NotNil(t, ht["actorTypeThree"])
})
}
func TestRemoveHashingTable(t *testing.T) {
testMember := &DaprHostMember{
Name: "fakeName",
Namespace: "ns1",
AppID: "fakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
}
testcases := []struct {
name string
totalTable int
}{
{"127.0.0.1:8080", 2},
{"127.0.0.1:8081", 0},
}
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
for _, tc := range testcases {
testMember.Name = tc.name
s.updateHashingTables(testMember)
}
for _, tc := range testcases {
t.Run("remove host "+tc.name, func(t *testing.T) {
testMember.Name = tc.name
s.removeHashingTables(testMember)
ht, err := s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, ht, tc.totalTable)
})
}
}
func TestRestoreHashingTables(t *testing.T) {
testnames := []string{
"127.0.0.1:8080",
"127.0.0.1:8081",
}
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 100,
})
s.data.Namespace = make(map[string]*daprNamespace)
s.data.Namespace["ns1"] = &daprNamespace{
Members: make(map[string]*DaprHostMember),
}
for _, tn := range testnames {
s.lock.Lock()
s.data.Namespace["ns1"].Members[tn] = &DaprHostMember{
Name: tn,
Namespace: "ns1",
AppID: "fakeID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
}
s.lock.Unlock()
}
ht, err := s.hashingTableMap("ns1")
require.NoError(t, err)
require.Empty(t, ht)
s.restoreHashingTables()
ht, err = s.hashingTableMap("ns1")
require.NoError(t, err)
require.Len(t, ht, 2)
}
func TestUpdateAPILevel(t *testing.T) {
t.Run("no min nor max api levels arguments", func(t *testing.T) {
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
})
m1 := &DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID1",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
UpdatedAt: 1,
APILevel: 10,
}
m2 := &DaprHostMember{
Name: "127.0.0.1:8081",
Namespace: "ns1",
AppID: "FakeID2",
Entities: []string{"actorTypeThree", "actorTypeFour"},
UpdatedAt: 2,
APILevel: 20,
}
m3 := &DaprHostMember{
Name: "127.0.0.1:8082",
Namespace: "ns2",
AppID: "FakeID3",
Entities: []string{"actorTypeFive"},
UpdatedAt: 3,
APILevel: 30,
}
s.upsertMember(m1)
require.Equal(t, uint32(10), s.data.APILevel)
s.upsertMember(m2)
require.Equal(t, uint32(10), s.data.APILevel)
s.upsertMember(m3)
require.Equal(t, uint32(10), s.data.APILevel)
s.removeMember(m1)
require.Equal(t, uint32(20), s.data.APILevel)
s.removeMember(m2)
require.Equal(t, uint32(30), s.data.APILevel)
// TODO @elena - do we want to keep the cluster's last known api level, when all members are removed?
// That's what we do currently, but I wonder why it's the case
s.removeMember(m3)
require.Equal(t, uint32(30), s.data.APILevel)
})
t.Run("min api levels set", func(t *testing.T) {
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 20,
maxAPILevel: 100,
})
m1 := &DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID1",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
UpdatedAt: 1,
APILevel: 10,
}
m2 := &DaprHostMember{
Name: "127.0.0.1:8081",
Namespace: "ns2",
AppID: "FakeID1",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
UpdatedAt: 2,
APILevel: 30,
}
s.upsertMember(m1)
require.Equal(t, uint32(20), s.data.APILevel)
s.upsertMember(m2)
require.Equal(t, uint32(20), s.data.APILevel)
s.removeMember(m1)
require.Equal(t, uint32(30), s.data.APILevel)
})
t.Run("max api levels set", func(t *testing.T) {
s := newDaprHostMemberState(DaprHostMemberStateConfig{
replicationFactor: 10,
minAPILevel: 0,
maxAPILevel: 20,
})
s.upsertMember(&DaprHostMember{
Name: "127.0.0.1:8080",
Namespace: "ns1",
AppID: "FakeID1",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
UpdatedAt: 1,
APILevel: 30,
})
require.Equal(t, uint32(20), s.data.APILevel)
})
}
|
mikeee/dapr
|
pkg/placement/raft/state_test.go
|
GO
|
mit
| 9,778 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"bytes"
"errors"
"os"
"github.com/hashicorp/go-msgpack/v2/codec"
)
const defaultDirPermission = 0o755
func ensureDir(dirName string) error {
info, err := os.Stat(dirName)
if !os.IsNotExist(err) && !info.Mode().IsDir() {
return errors.New("file already existed")
}
err = os.Mkdir(dirName, defaultDirPermission)
if err == nil || os.IsExist(err) {
return nil
}
return err
}
func makeRaftLogCommand(t CommandType, member DaprHostMember) ([]byte, error) {
buf := bytes.NewBuffer(nil)
buf.WriteByte(uint8(t))
err := codec.NewEncoder(buf, &codec.MsgpackHandle{}).Encode(member)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func marshalMsgPack(in interface{}) ([]byte, error) {
buf := bytes.NewBuffer(nil)
enc := codec.NewEncoder(buf, &codec.MsgpackHandle{})
err := enc.Encode(in)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func unmarshalMsgPack(in []byte, out interface{}) error {
dec := codec.NewDecoderBytes(in, &codec.MsgpackHandle{})
return dec.Decode(out)
}
func raftAddressForID(id string, nodes []PeerInfo) string {
for _, node := range nodes {
if node.ID == id {
return node.Address
}
}
return ""
}
|
mikeee/dapr
|
pkg/placement/raft/util.go
|
GO
|
mit
| 1,768 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package raft
import (
"fmt"
"os"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestEnsureDir(t *testing.T) {
testDir := "_testDir"
t.Run("create dir successfully", func(t *testing.T) {
err := ensureDir(testDir)
require.NoError(t, err)
err = os.Remove(testDir)
require.NoError(t, err)
})
t.Run("ensure the existing directory", func(t *testing.T) {
err := os.Mkdir(testDir, 0o700)
require.NoError(t, err)
err = ensureDir(testDir)
require.NoError(t, err)
err = os.Remove(testDir)
require.NoError(t, err)
})
t.Run("fails to create dir", func(t *testing.T) {
file, err := os.Create(testDir)
require.NoError(t, err)
file.Close()
err = ensureDir(testDir)
require.Error(t, err)
err = os.Remove(testDir)
require.NoError(t, err)
})
}
func TestRaftAddressForID(t *testing.T) {
raftAddressTests := []struct {
in []PeerInfo
id string
out string
}{
{
[]PeerInfo{
{ID: "node0", Address: "127.0.0.1:3030"},
{ID: "node1", Address: "127.0.0.1:3031"},
},
"node0",
"127.0.0.1:3030",
}, {
[]PeerInfo{
{ID: "node0", Address: "127.0.0.1:3030"},
},
"node1",
"",
},
}
for _, tt := range raftAddressTests {
t.Run(fmt.Sprintf("find %s from %v", tt.id, tt.in), func(t *testing.T) {
assert.Equal(t, tt.out, raftAddressForID(tt.id, tt.in))
})
}
}
func TestMarshalAndUnmarshalMsgpack(t *testing.T) {
type testStruct struct {
Name string
StringArrayList []string
notSerialized map[string]string
}
testObject := testStruct{
Name: "namevalue",
StringArrayList: []string{"value1", "value2"},
notSerialized: map[string]string{
"key": "value",
},
}
encoded, err := marshalMsgPack(testObject)
require.NoError(t, err)
var decoded testStruct
err = unmarshalMsgPack(encoded, &decoded)
require.NoError(t, err)
assert.Equal(t, testObject.Name, decoded.Name)
assert.Equal(t, testObject.StringArrayList, decoded.StringArrayList)
assert.Nil(t, decoded.notSerialized)
}
func TestMakeRaftLogCommand(t *testing.T) {
// arrange
testMember := DaprHostMember{
Name: "127.0.0.1:3030",
Namespace: "ns1",
AppID: "fakeAppID",
Entities: []string{"actorTypeOne", "actorTypeTwo"},
}
// act
cmdLog, _ := makeRaftLogCommand(MemberUpsert, testMember)
// assert
assert.Equal(t, uint8(MemberUpsert), cmdLog[0])
unmarshaled := DaprHostMember{}
unmarshalMsgPack(cmdLog[1:], &unmarshaled)
assert.EqualValues(t, testMember, unmarshaled)
}
|
mikeee/dapr
|
pkg/placement/raft/util_test.go
|
GO
|
mit
| 3,082 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package placement
import "github.com/dapr/dapr/pkg/placement/raft"
type PlacementTables struct {
HostList []HostInfo `json:"hostList,omitempty"`
TableVersion uint64 `json:"tableVersion"`
APILevel uint32 `json:"apiLevel"`
}
type HostInfo struct {
Name string `json:"name,omitempty"`
Namespace string `json:"namespace,omitempty"`
AppID string `json:"appId,omitempty"`
ActorTypes []string `json:"actorTypes,omitempty"`
UpdatedAt int64 `json:"updatedAt,omitempty"`
APILevel uint32 `json:"apiLevel"`
}
// GetPlacementTables returns the current placement host infos.
func (p *Service) GetPlacementTables() (*PlacementTables, error) {
state := p.raftNode.FSM().State()
response := &PlacementTables{
TableVersion: state.TableGeneration(),
APILevel: state.APILevel(),
}
if response.APILevel < p.minAPILevel {
response.APILevel = p.minAPILevel
}
if p.maxAPILevel != nil && response.APILevel > *p.maxAPILevel {
response.APILevel = *p.maxAPILevel
}
members := make([]HostInfo, 0, state.MemberCount())
state.ForEachHost(func(host *raft.DaprHostMember) bool {
members = append(members, HostInfo{
Name: host.Name,
Namespace: host.Namespace,
AppID: host.AppID,
ActorTypes: host.Entities,
UpdatedAt: host.UpdatedAt,
APILevel: host.APILevel,
})
return true
})
response.HostList = members
return response, nil
}
|
mikeee/dapr
|
pkg/placement/tables.go
|
GO
|
mit
| 1,973 |
/*
Copyright 2024 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package tests
import (
"context"
"fmt"
"log"
"testing"
"time"
clocktesting "k8s.io/utils/clock/testing"
"github.com/dapr/dapr/pkg/placement/raft"
"github.com/dapr/dapr/pkg/security/fake"
daprtesting "github.com/dapr/dapr/pkg/testing"
)
func Raft(t *testing.T) *raft.Server {
t.Helper()
ports, err := daprtesting.GetFreePorts(1)
if err != nil {
log.Fatalf("failed to get test server port: %v", err)
return nil
}
clock := clocktesting.NewFakeClock(time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC))
testRaftServer := raft.New(raft.Options{
ID: "testnode",
InMem: true,
Peers: []raft.PeerInfo{
{
ID: "testnode",
Address: fmt.Sprintf("127.0.0.1:%d", ports[0]),
},
},
LogStorePath: "",
Clock: clock,
})
ctx, cancel := context.WithCancel(context.Background())
serverStopped := make(chan struct{})
go func() {
defer close(serverStopped)
if err := testRaftServer.StartRaft(ctx, fake.New(), nil); err != nil {
log.Fatalf("error running test raft server: %v", err)
}
}()
t.Cleanup(cancel)
// Wait until test raft node become a leader.
//nolint:staticcheck
for range time.Tick(time.Microsecond) {
clock.Step(time.Second * 2)
if testRaftServer.IsLeader() {
break
}
}
// It is painful that we have to include a `time.Sleep` here, but due to the
// non-deterministic behaviour of the raft library we are using we will fail
// later fail on slower test runner machines. A clock timer wait means we
// have a _better_ chance of being in the right spot in the state machine and
// the network has died down. Ideally we should move to a different raft
// library that is more deterministic and reliable for our use case.
time.Sleep(time.Second * 3)
return testRaftServer
}
|
mikeee/dapr
|
pkg/placement/tests/tests.go
|
GO
|
mit
| 2,317 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package ports
import (
"crypto/sha256"
"net"
"os"
"strconv"
"strings"
"github.com/phayes/freeport"
)
// GetStablePort returns an available TCP port.
// It first attempts to get a free port that is between start and start+2047, which is calculated in a deterministic way based on the current process' environment.
// If no available port can be found, it returns a random port (which could be outside of the range defined above).
func GetStablePort(start int, appID string) (int, error) {
// Try determining a "stable" port
// The algorithm considers the following elements to generate a "random-looking", but stable, port number:
// - app-id: app-id values should be unique within a solution
// - Current working directory: allows separating different projects a developer is working on
// - ID of the current user: allows separating different users
// - Hostname: this is also different within each container
parts := make([]string, 4)
parts[0] = appID
parts[1], _ = os.Getwd()
parts[2] = strconv.Itoa(os.Getuid())
parts[3], _ = os.Hostname()
base := []byte(strings.Join(parts, "|"))
// Compute the SHA-256 hash to generate a "random", but stable, sequence of binary values
h := sha256.Sum256(base)
// Get the first 11 bits (0-2047) as "random number"
rnd := int(h[0]) + int(h[1]>>5)<<8
port := start + rnd
// Check if the port is available
addr, err := net.ResolveTCPAddr("tcp", "localhost:"+strconv.Itoa(port))
if err != nil {
// Consider these as hard errors, as it should never happen that a port can't be resolved
return 0, err
}
// Try listening on that port; if it works, assume the port is available
l, err := net.ListenTCP("tcp", addr)
if err == nil {
l.Close()
return port, nil
}
// Fall back to returning a random port
return freeport.GetFreePort()
}
|
mikeee/dapr
|
pkg/ports/ports.go
|
GO
|
mit
| 2,373 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package ports
import (
"net"
"strconv"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestGetStablePort(t *testing.T) {
// Try twice; if there's an error, use a different starting port to avoid conflicts
getPort := func(t *testing.T, appID string) int {
t.Helper()
startPort := 10233
getport:
port, err := GetStablePort(startPort, appID)
if err != nil && startPort == 10233 {
startPort = 22444
goto getport
}
require.NoError(t, err)
return port
}
t.Run("invoking twice should return the same port", func(t *testing.T) {
port1 := getPort(t, "myapp")
assert.True(t, (port1 >= 10233 && port1 <= 12280) || (port1 >= 22444 && port1 <= 24491))
port2 := getPort(t, "myapp")
assert.Equal(t, port1, port2)
})
t.Run("Invoking with a different appID returns a different port", func(t *testing.T) {
port1 := getPort(t, "myapp1")
assert.True(t, (port1 >= 10233 && port1 <= 12280) || (port1 >= 22444 && port1 <= 24491))
port2 := getPort(t, "myapp2")
assert.True(t, (port2 >= 10233 && port2 <= 12280) || (port2 >= 22444 && port2 <= 24491))
assert.NotEqual(t, port1, port2)
})
t.Run("returns a random port if the stable one is busy", func(t *testing.T) {
port1 := getPort(t, "myapp1")
assert.True(t, (port1 >= 10233 && port1 <= 12280) || (port1 >= 22444 && port1 <= 24491))
addr, err := net.ResolveTCPAddr("tcp", "localhost:"+strconv.Itoa(port1))
require.NoError(t, err)
l, err := net.ListenTCP("tcp", addr)
require.NoError(t, err)
defer l.Close()
port2 := getPort(t, "myapp1")
assert.NotEqual(t, port1, port2)
})
}
|
mikeee/dapr
|
pkg/ports/ports_test.go
|
GO
|
mit
| 2,190 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/common/v1/common.proto
package common
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Type of HTTP 1.1 Methods
// RFC 7231: https://tools.ietf.org/html/rfc7231#page-24
// RFC 5789: https://datatracker.ietf.org/doc/html/rfc5789
type HTTPExtension_Verb int32
const (
HTTPExtension_NONE HTTPExtension_Verb = 0
HTTPExtension_GET HTTPExtension_Verb = 1
HTTPExtension_HEAD HTTPExtension_Verb = 2
HTTPExtension_POST HTTPExtension_Verb = 3
HTTPExtension_PUT HTTPExtension_Verb = 4
HTTPExtension_DELETE HTTPExtension_Verb = 5
HTTPExtension_CONNECT HTTPExtension_Verb = 6
HTTPExtension_OPTIONS HTTPExtension_Verb = 7
HTTPExtension_TRACE HTTPExtension_Verb = 8
HTTPExtension_PATCH HTTPExtension_Verb = 9
)
// Enum value maps for HTTPExtension_Verb.
var (
HTTPExtension_Verb_name = map[int32]string{
0: "NONE",
1: "GET",
2: "HEAD",
3: "POST",
4: "PUT",
5: "DELETE",
6: "CONNECT",
7: "OPTIONS",
8: "TRACE",
9: "PATCH",
}
HTTPExtension_Verb_value = map[string]int32{
"NONE": 0,
"GET": 1,
"HEAD": 2,
"POST": 3,
"PUT": 4,
"DELETE": 5,
"CONNECT": 6,
"OPTIONS": 7,
"TRACE": 8,
"PATCH": 9,
}
)
func (x HTTPExtension_Verb) Enum() *HTTPExtension_Verb {
p := new(HTTPExtension_Verb)
*p = x
return p
}
func (x HTTPExtension_Verb) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (HTTPExtension_Verb) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_common_v1_common_proto_enumTypes[0].Descriptor()
}
func (HTTPExtension_Verb) Type() protoreflect.EnumType {
return &file_dapr_proto_common_v1_common_proto_enumTypes[0]
}
func (x HTTPExtension_Verb) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use HTTPExtension_Verb.Descriptor instead.
func (HTTPExtension_Verb) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{0, 0}
}
// Enum describing the supported concurrency for state.
type StateOptions_StateConcurrency int32
const (
StateOptions_CONCURRENCY_UNSPECIFIED StateOptions_StateConcurrency = 0
StateOptions_CONCURRENCY_FIRST_WRITE StateOptions_StateConcurrency = 1
StateOptions_CONCURRENCY_LAST_WRITE StateOptions_StateConcurrency = 2
)
// Enum value maps for StateOptions_StateConcurrency.
var (
StateOptions_StateConcurrency_name = map[int32]string{
0: "CONCURRENCY_UNSPECIFIED",
1: "CONCURRENCY_FIRST_WRITE",
2: "CONCURRENCY_LAST_WRITE",
}
StateOptions_StateConcurrency_value = map[string]int32{
"CONCURRENCY_UNSPECIFIED": 0,
"CONCURRENCY_FIRST_WRITE": 1,
"CONCURRENCY_LAST_WRITE": 2,
}
)
func (x StateOptions_StateConcurrency) Enum() *StateOptions_StateConcurrency {
p := new(StateOptions_StateConcurrency)
*p = x
return p
}
func (x StateOptions_StateConcurrency) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (StateOptions_StateConcurrency) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_common_v1_common_proto_enumTypes[1].Descriptor()
}
func (StateOptions_StateConcurrency) Type() protoreflect.EnumType {
return &file_dapr_proto_common_v1_common_proto_enumTypes[1]
}
func (x StateOptions_StateConcurrency) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use StateOptions_StateConcurrency.Descriptor instead.
func (StateOptions_StateConcurrency) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{6, 0}
}
// Enum describing the supported consistency for state.
type StateOptions_StateConsistency int32
const (
StateOptions_CONSISTENCY_UNSPECIFIED StateOptions_StateConsistency = 0
StateOptions_CONSISTENCY_EVENTUAL StateOptions_StateConsistency = 1
StateOptions_CONSISTENCY_STRONG StateOptions_StateConsistency = 2
)
// Enum value maps for StateOptions_StateConsistency.
var (
StateOptions_StateConsistency_name = map[int32]string{
0: "CONSISTENCY_UNSPECIFIED",
1: "CONSISTENCY_EVENTUAL",
2: "CONSISTENCY_STRONG",
}
StateOptions_StateConsistency_value = map[string]int32{
"CONSISTENCY_UNSPECIFIED": 0,
"CONSISTENCY_EVENTUAL": 1,
"CONSISTENCY_STRONG": 2,
}
)
func (x StateOptions_StateConsistency) Enum() *StateOptions_StateConsistency {
p := new(StateOptions_StateConsistency)
*p = x
return p
}
func (x StateOptions_StateConsistency) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (StateOptions_StateConsistency) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_common_v1_common_proto_enumTypes[2].Descriptor()
}
func (StateOptions_StateConsistency) Type() protoreflect.EnumType {
return &file_dapr_proto_common_v1_common_proto_enumTypes[2]
}
func (x StateOptions_StateConsistency) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use StateOptions_StateConsistency.Descriptor instead.
func (StateOptions_StateConsistency) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{6, 1}
}
// HTTPExtension includes HTTP verb and querystring
// when Dapr runtime delivers HTTP content.
//
// For example, when callers calls http invoke api
// POST http://localhost:3500/v1.0/invoke/<app_id>/method/<method>?query1=value1&query2=value2
//
// Dapr runtime will parse POST as a verb and extract querystring to quersytring map.
type HTTPExtension struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. HTTP verb.
Verb HTTPExtension_Verb `protobuf:"varint,1,opt,name=verb,proto3,enum=dapr.proto.common.v1.HTTPExtension_Verb" json:"verb,omitempty"`
// Optional. querystring represents an encoded HTTP url query string in the following format: name=value&name2=value2
Querystring string `protobuf:"bytes,2,opt,name=querystring,proto3" json:"querystring,omitempty"`
}
func (x *HTTPExtension) Reset() {
*x = HTTPExtension{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HTTPExtension) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HTTPExtension) ProtoMessage() {}
func (x *HTTPExtension) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HTTPExtension.ProtoReflect.Descriptor instead.
func (*HTTPExtension) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{0}
}
func (x *HTTPExtension) GetVerb() HTTPExtension_Verb {
if x != nil {
return x.Verb
}
return HTTPExtension_NONE
}
func (x *HTTPExtension) GetQuerystring() string {
if x != nil {
return x.Querystring
}
return ""
}
// 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.
type InvokeRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. method is a method name which will be invoked by caller.
Method string `protobuf:"bytes,1,opt,name=method,proto3" json:"method,omitempty"`
// 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.
Data *anypb.Any `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// The type of data content.
//
// This field is required if data delivers http request body
// Otherwise, this is optional.
ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
// HTTP specific fields if request conveys http-compatible request.
//
// This field is required for http-compatible request. Otherwise,
// this field is optional.
HttpExtension *HTTPExtension `protobuf:"bytes,4,opt,name=http_extension,json=httpExtension,proto3" json:"http_extension,omitempty"`
}
func (x *InvokeRequest) Reset() {
*x = InvokeRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeRequest) ProtoMessage() {}
func (x *InvokeRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeRequest.ProtoReflect.Descriptor instead.
func (*InvokeRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{1}
}
func (x *InvokeRequest) GetMethod() string {
if x != nil {
return x.Method
}
return ""
}
func (x *InvokeRequest) GetData() *anypb.Any {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeRequest) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
func (x *InvokeRequest) GetHttpExtension() *HTTPExtension {
if x != nil {
return x.HttpExtension
}
return nil
}
// 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.
type InvokeResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required in unary RPCs. The content body of InvokeService response.
Data *anypb.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// Required. The type of data content.
ContentType string `protobuf:"bytes,2,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *InvokeResponse) Reset() {
*x = InvokeResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeResponse) ProtoMessage() {}
func (x *InvokeResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeResponse.ProtoReflect.Descriptor instead.
func (*InvokeResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{2}
}
func (x *InvokeResponse) GetData() *anypb.Any {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeResponse) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
// Chunk of data sent in a streaming request or response.
// This is used in requests including InternalInvokeRequestStream.
type StreamPayload struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 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.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// Sequence number. This is a counter that starts from 0 and increments by 1 on each chunk sent.
Seq uint64 `protobuf:"varint,2,opt,name=seq,proto3" json:"seq,omitempty"`
}
func (x *StreamPayload) Reset() {
*x = StreamPayload{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StreamPayload) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StreamPayload) ProtoMessage() {}
func (x *StreamPayload) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StreamPayload.ProtoReflect.Descriptor instead.
func (*StreamPayload) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{3}
}
func (x *StreamPayload) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *StreamPayload) GetSeq() uint64 {
if x != nil {
return x.Seq
}
return 0
}
// StateItem represents state key, value, and additional options to save state.
type StateItem struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The state key
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// Required. The state data for key
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
// The entity tag which represents the specific version of data.
// The exact ETag format is defined by the corresponding data store.
Etag *Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// The metadata which will be passed to state store component.
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Options for concurrency and consistency to save the state.
Options *StateOptions `protobuf:"bytes,5,opt,name=options,proto3" json:"options,omitempty"`
}
func (x *StateItem) Reset() {
*x = StateItem{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StateItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StateItem) ProtoMessage() {}
func (x *StateItem) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StateItem.ProtoReflect.Descriptor instead.
func (*StateItem) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{4}
}
func (x *StateItem) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *StateItem) GetValue() []byte {
if x != nil {
return x.Value
}
return nil
}
func (x *StateItem) GetEtag() *Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *StateItem) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *StateItem) GetOptions() *StateOptions {
if x != nil {
return x.Options
}
return nil
}
// Etag represents a state item version
type Etag struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// value sets the etag value
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}
func (x *Etag) Reset() {
*x = Etag{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Etag) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Etag) ProtoMessage() {}
func (x *Etag) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Etag.ProtoReflect.Descriptor instead.
func (*Etag) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{5}
}
func (x *Etag) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
// StateOptions configures concurrency and consistency for state operations
type StateOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Concurrency StateOptions_StateConcurrency `protobuf:"varint,1,opt,name=concurrency,proto3,enum=dapr.proto.common.v1.StateOptions_StateConcurrency" json:"concurrency,omitempty"`
Consistency StateOptions_StateConsistency `protobuf:"varint,2,opt,name=consistency,proto3,enum=dapr.proto.common.v1.StateOptions_StateConsistency" json:"consistency,omitempty"`
}
func (x *StateOptions) Reset() {
*x = StateOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StateOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StateOptions) ProtoMessage() {}
func (x *StateOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StateOptions.ProtoReflect.Descriptor instead.
func (*StateOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{6}
}
func (x *StateOptions) GetConcurrency() StateOptions_StateConcurrency {
if x != nil {
return x.Concurrency
}
return StateOptions_CONCURRENCY_UNSPECIFIED
}
func (x *StateOptions) GetConsistency() StateOptions_StateConsistency {
if x != nil {
return x.Consistency
}
return StateOptions_CONSISTENCY_UNSPECIFIED
}
// ConfigurationItem represents all the configuration with its name(key).
type ConfigurationItem struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The value of configuration item.
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
// Version is response only and cannot be fetched. Store is not expected to keep all versions available
Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
// the metadata which will be passed to/from configuration store component.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *ConfigurationItem) Reset() {
*x = ConfigurationItem{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ConfigurationItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ConfigurationItem) ProtoMessage() {}
func (x *ConfigurationItem) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_common_v1_common_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ConfigurationItem.ProtoReflect.Descriptor instead.
func (*ConfigurationItem) Descriptor() ([]byte, []int) {
return file_dapr_proto_common_v1_common_proto_rawDescGZIP(), []int{7}
}
func (x *ConfigurationItem) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
func (x *ConfigurationItem) GetVersion() string {
if x != nil {
return x.Version
}
return ""
}
func (x *ConfigurationItem) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
var File_dapr_proto_common_v1_common_proto protoreflect.FileDescriptor
var file_dapr_proto_common_v1_common_proto_rawDesc = []byte{
0x0a, 0x21, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d,
0x6d, 0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x12, 0x14, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe3, 0x01, 0x0a, 0x0d, 0x48, 0x54, 0x54, 0x50, 0x45, 0x78, 0x74,
0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3c, 0x0a, 0x04, 0x76, 0x65, 0x72, 0x62, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0e, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x54, 0x54, 0x50,
0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x65, 0x72, 0x62, 0x52, 0x04,
0x76, 0x65, 0x72, 0x62, 0x12, 0x20, 0x0a, 0x0b, 0x71, 0x75, 0x65, 0x72, 0x79, 0x73, 0x74, 0x72,
0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x71, 0x75, 0x65, 0x72, 0x79,
0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x72, 0x0a, 0x04, 0x56, 0x65, 0x72, 0x62, 0x12, 0x08,
0x0a, 0x04, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x47, 0x45, 0x54, 0x10,
0x01, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x45, 0x41, 0x44, 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x50,
0x4f, 0x53, 0x54, 0x10, 0x03, 0x12, 0x07, 0x0a, 0x03, 0x50, 0x55, 0x54, 0x10, 0x04, 0x12, 0x0a,
0x0a, 0x06, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x05, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x4f,
0x4e, 0x4e, 0x45, 0x43, 0x54, 0x10, 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x50, 0x54, 0x49, 0x4f,
0x4e, 0x53, 0x10, 0x07, 0x12, 0x09, 0x0a, 0x05, 0x54, 0x52, 0x41, 0x43, 0x45, 0x10, 0x08, 0x12,
0x09, 0x0a, 0x05, 0x50, 0x41, 0x54, 0x43, 0x48, 0x10, 0x09, 0x22, 0xc0, 0x01, 0x0a, 0x0d, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06,
0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65,
0x74, 0x68, 0x6f, 0x64, 0x12, 0x28, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21,
0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03,
0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70,
0x65, 0x12, 0x4a, 0x0a, 0x0e, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31,
0x2e, 0x48, 0x54, 0x54, 0x50, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0d,
0x68, 0x74, 0x74, 0x70, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x5d, 0x0a,
0x0e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x28, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x41, 0x6e, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e,
0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x35, 0x0a, 0x0d,
0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x12, 0x0a,
0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74,
0x61, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x65, 0x71, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03,
0x73, 0x65, 0x71, 0x22, 0xa9, 0x02, 0x0a, 0x09, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65,
0x6d, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x65, 0x74, 0x61,
0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x45,
0x74, 0x61, 0x67, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x49, 0x0a, 0x08, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e,
0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x12, 0x3c, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61,
0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22,
0x1c, 0x0a, 0x04, 0x45, 0x74, 0x61, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x89, 0x03,
0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x55,
0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0e, 0x32, 0x33, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65,
0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e,
0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72,
0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x55, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74,
0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x33, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76,
0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x53,
0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x52,
0x0b, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x22, 0x68, 0x0a, 0x10,
0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79,
0x12, 0x1b, 0x0a, 0x17, 0x43, 0x4f, 0x4e, 0x43, 0x55, 0x52, 0x52, 0x45, 0x4e, 0x43, 0x59, 0x5f,
0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1b, 0x0a,
0x17, 0x43, 0x4f, 0x4e, 0x43, 0x55, 0x52, 0x52, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x46, 0x49, 0x52,
0x53, 0x54, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x43, 0x4f,
0x4e, 0x43, 0x55, 0x52, 0x52, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x4c, 0x41, 0x53, 0x54, 0x5f, 0x57,
0x52, 0x49, 0x54, 0x45, 0x10, 0x02, 0x22, 0x61, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43,
0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x4f,
0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43,
0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x4f, 0x4e, 0x53, 0x49,
0x53, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x55, 0x41, 0x4c, 0x10,
0x01, 0x12, 0x16, 0x0a, 0x12, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x43, 0x59,
0x5f, 0x53, 0x54, 0x52, 0x4f, 0x4e, 0x47, 0x10, 0x02, 0x22, 0xd3, 0x01, 0x0a, 0x11, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x12,
0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
0x51, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42,
0x69, 0x0a, 0x0a, 0x69, 0x6f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x0c, 0x43,
0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x5a, 0x2f, 0x67, 0x69, 0x74,
0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70,
0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x6d,
0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0xaa, 0x02, 0x1b, 0x44,
0x61, 0x70, 0x72, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x67,
0x65, 0x6e, 0x2e, 0x47, 0x72, 0x70, 0x63, 0x2e, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x33,
}
var (
file_dapr_proto_common_v1_common_proto_rawDescOnce sync.Once
file_dapr_proto_common_v1_common_proto_rawDescData = file_dapr_proto_common_v1_common_proto_rawDesc
)
func file_dapr_proto_common_v1_common_proto_rawDescGZIP() []byte {
file_dapr_proto_common_v1_common_proto_rawDescOnce.Do(func() {
file_dapr_proto_common_v1_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_common_v1_common_proto_rawDescData)
})
return file_dapr_proto_common_v1_common_proto_rawDescData
}
var file_dapr_proto_common_v1_common_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_dapr_proto_common_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
var file_dapr_proto_common_v1_common_proto_goTypes = []interface{}{
(HTTPExtension_Verb)(0), // 0: dapr.proto.common.v1.HTTPExtension.Verb
(StateOptions_StateConcurrency)(0), // 1: dapr.proto.common.v1.StateOptions.StateConcurrency
(StateOptions_StateConsistency)(0), // 2: dapr.proto.common.v1.StateOptions.StateConsistency
(*HTTPExtension)(nil), // 3: dapr.proto.common.v1.HTTPExtension
(*InvokeRequest)(nil), // 4: dapr.proto.common.v1.InvokeRequest
(*InvokeResponse)(nil), // 5: dapr.proto.common.v1.InvokeResponse
(*StreamPayload)(nil), // 6: dapr.proto.common.v1.StreamPayload
(*StateItem)(nil), // 7: dapr.proto.common.v1.StateItem
(*Etag)(nil), // 8: dapr.proto.common.v1.Etag
(*StateOptions)(nil), // 9: dapr.proto.common.v1.StateOptions
(*ConfigurationItem)(nil), // 10: dapr.proto.common.v1.ConfigurationItem
nil, // 11: dapr.proto.common.v1.StateItem.MetadataEntry
nil, // 12: dapr.proto.common.v1.ConfigurationItem.MetadataEntry
(*anypb.Any)(nil), // 13: google.protobuf.Any
}
var file_dapr_proto_common_v1_common_proto_depIdxs = []int32{
0, // 0: dapr.proto.common.v1.HTTPExtension.verb:type_name -> dapr.proto.common.v1.HTTPExtension.Verb
13, // 1: dapr.proto.common.v1.InvokeRequest.data:type_name -> google.protobuf.Any
3, // 2: dapr.proto.common.v1.InvokeRequest.http_extension:type_name -> dapr.proto.common.v1.HTTPExtension
13, // 3: dapr.proto.common.v1.InvokeResponse.data:type_name -> google.protobuf.Any
8, // 4: dapr.proto.common.v1.StateItem.etag:type_name -> dapr.proto.common.v1.Etag
11, // 5: dapr.proto.common.v1.StateItem.metadata:type_name -> dapr.proto.common.v1.StateItem.MetadataEntry
9, // 6: dapr.proto.common.v1.StateItem.options:type_name -> dapr.proto.common.v1.StateOptions
1, // 7: dapr.proto.common.v1.StateOptions.concurrency:type_name -> dapr.proto.common.v1.StateOptions.StateConcurrency
2, // 8: dapr.proto.common.v1.StateOptions.consistency:type_name -> dapr.proto.common.v1.StateOptions.StateConsistency
12, // 9: dapr.proto.common.v1.ConfigurationItem.metadata:type_name -> dapr.proto.common.v1.ConfigurationItem.MetadataEntry
10, // [10:10] is the sub-list for method output_type
10, // [10:10] is the sub-list for method input_type
10, // [10:10] is the sub-list for extension type_name
10, // [10:10] is the sub-list for extension extendee
0, // [0:10] is the sub-list for field type_name
}
func init() { file_dapr_proto_common_v1_common_proto_init() }
func file_dapr_proto_common_v1_common_proto_init() {
if File_dapr_proto_common_v1_common_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_common_v1_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HTTPExtension); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StreamPayload); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StateItem); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Etag); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StateOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_common_v1_common_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ConfigurationItem); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_common_v1_common_proto_rawDesc,
NumEnums: 3,
NumMessages: 10,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_dapr_proto_common_v1_common_proto_goTypes,
DependencyIndexes: file_dapr_proto_common_v1_common_proto_depIdxs,
EnumInfos: file_dapr_proto_common_v1_common_proto_enumTypes,
MessageInfos: file_dapr_proto_common_v1_common_proto_msgTypes,
}.Build()
File_dapr_proto_common_v1_common_proto = out.File
file_dapr_proto_common_v1_common_proto_rawDesc = nil
file_dapr_proto_common_v1_common_proto_goTypes = nil
file_dapr_proto_common_v1_common_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/common/v1/common.pb.go
|
GO
|
mit
| 38,894 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/components/v1/bindings.proto
package components
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// reserved for future-proof extensibility
type ListOperationsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *ListOperationsRequest) Reset() {
*x = ListOperationsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListOperationsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListOperationsRequest) ProtoMessage() {}
func (x *ListOperationsRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListOperationsRequest.ProtoReflect.Descriptor instead.
func (*ListOperationsRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{0}
}
type ListOperationsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// the list of all supported component operations.
Operations []string `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"`
}
func (x *ListOperationsResponse) Reset() {
*x = ListOperationsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListOperationsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListOperationsResponse) ProtoMessage() {}
func (x *ListOperationsResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListOperationsResponse.ProtoReflect.Descriptor instead.
func (*ListOperationsResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{1}
}
func (x *ListOperationsResponse) GetOperations() []string {
if x != nil {
return x.Operations
}
return nil
}
// InputBindingInitRequest is the request for initializing the input binding
// component.
type InputBindingInitRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The metadata request.
Metadata *MetadataRequest `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
}
func (x *InputBindingInitRequest) Reset() {
*x = InputBindingInitRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InputBindingInitRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InputBindingInitRequest) ProtoMessage() {}
func (x *InputBindingInitRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InputBindingInitRequest.ProtoReflect.Descriptor instead.
func (*InputBindingInitRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{2}
}
func (x *InputBindingInitRequest) GetMetadata() *MetadataRequest {
if x != nil {
return x.Metadata
}
return nil
}
// reserved for future-proof extensibility
type InputBindingInitResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *InputBindingInitResponse) Reset() {
*x = InputBindingInitResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InputBindingInitResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InputBindingInitResponse) ProtoMessage() {}
func (x *InputBindingInitResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InputBindingInitResponse.ProtoReflect.Descriptor instead.
func (*InputBindingInitResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{3}
}
// OutputBindingInitRequest is the request for initializing the output binding
// component.
type OutputBindingInitRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The metadata request.
Metadata *MetadataRequest `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
}
func (x *OutputBindingInitRequest) Reset() {
*x = OutputBindingInitRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *OutputBindingInitRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*OutputBindingInitRequest) ProtoMessage() {}
func (x *OutputBindingInitRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use OutputBindingInitRequest.ProtoReflect.Descriptor instead.
func (*OutputBindingInitRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{4}
}
func (x *OutputBindingInitRequest) GetMetadata() *MetadataRequest {
if x != nil {
return x.Metadata
}
return nil
}
// reserved for future-proof extensibility
type OutputBindingInitResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *OutputBindingInitResponse) Reset() {
*x = OutputBindingInitResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *OutputBindingInitResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*OutputBindingInitResponse) ProtoMessage() {}
func (x *OutputBindingInitResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use OutputBindingInitResponse.ProtoReflect.Descriptor instead.
func (*OutputBindingInitResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{5}
}
// Used for describing errors when ack'ing messages.
type AckResponseError struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}
func (x *AckResponseError) Reset() {
*x = AckResponseError{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AckResponseError) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AckResponseError) ProtoMessage() {}
func (x *AckResponseError) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AckResponseError.ProtoReflect.Descriptor instead.
func (*AckResponseError) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{6}
}
func (x *AckResponseError) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
type ReadRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The handle response.
ResponseData []byte `protobuf:"bytes,1,opt,name=response_data,json=responseData,proto3" json:"response_data,omitempty"`
// The unique message ID.
MessageId string `protobuf:"bytes,2,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
// Optional, should not be fulfilled when the message was successfully
// handled.
ResponseError *AckResponseError `protobuf:"bytes,3,opt,name=response_error,json=responseError,proto3" json:"response_error,omitempty"`
}
func (x *ReadRequest) Reset() {
*x = ReadRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ReadRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReadRequest) ProtoMessage() {}
func (x *ReadRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ReadRequest.ProtoReflect.Descriptor instead.
func (*ReadRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{7}
}
func (x *ReadRequest) GetResponseData() []byte {
if x != nil {
return x.ResponseData
}
return nil
}
func (x *ReadRequest) GetMessageId() string {
if x != nil {
return x.MessageId
}
return ""
}
func (x *ReadRequest) GetResponseError() *AckResponseError {
if x != nil {
return x.ResponseError
}
return nil
}
type ReadResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The Read binding Data.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The message metadata
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The message content type.
ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
// The {transient} message ID used for ACK-ing it later.
MessageId string `protobuf:"bytes,4,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
}
func (x *ReadResponse) Reset() {
*x = ReadResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ReadResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ReadResponse) ProtoMessage() {}
func (x *ReadResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ReadResponse.ProtoReflect.Descriptor instead.
func (*ReadResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{8}
}
func (x *ReadResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *ReadResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *ReadResponse) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
func (x *ReadResponse) GetMessageId() string {
if x != nil {
return x.MessageId
}
return ""
}
// Used for invoking systems with optional payload.
type InvokeRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The invoke payload.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The invoke metadata.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The system supported operation.
Operation string `protobuf:"bytes,3,opt,name=operation,proto3" json:"operation,omitempty"`
}
func (x *InvokeRequest) Reset() {
*x = InvokeRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeRequest) ProtoMessage() {}
func (x *InvokeRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeRequest.ProtoReflect.Descriptor instead.
func (*InvokeRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{9}
}
func (x *InvokeRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *InvokeRequest) GetOperation() string {
if x != nil {
return x.Operation
}
return ""
}
// Response from the invoked system.
type InvokeResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The response payload.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The response metadata.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The response content-type.
ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *InvokeResponse) Reset() {
*x = InvokeResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeResponse) ProtoMessage() {}
func (x *InvokeResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_bindings_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeResponse.ProtoReflect.Descriptor instead.
func (*InvokeResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_bindings_proto_rawDescGZIP(), []int{10}
}
func (x *InvokeResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *InvokeResponse) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
var File_dapr_proto_components_v1_bindings_proto protoreflect.FileDescriptor
var file_dapr_proto_components_v1_bindings_proto_rawDesc = []byte{
0x0a, 0x27, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x69, 0x6e, 0x64, 0x69,
0x6e, 0x67, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
0x2e, 0x76, 0x31, 0x1a, 0x25, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f,
0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x17, 0x0a, 0x15, 0x4c, 0x69,
0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x22, 0x38, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a,
0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x09, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x60, 0x0a,
0x17, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x69,
0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22,
0x1a, 0x0a, 0x18, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49,
0x6e, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x61, 0x0a, 0x18, 0x4f,
0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x69, 0x74,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x1b,
0x0a, 0x19, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49,
0x6e, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2c, 0x0a, 0x10, 0x41,
0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12,
0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xa4, 0x01, 0x0a, 0x0b, 0x52, 0x65,
0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
0x52, 0x0c, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1d,
0x0a, 0x0a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x09, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x49, 0x64, 0x12, 0x51, 0x0a,
0x0e, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18,
0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x41, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x72, 0x72, 0x6f,
0x72, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72,
0x22, 0xf3, 0x01, 0x0a, 0x0c, 0x52, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x50, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65,
0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63,
0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x6d, 0x65,
0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x49, 0x64, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd1, 0x01, 0x0a, 0x0d, 0x49, 0x6e, 0x76, 0x6f, 0x6b,
0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x51, 0x0a, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12,
0x1c, 0x0a, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01,
0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x3b, 0x0a,
0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd8, 0x01, 0x0a, 0x0e, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a,
0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74,
0x61, 0x12, 0x52, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e,
0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x32, 0xb5, 0x02, 0x0a, 0x0c, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x42,
0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x6f, 0x0a, 0x04, 0x49, 0x6e, 0x69, 0x74, 0x12, 0x31,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x42,
0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x70,
0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x04, 0x52, 0x65, 0x61, 0x64, 0x12,
0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
0x28, 0x01, 0x30, 0x01, 0x12, 0x57, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50,
0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x32, 0xb1, 0x03,
0x0a, 0x0d, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12,
0x71, 0x0a, 0x04, 0x49, 0x6e, 0x69, 0x74, 0x12, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67,
0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e,
0x64, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x12, 0x5d, 0x0a, 0x06, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x12, 0x27, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x00, 0x12, 0x75, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x12, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4c,
0x69, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e,
0x4c, 0x69, 0x73, 0x74, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67,
0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x00, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76,
0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_components_v1_bindings_proto_rawDescOnce sync.Once
file_dapr_proto_components_v1_bindings_proto_rawDescData = file_dapr_proto_components_v1_bindings_proto_rawDesc
)
func file_dapr_proto_components_v1_bindings_proto_rawDescGZIP() []byte {
file_dapr_proto_components_v1_bindings_proto_rawDescOnce.Do(func() {
file_dapr_proto_components_v1_bindings_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_components_v1_bindings_proto_rawDescData)
})
return file_dapr_proto_components_v1_bindings_proto_rawDescData
}
var file_dapr_proto_components_v1_bindings_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_dapr_proto_components_v1_bindings_proto_goTypes = []interface{}{
(*ListOperationsRequest)(nil), // 0: dapr.proto.components.v1.ListOperationsRequest
(*ListOperationsResponse)(nil), // 1: dapr.proto.components.v1.ListOperationsResponse
(*InputBindingInitRequest)(nil), // 2: dapr.proto.components.v1.InputBindingInitRequest
(*InputBindingInitResponse)(nil), // 3: dapr.proto.components.v1.InputBindingInitResponse
(*OutputBindingInitRequest)(nil), // 4: dapr.proto.components.v1.OutputBindingInitRequest
(*OutputBindingInitResponse)(nil), // 5: dapr.proto.components.v1.OutputBindingInitResponse
(*AckResponseError)(nil), // 6: dapr.proto.components.v1.AckResponseError
(*ReadRequest)(nil), // 7: dapr.proto.components.v1.ReadRequest
(*ReadResponse)(nil), // 8: dapr.proto.components.v1.ReadResponse
(*InvokeRequest)(nil), // 9: dapr.proto.components.v1.InvokeRequest
(*InvokeResponse)(nil), // 10: dapr.proto.components.v1.InvokeResponse
nil, // 11: dapr.proto.components.v1.ReadResponse.MetadataEntry
nil, // 12: dapr.proto.components.v1.InvokeRequest.MetadataEntry
nil, // 13: dapr.proto.components.v1.InvokeResponse.MetadataEntry
(*MetadataRequest)(nil), // 14: dapr.proto.components.v1.MetadataRequest
(*PingRequest)(nil), // 15: dapr.proto.components.v1.PingRequest
(*PingResponse)(nil), // 16: dapr.proto.components.v1.PingResponse
}
var file_dapr_proto_components_v1_bindings_proto_depIdxs = []int32{
14, // 0: dapr.proto.components.v1.InputBindingInitRequest.metadata:type_name -> dapr.proto.components.v1.MetadataRequest
14, // 1: dapr.proto.components.v1.OutputBindingInitRequest.metadata:type_name -> dapr.proto.components.v1.MetadataRequest
6, // 2: dapr.proto.components.v1.ReadRequest.response_error:type_name -> dapr.proto.components.v1.AckResponseError
11, // 3: dapr.proto.components.v1.ReadResponse.metadata:type_name -> dapr.proto.components.v1.ReadResponse.MetadataEntry
12, // 4: dapr.proto.components.v1.InvokeRequest.metadata:type_name -> dapr.proto.components.v1.InvokeRequest.MetadataEntry
13, // 5: dapr.proto.components.v1.InvokeResponse.metadata:type_name -> dapr.proto.components.v1.InvokeResponse.MetadataEntry
2, // 6: dapr.proto.components.v1.InputBinding.Init:input_type -> dapr.proto.components.v1.InputBindingInitRequest
7, // 7: dapr.proto.components.v1.InputBinding.Read:input_type -> dapr.proto.components.v1.ReadRequest
15, // 8: dapr.proto.components.v1.InputBinding.Ping:input_type -> dapr.proto.components.v1.PingRequest
4, // 9: dapr.proto.components.v1.OutputBinding.Init:input_type -> dapr.proto.components.v1.OutputBindingInitRequest
9, // 10: dapr.proto.components.v1.OutputBinding.Invoke:input_type -> dapr.proto.components.v1.InvokeRequest
0, // 11: dapr.proto.components.v1.OutputBinding.ListOperations:input_type -> dapr.proto.components.v1.ListOperationsRequest
15, // 12: dapr.proto.components.v1.OutputBinding.Ping:input_type -> dapr.proto.components.v1.PingRequest
3, // 13: dapr.proto.components.v1.InputBinding.Init:output_type -> dapr.proto.components.v1.InputBindingInitResponse
8, // 14: dapr.proto.components.v1.InputBinding.Read:output_type -> dapr.proto.components.v1.ReadResponse
16, // 15: dapr.proto.components.v1.InputBinding.Ping:output_type -> dapr.proto.components.v1.PingResponse
5, // 16: dapr.proto.components.v1.OutputBinding.Init:output_type -> dapr.proto.components.v1.OutputBindingInitResponse
10, // 17: dapr.proto.components.v1.OutputBinding.Invoke:output_type -> dapr.proto.components.v1.InvokeResponse
1, // 18: dapr.proto.components.v1.OutputBinding.ListOperations:output_type -> dapr.proto.components.v1.ListOperationsResponse
16, // 19: dapr.proto.components.v1.OutputBinding.Ping:output_type -> dapr.proto.components.v1.PingResponse
13, // [13:20] is the sub-list for method output_type
6, // [6:13] is the sub-list for method input_type
6, // [6:6] is the sub-list for extension type_name
6, // [6:6] is the sub-list for extension extendee
0, // [0:6] is the sub-list for field type_name
}
func init() { file_dapr_proto_components_v1_bindings_proto_init() }
func file_dapr_proto_components_v1_bindings_proto_init() {
if File_dapr_proto_components_v1_bindings_proto != nil {
return
}
file_dapr_proto_components_v1_common_proto_init()
if !protoimpl.UnsafeEnabled {
file_dapr_proto_components_v1_bindings_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListOperationsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListOperationsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InputBindingInitRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InputBindingInitResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*OutputBindingInitRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*OutputBindingInitResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AckResponseError); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ReadRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ReadResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_bindings_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_components_v1_bindings_proto_rawDesc,
NumEnums: 0,
NumMessages: 14,
NumExtensions: 0,
NumServices: 2,
},
GoTypes: file_dapr_proto_components_v1_bindings_proto_goTypes,
DependencyIndexes: file_dapr_proto_components_v1_bindings_proto_depIdxs,
MessageInfos: file_dapr_proto_components_v1_bindings_proto_msgTypes,
}.Build()
File_dapr_proto_components_v1_bindings_proto = out.File
file_dapr_proto_components_v1_bindings_proto_rawDesc = nil
file_dapr_proto_components_v1_bindings_proto_goTypes = nil
file_dapr_proto_components_v1_bindings_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/components/v1/bindings.pb.go
|
GO
|
mit
| 40,293 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/components/v1/bindings.proto
package components
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
InputBinding_Init_FullMethodName = "/dapr.proto.components.v1.InputBinding/Init"
InputBinding_Read_FullMethodName = "/dapr.proto.components.v1.InputBinding/Read"
InputBinding_Ping_FullMethodName = "/dapr.proto.components.v1.InputBinding/Ping"
)
// InputBindingClient is the client API for InputBinding service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type InputBindingClient interface {
// Initializes the inputbinding component component with the given metadata.
Init(ctx context.Context, in *InputBindingInitRequest, opts ...grpc.CallOption) (*InputBindingInitResponse, error)
// Establishes a stream with the server, which sends messages down to the
// client. The client streams acknowledgements back to the server. The server
// will close the stream and return the status on any error. In case of closed
// connection, the client should re-establish the stream.
Read(ctx context.Context, opts ...grpc.CallOption) (InputBinding_ReadClient, error)
// Ping the InputBinding. Used for liveness porpuses.
Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
}
type inputBindingClient struct {
cc grpc.ClientConnInterface
}
func NewInputBindingClient(cc grpc.ClientConnInterface) InputBindingClient {
return &inputBindingClient{cc}
}
func (c *inputBindingClient) Init(ctx context.Context, in *InputBindingInitRequest, opts ...grpc.CallOption) (*InputBindingInitResponse, error) {
out := new(InputBindingInitResponse)
err := c.cc.Invoke(ctx, InputBinding_Init_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *inputBindingClient) Read(ctx context.Context, opts ...grpc.CallOption) (InputBinding_ReadClient, error) {
stream, err := c.cc.NewStream(ctx, &InputBinding_ServiceDesc.Streams[0], InputBinding_Read_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &inputBindingReadClient{stream}
return x, nil
}
type InputBinding_ReadClient interface {
Send(*ReadRequest) error
Recv() (*ReadResponse, error)
grpc.ClientStream
}
type inputBindingReadClient struct {
grpc.ClientStream
}
func (x *inputBindingReadClient) Send(m *ReadRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *inputBindingReadClient) Recv() (*ReadResponse, error) {
m := new(ReadResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *inputBindingClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
out := new(PingResponse)
err := c.cc.Invoke(ctx, InputBinding_Ping_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// InputBindingServer is the server API for InputBinding service.
// All implementations should embed UnimplementedInputBindingServer
// for forward compatibility
type InputBindingServer interface {
// Initializes the inputbinding component component with the given metadata.
Init(context.Context, *InputBindingInitRequest) (*InputBindingInitResponse, error)
// Establishes a stream with the server, which sends messages down to the
// client. The client streams acknowledgements back to the server. The server
// will close the stream and return the status on any error. In case of closed
// connection, the client should re-establish the stream.
Read(InputBinding_ReadServer) error
// Ping the InputBinding. Used for liveness porpuses.
Ping(context.Context, *PingRequest) (*PingResponse, error)
}
// UnimplementedInputBindingServer should be embedded to have forward compatible implementations.
type UnimplementedInputBindingServer struct {
}
func (UnimplementedInputBindingServer) Init(context.Context, *InputBindingInitRequest) (*InputBindingInitResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (UnimplementedInputBindingServer) Read(InputBinding_ReadServer) error {
return status.Errorf(codes.Unimplemented, "method Read not implemented")
}
func (UnimplementedInputBindingServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
// UnsafeInputBindingServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to InputBindingServer will
// result in compilation errors.
type UnsafeInputBindingServer interface {
mustEmbedUnimplementedInputBindingServer()
}
func RegisterInputBindingServer(s grpc.ServiceRegistrar, srv InputBindingServer) {
s.RegisterService(&InputBinding_ServiceDesc, srv)
}
func _InputBinding_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InputBindingInitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(InputBindingServer).Init(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: InputBinding_Init_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(InputBindingServer).Init(ctx, req.(*InputBindingInitRequest))
}
return interceptor(ctx, in, info, handler)
}
func _InputBinding_Read_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(InputBindingServer).Read(&inputBindingReadServer{stream})
}
type InputBinding_ReadServer interface {
Send(*ReadResponse) error
Recv() (*ReadRequest, error)
grpc.ServerStream
}
type inputBindingReadServer struct {
grpc.ServerStream
}
func (x *inputBindingReadServer) Send(m *ReadResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *inputBindingReadServer) Recv() (*ReadRequest, error) {
m := new(ReadRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _InputBinding_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(InputBindingServer).Ping(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: InputBinding_Ping_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(InputBindingServer).Ping(ctx, req.(*PingRequest))
}
return interceptor(ctx, in, info, handler)
}
// InputBinding_ServiceDesc is the grpc.ServiceDesc for InputBinding service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InputBinding_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.InputBinding",
HandlerType: (*InputBindingServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Init",
Handler: _InputBinding_Init_Handler,
},
{
MethodName: "Ping",
Handler: _InputBinding_Ping_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "Read",
Handler: _InputBinding_Read_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "dapr/proto/components/v1/bindings.proto",
}
const (
OutputBinding_Init_FullMethodName = "/dapr.proto.components.v1.OutputBinding/Init"
OutputBinding_Invoke_FullMethodName = "/dapr.proto.components.v1.OutputBinding/Invoke"
OutputBinding_ListOperations_FullMethodName = "/dapr.proto.components.v1.OutputBinding/ListOperations"
OutputBinding_Ping_FullMethodName = "/dapr.proto.components.v1.OutputBinding/Ping"
)
// OutputBindingClient is the client API for OutputBinding service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type OutputBindingClient interface {
// Initializes the outputbinding component component with the given metadata.
Init(ctx context.Context, in *OutputBindingInitRequest, opts ...grpc.CallOption) (*OutputBindingInitResponse, error)
// Invoke remote systems with optional payloads.
Invoke(ctx context.Context, in *InvokeRequest, opts ...grpc.CallOption) (*InvokeResponse, error)
// ListOperations list system supported operations.
ListOperations(ctx context.Context, in *ListOperationsRequest, opts ...grpc.CallOption) (*ListOperationsResponse, error)
// Ping the OutputBinding. Used for liveness porpuses.
Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
}
type outputBindingClient struct {
cc grpc.ClientConnInterface
}
func NewOutputBindingClient(cc grpc.ClientConnInterface) OutputBindingClient {
return &outputBindingClient{cc}
}
func (c *outputBindingClient) Init(ctx context.Context, in *OutputBindingInitRequest, opts ...grpc.CallOption) (*OutputBindingInitResponse, error) {
out := new(OutputBindingInitResponse)
err := c.cc.Invoke(ctx, OutputBinding_Init_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *outputBindingClient) Invoke(ctx context.Context, in *InvokeRequest, opts ...grpc.CallOption) (*InvokeResponse, error) {
out := new(InvokeResponse)
err := c.cc.Invoke(ctx, OutputBinding_Invoke_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *outputBindingClient) ListOperations(ctx context.Context, in *ListOperationsRequest, opts ...grpc.CallOption) (*ListOperationsResponse, error) {
out := new(ListOperationsResponse)
err := c.cc.Invoke(ctx, OutputBinding_ListOperations_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *outputBindingClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
out := new(PingResponse)
err := c.cc.Invoke(ctx, OutputBinding_Ping_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// OutputBindingServer is the server API for OutputBinding service.
// All implementations should embed UnimplementedOutputBindingServer
// for forward compatibility
type OutputBindingServer interface {
// Initializes the outputbinding component component with the given metadata.
Init(context.Context, *OutputBindingInitRequest) (*OutputBindingInitResponse, error)
// Invoke remote systems with optional payloads.
Invoke(context.Context, *InvokeRequest) (*InvokeResponse, error)
// ListOperations list system supported operations.
ListOperations(context.Context, *ListOperationsRequest) (*ListOperationsResponse, error)
// Ping the OutputBinding. Used for liveness porpuses.
Ping(context.Context, *PingRequest) (*PingResponse, error)
}
// UnimplementedOutputBindingServer should be embedded to have forward compatible implementations.
type UnimplementedOutputBindingServer struct {
}
func (UnimplementedOutputBindingServer) Init(context.Context, *OutputBindingInitRequest) (*OutputBindingInitResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (UnimplementedOutputBindingServer) Invoke(context.Context, *InvokeRequest) (*InvokeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Invoke not implemented")
}
func (UnimplementedOutputBindingServer) ListOperations(context.Context, *ListOperationsRequest) (*ListOperationsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListOperations not implemented")
}
func (UnimplementedOutputBindingServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
// UnsafeOutputBindingServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to OutputBindingServer will
// result in compilation errors.
type UnsafeOutputBindingServer interface {
mustEmbedUnimplementedOutputBindingServer()
}
func RegisterOutputBindingServer(s grpc.ServiceRegistrar, srv OutputBindingServer) {
s.RegisterService(&OutputBinding_ServiceDesc, srv)
}
func _OutputBinding_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(OutputBindingInitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OutputBindingServer).Init(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: OutputBinding_Init_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OutputBindingServer).Init(ctx, req.(*OutputBindingInitRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OutputBinding_Invoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InvokeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OutputBindingServer).Invoke(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: OutputBinding_Invoke_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OutputBindingServer).Invoke(ctx, req.(*InvokeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OutputBinding_ListOperations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListOperationsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OutputBindingServer).ListOperations(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: OutputBinding_ListOperations_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OutputBindingServer).ListOperations(ctx, req.(*ListOperationsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _OutputBinding_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OutputBindingServer).Ping(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: OutputBinding_Ping_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OutputBindingServer).Ping(ctx, req.(*PingRequest))
}
return interceptor(ctx, in, info, handler)
}
// OutputBinding_ServiceDesc is the grpc.ServiceDesc for OutputBinding service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var OutputBinding_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.OutputBinding",
HandlerType: (*OutputBindingServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Init",
Handler: _OutputBinding_Init_Handler,
},
{
MethodName: "Invoke",
Handler: _OutputBinding_Invoke_Handler,
},
{
MethodName: "ListOperations",
Handler: _OutputBinding_ListOperations_Handler,
},
{
MethodName: "Ping",
Handler: _OutputBinding_Ping_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/components/v1/bindings.proto",
}
|
mikeee/dapr
|
pkg/proto/components/v1/bindings_grpc.pb.go
|
GO
|
mit
| 16,751 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/components/v1/common.proto
package components
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Base metadata request for all components
type MetadataRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Properties map[string]string `protobuf:"bytes,1,rep,name=properties,proto3" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *MetadataRequest) Reset() {
*x = MetadataRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *MetadataRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MetadataRequest) ProtoMessage() {}
func (x *MetadataRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MetadataRequest.ProtoReflect.Descriptor instead.
func (*MetadataRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_common_proto_rawDescGZIP(), []int{0}
}
func (x *MetadataRequest) GetProperties() map[string]string {
if x != nil {
return x.Properties
}
return nil
}
// reserved for future-proof extensibility
type FeaturesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *FeaturesRequest) Reset() {
*x = FeaturesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FeaturesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FeaturesRequest) ProtoMessage() {}
func (x *FeaturesRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FeaturesRequest.ProtoReflect.Descriptor instead.
func (*FeaturesRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_common_proto_rawDescGZIP(), []int{1}
}
type FeaturesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Features []string `protobuf:"bytes,1,rep,name=features,proto3" json:"features,omitempty"`
}
func (x *FeaturesResponse) Reset() {
*x = FeaturesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FeaturesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FeaturesResponse) ProtoMessage() {}
func (x *FeaturesResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FeaturesResponse.ProtoReflect.Descriptor instead.
func (*FeaturesResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_common_proto_rawDescGZIP(), []int{2}
}
func (x *FeaturesResponse) GetFeatures() []string {
if x != nil {
return x.Features
}
return nil
}
// reserved for future-proof extensibility
type PingRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PingRequest) Reset() {
*x = PingRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PingRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PingRequest) ProtoMessage() {}
func (x *PingRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PingRequest.ProtoReflect.Descriptor instead.
func (*PingRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_common_proto_rawDescGZIP(), []int{3}
}
// reserved for future-proof extensibility
type PingResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PingResponse) Reset() {
*x = PingResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PingResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PingResponse) ProtoMessage() {}
func (x *PingResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_common_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PingResponse.ProtoReflect.Descriptor instead.
func (*PingResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_common_proto_rawDescGZIP(), []int{4}
}
var File_dapr_proto_components_v1_common_proto protoreflect.FileDescriptor
var file_dapr_proto_components_v1_common_proto_rawDesc = []byte{
0x0a, 0x25, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x22, 0xab, 0x01, 0x0a, 0x0f, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x59, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74,
0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73,
0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22,
0x11, 0x0a, 0x0f, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x22, 0x2e, 0x0a, 0x10, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72,
0x65, 0x73, 0x22, 0x0d, 0x0a, 0x0b, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x22, 0x0e, 0x0a, 0x0c, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x42, 0x74, 0x0a, 0x0a, 0x69, 0x6f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x42,
0x0f, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73,
0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70,
0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0xaa, 0x02, 0x1b, 0x44, 0x61, 0x70, 0x72,
0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x67, 0x65, 0x6e, 0x2e,
0x47, 0x72, 0x70, 0x63, 0x2e, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_components_v1_common_proto_rawDescOnce sync.Once
file_dapr_proto_components_v1_common_proto_rawDescData = file_dapr_proto_components_v1_common_proto_rawDesc
)
func file_dapr_proto_components_v1_common_proto_rawDescGZIP() []byte {
file_dapr_proto_components_v1_common_proto_rawDescOnce.Do(func() {
file_dapr_proto_components_v1_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_components_v1_common_proto_rawDescData)
})
return file_dapr_proto_components_v1_common_proto_rawDescData
}
var file_dapr_proto_components_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_dapr_proto_components_v1_common_proto_goTypes = []interface{}{
(*MetadataRequest)(nil), // 0: dapr.proto.components.v1.MetadataRequest
(*FeaturesRequest)(nil), // 1: dapr.proto.components.v1.FeaturesRequest
(*FeaturesResponse)(nil), // 2: dapr.proto.components.v1.FeaturesResponse
(*PingRequest)(nil), // 3: dapr.proto.components.v1.PingRequest
(*PingResponse)(nil), // 4: dapr.proto.components.v1.PingResponse
nil, // 5: dapr.proto.components.v1.MetadataRequest.PropertiesEntry
}
var file_dapr_proto_components_v1_common_proto_depIdxs = []int32{
5, // 0: dapr.proto.components.v1.MetadataRequest.properties:type_name -> dapr.proto.components.v1.MetadataRequest.PropertiesEntry
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_dapr_proto_components_v1_common_proto_init() }
func file_dapr_proto_components_v1_common_proto_init() {
if File_dapr_proto_components_v1_common_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_components_v1_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MetadataRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_common_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FeaturesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_common_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FeaturesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_common_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PingRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_common_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PingResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_components_v1_common_proto_rawDesc,
NumEnums: 0,
NumMessages: 6,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_dapr_proto_components_v1_common_proto_goTypes,
DependencyIndexes: file_dapr_proto_components_v1_common_proto_depIdxs,
MessageInfos: file_dapr_proto_components_v1_common_proto_msgTypes,
}.Build()
File_dapr_proto_components_v1_common_proto = out.File
file_dapr_proto_components_v1_common_proto_rawDesc = nil
file_dapr_proto_components_v1_common_proto_goTypes = nil
file_dapr_proto_components_v1_common_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/components/v1/common.pb.go
|
GO
|
mit
| 14,053 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/components/v1/pubsub.proto
package components
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Used for describing errors when ack'ing messages.
type AckMessageError struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}
func (x *AckMessageError) Reset() {
*x = AckMessageError{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AckMessageError) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AckMessageError) ProtoMessage() {}
func (x *AckMessageError) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AckMessageError.ProtoReflect.Descriptor instead.
func (*AckMessageError) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{0}
}
func (x *AckMessageError) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
// Used for acknowledge a message.
type PullMessagesRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The subscribed topic for which to initialize the new stream. This
// must be provided in the first request on the stream, and must not be set in
// subsequent requests from client to server.
Topic *Topic `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
// The unique message ID.
AckMessageId string `protobuf:"bytes,2,opt,name=ack_message_id,json=ackMessageId,proto3" json:"ack_message_id,omitempty"`
// Optional, should not be fulfilled when the message was successfully
// handled.
AckError *AckMessageError `protobuf:"bytes,3,opt,name=ack_error,json=ackError,proto3" json:"ack_error,omitempty"`
}
func (x *PullMessagesRequest) Reset() {
*x = PullMessagesRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PullMessagesRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PullMessagesRequest) ProtoMessage() {}
func (x *PullMessagesRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PullMessagesRequest.ProtoReflect.Descriptor instead.
func (*PullMessagesRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{1}
}
func (x *PullMessagesRequest) GetTopic() *Topic {
if x != nil {
return x.Topic
}
return nil
}
func (x *PullMessagesRequest) GetAckMessageId() string {
if x != nil {
return x.AckMessageId
}
return ""
}
func (x *PullMessagesRequest) GetAckError() *AckMessageError {
if x != nil {
return x.AckError
}
return nil
}
// PubSubInitRequest is the request for initializing the pubsub component.
type PubSubInitRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The metadata request.
Metadata *MetadataRequest `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
}
func (x *PubSubInitRequest) Reset() {
*x = PubSubInitRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PubSubInitRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PubSubInitRequest) ProtoMessage() {}
func (x *PubSubInitRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PubSubInitRequest.ProtoReflect.Descriptor instead.
func (*PubSubInitRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{2}
}
func (x *PubSubInitRequest) GetMetadata() *MetadataRequest {
if x != nil {
return x.Metadata
}
return nil
}
// reserved for future-proof extensibility
type PubSubInitResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PubSubInitResponse) Reset() {
*x = PubSubInitResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PubSubInitResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PubSubInitResponse) ProtoMessage() {}
func (x *PubSubInitResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PubSubInitResponse.ProtoReflect.Descriptor instead.
func (*PubSubInitResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{3}
}
type PublishRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The pubsub name.
PubsubName string `protobuf:"bytes,2,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// The publishing topic.
Topic string `protobuf:"bytes,3,opt,name=topic,proto3" json:"topic,omitempty"`
// Message metadata.
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The data content type.
ContentType string `protobuf:"bytes,5,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *PublishRequest) Reset() {
*x = PublishRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PublishRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PublishRequest) ProtoMessage() {}
func (x *PublishRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PublishRequest.ProtoReflect.Descriptor instead.
func (*PublishRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{4}
}
func (x *PublishRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *PublishRequest) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *PublishRequest) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *PublishRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *PublishRequest) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
type BulkPublishRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Entries []*BulkMessageEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
PubsubName string `protobuf:"bytes,2,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
Topic string `protobuf:"bytes,3,opt,name=topic,proto3" json:"topic,omitempty"`
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkPublishRequest) Reset() {
*x = BulkPublishRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishRequest) ProtoMessage() {}
func (x *BulkPublishRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishRequest.ProtoReflect.Descriptor instead.
func (*BulkPublishRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{5}
}
func (x *BulkPublishRequest) GetEntries() []*BulkMessageEntry {
if x != nil {
return x.Entries
}
return nil
}
func (x *BulkPublishRequest) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *BulkPublishRequest) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *BulkPublishRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
type BulkMessageEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"`
Event []byte `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkMessageEntry) Reset() {
*x = BulkMessageEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkMessageEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkMessageEntry) ProtoMessage() {}
func (x *BulkMessageEntry) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkMessageEntry.ProtoReflect.Descriptor instead.
func (*BulkMessageEntry) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{6}
}
func (x *BulkMessageEntry) GetEntryId() string {
if x != nil {
return x.EntryId
}
return ""
}
func (x *BulkMessageEntry) GetEvent() []byte {
if x != nil {
return x.Event
}
return nil
}
func (x *BulkMessageEntry) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
func (x *BulkMessageEntry) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
type BulkPublishResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
FailedEntries []*BulkPublishResponseFailedEntry `protobuf:"bytes,1,rep,name=failed_entries,json=failedEntries,proto3" json:"failed_entries,omitempty"`
}
func (x *BulkPublishResponse) Reset() {
*x = BulkPublishResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishResponse) ProtoMessage() {}
func (x *BulkPublishResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishResponse.ProtoReflect.Descriptor instead.
func (*BulkPublishResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{7}
}
func (x *BulkPublishResponse) GetFailedEntries() []*BulkPublishResponseFailedEntry {
if x != nil {
return x.FailedEntries
}
return nil
}
type BulkPublishResponseFailedEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"`
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
}
func (x *BulkPublishResponseFailedEntry) Reset() {
*x = BulkPublishResponseFailedEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishResponseFailedEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishResponseFailedEntry) ProtoMessage() {}
func (x *BulkPublishResponseFailedEntry) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishResponseFailedEntry.ProtoReflect.Descriptor instead.
func (*BulkPublishResponseFailedEntry) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{8}
}
func (x *BulkPublishResponseFailedEntry) GetEntryId() string {
if x != nil {
return x.EntryId
}
return ""
}
func (x *BulkPublishResponseFailedEntry) GetError() string {
if x != nil {
return x.Error
}
return ""
}
// reserved for future-proof extensibility
type PublishResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PublishResponse) Reset() {
*x = PublishResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PublishResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PublishResponse) ProtoMessage() {}
func (x *PublishResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PublishResponse.ProtoReflect.Descriptor instead.
func (*PublishResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{9}
}
type Topic struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The topic name desired to be subscribed
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Metadata related subscribe request.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *Topic) Reset() {
*x = Topic{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Topic) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Topic) ProtoMessage() {}
func (x *Topic) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Topic.ProtoReflect.Descriptor instead.
func (*Topic) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{10}
}
func (x *Topic) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Topic) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
type PullMessagesResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The message content.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The topic where the message come from.
TopicName string `protobuf:"bytes,2,opt,name=topic_name,json=topicName,proto3" json:"topic_name,omitempty"`
// The message related metadata.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The message content type.
ContentType string `protobuf:"bytes,4,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
// The message {transient} ID. Its used for ack'ing it later.
Id string `protobuf:"bytes,5,opt,name=id,proto3" json:"id,omitempty"`
}
func (x *PullMessagesResponse) Reset() {
*x = PullMessagesResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PullMessagesResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PullMessagesResponse) ProtoMessage() {}
func (x *PullMessagesResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_pubsub_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PullMessagesResponse.ProtoReflect.Descriptor instead.
func (*PullMessagesResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP(), []int{11}
}
func (x *PullMessagesResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *PullMessagesResponse) GetTopicName() string {
if x != nil {
return x.TopicName
}
return ""
}
func (x *PullMessagesResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *PullMessagesResponse) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
func (x *PullMessagesResponse) GetId() string {
if x != nil {
return x.Id
}
return ""
}
var File_dapr_proto_components_v1_pubsub_proto protoreflect.FileDescriptor
var file_dapr_proto_components_v1_pubsub_proto_rawDesc = []byte{
0x0a, 0x25, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x75, 0x62, 0x73, 0x75,
0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x1a, 0x25, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d,
0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x2b, 0x0a, 0x0f, 0x41, 0x63, 0x6b, 0x4d,
0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d,
0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65,
0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xba, 0x01, 0x0a, 0x13, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65,
0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a,
0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x52, 0x05, 0x74,
0x6f, 0x70, 0x69, 0x63, 0x12, 0x24, 0x0a, 0x0e, 0x61, 0x63, 0x6b, 0x5f, 0x6d, 0x65, 0x73, 0x73,
0x61, 0x67, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x61, 0x63,
0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x49, 0x64, 0x12, 0x46, 0x0a, 0x09, 0x61, 0x63,
0x6b, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f,
0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x6b, 0x4d, 0x65, 0x73, 0x73,
0x61, 0x67, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x08, 0x61, 0x63, 0x6b, 0x45, 0x72, 0x72,
0x6f, 0x72, 0x22, 0x5a, 0x0a, 0x11, 0x50, 0x75, 0x62, 0x53, 0x75, 0x62, 0x49, 0x6e, 0x69, 0x74,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x14,
0x0a, 0x12, 0x50, 0x75, 0x62, 0x53, 0x75, 0x62, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x22, 0x8f, 0x02, 0x0a, 0x0e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18,
0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1f, 0x0a, 0x0b, 0x70,
0x75, 0x62, 0x73, 0x75, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x0a, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05,
0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70,
0x69, 0x63, 0x12, 0x52, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e,
0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f,
0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xa6, 0x02, 0x0a, 0x12, 0x42, 0x75, 0x6c, 0x6b, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x44, 0x0a,
0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x4d, 0x65,
0x73, 0x73, 0x61, 0x67, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72,
0x69, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62,
0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x03, 0x20,
0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x56, 0x0a, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c,
0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22,
0xf9, 0x01, 0x0a, 0x10, 0x42, 0x75, 0x6c, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x5f, 0x69, 0x64,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x49, 0x64, 0x12,
0x14, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05,
0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e,
0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x54, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b,
0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x76, 0x0a, 0x13, 0x42,
0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x12, 0x5f, 0x0a, 0x0e, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x74,
0x72, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73,
0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72,
0x69, 0x65, 0x73, 0x22, 0x51, 0x0a, 0x1e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69,
0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x5f, 0x69,
0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x49, 0x64,
0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x11, 0x0a, 0x0f, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73,
0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa3, 0x01, 0x0a, 0x05, 0x54, 0x6f,
0x70, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x49, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22,
0x93, 0x02, 0x0a, 0x14, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1d, 0x0a, 0x0a,
0x74, 0x6f, 0x70, 0x69, 0x63, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x09, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x58, 0x0a, 0x08, 0x6d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f,
0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e,
0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x05,
0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x32, 0xf0, 0x04, 0x0a, 0x06, 0x50, 0x75, 0x62, 0x53, 0x75, 0x62,
0x12, 0x63, 0x0a, 0x04, 0x49, 0x6e, 0x69, 0x74, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x53, 0x75, 0x62, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x50, 0x75, 0x62, 0x53, 0x75, 0x62, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x08, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65,
0x73, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x61,
0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x07, 0x50, 0x75,
0x62, 0x6c, 0x69, 0x73, 0x68, 0x12, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69,
0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x0b,
0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x12, 0x2c, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69,
0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x73, 0x0a, 0x0c, 0x50, 0x75,
0x6c, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, 0x2d, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12,
0x57, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68,
0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72,
0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f,
0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_components_v1_pubsub_proto_rawDescOnce sync.Once
file_dapr_proto_components_v1_pubsub_proto_rawDescData = file_dapr_proto_components_v1_pubsub_proto_rawDesc
)
func file_dapr_proto_components_v1_pubsub_proto_rawDescGZIP() []byte {
file_dapr_proto_components_v1_pubsub_proto_rawDescOnce.Do(func() {
file_dapr_proto_components_v1_pubsub_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_components_v1_pubsub_proto_rawDescData)
})
return file_dapr_proto_components_v1_pubsub_proto_rawDescData
}
var file_dapr_proto_components_v1_pubsub_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
var file_dapr_proto_components_v1_pubsub_proto_goTypes = []interface{}{
(*AckMessageError)(nil), // 0: dapr.proto.components.v1.AckMessageError
(*PullMessagesRequest)(nil), // 1: dapr.proto.components.v1.PullMessagesRequest
(*PubSubInitRequest)(nil), // 2: dapr.proto.components.v1.PubSubInitRequest
(*PubSubInitResponse)(nil), // 3: dapr.proto.components.v1.PubSubInitResponse
(*PublishRequest)(nil), // 4: dapr.proto.components.v1.PublishRequest
(*BulkPublishRequest)(nil), // 5: dapr.proto.components.v1.BulkPublishRequest
(*BulkMessageEntry)(nil), // 6: dapr.proto.components.v1.BulkMessageEntry
(*BulkPublishResponse)(nil), // 7: dapr.proto.components.v1.BulkPublishResponse
(*BulkPublishResponseFailedEntry)(nil), // 8: dapr.proto.components.v1.BulkPublishResponseFailedEntry
(*PublishResponse)(nil), // 9: dapr.proto.components.v1.PublishResponse
(*Topic)(nil), // 10: dapr.proto.components.v1.Topic
(*PullMessagesResponse)(nil), // 11: dapr.proto.components.v1.PullMessagesResponse
nil, // 12: dapr.proto.components.v1.PublishRequest.MetadataEntry
nil, // 13: dapr.proto.components.v1.BulkPublishRequest.MetadataEntry
nil, // 14: dapr.proto.components.v1.BulkMessageEntry.MetadataEntry
nil, // 15: dapr.proto.components.v1.Topic.MetadataEntry
nil, // 16: dapr.proto.components.v1.PullMessagesResponse.MetadataEntry
(*MetadataRequest)(nil), // 17: dapr.proto.components.v1.MetadataRequest
(*FeaturesRequest)(nil), // 18: dapr.proto.components.v1.FeaturesRequest
(*PingRequest)(nil), // 19: dapr.proto.components.v1.PingRequest
(*FeaturesResponse)(nil), // 20: dapr.proto.components.v1.FeaturesResponse
(*PingResponse)(nil), // 21: dapr.proto.components.v1.PingResponse
}
var file_dapr_proto_components_v1_pubsub_proto_depIdxs = []int32{
10, // 0: dapr.proto.components.v1.PullMessagesRequest.topic:type_name -> dapr.proto.components.v1.Topic
0, // 1: dapr.proto.components.v1.PullMessagesRequest.ack_error:type_name -> dapr.proto.components.v1.AckMessageError
17, // 2: dapr.proto.components.v1.PubSubInitRequest.metadata:type_name -> dapr.proto.components.v1.MetadataRequest
12, // 3: dapr.proto.components.v1.PublishRequest.metadata:type_name -> dapr.proto.components.v1.PublishRequest.MetadataEntry
6, // 4: dapr.proto.components.v1.BulkPublishRequest.entries:type_name -> dapr.proto.components.v1.BulkMessageEntry
13, // 5: dapr.proto.components.v1.BulkPublishRequest.metadata:type_name -> dapr.proto.components.v1.BulkPublishRequest.MetadataEntry
14, // 6: dapr.proto.components.v1.BulkMessageEntry.metadata:type_name -> dapr.proto.components.v1.BulkMessageEntry.MetadataEntry
8, // 7: dapr.proto.components.v1.BulkPublishResponse.failed_entries:type_name -> dapr.proto.components.v1.BulkPublishResponseFailedEntry
15, // 8: dapr.proto.components.v1.Topic.metadata:type_name -> dapr.proto.components.v1.Topic.MetadataEntry
16, // 9: dapr.proto.components.v1.PullMessagesResponse.metadata:type_name -> dapr.proto.components.v1.PullMessagesResponse.MetadataEntry
2, // 10: dapr.proto.components.v1.PubSub.Init:input_type -> dapr.proto.components.v1.PubSubInitRequest
18, // 11: dapr.proto.components.v1.PubSub.Features:input_type -> dapr.proto.components.v1.FeaturesRequest
4, // 12: dapr.proto.components.v1.PubSub.Publish:input_type -> dapr.proto.components.v1.PublishRequest
5, // 13: dapr.proto.components.v1.PubSub.BulkPublish:input_type -> dapr.proto.components.v1.BulkPublishRequest
1, // 14: dapr.proto.components.v1.PubSub.PullMessages:input_type -> dapr.proto.components.v1.PullMessagesRequest
19, // 15: dapr.proto.components.v1.PubSub.Ping:input_type -> dapr.proto.components.v1.PingRequest
3, // 16: dapr.proto.components.v1.PubSub.Init:output_type -> dapr.proto.components.v1.PubSubInitResponse
20, // 17: dapr.proto.components.v1.PubSub.Features:output_type -> dapr.proto.components.v1.FeaturesResponse
9, // 18: dapr.proto.components.v1.PubSub.Publish:output_type -> dapr.proto.components.v1.PublishResponse
7, // 19: dapr.proto.components.v1.PubSub.BulkPublish:output_type -> dapr.proto.components.v1.BulkPublishResponse
11, // 20: dapr.proto.components.v1.PubSub.PullMessages:output_type -> dapr.proto.components.v1.PullMessagesResponse
21, // 21: dapr.proto.components.v1.PubSub.Ping:output_type -> dapr.proto.components.v1.PingResponse
16, // [16:22] is the sub-list for method output_type
10, // [10:16] is the sub-list for method input_type
10, // [10:10] is the sub-list for extension type_name
10, // [10:10] is the sub-list for extension extendee
0, // [0:10] is the sub-list for field type_name
}
func init() { file_dapr_proto_components_v1_pubsub_proto_init() }
func file_dapr_proto_components_v1_pubsub_proto_init() {
if File_dapr_proto_components_v1_pubsub_proto != nil {
return
}
file_dapr_proto_components_v1_common_proto_init()
if !protoimpl.UnsafeEnabled {
file_dapr_proto_components_v1_pubsub_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AckMessageError); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PullMessagesRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PubSubInitRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PubSubInitResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PublishRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkMessageEntry); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishResponseFailedEntry); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PublishResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Topic); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_pubsub_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PullMessagesResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_components_v1_pubsub_proto_rawDesc,
NumEnums: 0,
NumMessages: 17,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_components_v1_pubsub_proto_goTypes,
DependencyIndexes: file_dapr_proto_components_v1_pubsub_proto_depIdxs,
MessageInfos: file_dapr_proto_components_v1_pubsub_proto_msgTypes,
}.Build()
File_dapr_proto_components_v1_pubsub_proto = out.File
file_dapr_proto_components_v1_pubsub_proto_rawDesc = nil
file_dapr_proto_components_v1_pubsub_proto_goTypes = nil
file_dapr_proto_components_v1_pubsub_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/components/v1/pubsub.pb.go
|
GO
|
mit
| 47,568 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/components/v1/pubsub.proto
package components
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
PubSub_Init_FullMethodName = "/dapr.proto.components.v1.PubSub/Init"
PubSub_Features_FullMethodName = "/dapr.proto.components.v1.PubSub/Features"
PubSub_Publish_FullMethodName = "/dapr.proto.components.v1.PubSub/Publish"
PubSub_BulkPublish_FullMethodName = "/dapr.proto.components.v1.PubSub/BulkPublish"
PubSub_PullMessages_FullMethodName = "/dapr.proto.components.v1.PubSub/PullMessages"
PubSub_Ping_FullMethodName = "/dapr.proto.components.v1.PubSub/Ping"
)
// PubSubClient is the client API for PubSub service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type PubSubClient interface {
// Initializes the pubsub component with the given metadata.
Init(ctx context.Context, in *PubSubInitRequest, opts ...grpc.CallOption) (*PubSubInitResponse, error)
// Returns a list of implemented pubsub features.
Features(ctx context.Context, in *FeaturesRequest, opts ...grpc.CallOption) (*FeaturesResponse, error)
// Publish publishes a new message for the given topic.
Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error)
BulkPublish(ctx context.Context, in *BulkPublishRequest, opts ...grpc.CallOption) (*BulkPublishResponse, error)
// Establishes a stream with the server (PubSub component), which sends
// messages down to the client (daprd). The client streams acknowledgements
// back to the server. The server will close the stream and return the status
// on any error. In case of closed connection, the client should re-establish
// the stream. The first message MUST contain a `topic` attribute on it that
// should be used for the entire streaming pull.
PullMessages(ctx context.Context, opts ...grpc.CallOption) (PubSub_PullMessagesClient, error)
// Ping the pubsub. Used for liveness porpuses.
Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
}
type pubSubClient struct {
cc grpc.ClientConnInterface
}
func NewPubSubClient(cc grpc.ClientConnInterface) PubSubClient {
return &pubSubClient{cc}
}
func (c *pubSubClient) Init(ctx context.Context, in *PubSubInitRequest, opts ...grpc.CallOption) (*PubSubInitResponse, error) {
out := new(PubSubInitResponse)
err := c.cc.Invoke(ctx, PubSub_Init_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pubSubClient) Features(ctx context.Context, in *FeaturesRequest, opts ...grpc.CallOption) (*FeaturesResponse, error) {
out := new(FeaturesResponse)
err := c.cc.Invoke(ctx, PubSub_Features_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pubSubClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error) {
out := new(PublishResponse)
err := c.cc.Invoke(ctx, PubSub_Publish_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pubSubClient) BulkPublish(ctx context.Context, in *BulkPublishRequest, opts ...grpc.CallOption) (*BulkPublishResponse, error) {
out := new(BulkPublishResponse)
err := c.cc.Invoke(ctx, PubSub_BulkPublish_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pubSubClient) PullMessages(ctx context.Context, opts ...grpc.CallOption) (PubSub_PullMessagesClient, error) {
stream, err := c.cc.NewStream(ctx, &PubSub_ServiceDesc.Streams[0], PubSub_PullMessages_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &pubSubPullMessagesClient{stream}
return x, nil
}
type PubSub_PullMessagesClient interface {
Send(*PullMessagesRequest) error
Recv() (*PullMessagesResponse, error)
grpc.ClientStream
}
type pubSubPullMessagesClient struct {
grpc.ClientStream
}
func (x *pubSubPullMessagesClient) Send(m *PullMessagesRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *pubSubPullMessagesClient) Recv() (*PullMessagesResponse, error) {
m := new(PullMessagesResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *pubSubClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
out := new(PingResponse)
err := c.cc.Invoke(ctx, PubSub_Ping_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// PubSubServer is the server API for PubSub service.
// All implementations should embed UnimplementedPubSubServer
// for forward compatibility
type PubSubServer interface {
// Initializes the pubsub component with the given metadata.
Init(context.Context, *PubSubInitRequest) (*PubSubInitResponse, error)
// Returns a list of implemented pubsub features.
Features(context.Context, *FeaturesRequest) (*FeaturesResponse, error)
// Publish publishes a new message for the given topic.
Publish(context.Context, *PublishRequest) (*PublishResponse, error)
BulkPublish(context.Context, *BulkPublishRequest) (*BulkPublishResponse, error)
// Establishes a stream with the server (PubSub component), which sends
// messages down to the client (daprd). The client streams acknowledgements
// back to the server. The server will close the stream and return the status
// on any error. In case of closed connection, the client should re-establish
// the stream. The first message MUST contain a `topic` attribute on it that
// should be used for the entire streaming pull.
PullMessages(PubSub_PullMessagesServer) error
// Ping the pubsub. Used for liveness porpuses.
Ping(context.Context, *PingRequest) (*PingResponse, error)
}
// UnimplementedPubSubServer should be embedded to have forward compatible implementations.
type UnimplementedPubSubServer struct {
}
func (UnimplementedPubSubServer) Init(context.Context, *PubSubInitRequest) (*PubSubInitResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (UnimplementedPubSubServer) Features(context.Context, *FeaturesRequest) (*FeaturesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Features not implemented")
}
func (UnimplementedPubSubServer) Publish(context.Context, *PublishRequest) (*PublishResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Publish not implemented")
}
func (UnimplementedPubSubServer) BulkPublish(context.Context, *BulkPublishRequest) (*BulkPublishResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BulkPublish not implemented")
}
func (UnimplementedPubSubServer) PullMessages(PubSub_PullMessagesServer) error {
return status.Errorf(codes.Unimplemented, "method PullMessages not implemented")
}
func (UnimplementedPubSubServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
// UnsafePubSubServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to PubSubServer will
// result in compilation errors.
type UnsafePubSubServer interface {
mustEmbedUnimplementedPubSubServer()
}
func RegisterPubSubServer(s grpc.ServiceRegistrar, srv PubSubServer) {
s.RegisterService(&PubSub_ServiceDesc, srv)
}
func _PubSub_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PubSubInitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PubSubServer).Init(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: PubSub_Init_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PubSubServer).Init(ctx, req.(*PubSubInitRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PubSub_Features_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FeaturesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PubSubServer).Features(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: PubSub_Features_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PubSubServer).Features(ctx, req.(*FeaturesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PubSub_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PublishRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PubSubServer).Publish(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: PubSub_Publish_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PubSubServer).Publish(ctx, req.(*PublishRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PubSub_BulkPublish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkPublishRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PubSubServer).BulkPublish(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: PubSub_BulkPublish_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PubSubServer).BulkPublish(ctx, req.(*BulkPublishRequest))
}
return interceptor(ctx, in, info, handler)
}
func _PubSub_PullMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(PubSubServer).PullMessages(&pubSubPullMessagesServer{stream})
}
type PubSub_PullMessagesServer interface {
Send(*PullMessagesResponse) error
Recv() (*PullMessagesRequest, error)
grpc.ServerStream
}
type pubSubPullMessagesServer struct {
grpc.ServerStream
}
func (x *pubSubPullMessagesServer) Send(m *PullMessagesResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *pubSubPullMessagesServer) Recv() (*PullMessagesRequest, error) {
m := new(PullMessagesRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _PubSub_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(PubSubServer).Ping(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: PubSub_Ping_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(PubSubServer).Ping(ctx, req.(*PingRequest))
}
return interceptor(ctx, in, info, handler)
}
// PubSub_ServiceDesc is the grpc.ServiceDesc for PubSub service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var PubSub_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.PubSub",
HandlerType: (*PubSubServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Init",
Handler: _PubSub_Init_Handler,
},
{
MethodName: "Features",
Handler: _PubSub_Features_Handler,
},
{
MethodName: "Publish",
Handler: _PubSub_Publish_Handler,
},
{
MethodName: "BulkPublish",
Handler: _PubSub_BulkPublish_Handler,
},
{
MethodName: "Ping",
Handler: _PubSub_Ping_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "PullMessages",
Handler: _PubSub_PullMessages_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "dapr/proto/components/v1/pubsub.proto",
}
|
mikeee/dapr
|
pkg/proto/components/v1/pubsub_grpc.pb.go
|
GO
|
mit
| 13,102 |
//
//Copyright 2023 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/components/v1/secretstore.proto
package components
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Request to initialize the secret store.
type SecretStoreInitRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Metadata *MetadataRequest `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
}
func (x *SecretStoreInitRequest) Reset() {
*x = SecretStoreInitRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SecretStoreInitRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SecretStoreInitRequest) ProtoMessage() {}
func (x *SecretStoreInitRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SecretStoreInitRequest.ProtoReflect.Descriptor instead.
func (*SecretStoreInitRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{0}
}
func (x *SecretStoreInitRequest) GetMetadata() *MetadataRequest {
if x != nil {
return x.Metadata
}
return nil
}
// Response from initialization.
type SecretStoreInitResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *SecretStoreInitResponse) Reset() {
*x = SecretStoreInitResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SecretStoreInitResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SecretStoreInitResponse) ProtoMessage() {}
func (x *SecretStoreInitResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SecretStoreInitResponse.ProtoReflect.Descriptor instead.
func (*SecretStoreInitResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{1}
}
// GetSecretRequest is the message to get secret from secret store.
type GetSecretRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of secret key.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The metadata which will be sent to secret store components.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSecretRequest) Reset() {
*x = GetSecretRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSecretRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSecretRequest) ProtoMessage() {}
func (x *GetSecretRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSecretRequest.ProtoReflect.Descriptor instead.
func (*GetSecretRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{2}
}
func (x *GetSecretRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *GetSecretRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// GetSecretResponse is the response message to convey the requested secret.
type GetSecretResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// data is the secret value. Some secret store, such as kubernetes secret
// store, can save multiple secrets for single secret key.
Data map[string]string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSecretResponse) Reset() {
*x = GetSecretResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSecretResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSecretResponse) ProtoMessage() {}
func (x *GetSecretResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSecretResponse.ProtoReflect.Descriptor instead.
func (*GetSecretResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{3}
}
func (x *GetSecretResponse) GetData() map[string]string {
if x != nil {
return x.Data
}
return nil
}
// BulkGetSecretRequest is the message to get the secrets from secret store.
type BulkGetSecretRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The metadata which will be sent to secret store components.
Metadata map[string]string `protobuf:"bytes,1,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkGetSecretRequest) Reset() {
*x = BulkGetSecretRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkGetSecretRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkGetSecretRequest) ProtoMessage() {}
func (x *BulkGetSecretRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkGetSecretRequest.ProtoReflect.Descriptor instead.
func (*BulkGetSecretRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{4}
}
func (x *BulkGetSecretRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// SecretResponse is a map of decrypted string/string values
type SecretResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Secrets map[string]string `protobuf:"bytes,1,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *SecretResponse) Reset() {
*x = SecretResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SecretResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SecretResponse) ProtoMessage() {}
func (x *SecretResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SecretResponse.ProtoReflect.Descriptor instead.
func (*SecretResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{5}
}
func (x *SecretResponse) GetSecrets() map[string]string {
if x != nil {
return x.Secrets
}
return nil
}
// BulkGetSecretResponse is the response message to convey the requested secrets.
type BulkGetSecretResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// data hold the secret values. Some secret store, such as kubernetes secret
// store, can save multiple secrets for single secret key.
Data map[string]*SecretResponse `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkGetSecretResponse) Reset() {
*x = BulkGetSecretResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkGetSecretResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkGetSecretResponse) ProtoMessage() {}
func (x *BulkGetSecretResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_secretstore_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkGetSecretResponse.ProtoReflect.Descriptor instead.
func (*BulkGetSecretResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP(), []int{6}
}
func (x *BulkGetSecretResponse) GetData() map[string]*SecretResponse {
if x != nil {
return x.Data
}
return nil
}
var File_dapr_proto_components_v1_secretstore_proto protoreflect.FileDescriptor
var file_dapr_proto_components_v1_secretstore_proto_rawDesc = []byte{
0x0a, 0x2a, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x63, 0x72, 0x65,
0x74, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x1a, 0x25, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31,
0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x5f, 0x0a,
0x16, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x49, 0x6e, 0x69, 0x74,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x19,
0x0a, 0x17, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x49, 0x6e, 0x69,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb7, 0x01, 0x0a, 0x10, 0x47, 0x65,
0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10,
0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x12, 0x54, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x38, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65,
0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
0x02, 0x38, 0x01, 0x22, 0x97, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x49, 0x0a, 0x04, 0x64, 0x61, 0x74,
0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04,
0x64, 0x61, 0x74, 0x61, 0x1a, 0x37, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xad, 0x01,
0x0a, 0x14, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x58, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65,
0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9d, 0x01,
0x0a, 0x0e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x4f, 0x0a, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x63,
0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x65, 0x63, 0x72,
0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74,
0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xc9, 0x01,
0x0a, 0x15, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18,
0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x61, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e,
0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x32, 0x8a, 0x04, 0x0a, 0x0b, 0x53, 0x65,
0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x12, 0x6d, 0x0a, 0x04, 0x49, 0x6e, 0x69,
0x74, 0x12, 0x30, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x63,
0x72, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53,
0x65, 0x63, 0x72, 0x65, 0x74, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x08, 0x46, 0x65, 0x61, 0x74,
0x75, 0x72, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e,
0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75,
0x72, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60, 0x0a,
0x03, 0x47, 0x65, 0x74, 0x12, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e,
0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53,
0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
0x6c, 0x0a, 0x07, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x12, 0x2e, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63,
0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63,
0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a,
0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70,
0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_components_v1_secretstore_proto_rawDescOnce sync.Once
file_dapr_proto_components_v1_secretstore_proto_rawDescData = file_dapr_proto_components_v1_secretstore_proto_rawDesc
)
func file_dapr_proto_components_v1_secretstore_proto_rawDescGZIP() []byte {
file_dapr_proto_components_v1_secretstore_proto_rawDescOnce.Do(func() {
file_dapr_proto_components_v1_secretstore_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_components_v1_secretstore_proto_rawDescData)
})
return file_dapr_proto_components_v1_secretstore_proto_rawDescData
}
var file_dapr_proto_components_v1_secretstore_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_dapr_proto_components_v1_secretstore_proto_goTypes = []interface{}{
(*SecretStoreInitRequest)(nil), // 0: dapr.proto.components.v1.SecretStoreInitRequest
(*SecretStoreInitResponse)(nil), // 1: dapr.proto.components.v1.SecretStoreInitResponse
(*GetSecretRequest)(nil), // 2: dapr.proto.components.v1.GetSecretRequest
(*GetSecretResponse)(nil), // 3: dapr.proto.components.v1.GetSecretResponse
(*BulkGetSecretRequest)(nil), // 4: dapr.proto.components.v1.BulkGetSecretRequest
(*SecretResponse)(nil), // 5: dapr.proto.components.v1.SecretResponse
(*BulkGetSecretResponse)(nil), // 6: dapr.proto.components.v1.BulkGetSecretResponse
nil, // 7: dapr.proto.components.v1.GetSecretRequest.MetadataEntry
nil, // 8: dapr.proto.components.v1.GetSecretResponse.DataEntry
nil, // 9: dapr.proto.components.v1.BulkGetSecretRequest.MetadataEntry
nil, // 10: dapr.proto.components.v1.SecretResponse.SecretsEntry
nil, // 11: dapr.proto.components.v1.BulkGetSecretResponse.DataEntry
(*MetadataRequest)(nil), // 12: dapr.proto.components.v1.MetadataRequest
(*FeaturesRequest)(nil), // 13: dapr.proto.components.v1.FeaturesRequest
(*PingRequest)(nil), // 14: dapr.proto.components.v1.PingRequest
(*FeaturesResponse)(nil), // 15: dapr.proto.components.v1.FeaturesResponse
(*PingResponse)(nil), // 16: dapr.proto.components.v1.PingResponse
}
var file_dapr_proto_components_v1_secretstore_proto_depIdxs = []int32{
12, // 0: dapr.proto.components.v1.SecretStoreInitRequest.metadata:type_name -> dapr.proto.components.v1.MetadataRequest
7, // 1: dapr.proto.components.v1.GetSecretRequest.metadata:type_name -> dapr.proto.components.v1.GetSecretRequest.MetadataEntry
8, // 2: dapr.proto.components.v1.GetSecretResponse.data:type_name -> dapr.proto.components.v1.GetSecretResponse.DataEntry
9, // 3: dapr.proto.components.v1.BulkGetSecretRequest.metadata:type_name -> dapr.proto.components.v1.BulkGetSecretRequest.MetadataEntry
10, // 4: dapr.proto.components.v1.SecretResponse.secrets:type_name -> dapr.proto.components.v1.SecretResponse.SecretsEntry
11, // 5: dapr.proto.components.v1.BulkGetSecretResponse.data:type_name -> dapr.proto.components.v1.BulkGetSecretResponse.DataEntry
5, // 6: dapr.proto.components.v1.BulkGetSecretResponse.DataEntry.value:type_name -> dapr.proto.components.v1.SecretResponse
0, // 7: dapr.proto.components.v1.SecretStore.Init:input_type -> dapr.proto.components.v1.SecretStoreInitRequest
13, // 8: dapr.proto.components.v1.SecretStore.Features:input_type -> dapr.proto.components.v1.FeaturesRequest
2, // 9: dapr.proto.components.v1.SecretStore.Get:input_type -> dapr.proto.components.v1.GetSecretRequest
4, // 10: dapr.proto.components.v1.SecretStore.BulkGet:input_type -> dapr.proto.components.v1.BulkGetSecretRequest
14, // 11: dapr.proto.components.v1.SecretStore.Ping:input_type -> dapr.proto.components.v1.PingRequest
1, // 12: dapr.proto.components.v1.SecretStore.Init:output_type -> dapr.proto.components.v1.SecretStoreInitResponse
15, // 13: dapr.proto.components.v1.SecretStore.Features:output_type -> dapr.proto.components.v1.FeaturesResponse
3, // 14: dapr.proto.components.v1.SecretStore.Get:output_type -> dapr.proto.components.v1.GetSecretResponse
6, // 15: dapr.proto.components.v1.SecretStore.BulkGet:output_type -> dapr.proto.components.v1.BulkGetSecretResponse
16, // 16: dapr.proto.components.v1.SecretStore.Ping:output_type -> dapr.proto.components.v1.PingResponse
12, // [12:17] is the sub-list for method output_type
7, // [7:12] is the sub-list for method input_type
7, // [7:7] is the sub-list for extension type_name
7, // [7:7] is the sub-list for extension extendee
0, // [0:7] is the sub-list for field type_name
}
func init() { file_dapr_proto_components_v1_secretstore_proto_init() }
func file_dapr_proto_components_v1_secretstore_proto_init() {
if File_dapr_proto_components_v1_secretstore_proto != nil {
return
}
file_dapr_proto_components_v1_common_proto_init()
if !protoimpl.UnsafeEnabled {
file_dapr_proto_components_v1_secretstore_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SecretStoreInitRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_secretstore_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SecretStoreInitResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_secretstore_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSecretRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_secretstore_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSecretResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_secretstore_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkGetSecretRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_secretstore_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SecretResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_secretstore_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkGetSecretResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_components_v1_secretstore_proto_rawDesc,
NumEnums: 0,
NumMessages: 12,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_components_v1_secretstore_proto_goTypes,
DependencyIndexes: file_dapr_proto_components_v1_secretstore_proto_depIdxs,
MessageInfos: file_dapr_proto_components_v1_secretstore_proto_msgTypes,
}.Build()
File_dapr_proto_components_v1_secretstore_proto = out.File
file_dapr_proto_components_v1_secretstore_proto_rawDesc = nil
file_dapr_proto_components_v1_secretstore_proto_goTypes = nil
file_dapr_proto_components_v1_secretstore_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/components/v1/secretstore.pb.go
|
GO
|
mit
| 29,893 |
//
//Copyright 2023 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/components/v1/secretstore.proto
package components
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
SecretStore_Init_FullMethodName = "/dapr.proto.components.v1.SecretStore/Init"
SecretStore_Features_FullMethodName = "/dapr.proto.components.v1.SecretStore/Features"
SecretStore_Get_FullMethodName = "/dapr.proto.components.v1.SecretStore/Get"
SecretStore_BulkGet_FullMethodName = "/dapr.proto.components.v1.SecretStore/BulkGet"
SecretStore_Ping_FullMethodName = "/dapr.proto.components.v1.SecretStore/Ping"
)
// SecretStoreClient is the client API for SecretStore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type SecretStoreClient interface {
// Initializes the secret store with the given metadata.
Init(ctx context.Context, in *SecretStoreInitRequest, opts ...grpc.CallOption) (*SecretStoreInitResponse, error)
// Returns a list of implemented secret store features.
Features(ctx context.Context, in *FeaturesRequest, opts ...grpc.CallOption) (*FeaturesResponse, error)
// Get an individual secret from the store.
Get(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error)
// Get all secrets from the store.
BulkGet(ctx context.Context, in *BulkGetSecretRequest, opts ...grpc.CallOption) (*BulkGetSecretResponse, error)
// Ping the pubsub. Used for liveness porpuses.
Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
}
type secretStoreClient struct {
cc grpc.ClientConnInterface
}
func NewSecretStoreClient(cc grpc.ClientConnInterface) SecretStoreClient {
return &secretStoreClient{cc}
}
func (c *secretStoreClient) Init(ctx context.Context, in *SecretStoreInitRequest, opts ...grpc.CallOption) (*SecretStoreInitResponse, error) {
out := new(SecretStoreInitResponse)
err := c.cc.Invoke(ctx, SecretStore_Init_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *secretStoreClient) Features(ctx context.Context, in *FeaturesRequest, opts ...grpc.CallOption) (*FeaturesResponse, error) {
out := new(FeaturesResponse)
err := c.cc.Invoke(ctx, SecretStore_Features_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *secretStoreClient) Get(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error) {
out := new(GetSecretResponse)
err := c.cc.Invoke(ctx, SecretStore_Get_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *secretStoreClient) BulkGet(ctx context.Context, in *BulkGetSecretRequest, opts ...grpc.CallOption) (*BulkGetSecretResponse, error) {
out := new(BulkGetSecretResponse)
err := c.cc.Invoke(ctx, SecretStore_BulkGet_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *secretStoreClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
out := new(PingResponse)
err := c.cc.Invoke(ctx, SecretStore_Ping_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// SecretStoreServer is the server API for SecretStore service.
// All implementations should embed UnimplementedSecretStoreServer
// for forward compatibility
type SecretStoreServer interface {
// Initializes the secret store with the given metadata.
Init(context.Context, *SecretStoreInitRequest) (*SecretStoreInitResponse, error)
// Returns a list of implemented secret store features.
Features(context.Context, *FeaturesRequest) (*FeaturesResponse, error)
// Get an individual secret from the store.
Get(context.Context, *GetSecretRequest) (*GetSecretResponse, error)
// Get all secrets from the store.
BulkGet(context.Context, *BulkGetSecretRequest) (*BulkGetSecretResponse, error)
// Ping the pubsub. Used for liveness porpuses.
Ping(context.Context, *PingRequest) (*PingResponse, error)
}
// UnimplementedSecretStoreServer should be embedded to have forward compatible implementations.
type UnimplementedSecretStoreServer struct {
}
func (UnimplementedSecretStoreServer) Init(context.Context, *SecretStoreInitRequest) (*SecretStoreInitResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (UnimplementedSecretStoreServer) Features(context.Context, *FeaturesRequest) (*FeaturesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Features not implemented")
}
func (UnimplementedSecretStoreServer) Get(context.Context, *GetSecretRequest) (*GetSecretResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedSecretStoreServer) BulkGet(context.Context, *BulkGetSecretRequest) (*BulkGetSecretResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BulkGet not implemented")
}
func (UnimplementedSecretStoreServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
// UnsafeSecretStoreServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SecretStoreServer will
// result in compilation errors.
type UnsafeSecretStoreServer interface {
mustEmbedUnimplementedSecretStoreServer()
}
func RegisterSecretStoreServer(s grpc.ServiceRegistrar, srv SecretStoreServer) {
s.RegisterService(&SecretStore_ServiceDesc, srv)
}
func _SecretStore_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SecretStoreInitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecretStoreServer).Init(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: SecretStore_Init_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecretStoreServer).Init(ctx, req.(*SecretStoreInitRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecretStore_Features_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FeaturesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecretStoreServer).Features(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: SecretStore_Features_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecretStoreServer).Features(ctx, req.(*FeaturesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecretStore_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSecretRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecretStoreServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: SecretStore_Get_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecretStoreServer).Get(ctx, req.(*GetSecretRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecretStore_BulkGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkGetSecretRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecretStoreServer).BulkGet(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: SecretStore_BulkGet_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecretStoreServer).BulkGet(ctx, req.(*BulkGetSecretRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecretStore_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecretStoreServer).Ping(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: SecretStore_Ping_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecretStoreServer).Ping(ctx, req.(*PingRequest))
}
return interceptor(ctx, in, info, handler)
}
// SecretStore_ServiceDesc is the grpc.ServiceDesc for SecretStore service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SecretStore_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.SecretStore",
HandlerType: (*SecretStoreServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Init",
Handler: _SecretStore_Init_Handler,
},
{
MethodName: "Features",
Handler: _SecretStore_Features_Handler,
},
{
MethodName: "Get",
Handler: _SecretStore_Get_Handler,
},
{
MethodName: "BulkGet",
Handler: _SecretStore_BulkGet_Handler,
},
{
MethodName: "Ping",
Handler: _SecretStore_Ping_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/components/v1/secretstore.proto",
}
|
mikeee/dapr
|
pkg/proto/components/v1/secretstore_grpc.pb.go
|
GO
|
mit
| 10,609 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/components/v1/state.proto
package components
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Sorting_Order int32
const (
Sorting_ASC Sorting_Order = 0
Sorting_DESC Sorting_Order = 1
)
// Enum value maps for Sorting_Order.
var (
Sorting_Order_name = map[int32]string{
0: "ASC",
1: "DESC",
}
Sorting_Order_value = map[string]int32{
"ASC": 0,
"DESC": 1,
}
)
func (x Sorting_Order) Enum() *Sorting_Order {
p := new(Sorting_Order)
*p = x
return p
}
func (x Sorting_Order) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Sorting_Order) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_components_v1_state_proto_enumTypes[0].Descriptor()
}
func (Sorting_Order) Type() protoreflect.EnumType {
return &file_dapr_proto_components_v1_state_proto_enumTypes[0]
}
func (x Sorting_Order) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use Sorting_Order.Descriptor instead.
func (Sorting_Order) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{0, 0}
}
// Enum describing the supported concurrency for state.
type StateOptions_StateConcurrency int32
const (
StateOptions_CONCURRENCY_UNSPECIFIED StateOptions_StateConcurrency = 0
StateOptions_CONCURRENCY_FIRST_WRITE StateOptions_StateConcurrency = 1
StateOptions_CONCURRENCY_LAST_WRITE StateOptions_StateConcurrency = 2
)
// Enum value maps for StateOptions_StateConcurrency.
var (
StateOptions_StateConcurrency_name = map[int32]string{
0: "CONCURRENCY_UNSPECIFIED",
1: "CONCURRENCY_FIRST_WRITE",
2: "CONCURRENCY_LAST_WRITE",
}
StateOptions_StateConcurrency_value = map[string]int32{
"CONCURRENCY_UNSPECIFIED": 0,
"CONCURRENCY_FIRST_WRITE": 1,
"CONCURRENCY_LAST_WRITE": 2,
}
)
func (x StateOptions_StateConcurrency) Enum() *StateOptions_StateConcurrency {
p := new(StateOptions_StateConcurrency)
*p = x
return p
}
func (x StateOptions_StateConcurrency) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (StateOptions_StateConcurrency) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_components_v1_state_proto_enumTypes[1].Descriptor()
}
func (StateOptions_StateConcurrency) Type() protoreflect.EnumType {
return &file_dapr_proto_components_v1_state_proto_enumTypes[1]
}
func (x StateOptions_StateConcurrency) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use StateOptions_StateConcurrency.Descriptor instead.
func (StateOptions_StateConcurrency) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{10, 0}
}
// Enum describing the supported consistency for state.
type StateOptions_StateConsistency int32
const (
StateOptions_CONSISTENCY_UNSPECIFIED StateOptions_StateConsistency = 0
StateOptions_CONSISTENCY_EVENTUAL StateOptions_StateConsistency = 1
StateOptions_CONSISTENCY_STRONG StateOptions_StateConsistency = 2
)
// Enum value maps for StateOptions_StateConsistency.
var (
StateOptions_StateConsistency_name = map[int32]string{
0: "CONSISTENCY_UNSPECIFIED",
1: "CONSISTENCY_EVENTUAL",
2: "CONSISTENCY_STRONG",
}
StateOptions_StateConsistency_value = map[string]int32{
"CONSISTENCY_UNSPECIFIED": 0,
"CONSISTENCY_EVENTUAL": 1,
"CONSISTENCY_STRONG": 2,
}
)
func (x StateOptions_StateConsistency) Enum() *StateOptions_StateConsistency {
p := new(StateOptions_StateConsistency)
*p = x
return p
}
func (x StateOptions_StateConsistency) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (StateOptions_StateConsistency) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_components_v1_state_proto_enumTypes[2].Descriptor()
}
func (StateOptions_StateConsistency) Type() protoreflect.EnumType {
return &file_dapr_proto_components_v1_state_proto_enumTypes[2]
}
func (x StateOptions_StateConsistency) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use StateOptions_StateConsistency.Descriptor instead.
func (StateOptions_StateConsistency) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{10, 1}
}
type Sorting struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key that should be used for sorting.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The order that should be used.
Order Sorting_Order `protobuf:"varint,2,opt,name=order,proto3,enum=dapr.proto.components.v1.Sorting_Order" json:"order,omitempty"`
}
func (x *Sorting) Reset() {
*x = Sorting{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Sorting) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Sorting) ProtoMessage() {}
func (x *Sorting) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Sorting.ProtoReflect.Descriptor instead.
func (*Sorting) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{0}
}
func (x *Sorting) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *Sorting) GetOrder() Sorting_Order {
if x != nil {
return x.Order
}
return Sorting_ASC
}
type Pagination struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Maximum of results that should be returned.
Limit int64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
// The pagination token.
Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
}
func (x *Pagination) Reset() {
*x = Pagination{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Pagination) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Pagination) ProtoMessage() {}
func (x *Pagination) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Pagination.ProtoReflect.Descriptor instead.
func (*Pagination) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{1}
}
func (x *Pagination) GetLimit() int64 {
if x != nil {
return x.Limit
}
return 0
}
func (x *Pagination) GetToken() string {
if x != nil {
return x.Token
}
return ""
}
type Query struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Filters that should be applied.
Filter map[string]*anypb.Any `protobuf:"bytes,1,rep,name=filter,proto3" json:"filter,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The sort order.
Sort []*Sorting `protobuf:"bytes,2,rep,name=sort,proto3" json:"sort,omitempty"`
// The query pagination params.
Pagination *Pagination `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}
func (x *Query) Reset() {
*x = Query{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Query) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Query) ProtoMessage() {}
func (x *Query) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Query.ProtoReflect.Descriptor instead.
func (*Query) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{2}
}
func (x *Query) GetFilter() map[string]*anypb.Any {
if x != nil {
return x.Filter
}
return nil
}
func (x *Query) GetSort() []*Sorting {
if x != nil {
return x.Sort
}
return nil
}
func (x *Query) GetPagination() *Pagination {
if x != nil {
return x.Pagination
}
return nil
}
// QueryRequest is for querying state store.
type QueryRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The query to be performed.
Query *Query `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
// Request associated metadata.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *QueryRequest) Reset() {
*x = QueryRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *QueryRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*QueryRequest) ProtoMessage() {}
func (x *QueryRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use QueryRequest.ProtoReflect.Descriptor instead.
func (*QueryRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{3}
}
func (x *QueryRequest) GetQuery() *Query {
if x != nil {
return x.Query
}
return nil
}
func (x *QueryRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// QueryItem is an object representing a single entry in query results.
type QueryItem struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The returned item Key.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The returned item Data.
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// The returned item ETag
Etag *Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// The returned error string.
Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
// The returned contenttype
ContentType string `protobuf:"bytes,5,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *QueryItem) Reset() {
*x = QueryItem{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *QueryItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*QueryItem) ProtoMessage() {}
func (x *QueryItem) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use QueryItem.ProtoReflect.Descriptor instead.
func (*QueryItem) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{4}
}
func (x *QueryItem) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *QueryItem) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *QueryItem) GetEtag() *Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *QueryItem) GetError() string {
if x != nil {
return x.Error
}
return ""
}
func (x *QueryItem) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
// QueryResponse is the query response.
type QueryResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The query response items.
Items []*QueryItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
// The response token.
Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
// Response associated metadata.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *QueryResponse) Reset() {
*x = QueryResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *QueryResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*QueryResponse) ProtoMessage() {}
func (x *QueryResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use QueryResponse.ProtoReflect.Descriptor instead.
func (*QueryResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{5}
}
func (x *QueryResponse) GetItems() []*QueryItem {
if x != nil {
return x.Items
}
return nil
}
func (x *QueryResponse) GetToken() string {
if x != nil {
return x.Token
}
return ""
}
func (x *QueryResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// TransactionalStateOperation describes operation type, key, and value for
// transactional operation.
type TransactionalStateOperation struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// request is either delete or set.
//
// Types that are assignable to Request:
//
// *TransactionalStateOperation_Delete
// *TransactionalStateOperation_Set
Request isTransactionalStateOperation_Request `protobuf_oneof:"request"`
}
func (x *TransactionalStateOperation) Reset() {
*x = TransactionalStateOperation{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TransactionalStateOperation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransactionalStateOperation) ProtoMessage() {}
func (x *TransactionalStateOperation) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransactionalStateOperation.ProtoReflect.Descriptor instead.
func (*TransactionalStateOperation) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{6}
}
func (m *TransactionalStateOperation) GetRequest() isTransactionalStateOperation_Request {
if m != nil {
return m.Request
}
return nil
}
func (x *TransactionalStateOperation) GetDelete() *DeleteRequest {
if x, ok := x.GetRequest().(*TransactionalStateOperation_Delete); ok {
return x.Delete
}
return nil
}
func (x *TransactionalStateOperation) GetSet() *SetRequest {
if x, ok := x.GetRequest().(*TransactionalStateOperation_Set); ok {
return x.Set
}
return nil
}
type isTransactionalStateOperation_Request interface {
isTransactionalStateOperation_Request()
}
type TransactionalStateOperation_Delete struct {
Delete *DeleteRequest `protobuf:"bytes,1,opt,name=delete,proto3,oneof"`
}
type TransactionalStateOperation_Set struct {
Set *SetRequest `protobuf:"bytes,2,opt,name=set,proto3,oneof"`
}
func (*TransactionalStateOperation_Delete) isTransactionalStateOperation_Request() {}
func (*TransactionalStateOperation_Set) isTransactionalStateOperation_Request() {}
// TransactionalStateRequest describes a transactional operation against a state
// store that comprises multiple types of operations The Request field is either
// a DeleteRequest or SetRequest.
type TransactionalStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Operations that should be performed.
Operations []*TransactionalStateOperation `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"`
// Request associated metadata.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *TransactionalStateRequest) Reset() {
*x = TransactionalStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TransactionalStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransactionalStateRequest) ProtoMessage() {}
func (x *TransactionalStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransactionalStateRequest.ProtoReflect.Descriptor instead.
func (*TransactionalStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{7}
}
func (x *TransactionalStateRequest) GetOperations() []*TransactionalStateOperation {
if x != nil {
return x.Operations
}
return nil
}
func (x *TransactionalStateRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// reserved for future-proof extensibility
type TransactionalStateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *TransactionalStateResponse) Reset() {
*x = TransactionalStateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TransactionalStateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransactionalStateResponse) ProtoMessage() {}
func (x *TransactionalStateResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransactionalStateResponse.ProtoReflect.Descriptor instead.
func (*TransactionalStateResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{8}
}
// Etag represents a state item version
type Etag struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// value sets the etag value
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}
func (x *Etag) Reset() {
*x = Etag{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Etag) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Etag) ProtoMessage() {}
func (x *Etag) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Etag.ProtoReflect.Descriptor instead.
func (*Etag) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{9}
}
func (x *Etag) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
// StateOptions configures concurrency and consistency for state operations
type StateOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Concurrency StateOptions_StateConcurrency `protobuf:"varint,1,opt,name=concurrency,proto3,enum=dapr.proto.components.v1.StateOptions_StateConcurrency" json:"concurrency,omitempty"`
Consistency StateOptions_StateConsistency `protobuf:"varint,2,opt,name=consistency,proto3,enum=dapr.proto.components.v1.StateOptions_StateConsistency" json:"consistency,omitempty"`
}
func (x *StateOptions) Reset() {
*x = StateOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StateOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StateOptions) ProtoMessage() {}
func (x *StateOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StateOptions.ProtoReflect.Descriptor instead.
func (*StateOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{10}
}
func (x *StateOptions) GetConcurrency() StateOptions_StateConcurrency {
if x != nil {
return x.Concurrency
}
return StateOptions_CONCURRENCY_UNSPECIFIED
}
func (x *StateOptions) GetConsistency() StateOptions_StateConsistency {
if x != nil {
return x.Consistency
}
return StateOptions_CONSISTENCY_UNSPECIFIED
}
// InitRequest is the request for initializing the component.
type InitRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Metadata *MetadataRequest `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
}
func (x *InitRequest) Reset() {
*x = InitRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InitRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InitRequest) ProtoMessage() {}
func (x *InitRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InitRequest.ProtoReflect.Descriptor instead.
func (*InitRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{11}
}
func (x *InitRequest) GetMetadata() *MetadataRequest {
if x != nil {
return x.Metadata
}
return nil
}
// reserved for future-proof extensibility
type InitResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *InitResponse) Reset() {
*x = InitResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InitResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InitResponse) ProtoMessage() {}
func (x *InitResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[12]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InitResponse.ProtoReflect.Descriptor instead.
func (*InitResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{12}
}
type GetRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key that should be retrieved.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// Request associated metadata.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The get consistency level.
Consistency StateOptions_StateConsistency `protobuf:"varint,3,opt,name=consistency,proto3,enum=dapr.proto.components.v1.StateOptions_StateConsistency" json:"consistency,omitempty"`
}
func (x *GetRequest) Reset() {
*x = GetRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetRequest) ProtoMessage() {}
func (x *GetRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[13]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetRequest.ProtoReflect.Descriptor instead.
func (*GetRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{13}
}
func (x *GetRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *GetRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *GetRequest) GetConsistency() StateOptions_StateConsistency {
if x != nil {
return x.Consistency
}
return StateOptions_CONSISTENCY_UNSPECIFIED
}
type GetResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The data of the GetRequest response.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The etag of the associated key.
Etag *Etag `protobuf:"bytes,2,opt,name=etag,proto3" json:"etag,omitempty"`
// Metadata related to the response.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The response data contenttype
ContentType string `protobuf:"bytes,4,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *GetResponse) Reset() {
*x = GetResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetResponse) ProtoMessage() {}
func (x *GetResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[14]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetResponse.ProtoReflect.Descriptor instead.
func (*GetResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{14}
}
func (x *GetResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *GetResponse) GetEtag() *Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *GetResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *GetResponse) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
type DeleteRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key that should be deleted.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The etag is used as a If-Match header, to allow certain levels of
// consistency.
Etag *Etag `protobuf:"bytes,2,opt,name=etag,proto3" json:"etag,omitempty"`
// The request metadata.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Options *StateOptions `protobuf:"bytes,4,opt,name=options,proto3" json:"options,omitempty"`
}
func (x *DeleteRequest) Reset() {
*x = DeleteRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteRequest) ProtoMessage() {}
func (x *DeleteRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[15]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteRequest.ProtoReflect.Descriptor instead.
func (*DeleteRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{15}
}
func (x *DeleteRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *DeleteRequest) GetEtag() *Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *DeleteRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *DeleteRequest) GetOptions() *StateOptions {
if x != nil {
return x.Options
}
return nil
}
// reserved for future-proof extensibility
type DeleteResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *DeleteResponse) Reset() {
*x = DeleteResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteResponse) ProtoMessage() {}
func (x *DeleteResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[16]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteResponse.ProtoReflect.Descriptor instead.
func (*DeleteResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{16}
}
type SetRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key that should be set.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// Value is the desired content of the given key.
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
// The etag is used as a If-Match header, to allow certain levels of
// consistency.
Etag *Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// The request metadata.
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The Set request options.
Options *StateOptions `protobuf:"bytes,5,opt,name=options,proto3" json:"options,omitempty"`
// The data contenttype
ContentType string `protobuf:"bytes,6,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *SetRequest) Reset() {
*x = SetRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetRequest) ProtoMessage() {}
func (x *SetRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[17]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetRequest.ProtoReflect.Descriptor instead.
func (*SetRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{17}
}
func (x *SetRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *SetRequest) GetValue() []byte {
if x != nil {
return x.Value
}
return nil
}
func (x *SetRequest) GetEtag() *Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *SetRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *SetRequest) GetOptions() *StateOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *SetRequest) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
// reserved for future-proof extensibility
type SetResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *SetResponse) Reset() {
*x = SetResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetResponse) ProtoMessage() {}
func (x *SetResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[18]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetResponse.ProtoReflect.Descriptor instead.
func (*SetResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{18}
}
type BulkDeleteRequestOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Parallelism int64 `protobuf:"varint,1,opt,name=parallelism,proto3" json:"parallelism,omitempty"`
}
func (x *BulkDeleteRequestOptions) Reset() {
*x = BulkDeleteRequestOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkDeleteRequestOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkDeleteRequestOptions) ProtoMessage() {}
func (x *BulkDeleteRequestOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[19]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkDeleteRequestOptions.ProtoReflect.Descriptor instead.
func (*BulkDeleteRequestOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{19}
}
func (x *BulkDeleteRequestOptions) GetParallelism() int64 {
if x != nil {
return x.Parallelism
}
return 0
}
type BulkDeleteRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Items []*DeleteRequest `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
Options *BulkDeleteRequestOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
}
func (x *BulkDeleteRequest) Reset() {
*x = BulkDeleteRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkDeleteRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkDeleteRequest) ProtoMessage() {}
func (x *BulkDeleteRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[20]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkDeleteRequest.ProtoReflect.Descriptor instead.
func (*BulkDeleteRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{20}
}
func (x *BulkDeleteRequest) GetItems() []*DeleteRequest {
if x != nil {
return x.Items
}
return nil
}
func (x *BulkDeleteRequest) GetOptions() *BulkDeleteRequestOptions {
if x != nil {
return x.Options
}
return nil
}
// reserved for future-proof extensibility
type BulkDeleteResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *BulkDeleteResponse) Reset() {
*x = BulkDeleteResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkDeleteResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkDeleteResponse) ProtoMessage() {}
func (x *BulkDeleteResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[21]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkDeleteResponse.ProtoReflect.Descriptor instead.
func (*BulkDeleteResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{21}
}
type BulkGetRequestOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Parallelism int64 `protobuf:"varint,1,opt,name=parallelism,proto3" json:"parallelism,omitempty"`
}
func (x *BulkGetRequestOptions) Reset() {
*x = BulkGetRequestOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkGetRequestOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkGetRequestOptions) ProtoMessage() {}
func (x *BulkGetRequestOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[22]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkGetRequestOptions.ProtoReflect.Descriptor instead.
func (*BulkGetRequestOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{22}
}
func (x *BulkGetRequestOptions) GetParallelism() int64 {
if x != nil {
return x.Parallelism
}
return 0
}
type BulkGetRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Items []*GetRequest `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
Options *BulkGetRequestOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
}
func (x *BulkGetRequest) Reset() {
*x = BulkGetRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkGetRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkGetRequest) ProtoMessage() {}
func (x *BulkGetRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[23]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkGetRequest.ProtoReflect.Descriptor instead.
func (*BulkGetRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{23}
}
func (x *BulkGetRequest) GetItems() []*GetRequest {
if x != nil {
return x.Items
}
return nil
}
func (x *BulkGetRequest) GetOptions() *BulkGetRequestOptions {
if x != nil {
return x.Options
}
return nil
}
type BulkStateItem struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The key of the fetched item.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The associated data of the fetched item.
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// The item ETag
Etag *Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// A fetch error if there's some.
Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
// The State Item metadata.
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The data contenttype
ContentType string `protobuf:"bytes,6,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
}
func (x *BulkStateItem) Reset() {
*x = BulkStateItem{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkStateItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkStateItem) ProtoMessage() {}
func (x *BulkStateItem) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[24]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkStateItem.ProtoReflect.Descriptor instead.
func (*BulkStateItem) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{24}
}
func (x *BulkStateItem) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *BulkStateItem) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *BulkStateItem) GetEtag() *Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *BulkStateItem) GetError() string {
if x != nil {
return x.Error
}
return ""
}
func (x *BulkStateItem) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *BulkStateItem) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
type BulkGetResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Items []*BulkStateItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
}
func (x *BulkGetResponse) Reset() {
*x = BulkGetResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkGetResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkGetResponse) ProtoMessage() {}
func (x *BulkGetResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[25]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkGetResponse.ProtoReflect.Descriptor instead.
func (*BulkGetResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{25}
}
func (x *BulkGetResponse) GetItems() []*BulkStateItem {
if x != nil {
return x.Items
}
return nil
}
type BulkSetRequestOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Parallelism int64 `protobuf:"varint,1,opt,name=parallelism,proto3" json:"parallelism,omitempty"`
}
func (x *BulkSetRequestOptions) Reset() {
*x = BulkSetRequestOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkSetRequestOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkSetRequestOptions) ProtoMessage() {}
func (x *BulkSetRequestOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[26]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkSetRequestOptions.ProtoReflect.Descriptor instead.
func (*BulkSetRequestOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{26}
}
func (x *BulkSetRequestOptions) GetParallelism() int64 {
if x != nil {
return x.Parallelism
}
return 0
}
type BulkSetRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Items []*SetRequest `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
Options *BulkSetRequestOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"`
}
func (x *BulkSetRequest) Reset() {
*x = BulkSetRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkSetRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkSetRequest) ProtoMessage() {}
func (x *BulkSetRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[27]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkSetRequest.ProtoReflect.Descriptor instead.
func (*BulkSetRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{27}
}
func (x *BulkSetRequest) GetItems() []*SetRequest {
if x != nil {
return x.Items
}
return nil
}
func (x *BulkSetRequest) GetOptions() *BulkSetRequestOptions {
if x != nil {
return x.Options
}
return nil
}
// reserved for future-proof extensibility
type BulkSetResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *BulkSetResponse) Reset() {
*x = BulkSetResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkSetResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkSetResponse) ProtoMessage() {}
func (x *BulkSetResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[28]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkSetResponse.ProtoReflect.Descriptor instead.
func (*BulkSetResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{28}
}
// MultiMaxSizeRequest is the request for MultiMaxSize. It is empty because
// there are no parameters.
type MultiMaxSizeRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *MultiMaxSizeRequest) Reset() {
*x = MultiMaxSizeRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *MultiMaxSizeRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MultiMaxSizeRequest) ProtoMessage() {}
func (x *MultiMaxSizeRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[29]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MultiMaxSizeRequest.ProtoReflect.Descriptor instead.
func (*MultiMaxSizeRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{29}
}
// MultiMaxSizeResponse is the response for MultiMaxSize.
type MultiMaxSizeResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The maximum number of operations that can be performed in a single
// transaction.
MaxSize int64 `protobuf:"varint,1,opt,name=max_size,json=maxSize,proto3" json:"max_size,omitempty"`
}
func (x *MultiMaxSizeResponse) Reset() {
*x = MultiMaxSizeResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *MultiMaxSizeResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MultiMaxSizeResponse) ProtoMessage() {}
func (x *MultiMaxSizeResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_components_v1_state_proto_msgTypes[30]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MultiMaxSizeResponse.ProtoReflect.Descriptor instead.
func (*MultiMaxSizeResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_components_v1_state_proto_rawDescGZIP(), []int{30}
}
func (x *MultiMaxSizeResponse) GetMaxSize() int64 {
if x != nil {
return x.MaxSize
}
return 0
}
var File_dapr_proto_components_v1_state_proto protoreflect.FileDescriptor
var file_dapr_proto_components_v1_state_proto_rawDesc = []byte{
0x0a, 0x24, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25, 0x64, 0x61, 0x70,
0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x22, 0x76, 0x0a, 0x07, 0x53, 0x6f, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x10, 0x0a,
0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
0x3d, 0x0a, 0x05, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x69, 0x6e,
0x67, 0x2e, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x05, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x22, 0x1a,
0x0a, 0x05, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x53, 0x43, 0x10, 0x00,
0x12, 0x08, 0x0a, 0x04, 0x44, 0x45, 0x53, 0x43, 0x10, 0x01, 0x22, 0x38, 0x0a, 0x0a, 0x50, 0x61,
0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69,
0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x14,
0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74,
0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x9a, 0x02, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x43,
0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x2e,
0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x66, 0x69, 0x6c,
0x74, 0x65, 0x72, 0x12, 0x35, 0x0a, 0x04, 0x73, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x21, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6f, 0x72,
0x74, 0x69, 0x6e, 0x67, 0x52, 0x04, 0x73, 0x6f, 0x72, 0x74, 0x12, 0x44, 0x0a, 0x0a, 0x70, 0x61,
0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x1a, 0x4f, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
0x01, 0x22, 0xd4, 0x01, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x35, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x1f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65,
0x72, 0x79, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x50, 0x0a, 0x08, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9e, 0x01, 0x0a, 0x09, 0x51, 0x75, 0x65,
0x72, 0x79, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x32, 0x0a, 0x04,
0x65, 0x74, 0x61, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x74, 0x61, 0x67, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67,
0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f,
0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0xf0, 0x01, 0x0a, 0x0d, 0x51, 0x75,
0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x05, 0x69,
0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x74, 0x65, 0x6d, 0x52,
0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x51, 0x0a, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a,
0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xa5, 0x01, 0x0a,
0x1b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74,
0x61, 0x74, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x06,
0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12,
0x38, 0x0a, 0x03, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x48, 0x00, 0x52, 0x03, 0x73, 0x65, 0x74, 0x42, 0x09, 0x0a, 0x07, 0x72, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x22, 0x8e, 0x02, 0x0a, 0x19, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x55, 0x0a, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53,
0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x6f,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5d, 0x0a, 0x08, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x1c, 0x0a, 0x1a, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x1c, 0x0a, 0x04, 0x45, 0x74, 0x61, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x22, 0x91, 0x03, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x12, 0x59, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e,
0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79,
0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x59, 0x0a,
0x0b, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x02, 0x20, 0x01,
0x28, 0x0e, 0x32, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74,
0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65,
0x43, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x0b, 0x63, 0x6f, 0x6e,
0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x22, 0x68, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x74,
0x65, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1b, 0x0a, 0x17,
0x43, 0x4f, 0x4e, 0x43, 0x55, 0x52, 0x52, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50,
0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x4f, 0x4e,
0x43, 0x55, 0x52, 0x52, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x46, 0x49, 0x52, 0x53, 0x54, 0x5f, 0x57,
0x52, 0x49, 0x54, 0x45, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x43, 0x4f, 0x4e, 0x43, 0x55, 0x52,
0x52, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x4c, 0x41, 0x53, 0x54, 0x5f, 0x57, 0x52, 0x49, 0x54, 0x45,
0x10, 0x02, 0x22, 0x61, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x69,
0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53,
0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45,
0x44, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e,
0x43, 0x59, 0x5f, 0x45, 0x56, 0x45, 0x4e, 0x54, 0x55, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x16, 0x0a,
0x12, 0x43, 0x4f, 0x4e, 0x53, 0x49, 0x53, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x53, 0x54, 0x52,
0x4f, 0x4e, 0x47, 0x10, 0x02, 0x22, 0x54, 0x0a, 0x0b, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x45, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x0e, 0x0a, 0x0c, 0x49,
0x6e, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x86, 0x02, 0x0a, 0x0a,
0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x4e, 0x0a, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x59, 0x0a, 0x0b,
0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28,
0x0e, 0x32, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61,
0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43,
0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x73,
0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x3a, 0x02, 0x38, 0x01, 0x22, 0x86, 0x02, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01,
0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x32, 0x0a, 0x04, 0x65, 0x74, 0x61, 0x67,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x45, 0x74, 0x61, 0x67, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x4f, 0x0a, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a,
0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20,
0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65,
0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xa7, 0x02,
0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x32, 0x0a, 0x04, 0x65, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x1e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x74, 0x61, 0x67, 0x52,
0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x51, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x40, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x10, 0x0a, 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74,
0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xda, 0x02, 0x0a, 0x0a, 0x53, 0x65,
0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x12, 0x32, 0x0a, 0x04, 0x65, 0x74, 0x61, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x74, 0x61, 0x67, 0x52, 0x04,
0x65, 0x74, 0x61, 0x67, 0x12, 0x4e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x12, 0x40, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18,
0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f,
0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x0d, 0x0a, 0x0b, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3c, 0x0a, 0x18, 0x42, 0x75, 0x6c, 0x6b, 0x44, 0x65, 0x6c,
0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d,
0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c,
0x69, 0x73, 0x6d, 0x22, 0xa0, 0x01, 0x0a, 0x11, 0x42, 0x75, 0x6c, 0x6b, 0x44, 0x65, 0x6c, 0x65,
0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x05, 0x69, 0x74, 0x65,
0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x4c, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x14, 0x0a, 0x12, 0x42, 0x75, 0x6c, 0x6b, 0x44, 0x65,
0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x39, 0x0a, 0x15,
0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65,
0x6c, 0x69, 0x73, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x61,
0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x22, 0x97, 0x01, 0x0a, 0x0e, 0x42, 0x75, 0x6c, 0x6b,
0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x05, 0x69, 0x74,
0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52,
0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x49, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x22, 0xb2, 0x02, 0x0a, 0x0d, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49,
0x74, 0x65, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x32, 0x0a, 0x04, 0x65, 0x74, 0x61,
0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x45, 0x74, 0x61, 0x67, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x14, 0x0a,
0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72,
0x72, 0x6f, 0x72, 0x12, 0x51, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18,
0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f,
0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x50, 0x0a, 0x0f, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x05, 0x69, 0x74, 0x65,
0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65,
0x6d, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x39, 0x0a, 0x15, 0x42, 0x75, 0x6c, 0x6b,
0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d,
0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c,
0x69, 0x73, 0x6d, 0x22, 0x97, 0x01, 0x0a, 0x0e, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x74, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18,
0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x05, 0x69, 0x74, 0x65,
0x6d, 0x73, 0x12, 0x49, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42,
0x75, 0x6c, 0x6b, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x11, 0x0a,
0x0f, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x15, 0x0a, 0x13, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x31, 0x0a, 0x14, 0x4d, 0x75, 0x6c, 0x74, 0x69,
0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x32, 0x71, 0x0a, 0x13, 0x51, 0x75,
0x65, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x74, 0x6f, 0x72,
0x65, 0x12, 0x5a, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x26, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75,
0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x32, 0x92, 0x01,
0x0a, 0x17, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53,
0x74, 0x61, 0x74, 0x65, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x12, 0x77, 0x0a, 0x08, 0x54, 0x72, 0x61,
0x6e, 0x73, 0x61, 0x63, 0x74, 0x12, 0x33, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74,
0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x32, 0xdd, 0x06, 0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x74, 0x6f, 0x72,
0x65, 0x12, 0x57, 0x0a, 0x04, 0x49, 0x6e, 0x69, 0x74, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x69, 0x74,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x08, 0x46, 0x65,
0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x61,
0x74, 0x75, 0x72, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
0x5d, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65,
0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54,
0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x24, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x03, 0x53, 0x65, 0x74, 0x12, 0x24, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x04, 0x50, 0x69,
0x6e, 0x67, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x69,
0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0a, 0x42, 0x75, 0x6c, 0x6b, 0x44, 0x65, 0x6c, 0x65, 0x74,
0x65, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c,
0x6b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x44, 0x65,
0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x60,
0x0a, 0x07, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x12, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42,
0x75, 0x6c, 0x6b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
0x12, 0x60, 0x0a, 0x07, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x74, 0x12, 0x28, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x74, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x32, 0x91, 0x01, 0x0a, 0x1e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x4d, 0x61,
0x78, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x6f, 0x0a, 0x0c, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x4d, 0x61,
0x78, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e,
0x4d, 0x75, 0x6c, 0x74, 0x69, 0x4d, 0x61, 0x78, 0x53, 0x69, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x39, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70,
0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_components_v1_state_proto_rawDescOnce sync.Once
file_dapr_proto_components_v1_state_proto_rawDescData = file_dapr_proto_components_v1_state_proto_rawDesc
)
func file_dapr_proto_components_v1_state_proto_rawDescGZIP() []byte {
file_dapr_proto_components_v1_state_proto_rawDescOnce.Do(func() {
file_dapr_proto_components_v1_state_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_components_v1_state_proto_rawDescData)
})
return file_dapr_proto_components_v1_state_proto_rawDescData
}
var file_dapr_proto_components_v1_state_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_dapr_proto_components_v1_state_proto_msgTypes = make([]protoimpl.MessageInfo, 40)
var file_dapr_proto_components_v1_state_proto_goTypes = []interface{}{
(Sorting_Order)(0), // 0: dapr.proto.components.v1.Sorting.Order
(StateOptions_StateConcurrency)(0), // 1: dapr.proto.components.v1.StateOptions.StateConcurrency
(StateOptions_StateConsistency)(0), // 2: dapr.proto.components.v1.StateOptions.StateConsistency
(*Sorting)(nil), // 3: dapr.proto.components.v1.Sorting
(*Pagination)(nil), // 4: dapr.proto.components.v1.Pagination
(*Query)(nil), // 5: dapr.proto.components.v1.Query
(*QueryRequest)(nil), // 6: dapr.proto.components.v1.QueryRequest
(*QueryItem)(nil), // 7: dapr.proto.components.v1.QueryItem
(*QueryResponse)(nil), // 8: dapr.proto.components.v1.QueryResponse
(*TransactionalStateOperation)(nil), // 9: dapr.proto.components.v1.TransactionalStateOperation
(*TransactionalStateRequest)(nil), // 10: dapr.proto.components.v1.TransactionalStateRequest
(*TransactionalStateResponse)(nil), // 11: dapr.proto.components.v1.TransactionalStateResponse
(*Etag)(nil), // 12: dapr.proto.components.v1.Etag
(*StateOptions)(nil), // 13: dapr.proto.components.v1.StateOptions
(*InitRequest)(nil), // 14: dapr.proto.components.v1.InitRequest
(*InitResponse)(nil), // 15: dapr.proto.components.v1.InitResponse
(*GetRequest)(nil), // 16: dapr.proto.components.v1.GetRequest
(*GetResponse)(nil), // 17: dapr.proto.components.v1.GetResponse
(*DeleteRequest)(nil), // 18: dapr.proto.components.v1.DeleteRequest
(*DeleteResponse)(nil), // 19: dapr.proto.components.v1.DeleteResponse
(*SetRequest)(nil), // 20: dapr.proto.components.v1.SetRequest
(*SetResponse)(nil), // 21: dapr.proto.components.v1.SetResponse
(*BulkDeleteRequestOptions)(nil), // 22: dapr.proto.components.v1.BulkDeleteRequestOptions
(*BulkDeleteRequest)(nil), // 23: dapr.proto.components.v1.BulkDeleteRequest
(*BulkDeleteResponse)(nil), // 24: dapr.proto.components.v1.BulkDeleteResponse
(*BulkGetRequestOptions)(nil), // 25: dapr.proto.components.v1.BulkGetRequestOptions
(*BulkGetRequest)(nil), // 26: dapr.proto.components.v1.BulkGetRequest
(*BulkStateItem)(nil), // 27: dapr.proto.components.v1.BulkStateItem
(*BulkGetResponse)(nil), // 28: dapr.proto.components.v1.BulkGetResponse
(*BulkSetRequestOptions)(nil), // 29: dapr.proto.components.v1.BulkSetRequestOptions
(*BulkSetRequest)(nil), // 30: dapr.proto.components.v1.BulkSetRequest
(*BulkSetResponse)(nil), // 31: dapr.proto.components.v1.BulkSetResponse
(*MultiMaxSizeRequest)(nil), // 32: dapr.proto.components.v1.MultiMaxSizeRequest
(*MultiMaxSizeResponse)(nil), // 33: dapr.proto.components.v1.MultiMaxSizeResponse
nil, // 34: dapr.proto.components.v1.Query.FilterEntry
nil, // 35: dapr.proto.components.v1.QueryRequest.MetadataEntry
nil, // 36: dapr.proto.components.v1.QueryResponse.MetadataEntry
nil, // 37: dapr.proto.components.v1.TransactionalStateRequest.MetadataEntry
nil, // 38: dapr.proto.components.v1.GetRequest.MetadataEntry
nil, // 39: dapr.proto.components.v1.GetResponse.MetadataEntry
nil, // 40: dapr.proto.components.v1.DeleteRequest.MetadataEntry
nil, // 41: dapr.proto.components.v1.SetRequest.MetadataEntry
nil, // 42: dapr.proto.components.v1.BulkStateItem.MetadataEntry
(*MetadataRequest)(nil), // 43: dapr.proto.components.v1.MetadataRequest
(*anypb.Any)(nil), // 44: google.protobuf.Any
(*FeaturesRequest)(nil), // 45: dapr.proto.components.v1.FeaturesRequest
(*PingRequest)(nil), // 46: dapr.proto.components.v1.PingRequest
(*FeaturesResponse)(nil), // 47: dapr.proto.components.v1.FeaturesResponse
(*PingResponse)(nil), // 48: dapr.proto.components.v1.PingResponse
}
var file_dapr_proto_components_v1_state_proto_depIdxs = []int32{
0, // 0: dapr.proto.components.v1.Sorting.order:type_name -> dapr.proto.components.v1.Sorting.Order
34, // 1: dapr.proto.components.v1.Query.filter:type_name -> dapr.proto.components.v1.Query.FilterEntry
3, // 2: dapr.proto.components.v1.Query.sort:type_name -> dapr.proto.components.v1.Sorting
4, // 3: dapr.proto.components.v1.Query.pagination:type_name -> dapr.proto.components.v1.Pagination
5, // 4: dapr.proto.components.v1.QueryRequest.query:type_name -> dapr.proto.components.v1.Query
35, // 5: dapr.proto.components.v1.QueryRequest.metadata:type_name -> dapr.proto.components.v1.QueryRequest.MetadataEntry
12, // 6: dapr.proto.components.v1.QueryItem.etag:type_name -> dapr.proto.components.v1.Etag
7, // 7: dapr.proto.components.v1.QueryResponse.items:type_name -> dapr.proto.components.v1.QueryItem
36, // 8: dapr.proto.components.v1.QueryResponse.metadata:type_name -> dapr.proto.components.v1.QueryResponse.MetadataEntry
18, // 9: dapr.proto.components.v1.TransactionalStateOperation.delete:type_name -> dapr.proto.components.v1.DeleteRequest
20, // 10: dapr.proto.components.v1.TransactionalStateOperation.set:type_name -> dapr.proto.components.v1.SetRequest
9, // 11: dapr.proto.components.v1.TransactionalStateRequest.operations:type_name -> dapr.proto.components.v1.TransactionalStateOperation
37, // 12: dapr.proto.components.v1.TransactionalStateRequest.metadata:type_name -> dapr.proto.components.v1.TransactionalStateRequest.MetadataEntry
1, // 13: dapr.proto.components.v1.StateOptions.concurrency:type_name -> dapr.proto.components.v1.StateOptions.StateConcurrency
2, // 14: dapr.proto.components.v1.StateOptions.consistency:type_name -> dapr.proto.components.v1.StateOptions.StateConsistency
43, // 15: dapr.proto.components.v1.InitRequest.metadata:type_name -> dapr.proto.components.v1.MetadataRequest
38, // 16: dapr.proto.components.v1.GetRequest.metadata:type_name -> dapr.proto.components.v1.GetRequest.MetadataEntry
2, // 17: dapr.proto.components.v1.GetRequest.consistency:type_name -> dapr.proto.components.v1.StateOptions.StateConsistency
12, // 18: dapr.proto.components.v1.GetResponse.etag:type_name -> dapr.proto.components.v1.Etag
39, // 19: dapr.proto.components.v1.GetResponse.metadata:type_name -> dapr.proto.components.v1.GetResponse.MetadataEntry
12, // 20: dapr.proto.components.v1.DeleteRequest.etag:type_name -> dapr.proto.components.v1.Etag
40, // 21: dapr.proto.components.v1.DeleteRequest.metadata:type_name -> dapr.proto.components.v1.DeleteRequest.MetadataEntry
13, // 22: dapr.proto.components.v1.DeleteRequest.options:type_name -> dapr.proto.components.v1.StateOptions
12, // 23: dapr.proto.components.v1.SetRequest.etag:type_name -> dapr.proto.components.v1.Etag
41, // 24: dapr.proto.components.v1.SetRequest.metadata:type_name -> dapr.proto.components.v1.SetRequest.MetadataEntry
13, // 25: dapr.proto.components.v1.SetRequest.options:type_name -> dapr.proto.components.v1.StateOptions
18, // 26: dapr.proto.components.v1.BulkDeleteRequest.items:type_name -> dapr.proto.components.v1.DeleteRequest
22, // 27: dapr.proto.components.v1.BulkDeleteRequest.options:type_name -> dapr.proto.components.v1.BulkDeleteRequestOptions
16, // 28: dapr.proto.components.v1.BulkGetRequest.items:type_name -> dapr.proto.components.v1.GetRequest
25, // 29: dapr.proto.components.v1.BulkGetRequest.options:type_name -> dapr.proto.components.v1.BulkGetRequestOptions
12, // 30: dapr.proto.components.v1.BulkStateItem.etag:type_name -> dapr.proto.components.v1.Etag
42, // 31: dapr.proto.components.v1.BulkStateItem.metadata:type_name -> dapr.proto.components.v1.BulkStateItem.MetadataEntry
27, // 32: dapr.proto.components.v1.BulkGetResponse.items:type_name -> dapr.proto.components.v1.BulkStateItem
20, // 33: dapr.proto.components.v1.BulkSetRequest.items:type_name -> dapr.proto.components.v1.SetRequest
29, // 34: dapr.proto.components.v1.BulkSetRequest.options:type_name -> dapr.proto.components.v1.BulkSetRequestOptions
44, // 35: dapr.proto.components.v1.Query.FilterEntry.value:type_name -> google.protobuf.Any
6, // 36: dapr.proto.components.v1.QueriableStateStore.Query:input_type -> dapr.proto.components.v1.QueryRequest
10, // 37: dapr.proto.components.v1.TransactionalStateStore.Transact:input_type -> dapr.proto.components.v1.TransactionalStateRequest
14, // 38: dapr.proto.components.v1.StateStore.Init:input_type -> dapr.proto.components.v1.InitRequest
45, // 39: dapr.proto.components.v1.StateStore.Features:input_type -> dapr.proto.components.v1.FeaturesRequest
18, // 40: dapr.proto.components.v1.StateStore.Delete:input_type -> dapr.proto.components.v1.DeleteRequest
16, // 41: dapr.proto.components.v1.StateStore.Get:input_type -> dapr.proto.components.v1.GetRequest
20, // 42: dapr.proto.components.v1.StateStore.Set:input_type -> dapr.proto.components.v1.SetRequest
46, // 43: dapr.proto.components.v1.StateStore.Ping:input_type -> dapr.proto.components.v1.PingRequest
23, // 44: dapr.proto.components.v1.StateStore.BulkDelete:input_type -> dapr.proto.components.v1.BulkDeleteRequest
26, // 45: dapr.proto.components.v1.StateStore.BulkGet:input_type -> dapr.proto.components.v1.BulkGetRequest
30, // 46: dapr.proto.components.v1.StateStore.BulkSet:input_type -> dapr.proto.components.v1.BulkSetRequest
32, // 47: dapr.proto.components.v1.TransactionalStoreMultiMaxSize.MultiMaxSize:input_type -> dapr.proto.components.v1.MultiMaxSizeRequest
8, // 48: dapr.proto.components.v1.QueriableStateStore.Query:output_type -> dapr.proto.components.v1.QueryResponse
11, // 49: dapr.proto.components.v1.TransactionalStateStore.Transact:output_type -> dapr.proto.components.v1.TransactionalStateResponse
15, // 50: dapr.proto.components.v1.StateStore.Init:output_type -> dapr.proto.components.v1.InitResponse
47, // 51: dapr.proto.components.v1.StateStore.Features:output_type -> dapr.proto.components.v1.FeaturesResponse
19, // 52: dapr.proto.components.v1.StateStore.Delete:output_type -> dapr.proto.components.v1.DeleteResponse
17, // 53: dapr.proto.components.v1.StateStore.Get:output_type -> dapr.proto.components.v1.GetResponse
21, // 54: dapr.proto.components.v1.StateStore.Set:output_type -> dapr.proto.components.v1.SetResponse
48, // 55: dapr.proto.components.v1.StateStore.Ping:output_type -> dapr.proto.components.v1.PingResponse
24, // 56: dapr.proto.components.v1.StateStore.BulkDelete:output_type -> dapr.proto.components.v1.BulkDeleteResponse
28, // 57: dapr.proto.components.v1.StateStore.BulkGet:output_type -> dapr.proto.components.v1.BulkGetResponse
31, // 58: dapr.proto.components.v1.StateStore.BulkSet:output_type -> dapr.proto.components.v1.BulkSetResponse
33, // 59: dapr.proto.components.v1.TransactionalStoreMultiMaxSize.MultiMaxSize:output_type -> dapr.proto.components.v1.MultiMaxSizeResponse
48, // [48:60] is the sub-list for method output_type
36, // [36:48] is the sub-list for method input_type
36, // [36:36] is the sub-list for extension type_name
36, // [36:36] is the sub-list for extension extendee
0, // [0:36] is the sub-list for field type_name
}
func init() { file_dapr_proto_components_v1_state_proto_init() }
func file_dapr_proto_components_v1_state_proto_init() {
if File_dapr_proto_components_v1_state_proto != nil {
return
}
file_dapr_proto_components_v1_common_proto_init()
if !protoimpl.UnsafeEnabled {
file_dapr_proto_components_v1_state_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Sorting); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Pagination); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Query); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*QueryRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*QueryItem); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*QueryResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TransactionalStateOperation); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TransactionalStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TransactionalStateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Etag); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StateOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InitRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InitResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkDeleteRequestOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkDeleteRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkDeleteResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkGetRequestOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkGetRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkStateItem); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkGetResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkSetRequestOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkSetRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkSetResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MultiMaxSizeRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MultiMaxSizeResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
file_dapr_proto_components_v1_state_proto_msgTypes[6].OneofWrappers = []interface{}{
(*TransactionalStateOperation_Delete)(nil),
(*TransactionalStateOperation_Set)(nil),
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_components_v1_state_proto_rawDesc,
NumEnums: 3,
NumMessages: 40,
NumExtensions: 0,
NumServices: 4,
},
GoTypes: file_dapr_proto_components_v1_state_proto_goTypes,
DependencyIndexes: file_dapr_proto_components_v1_state_proto_depIdxs,
EnumInfos: file_dapr_proto_components_v1_state_proto_enumTypes,
MessageInfos: file_dapr_proto_components_v1_state_proto_msgTypes,
}.Build()
File_dapr_proto_components_v1_state_proto = out.File
file_dapr_proto_components_v1_state_proto_rawDesc = nil
file_dapr_proto_components_v1_state_proto_goTypes = nil
file_dapr_proto_components_v1_state_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/components/v1/state.pb.go
|
GO
|
mit
| 112,624 |
//
//Copyright 2022 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/components/v1/state.proto
package components
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
QueriableStateStore_Query_FullMethodName = "/dapr.proto.components.v1.QueriableStateStore/Query"
)
// QueriableStateStoreClient is the client API for QueriableStateStore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type QueriableStateStoreClient interface {
// Query performs a query request on the statestore.
Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error)
}
type queriableStateStoreClient struct {
cc grpc.ClientConnInterface
}
func NewQueriableStateStoreClient(cc grpc.ClientConnInterface) QueriableStateStoreClient {
return &queriableStateStoreClient{cc}
}
func (c *queriableStateStoreClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResponse, error) {
out := new(QueryResponse)
err := c.cc.Invoke(ctx, QueriableStateStore_Query_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// QueriableStateStoreServer is the server API for QueriableStateStore service.
// All implementations should embed UnimplementedQueriableStateStoreServer
// for forward compatibility
type QueriableStateStoreServer interface {
// Query performs a query request on the statestore.
Query(context.Context, *QueryRequest) (*QueryResponse, error)
}
// UnimplementedQueriableStateStoreServer should be embedded to have forward compatible implementations.
type UnimplementedQueriableStateStoreServer struct {
}
func (UnimplementedQueriableStateStoreServer) Query(context.Context, *QueryRequest) (*QueryResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Query not implemented")
}
// UnsafeQueriableStateStoreServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to QueriableStateStoreServer will
// result in compilation errors.
type UnsafeQueriableStateStoreServer interface {
mustEmbedUnimplementedQueriableStateStoreServer()
}
func RegisterQueriableStateStoreServer(s grpc.ServiceRegistrar, srv QueriableStateStoreServer) {
s.RegisterService(&QueriableStateStore_ServiceDesc, srv)
}
func _QueriableStateStore_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueriableStateStoreServer).Query(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: QueriableStateStore_Query_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueriableStateStoreServer).Query(ctx, req.(*QueryRequest))
}
return interceptor(ctx, in, info, handler)
}
// QueriableStateStore_ServiceDesc is the grpc.ServiceDesc for QueriableStateStore service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var QueriableStateStore_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.QueriableStateStore",
HandlerType: (*QueriableStateStoreServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Query",
Handler: _QueriableStateStore_Query_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/components/v1/state.proto",
}
const (
TransactionalStateStore_Transact_FullMethodName = "/dapr.proto.components.v1.TransactionalStateStore/Transact"
)
// TransactionalStateStoreClient is the client API for TransactionalStateStore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type TransactionalStateStoreClient interface {
// Transact executes multiples operation in a transactional environment.
Transact(ctx context.Context, in *TransactionalStateRequest, opts ...grpc.CallOption) (*TransactionalStateResponse, error)
}
type transactionalStateStoreClient struct {
cc grpc.ClientConnInterface
}
func NewTransactionalStateStoreClient(cc grpc.ClientConnInterface) TransactionalStateStoreClient {
return &transactionalStateStoreClient{cc}
}
func (c *transactionalStateStoreClient) Transact(ctx context.Context, in *TransactionalStateRequest, opts ...grpc.CallOption) (*TransactionalStateResponse, error) {
out := new(TransactionalStateResponse)
err := c.cc.Invoke(ctx, TransactionalStateStore_Transact_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// TransactionalStateStoreServer is the server API for TransactionalStateStore service.
// All implementations should embed UnimplementedTransactionalStateStoreServer
// for forward compatibility
type TransactionalStateStoreServer interface {
// Transact executes multiples operation in a transactional environment.
Transact(context.Context, *TransactionalStateRequest) (*TransactionalStateResponse, error)
}
// UnimplementedTransactionalStateStoreServer should be embedded to have forward compatible implementations.
type UnimplementedTransactionalStateStoreServer struct {
}
func (UnimplementedTransactionalStateStoreServer) Transact(context.Context, *TransactionalStateRequest) (*TransactionalStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Transact not implemented")
}
// UnsafeTransactionalStateStoreServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TransactionalStateStoreServer will
// result in compilation errors.
type UnsafeTransactionalStateStoreServer interface {
mustEmbedUnimplementedTransactionalStateStoreServer()
}
func RegisterTransactionalStateStoreServer(s grpc.ServiceRegistrar, srv TransactionalStateStoreServer) {
s.RegisterService(&TransactionalStateStore_ServiceDesc, srv)
}
func _TransactionalStateStore_Transact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TransactionalStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TransactionalStateStoreServer).Transact(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: TransactionalStateStore_Transact_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TransactionalStateStoreServer).Transact(ctx, req.(*TransactionalStateRequest))
}
return interceptor(ctx, in, info, handler)
}
// TransactionalStateStore_ServiceDesc is the grpc.ServiceDesc for TransactionalStateStore service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TransactionalStateStore_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.TransactionalStateStore",
HandlerType: (*TransactionalStateStoreServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Transact",
Handler: _TransactionalStateStore_Transact_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/components/v1/state.proto",
}
const (
StateStore_Init_FullMethodName = "/dapr.proto.components.v1.StateStore/Init"
StateStore_Features_FullMethodName = "/dapr.proto.components.v1.StateStore/Features"
StateStore_Delete_FullMethodName = "/dapr.proto.components.v1.StateStore/Delete"
StateStore_Get_FullMethodName = "/dapr.proto.components.v1.StateStore/Get"
StateStore_Set_FullMethodName = "/dapr.proto.components.v1.StateStore/Set"
StateStore_Ping_FullMethodName = "/dapr.proto.components.v1.StateStore/Ping"
StateStore_BulkDelete_FullMethodName = "/dapr.proto.components.v1.StateStore/BulkDelete"
StateStore_BulkGet_FullMethodName = "/dapr.proto.components.v1.StateStore/BulkGet"
StateStore_BulkSet_FullMethodName = "/dapr.proto.components.v1.StateStore/BulkSet"
)
// StateStoreClient is the client API for StateStore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type StateStoreClient interface {
// Initializes the state store component with the given metadata.
Init(ctx context.Context, in *InitRequest, opts ...grpc.CallOption) (*InitResponse, error)
// Returns a list of implemented state store features.
Features(ctx context.Context, in *FeaturesRequest, opts ...grpc.CallOption) (*FeaturesResponse, error)
// Deletes the specified key from the state store.
Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error)
// Get data from the given key.
Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
// Sets the value of the specified key.
Set(ctx context.Context, in *SetRequest, opts ...grpc.CallOption) (*SetResponse, error)
// Ping the state store. Used for liveness porpuses.
Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
// Deletes many keys at once.
BulkDelete(ctx context.Context, in *BulkDeleteRequest, opts ...grpc.CallOption) (*BulkDeleteResponse, error)
// Retrieves many keys at once.
BulkGet(ctx context.Context, in *BulkGetRequest, opts ...grpc.CallOption) (*BulkGetResponse, error)
// Set the value of many keys at once.
BulkSet(ctx context.Context, in *BulkSetRequest, opts ...grpc.CallOption) (*BulkSetResponse, error)
}
type stateStoreClient struct {
cc grpc.ClientConnInterface
}
func NewStateStoreClient(cc grpc.ClientConnInterface) StateStoreClient {
return &stateStoreClient{cc}
}
func (c *stateStoreClient) Init(ctx context.Context, in *InitRequest, opts ...grpc.CallOption) (*InitResponse, error) {
out := new(InitResponse)
err := c.cc.Invoke(ctx, StateStore_Init_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) Features(ctx context.Context, in *FeaturesRequest, opts ...grpc.CallOption) (*FeaturesResponse, error) {
out := new(FeaturesResponse)
err := c.cc.Invoke(ctx, StateStore_Features_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {
out := new(DeleteResponse)
err := c.cc.Invoke(ctx, StateStore_Delete_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
out := new(GetResponse)
err := c.cc.Invoke(ctx, StateStore_Get_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) Set(ctx context.Context, in *SetRequest, opts ...grpc.CallOption) (*SetResponse, error) {
out := new(SetResponse)
err := c.cc.Invoke(ctx, StateStore_Set_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
out := new(PingResponse)
err := c.cc.Invoke(ctx, StateStore_Ping_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) BulkDelete(ctx context.Context, in *BulkDeleteRequest, opts ...grpc.CallOption) (*BulkDeleteResponse, error) {
out := new(BulkDeleteResponse)
err := c.cc.Invoke(ctx, StateStore_BulkDelete_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) BulkGet(ctx context.Context, in *BulkGetRequest, opts ...grpc.CallOption) (*BulkGetResponse, error) {
out := new(BulkGetResponse)
err := c.cc.Invoke(ctx, StateStore_BulkGet_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreClient) BulkSet(ctx context.Context, in *BulkSetRequest, opts ...grpc.CallOption) (*BulkSetResponse, error) {
out := new(BulkSetResponse)
err := c.cc.Invoke(ctx, StateStore_BulkSet_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// StateStoreServer is the server API for StateStore service.
// All implementations should embed UnimplementedStateStoreServer
// for forward compatibility
type StateStoreServer interface {
// Initializes the state store component with the given metadata.
Init(context.Context, *InitRequest) (*InitResponse, error)
// Returns a list of implemented state store features.
Features(context.Context, *FeaturesRequest) (*FeaturesResponse, error)
// Deletes the specified key from the state store.
Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)
// Get data from the given key.
Get(context.Context, *GetRequest) (*GetResponse, error)
// Sets the value of the specified key.
Set(context.Context, *SetRequest) (*SetResponse, error)
// Ping the state store. Used for liveness porpuses.
Ping(context.Context, *PingRequest) (*PingResponse, error)
// Deletes many keys at once.
BulkDelete(context.Context, *BulkDeleteRequest) (*BulkDeleteResponse, error)
// Retrieves many keys at once.
BulkGet(context.Context, *BulkGetRequest) (*BulkGetResponse, error)
// Set the value of many keys at once.
BulkSet(context.Context, *BulkSetRequest) (*BulkSetResponse, error)
}
// UnimplementedStateStoreServer should be embedded to have forward compatible implementations.
type UnimplementedStateStoreServer struct {
}
func (UnimplementedStateStoreServer) Init(context.Context, *InitRequest) (*InitResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Init not implemented")
}
func (UnimplementedStateStoreServer) Features(context.Context, *FeaturesRequest) (*FeaturesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Features not implemented")
}
func (UnimplementedStateStoreServer) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedStateStoreServer) Get(context.Context, *GetRequest) (*GetResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedStateStoreServer) Set(context.Context, *SetRequest) (*SetResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (UnimplementedStateStoreServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedStateStoreServer) BulkDelete(context.Context, *BulkDeleteRequest) (*BulkDeleteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BulkDelete not implemented")
}
func (UnimplementedStateStoreServer) BulkGet(context.Context, *BulkGetRequest) (*BulkGetResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BulkGet not implemented")
}
func (UnimplementedStateStoreServer) BulkSet(context.Context, *BulkSetRequest) (*BulkSetResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BulkSet not implemented")
}
// UnsafeStateStoreServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to StateStoreServer will
// result in compilation errors.
type UnsafeStateStoreServer interface {
mustEmbedUnimplementedStateStoreServer()
}
func RegisterStateStoreServer(s grpc.ServiceRegistrar, srv StateStoreServer) {
s.RegisterService(&StateStore_ServiceDesc, srv)
}
func _StateStore_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InitRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).Init(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_Init_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).Init(ctx, req.(*InitRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_Features_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FeaturesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).Features(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_Features_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).Features(ctx, req.(*FeaturesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).Delete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_Delete_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).Delete(ctx, req.(*DeleteRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_Get_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).Get(ctx, req.(*GetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).Set(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_Set_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).Set(ctx, req.(*SetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).Ping(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_Ping_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).Ping(ctx, req.(*PingRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_BulkDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkDeleteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).BulkDelete(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_BulkDelete_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).BulkDelete(ctx, req.(*BulkDeleteRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_BulkGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkGetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).BulkGet(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_BulkGet_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).BulkGet(ctx, req.(*BulkGetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStore_BulkSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkSetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServer).BulkSet(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStore_BulkSet_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServer).BulkSet(ctx, req.(*BulkSetRequest))
}
return interceptor(ctx, in, info, handler)
}
// StateStore_ServiceDesc is the grpc.ServiceDesc for StateStore service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var StateStore_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.StateStore",
HandlerType: (*StateStoreServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Init",
Handler: _StateStore_Init_Handler,
},
{
MethodName: "Features",
Handler: _StateStore_Features_Handler,
},
{
MethodName: "Delete",
Handler: _StateStore_Delete_Handler,
},
{
MethodName: "Get",
Handler: _StateStore_Get_Handler,
},
{
MethodName: "Set",
Handler: _StateStore_Set_Handler,
},
{
MethodName: "Ping",
Handler: _StateStore_Ping_Handler,
},
{
MethodName: "BulkDelete",
Handler: _StateStore_BulkDelete_Handler,
},
{
MethodName: "BulkGet",
Handler: _StateStore_BulkGet_Handler,
},
{
MethodName: "BulkSet",
Handler: _StateStore_BulkSet_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/components/v1/state.proto",
}
const (
TransactionalStoreMultiMaxSize_MultiMaxSize_FullMethodName = "/dapr.proto.components.v1.TransactionalStoreMultiMaxSize/MultiMaxSize"
)
// TransactionalStoreMultiMaxSizeClient is the client API for TransactionalStoreMultiMaxSize service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type TransactionalStoreMultiMaxSizeClient interface {
// MultiMaxSize returns the maximum number of operations that can be performed
// in a single transaction.
MultiMaxSize(ctx context.Context, in *MultiMaxSizeRequest, opts ...grpc.CallOption) (*MultiMaxSizeResponse, error)
}
type transactionalStoreMultiMaxSizeClient struct {
cc grpc.ClientConnInterface
}
func NewTransactionalStoreMultiMaxSizeClient(cc grpc.ClientConnInterface) TransactionalStoreMultiMaxSizeClient {
return &transactionalStoreMultiMaxSizeClient{cc}
}
func (c *transactionalStoreMultiMaxSizeClient) MultiMaxSize(ctx context.Context, in *MultiMaxSizeRequest, opts ...grpc.CallOption) (*MultiMaxSizeResponse, error) {
out := new(MultiMaxSizeResponse)
err := c.cc.Invoke(ctx, TransactionalStoreMultiMaxSize_MultiMaxSize_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// TransactionalStoreMultiMaxSizeServer is the server API for TransactionalStoreMultiMaxSize service.
// All implementations should embed UnimplementedTransactionalStoreMultiMaxSizeServer
// for forward compatibility
type TransactionalStoreMultiMaxSizeServer interface {
// MultiMaxSize returns the maximum number of operations that can be performed
// in a single transaction.
MultiMaxSize(context.Context, *MultiMaxSizeRequest) (*MultiMaxSizeResponse, error)
}
// UnimplementedTransactionalStoreMultiMaxSizeServer should be embedded to have forward compatible implementations.
type UnimplementedTransactionalStoreMultiMaxSizeServer struct {
}
func (UnimplementedTransactionalStoreMultiMaxSizeServer) MultiMaxSize(context.Context, *MultiMaxSizeRequest) (*MultiMaxSizeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method MultiMaxSize not implemented")
}
// UnsafeTransactionalStoreMultiMaxSizeServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TransactionalStoreMultiMaxSizeServer will
// result in compilation errors.
type UnsafeTransactionalStoreMultiMaxSizeServer interface {
mustEmbedUnimplementedTransactionalStoreMultiMaxSizeServer()
}
func RegisterTransactionalStoreMultiMaxSizeServer(s grpc.ServiceRegistrar, srv TransactionalStoreMultiMaxSizeServer) {
s.RegisterService(&TransactionalStoreMultiMaxSize_ServiceDesc, srv)
}
func _TransactionalStoreMultiMaxSize_MultiMaxSize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MultiMaxSizeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TransactionalStoreMultiMaxSizeServer).MultiMaxSize(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: TransactionalStoreMultiMaxSize_MultiMaxSize_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TransactionalStoreMultiMaxSizeServer).MultiMaxSize(ctx, req.(*MultiMaxSizeRequest))
}
return interceptor(ctx, in, info, handler)
}
// TransactionalStoreMultiMaxSize_ServiceDesc is the grpc.ServiceDesc for TransactionalStoreMultiMaxSize service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TransactionalStoreMultiMaxSize_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.components.v1.TransactionalStoreMultiMaxSize",
HandlerType: (*TransactionalStoreMultiMaxSizeServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "MultiMaxSize",
Handler: _TransactionalStoreMultiMaxSize_MultiMaxSize_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/components/v1/state.proto",
}
|
mikeee/dapr
|
pkg/proto/components/v1/state_grpc.pb.go
|
GO
|
mit
| 27,786 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/internals/v1/apiversion.proto
package internals
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// APIVersion represents the version of Dapr Runtime API.
type APIVersion int32
const (
// unspecified apiversion
APIVersion_APIVERSION_UNSPECIFIED APIVersion = 0
// Dapr API v1
APIVersion_V1 APIVersion = 1
)
// Enum value maps for APIVersion.
var (
APIVersion_name = map[int32]string{
0: "APIVERSION_UNSPECIFIED",
1: "V1",
}
APIVersion_value = map[string]int32{
"APIVERSION_UNSPECIFIED": 0,
"V1": 1,
}
)
func (x APIVersion) Enum() *APIVersion {
p := new(APIVersion)
*p = x
return p
}
func (x APIVersion) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (APIVersion) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_internals_v1_apiversion_proto_enumTypes[0].Descriptor()
}
func (APIVersion) Type() protoreflect.EnumType {
return &file_dapr_proto_internals_v1_apiversion_proto_enumTypes[0]
}
func (x APIVersion) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use APIVersion.Descriptor instead.
func (APIVersion) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_apiversion_proto_rawDescGZIP(), []int{0}
}
var File_dapr_proto_internals_v1_apiversion_proto protoreflect.FileDescriptor
var file_dapr_proto_internals_v1_apiversion_proto_rawDesc = []byte{
0x0a, 0x28, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x76, 0x65, 0x72,
0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73,
0x2e, 0x76, 0x31, 0x2a, 0x30, 0x0a, 0x0a, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
0x6e, 0x12, 0x1a, 0x0a, 0x16, 0x41, 0x50, 0x49, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f,
0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x06, 0x0a,
0x02, 0x56, 0x31, 0x10, 0x01, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b,
0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x73, 0x2f, 0x76, 0x31, 0x3b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x62, 0x06,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_internals_v1_apiversion_proto_rawDescOnce sync.Once
file_dapr_proto_internals_v1_apiversion_proto_rawDescData = file_dapr_proto_internals_v1_apiversion_proto_rawDesc
)
func file_dapr_proto_internals_v1_apiversion_proto_rawDescGZIP() []byte {
file_dapr_proto_internals_v1_apiversion_proto_rawDescOnce.Do(func() {
file_dapr_proto_internals_v1_apiversion_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_internals_v1_apiversion_proto_rawDescData)
})
return file_dapr_proto_internals_v1_apiversion_proto_rawDescData
}
var file_dapr_proto_internals_v1_apiversion_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_dapr_proto_internals_v1_apiversion_proto_goTypes = []interface{}{
(APIVersion)(0), // 0: dapr.proto.internals.v1.APIVersion
}
var file_dapr_proto_internals_v1_apiversion_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_dapr_proto_internals_v1_apiversion_proto_init() }
func file_dapr_proto_internals_v1_apiversion_proto_init() {
if File_dapr_proto_internals_v1_apiversion_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_internals_v1_apiversion_proto_rawDesc,
NumEnums: 1,
NumMessages: 0,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_dapr_proto_internals_v1_apiversion_proto_goTypes,
DependencyIndexes: file_dapr_proto_internals_v1_apiversion_proto_depIdxs,
EnumInfos: file_dapr_proto_internals_v1_apiversion_proto_enumTypes,
}.Build()
File_dapr_proto_internals_v1_apiversion_proto = out.File
file_dapr_proto_internals_v1_apiversion_proto_rawDesc = nil
file_dapr_proto_internals_v1_apiversion_proto_goTypes = nil
file_dapr_proto_internals_v1_apiversion_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/internals/v1/apiversion.pb.go
|
GO
|
mit
| 5,706 |
//
//Copyright 2023 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/internals/v1/reminders.proto
package internals
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Reminder represents a reminder that is stored in the Dapr actor state store.
type Reminder struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
ActorType string `protobuf:"bytes,2,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
Period string `protobuf:"bytes,5,opt,name=period,proto3" json:"period,omitempty"`
RegisteredTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=registered_time,json=registeredTime,proto3" json:"registered_time,omitempty"`
DueTime string `protobuf:"bytes,7,opt,name=due_time,json=dueTime,proto3" json:"due_time,omitempty"`
ExpirationTime *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
}
func (x *Reminder) Reset() {
*x = Reminder{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_reminders_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Reminder) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Reminder) ProtoMessage() {}
func (x *Reminder) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_reminders_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Reminder.ProtoReflect.Descriptor instead.
func (*Reminder) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_reminders_proto_rawDescGZIP(), []int{0}
}
func (x *Reminder) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *Reminder) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *Reminder) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Reminder) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *Reminder) GetPeriod() string {
if x != nil {
return x.Period
}
return ""
}
func (x *Reminder) GetRegisteredTime() *timestamppb.Timestamp {
if x != nil {
return x.RegisteredTime
}
return nil
}
func (x *Reminder) GetDueTime() string {
if x != nil {
return x.DueTime
}
return ""
}
func (x *Reminder) GetExpirationTime() *timestamppb.Timestamp {
if x != nil {
return x.ExpirationTime
}
return nil
}
// Reminders is a collection of reminders.
type Reminders struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Reminders []*Reminder `protobuf:"bytes,1,rep,name=reminders,proto3" json:"reminders,omitempty"`
}
func (x *Reminders) Reset() {
*x = Reminders{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_reminders_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Reminders) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Reminders) ProtoMessage() {}
func (x *Reminders) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_reminders_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Reminders.ProtoReflect.Descriptor instead.
func (*Reminders) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_reminders_proto_rawDescGZIP(), []int{1}
}
func (x *Reminders) GetReminders() []*Reminder {
if x != nil {
return x.Reminders
}
return nil
}
var File_dapr_proto_internals_v1_reminders_proto protoreflect.FileDescriptor
var file_dapr_proto_internals_v1_reminders_proto_rawDesc = []byte{
0x0a, 0x27, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x72, 0x65, 0x6d, 0x69, 0x6e, 0x64,
0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e,
0x76, 0x31, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x22, 0xa9, 0x02, 0x0a, 0x08, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72,
0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x61,
0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x09, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12,
0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61,
0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x05, 0x20, 0x01,
0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x43, 0x0a, 0x0f, 0x72, 0x65,
0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52,
0x0e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12,
0x19, 0x0a, 0x08, 0x64, 0x75, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28,
0x09, 0x52, 0x07, 0x64, 0x75, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x43, 0x0a, 0x0f, 0x65, 0x78,
0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52,
0x0e, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22,
0x4c, 0x0a, 0x09, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x12, 0x3f, 0x0a, 0x09,
0x72, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
0x21, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64,
0x65, 0x72, 0x52, 0x09, 0x72, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x42, 0x37, 0x5a,
0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72,
0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_internals_v1_reminders_proto_rawDescOnce sync.Once
file_dapr_proto_internals_v1_reminders_proto_rawDescData = file_dapr_proto_internals_v1_reminders_proto_rawDesc
)
func file_dapr_proto_internals_v1_reminders_proto_rawDescGZIP() []byte {
file_dapr_proto_internals_v1_reminders_proto_rawDescOnce.Do(func() {
file_dapr_proto_internals_v1_reminders_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_internals_v1_reminders_proto_rawDescData)
})
return file_dapr_proto_internals_v1_reminders_proto_rawDescData
}
var file_dapr_proto_internals_v1_reminders_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_dapr_proto_internals_v1_reminders_proto_goTypes = []interface{}{
(*Reminder)(nil), // 0: dapr.proto.internals.v1.Reminder
(*Reminders)(nil), // 1: dapr.proto.internals.v1.Reminders
(*timestamppb.Timestamp)(nil), // 2: google.protobuf.Timestamp
}
var file_dapr_proto_internals_v1_reminders_proto_depIdxs = []int32{
2, // 0: dapr.proto.internals.v1.Reminder.registered_time:type_name -> google.protobuf.Timestamp
2, // 1: dapr.proto.internals.v1.Reminder.expiration_time:type_name -> google.protobuf.Timestamp
0, // 2: dapr.proto.internals.v1.Reminders.reminders:type_name -> dapr.proto.internals.v1.Reminder
3, // [3:3] is the sub-list for method output_type
3, // [3:3] is the sub-list for method input_type
3, // [3:3] is the sub-list for extension type_name
3, // [3:3] is the sub-list for extension extendee
0, // [0:3] is the sub-list for field type_name
}
func init() { file_dapr_proto_internals_v1_reminders_proto_init() }
func file_dapr_proto_internals_v1_reminders_proto_init() {
if File_dapr_proto_internals_v1_reminders_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_internals_v1_reminders_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Reminder); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_internals_v1_reminders_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Reminders); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_internals_v1_reminders_proto_rawDesc,
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_dapr_proto_internals_v1_reminders_proto_goTypes,
DependencyIndexes: file_dapr_proto_internals_v1_reminders_proto_depIdxs,
MessageInfos: file_dapr_proto_internals_v1_reminders_proto_msgTypes,
}.Build()
File_dapr_proto_internals_v1_reminders_proto = out.File
file_dapr_proto_internals_v1_reminders_proto_rawDesc = nil
file_dapr_proto_internals_v1_reminders_proto_goTypes = nil
file_dapr_proto_internals_v1_reminders_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/internals/v1/reminders.pb.go
|
GO
|
mit
| 11,901 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/internals/v1/service_invocation.proto
package internals
import (
v1 "github.com/dapr/dapr/pkg/proto/common/v1"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Actor represents actor using actor_type and actor_id
type Actor struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The type of actor.
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
// Required. The ID of actor type (actor_type)
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
}
func (x *Actor) Reset() {
*x = Actor{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Actor) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Actor) ProtoMessage() {}
func (x *Actor) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Actor.ProtoReflect.Descriptor instead.
func (*Actor) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP(), []int{0}
}
func (x *Actor) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *Actor) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
// InternalInvokeRequest is the message to transfer caller's data to callee
// for service invocation. This includes callee's app id and caller's request data.
type InternalInvokeRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The version of Dapr runtime API.
Ver APIVersion `protobuf:"varint,1,opt,name=ver,proto3,enum=dapr.proto.internals.v1.APIVersion" json:"ver,omitempty"`
// Required. metadata holds caller's HTTP headers or gRPC metadata.
Metadata map[string]*ListStringValue `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Required. message including caller's invocation request.
Message *v1.InvokeRequest `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
// Actor type and id. This field is used only for
// actor service invocation.
Actor *Actor `protobuf:"bytes,4,opt,name=actor,proto3" json:"actor,omitempty"`
}
func (x *InternalInvokeRequest) Reset() {
*x = InternalInvokeRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InternalInvokeRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InternalInvokeRequest) ProtoMessage() {}
func (x *InternalInvokeRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InternalInvokeRequest.ProtoReflect.Descriptor instead.
func (*InternalInvokeRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP(), []int{1}
}
func (x *InternalInvokeRequest) GetVer() APIVersion {
if x != nil {
return x.Ver
}
return APIVersion_APIVERSION_UNSPECIFIED
}
func (x *InternalInvokeRequest) GetMetadata() map[string]*ListStringValue {
if x != nil {
return x.Metadata
}
return nil
}
func (x *InternalInvokeRequest) GetMessage() *v1.InvokeRequest {
if x != nil {
return x.Message
}
return nil
}
func (x *InternalInvokeRequest) GetActor() *Actor {
if x != nil {
return x.Actor
}
return nil
}
// InternalInvokeResponse is the message to transfer callee's response to caller
// for service invocation.
type InternalInvokeResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. HTTP/gRPC status.
Status *Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
// Required. The app callback response headers.
Headers map[string]*ListStringValue `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// App callback response trailers.
// This will be used only for gRPC app callback
Trailers map[string]*ListStringValue `protobuf:"bytes,3,rep,name=trailers,proto3" json:"trailers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Callee's invocation response message.
Message *v1.InvokeResponse `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
}
func (x *InternalInvokeResponse) Reset() {
*x = InternalInvokeResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InternalInvokeResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InternalInvokeResponse) ProtoMessage() {}
func (x *InternalInvokeResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InternalInvokeResponse.ProtoReflect.Descriptor instead.
func (*InternalInvokeResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP(), []int{2}
}
func (x *InternalInvokeResponse) GetStatus() *Status {
if x != nil {
return x.Status
}
return nil
}
func (x *InternalInvokeResponse) GetHeaders() map[string]*ListStringValue {
if x != nil {
return x.Headers
}
return nil
}
func (x *InternalInvokeResponse) GetTrailers() map[string]*ListStringValue {
if x != nil {
return x.Trailers
}
return nil
}
func (x *InternalInvokeResponse) GetMessage() *v1.InvokeResponse {
if x != nil {
return x.Message
}
return nil
}
// InternalInvokeRequestStream is a variant of InternalInvokeRequest used in streaming RPCs.
type InternalInvokeRequestStream struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Request details.
// This does not contain any data in message.data.
Request *InternalInvokeRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
// Chunk of data.
Payload *v1.StreamPayload `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
}
func (x *InternalInvokeRequestStream) Reset() {
*x = InternalInvokeRequestStream{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InternalInvokeRequestStream) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InternalInvokeRequestStream) ProtoMessage() {}
func (x *InternalInvokeRequestStream) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InternalInvokeRequestStream.ProtoReflect.Descriptor instead.
func (*InternalInvokeRequestStream) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP(), []int{3}
}
func (x *InternalInvokeRequestStream) GetRequest() *InternalInvokeRequest {
if x != nil {
return x.Request
}
return nil
}
func (x *InternalInvokeRequestStream) GetPayload() *v1.StreamPayload {
if x != nil {
return x.Payload
}
return nil
}
// InternalInvokeResponseStream is a variant of InternalInvokeResponse used in streaming RPCs.
type InternalInvokeResponseStream struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Response details.
// This does not contain any data in message.data.
Response *InternalInvokeResponse `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
// Chunk of data.
Payload *v1.StreamPayload `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
}
func (x *InternalInvokeResponseStream) Reset() {
*x = InternalInvokeResponseStream{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InternalInvokeResponseStream) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InternalInvokeResponseStream) ProtoMessage() {}
func (x *InternalInvokeResponseStream) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InternalInvokeResponseStream.ProtoReflect.Descriptor instead.
func (*InternalInvokeResponseStream) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP(), []int{4}
}
func (x *InternalInvokeResponseStream) GetResponse() *InternalInvokeResponse {
if x != nil {
return x.Response
}
return nil
}
func (x *InternalInvokeResponseStream) GetPayload() *v1.StreamPayload {
if x != nil {
return x.Payload
}
return nil
}
// ListStringValue represents string value array
type ListStringValue struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The array of string.
Values []string `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
}
func (x *ListStringValue) Reset() {
*x = ListStringValue{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListStringValue) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListStringValue) ProtoMessage() {}
func (x *ListStringValue) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListStringValue.ProtoReflect.Descriptor instead.
func (*ListStringValue) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP(), []int{5}
}
func (x *ListStringValue) GetValues() []string {
if x != nil {
return x.Values
}
return nil
}
var File_dapr_proto_internals_v1_service_invocation_proto protoreflect.FileDescriptor
var file_dapr_proto_internals_v1_service_invocation_proto_rawDesc = []byte{
0x0a, 0x30, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63,
0x65, 0x5f, 0x69, 0x6e, 0x76, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x12, 0x17, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69,
0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x1a, 0x21, 0x64, 0x61, 0x70,
0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x76,
0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x28,
0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x69, 0x76, 0x65, 0x72, 0x73, 0x69,
0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x24, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76,
0x31, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x41,
0x0a, 0x05, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x74, 0x6f, 0x72,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x74,
0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f,
0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x49,
0x64, 0x22, 0x84, 0x03, 0x0a, 0x15, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e,
0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x03, 0x76,
0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x76,
0x65, 0x72, 0x12, 0x58, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49,
0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3d, 0x0a, 0x07,
0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x61,
0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x73, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x05, 0x61, 0x63, 0x74, 0x6f,
0x72, 0x1a, 0x65, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x03, 0x6b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69,
0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x91, 0x04, 0x0a, 0x16, 0x49, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x37, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74,
0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x56, 0x0a, 0x07,
0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x48,
0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x68, 0x65, 0x61,
0x64, 0x65, 0x72, 0x73, 0x12, 0x59, 0x0a, 0x08, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72, 0x73,
0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31,
0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72, 0x73,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72, 0x73, 0x12,
0x3e, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x24, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f,
0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a,
0x64, 0x0a, 0x0c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x3e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53,
0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x65, 0x0a, 0x0d, 0x54, 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72,
0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75,
0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xa6, 0x01, 0x0a,
0x1b, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x48, 0x0a, 0x07,
0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x72,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61,
0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53,
0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x07, 0x70, 0x61,
0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xaa, 0x01, 0x0a, 0x1c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e,
0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x4b, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e,
0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b,
0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x65,
0x61, 0x6d, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f,
0x61, 0x64, 0x22, 0x29, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67,
0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18,
0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x32, 0xfa, 0x02,
0x0a, 0x11, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6e, 0x76, 0x6f, 0x63, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x12, 0x6e, 0x0a, 0x09, 0x43, 0x61, 0x6c, 0x6c, 0x41, 0x63, 0x74, 0x6f, 0x72,
0x12, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x6e, 0x0a, 0x09, 0x43, 0x61, 0x6c, 0x6c, 0x4c, 0x6f, 0x63, 0x61, 0x6c,
0x12, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e,
0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x84, 0x01, 0x0a, 0x0f, 0x43, 0x61, 0x6c, 0x6c, 0x4c, 0x6f, 0x63, 0x61,
0x6c, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76,
0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x1a, 0x35, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72,
0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74,
0x72, 0x65, 0x61, 0x6d, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69,
0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61,
0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x3b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
0x61, 0x6c, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_internals_v1_service_invocation_proto_rawDescOnce sync.Once
file_dapr_proto_internals_v1_service_invocation_proto_rawDescData = file_dapr_proto_internals_v1_service_invocation_proto_rawDesc
)
func file_dapr_proto_internals_v1_service_invocation_proto_rawDescGZIP() []byte {
file_dapr_proto_internals_v1_service_invocation_proto_rawDescOnce.Do(func() {
file_dapr_proto_internals_v1_service_invocation_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_internals_v1_service_invocation_proto_rawDescData)
})
return file_dapr_proto_internals_v1_service_invocation_proto_rawDescData
}
var file_dapr_proto_internals_v1_service_invocation_proto_msgTypes = make([]protoimpl.MessageInfo, 9)
var file_dapr_proto_internals_v1_service_invocation_proto_goTypes = []interface{}{
(*Actor)(nil), // 0: dapr.proto.internals.v1.Actor
(*InternalInvokeRequest)(nil), // 1: dapr.proto.internals.v1.InternalInvokeRequest
(*InternalInvokeResponse)(nil), // 2: dapr.proto.internals.v1.InternalInvokeResponse
(*InternalInvokeRequestStream)(nil), // 3: dapr.proto.internals.v1.InternalInvokeRequestStream
(*InternalInvokeResponseStream)(nil), // 4: dapr.proto.internals.v1.InternalInvokeResponseStream
(*ListStringValue)(nil), // 5: dapr.proto.internals.v1.ListStringValue
nil, // 6: dapr.proto.internals.v1.InternalInvokeRequest.MetadataEntry
nil, // 7: dapr.proto.internals.v1.InternalInvokeResponse.HeadersEntry
nil, // 8: dapr.proto.internals.v1.InternalInvokeResponse.TrailersEntry
(APIVersion)(0), // 9: dapr.proto.internals.v1.APIVersion
(*v1.InvokeRequest)(nil), // 10: dapr.proto.common.v1.InvokeRequest
(*Status)(nil), // 11: dapr.proto.internals.v1.Status
(*v1.InvokeResponse)(nil), // 12: dapr.proto.common.v1.InvokeResponse
(*v1.StreamPayload)(nil), // 13: dapr.proto.common.v1.StreamPayload
}
var file_dapr_proto_internals_v1_service_invocation_proto_depIdxs = []int32{
9, // 0: dapr.proto.internals.v1.InternalInvokeRequest.ver:type_name -> dapr.proto.internals.v1.APIVersion
6, // 1: dapr.proto.internals.v1.InternalInvokeRequest.metadata:type_name -> dapr.proto.internals.v1.InternalInvokeRequest.MetadataEntry
10, // 2: dapr.proto.internals.v1.InternalInvokeRequest.message:type_name -> dapr.proto.common.v1.InvokeRequest
0, // 3: dapr.proto.internals.v1.InternalInvokeRequest.actor:type_name -> dapr.proto.internals.v1.Actor
11, // 4: dapr.proto.internals.v1.InternalInvokeResponse.status:type_name -> dapr.proto.internals.v1.Status
7, // 5: dapr.proto.internals.v1.InternalInvokeResponse.headers:type_name -> dapr.proto.internals.v1.InternalInvokeResponse.HeadersEntry
8, // 6: dapr.proto.internals.v1.InternalInvokeResponse.trailers:type_name -> dapr.proto.internals.v1.InternalInvokeResponse.TrailersEntry
12, // 7: dapr.proto.internals.v1.InternalInvokeResponse.message:type_name -> dapr.proto.common.v1.InvokeResponse
1, // 8: dapr.proto.internals.v1.InternalInvokeRequestStream.request:type_name -> dapr.proto.internals.v1.InternalInvokeRequest
13, // 9: dapr.proto.internals.v1.InternalInvokeRequestStream.payload:type_name -> dapr.proto.common.v1.StreamPayload
2, // 10: dapr.proto.internals.v1.InternalInvokeResponseStream.response:type_name -> dapr.proto.internals.v1.InternalInvokeResponse
13, // 11: dapr.proto.internals.v1.InternalInvokeResponseStream.payload:type_name -> dapr.proto.common.v1.StreamPayload
5, // 12: dapr.proto.internals.v1.InternalInvokeRequest.MetadataEntry.value:type_name -> dapr.proto.internals.v1.ListStringValue
5, // 13: dapr.proto.internals.v1.InternalInvokeResponse.HeadersEntry.value:type_name -> dapr.proto.internals.v1.ListStringValue
5, // 14: dapr.proto.internals.v1.InternalInvokeResponse.TrailersEntry.value:type_name -> dapr.proto.internals.v1.ListStringValue
1, // 15: dapr.proto.internals.v1.ServiceInvocation.CallActor:input_type -> dapr.proto.internals.v1.InternalInvokeRequest
1, // 16: dapr.proto.internals.v1.ServiceInvocation.CallLocal:input_type -> dapr.proto.internals.v1.InternalInvokeRequest
3, // 17: dapr.proto.internals.v1.ServiceInvocation.CallLocalStream:input_type -> dapr.proto.internals.v1.InternalInvokeRequestStream
2, // 18: dapr.proto.internals.v1.ServiceInvocation.CallActor:output_type -> dapr.proto.internals.v1.InternalInvokeResponse
2, // 19: dapr.proto.internals.v1.ServiceInvocation.CallLocal:output_type -> dapr.proto.internals.v1.InternalInvokeResponse
4, // 20: dapr.proto.internals.v1.ServiceInvocation.CallLocalStream:output_type -> dapr.proto.internals.v1.InternalInvokeResponseStream
18, // [18:21] is the sub-list for method output_type
15, // [15:18] is the sub-list for method input_type
15, // [15:15] is the sub-list for extension type_name
15, // [15:15] is the sub-list for extension extendee
0, // [0:15] is the sub-list for field type_name
}
func init() { file_dapr_proto_internals_v1_service_invocation_proto_init() }
func file_dapr_proto_internals_v1_service_invocation_proto_init() {
if File_dapr_proto_internals_v1_service_invocation_proto != nil {
return
}
file_dapr_proto_internals_v1_apiversion_proto_init()
file_dapr_proto_internals_v1_status_proto_init()
if !protoimpl.UnsafeEnabled {
file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Actor); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InternalInvokeRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InternalInvokeResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InternalInvokeRequestStream); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InternalInvokeResponseStream); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_internals_v1_service_invocation_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListStringValue); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_internals_v1_service_invocation_proto_rawDesc,
NumEnums: 0,
NumMessages: 9,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_internals_v1_service_invocation_proto_goTypes,
DependencyIndexes: file_dapr_proto_internals_v1_service_invocation_proto_depIdxs,
MessageInfos: file_dapr_proto_internals_v1_service_invocation_proto_msgTypes,
}.Build()
File_dapr_proto_internals_v1_service_invocation_proto = out.File
file_dapr_proto_internals_v1_service_invocation_proto_rawDesc = nil
file_dapr_proto_internals_v1_service_invocation_proto_goTypes = nil
file_dapr_proto_internals_v1_service_invocation_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/internals/v1/service_invocation.pb.go
|
GO
|
mit
| 33,262 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package internals
import (
"encoding/base64"
"net/http"
"strings"
commonv1pb "github.com/dapr/dapr/pkg/proto/common/v1"
"google.golang.org/protobuf/types/known/anypb"
)
const (
// GRPCContentType is the MIME media type for grpc.
GRPCContentType = "application/grpc"
// JSONContentType is the MIME media type for JSON.
JSONContentType = "application/json"
// ProtobufContentType is the MIME media type for Protobuf.
ProtobufContentType = "application/x-protobuf"
// OctetStreamContentType is the MIME media type for arbitrary binary data.
OctetStreamContentType = "application/octet-stream"
)
const (
// Separator for strings containing multiple tokens.
daprSeparator = "||"
// gRPCBinaryMetadata is the suffix of grpc metadata binary value.
gRPCBinaryMetadataSuffix = "-bin"
)
// This file contains additional, hand-written methods added to the generated objects.
// GetActorKey returns the key for the actor.
func (x *Actor) GetActorKey() string {
if x == nil {
return ""
}
return x.GetActorType() + daprSeparator + x.GetActorId()
}
// NewInternalInvokeRequest returns an InternalInvokeRequest with the given method
func NewInternalInvokeRequest(method string) *InternalInvokeRequest {
return &InternalInvokeRequest{
Ver: APIVersion_V1,
Message: &commonv1pb.InvokeRequest{
Method: method,
},
}
}
// WithActor sets actor type and id.
func (x *InternalInvokeRequest) WithActor(actorType, actorID string) *InternalInvokeRequest {
x.Actor = &Actor{
ActorType: actorType,
ActorId: actorID,
}
return x
}
// WithData sets the data.
func (x *InternalInvokeRequest) WithData(data []byte) *InternalInvokeRequest {
if x.Message.Data == nil {
x.Message.Data = &anypb.Any{}
}
x.Message.Data.Value = data
return x
}
// WithContentType sets the content type.
func (x *InternalInvokeRequest) WithContentType(contentType string) *InternalInvokeRequest {
x.Message.ContentType = contentType
return x
}
// WithDataTypeURL sets the type_url property for the data.
// When a type_url is set, the Content-Type automatically becomes the protobuf one.
func (x *InternalInvokeRequest) WithDataTypeURL(val string) *InternalInvokeRequest {
if x.Message.Data == nil {
x.Message.Data = &anypb.Any{}
}
x.Message.Data.TypeUrl = val
x.Message.ContentType = ProtobufContentType
return x
}
// WithHTTPExtension sets new HTTP extension with verb and querystring.
func (x *InternalInvokeRequest) WithHTTPExtension(verb string, querystring string) *InternalInvokeRequest {
httpMethod, ok := commonv1pb.HTTPExtension_Verb_value[strings.ToUpper(verb)]
if !ok {
httpMethod = int32(commonv1pb.HTTPExtension_POST)
}
x.Message.HttpExtension = &commonv1pb.HTTPExtension{
Verb: commonv1pb.HTTPExtension_Verb(httpMethod),
Querystring: querystring,
}
return x
}
// WithMetadata sets metadata.
func (x *InternalInvokeRequest) WithMetadata(md map[string][]string) *InternalInvokeRequest {
x.Metadata = MetadataToInternalMetadata(md)
return x
}
// WithHTTPHeaders sets metadata from HTTP request headers.
func (x *InternalInvokeRequest) WithHTTPHeaders(header http.Header) *InternalInvokeRequest {
x.Metadata = HTTPHeadersToInternalMetadata(header)
return x
}
// WithFastHTTPHeaders sets metadata from fasthttp request headers.
func (x *InternalInvokeRequest) WithFastHTTPHeaders(header fasthttpHeaders) *InternalInvokeRequest {
x.Metadata = FastHTTPHeadersToInternalMetadata(header)
return x
}
// IsHTTPResponse returns true if response status code is http response status.
func (x *InternalInvokeResponse) IsHTTPResponse() bool {
if x == nil {
return false
}
// gRPC status code <= 15 - https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
// HTTP status code >= 100 - https://tools.ietf.org/html/rfc2616#section-10
return x.GetStatus().Code >= 100
}
// MetadataToInternalMetadata converts metadata to Dapr internal metadata map.
func MetadataToInternalMetadata(md map[string][]string) map[string]*ListStringValue {
internalMD := make(map[string]*ListStringValue, len(md))
for k, values := range md {
if strings.HasSuffix(k, gRPCBinaryMetadataSuffix) {
// Binary key requires base64 encoding for the value
vals := make([]string, len(values))
for i, val := range values {
vals[i] = base64.StdEncoding.EncodeToString([]byte(val))
}
internalMD[k] = &ListStringValue{
Values: vals,
}
} else {
internalMD[k] = &ListStringValue{
Values: values,
}
}
}
return internalMD
}
// HTTPHeadersToInternalMetadata converts http headers to Dapr internal metadata map.
func HTTPHeadersToInternalMetadata(header http.Header) map[string]*ListStringValue {
internalMD := make(map[string]*ListStringValue, len(header))
for key, val := range header {
// Note: HTTP headers can never be binary (only gRPC supports binary headers)
if internalMD[key] == nil || len(internalMD[key].Values) == 0 {
internalMD[key] = &ListStringValue{
Values: val,
}
} else {
internalMD[key].Values = append(internalMD[key].Values, val...)
}
}
return internalMD
}
// Covers *fasthttp.RequestHeader and *fasthttp.ResponseHeader
type fasthttpHeaders interface {
Len() int
VisitAll(f func(key []byte, value []byte))
}
// FastHTTPHeadersToInternalMetadata converts fasthttp headers to Dapr internal metadata map.
func FastHTTPHeadersToInternalMetadata(header fasthttpHeaders) map[string]*ListStringValue {
internalMD := make(map[string]*ListStringValue, header.Len())
header.VisitAll(func(key []byte, value []byte) {
// Note: fasthttp headers can never be binary (only gRPC supports binary headers)
keyStr := string(key)
if internalMD[keyStr] == nil || len(internalMD[keyStr].Values) == 0 {
internalMD[keyStr] = &ListStringValue{
Values: []string{string(value)},
}
} else {
internalMD[keyStr].Values = append(internalMD[keyStr].Values, string(value))
}
})
return internalMD
}
|
mikeee/dapr
|
pkg/proto/internals/v1/service_invocation_additional.go
|
GO
|
mit
| 6,459 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package internals
import (
"encoding/base64"
"net/http"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc/metadata"
)
func TestMetadataToInternalMetadata(t *testing.T) {
keyBinValue := []byte{101, 200}
testMD := metadata.Pairs(
"key", "key value",
"key-bin", string(keyBinValue),
)
testMD.Append("multikey", "ciao", "mamma")
internalMD := MetadataToInternalMetadata(testMD)
require.Equal(t, 1, len(internalMD["key"].GetValues()))
assert.Equal(t, "key value", internalMD["key"].GetValues()[0])
require.Equal(t, 1, len(internalMD["key-bin"].GetValues()))
assert.Equal(t, base64.StdEncoding.EncodeToString(keyBinValue), internalMD["key-bin"].GetValues()[0], "binary metadata must be saved")
require.Equal(t, 2, len(internalMD["multikey"].GetValues()))
assert.Equal(t, []string{"ciao", "mamma"}, internalMD["multikey"].GetValues())
}
func TestHTTPHeadersToInternalMetadata(t *testing.T) {
header := http.Header{}
header.Add("foo", "test")
header.Add("bar", "test2")
header.Add("bar", "test3")
imd := HTTPHeadersToInternalMetadata(header)
require.NotEmpty(t, imd)
require.NotEmpty(t, imd["Foo"])
require.NotEmpty(t, imd["Foo"].Values)
assert.Equal(t, []string{"test"}, imd["Foo"].Values)
require.NotEmpty(t, imd["Bar"])
require.NotEmpty(t, imd["Bar"].Values)
assert.Equal(t, []string{"test2", "test3"}, imd["Bar"].Values)
}
|
mikeee/dapr
|
pkg/proto/internals/v1/service_invocation_additional_test.go
|
GO
|
mit
| 1,981 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/internals/v1/service_invocation.proto
package internals
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
ServiceInvocation_CallActor_FullMethodName = "/dapr.proto.internals.v1.ServiceInvocation/CallActor"
ServiceInvocation_CallLocal_FullMethodName = "/dapr.proto.internals.v1.ServiceInvocation/CallLocal"
ServiceInvocation_CallLocalStream_FullMethodName = "/dapr.proto.internals.v1.ServiceInvocation/CallLocalStream"
)
// ServiceInvocationClient is the client API for ServiceInvocation service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ServiceInvocationClient interface {
// Invokes a method of the specific actor.
CallActor(ctx context.Context, in *InternalInvokeRequest, opts ...grpc.CallOption) (*InternalInvokeResponse, error)
// Invokes a method of the specific service.
CallLocal(ctx context.Context, in *InternalInvokeRequest, opts ...grpc.CallOption) (*InternalInvokeResponse, error)
// Invokes a method of the specific service using a stream of data.
// Although this uses a bi-directional stream, it behaves as a "simple RPC" in which the caller sends the full request (chunked in multiple messages in the stream), then reads the full response (chunked in the stream).
// Each message in the stream contains a `InternalInvokeRequestStream` (for caller) or `InternalInvokeResponseStream` (for callee):
// - The first message in the stream MUST contain a `request` (caller) or `response` (callee) message with all required properties present.
// - The first message in the stream MAY contain a `payload`, which is not required and may be empty.
// - Subsequent messages (any message except the first one in the stream) MUST contain a `payload` and MUST NOT contain any other property (like `request` or `response`).
// - Each message with a `payload` MUST contain a sequence number in `seq`, which is a counter that starts from 0 and MUST be incremented by 1 in each chunk. The `seq` counter MUST NOT be included if the message does not have a `payload`.
// - When the sender has completed sending the data, it MUST call `CloseSend` on the stream.
// The caller and callee must send at least one message in the stream. If only 1 message is sent in each direction, that message must contain both a `request`/`response` (the `payload` may be empty).
CallLocalStream(ctx context.Context, opts ...grpc.CallOption) (ServiceInvocation_CallLocalStreamClient, error)
}
type serviceInvocationClient struct {
cc grpc.ClientConnInterface
}
func NewServiceInvocationClient(cc grpc.ClientConnInterface) ServiceInvocationClient {
return &serviceInvocationClient{cc}
}
func (c *serviceInvocationClient) CallActor(ctx context.Context, in *InternalInvokeRequest, opts ...grpc.CallOption) (*InternalInvokeResponse, error) {
out := new(InternalInvokeResponse)
err := c.cc.Invoke(ctx, ServiceInvocation_CallActor_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *serviceInvocationClient) CallLocal(ctx context.Context, in *InternalInvokeRequest, opts ...grpc.CallOption) (*InternalInvokeResponse, error) {
out := new(InternalInvokeResponse)
err := c.cc.Invoke(ctx, ServiceInvocation_CallLocal_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *serviceInvocationClient) CallLocalStream(ctx context.Context, opts ...grpc.CallOption) (ServiceInvocation_CallLocalStreamClient, error) {
stream, err := c.cc.NewStream(ctx, &ServiceInvocation_ServiceDesc.Streams[0], ServiceInvocation_CallLocalStream_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &serviceInvocationCallLocalStreamClient{stream}
return x, nil
}
type ServiceInvocation_CallLocalStreamClient interface {
Send(*InternalInvokeRequestStream) error
Recv() (*InternalInvokeResponseStream, error)
grpc.ClientStream
}
type serviceInvocationCallLocalStreamClient struct {
grpc.ClientStream
}
func (x *serviceInvocationCallLocalStreamClient) Send(m *InternalInvokeRequestStream) error {
return x.ClientStream.SendMsg(m)
}
func (x *serviceInvocationCallLocalStreamClient) Recv() (*InternalInvokeResponseStream, error) {
m := new(InternalInvokeResponseStream)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// ServiceInvocationServer is the server API for ServiceInvocation service.
// All implementations should embed UnimplementedServiceInvocationServer
// for forward compatibility
type ServiceInvocationServer interface {
// Invokes a method of the specific actor.
CallActor(context.Context, *InternalInvokeRequest) (*InternalInvokeResponse, error)
// Invokes a method of the specific service.
CallLocal(context.Context, *InternalInvokeRequest) (*InternalInvokeResponse, error)
// Invokes a method of the specific service using a stream of data.
// Although this uses a bi-directional stream, it behaves as a "simple RPC" in which the caller sends the full request (chunked in multiple messages in the stream), then reads the full response (chunked in the stream).
// Each message in the stream contains a `InternalInvokeRequestStream` (for caller) or `InternalInvokeResponseStream` (for callee):
// - The first message in the stream MUST contain a `request` (caller) or `response` (callee) message with all required properties present.
// - The first message in the stream MAY contain a `payload`, which is not required and may be empty.
// - Subsequent messages (any message except the first one in the stream) MUST contain a `payload` and MUST NOT contain any other property (like `request` or `response`).
// - Each message with a `payload` MUST contain a sequence number in `seq`, which is a counter that starts from 0 and MUST be incremented by 1 in each chunk. The `seq` counter MUST NOT be included if the message does not have a `payload`.
// - When the sender has completed sending the data, it MUST call `CloseSend` on the stream.
// The caller and callee must send at least one message in the stream. If only 1 message is sent in each direction, that message must contain both a `request`/`response` (the `payload` may be empty).
CallLocalStream(ServiceInvocation_CallLocalStreamServer) error
}
// UnimplementedServiceInvocationServer should be embedded to have forward compatible implementations.
type UnimplementedServiceInvocationServer struct {
}
func (UnimplementedServiceInvocationServer) CallActor(context.Context, *InternalInvokeRequest) (*InternalInvokeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CallActor not implemented")
}
func (UnimplementedServiceInvocationServer) CallLocal(context.Context, *InternalInvokeRequest) (*InternalInvokeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CallLocal not implemented")
}
func (UnimplementedServiceInvocationServer) CallLocalStream(ServiceInvocation_CallLocalStreamServer) error {
return status.Errorf(codes.Unimplemented, "method CallLocalStream not implemented")
}
// UnsafeServiceInvocationServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ServiceInvocationServer will
// result in compilation errors.
type UnsafeServiceInvocationServer interface {
mustEmbedUnimplementedServiceInvocationServer()
}
func RegisterServiceInvocationServer(s grpc.ServiceRegistrar, srv ServiceInvocationServer) {
s.RegisterService(&ServiceInvocation_ServiceDesc, srv)
}
func _ServiceInvocation_CallActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InternalInvokeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ServiceInvocationServer).CallActor(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: ServiceInvocation_CallActor_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ServiceInvocationServer).CallActor(ctx, req.(*InternalInvokeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ServiceInvocation_CallLocal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InternalInvokeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ServiceInvocationServer).CallLocal(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: ServiceInvocation_CallLocal_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ServiceInvocationServer).CallLocal(ctx, req.(*InternalInvokeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ServiceInvocation_CallLocalStream_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(ServiceInvocationServer).CallLocalStream(&serviceInvocationCallLocalStreamServer{stream})
}
type ServiceInvocation_CallLocalStreamServer interface {
Send(*InternalInvokeResponseStream) error
Recv() (*InternalInvokeRequestStream, error)
grpc.ServerStream
}
type serviceInvocationCallLocalStreamServer struct {
grpc.ServerStream
}
func (x *serviceInvocationCallLocalStreamServer) Send(m *InternalInvokeResponseStream) error {
return x.ServerStream.SendMsg(m)
}
func (x *serviceInvocationCallLocalStreamServer) Recv() (*InternalInvokeRequestStream, error) {
m := new(InternalInvokeRequestStream)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// ServiceInvocation_ServiceDesc is the grpc.ServiceDesc for ServiceInvocation service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServiceInvocation_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.internals.v1.ServiceInvocation",
HandlerType: (*ServiceInvocationServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "CallActor",
Handler: _ServiceInvocation_CallActor_Handler,
},
{
MethodName: "CallLocal",
Handler: _ServiceInvocation_CallLocal_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "CallLocalStream",
Handler: _ServiceInvocation_CallLocalStream_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "dapr/proto/internals/v1/service_invocation.proto",
}
|
mikeee/dapr
|
pkg/proto/internals/v1/service_invocation_grpc.pb.go
|
GO
|
mit
| 11,599 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/internals/v1/status.proto
package internals
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Status represents the response status for HTTP and gRPC app channel.
type Status struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The status code
Code int32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
// Error message
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
// A list of messages that carry the error details
Details []*anypb.Any `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
}
func (x *Status) Reset() {
*x = Status{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_internals_v1_status_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Status) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Status) ProtoMessage() {}
func (x *Status) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_internals_v1_status_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Status.ProtoReflect.Descriptor instead.
func (*Status) Descriptor() ([]byte, []int) {
return file_dapr_proto_internals_v1_status_proto_rawDescGZIP(), []int{0}
}
func (x *Status) GetCode() int32 {
if x != nil {
return x.Code
}
return 0
}
func (x *Status) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
func (x *Status) GetDetails() []*anypb.Any {
if x != nil {
return x.Details
}
return nil
}
var File_dapr_proto_internals_v1_status_proto protoreflect.FileDescriptor
var file_dapr_proto_internals_v1_status_proto_rawDesc = []byte{
0x0a, 0x24, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74,
0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2e, 0x76, 0x31, 0x1a,
0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x66, 0x0a, 0x06, 0x53, 0x74,
0x61, 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x05, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73,
0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61,
0x67, 0x65, 0x12, 0x2e, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69,
0x6c, 0x73, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x2f, 0x76,
0x31, 0x3b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_internals_v1_status_proto_rawDescOnce sync.Once
file_dapr_proto_internals_v1_status_proto_rawDescData = file_dapr_proto_internals_v1_status_proto_rawDesc
)
func file_dapr_proto_internals_v1_status_proto_rawDescGZIP() []byte {
file_dapr_proto_internals_v1_status_proto_rawDescOnce.Do(func() {
file_dapr_proto_internals_v1_status_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_internals_v1_status_proto_rawDescData)
})
return file_dapr_proto_internals_v1_status_proto_rawDescData
}
var file_dapr_proto_internals_v1_status_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_dapr_proto_internals_v1_status_proto_goTypes = []interface{}{
(*Status)(nil), // 0: dapr.proto.internals.v1.Status
(*anypb.Any)(nil), // 1: google.protobuf.Any
}
var file_dapr_proto_internals_v1_status_proto_depIdxs = []int32{
1, // 0: dapr.proto.internals.v1.Status.details:type_name -> google.protobuf.Any
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_dapr_proto_internals_v1_status_proto_init() }
func file_dapr_proto_internals_v1_status_proto_init() {
if File_dapr_proto_internals_v1_status_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_internals_v1_status_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Status); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_internals_v1_status_proto_rawDesc,
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_dapr_proto_internals_v1_status_proto_goTypes,
DependencyIndexes: file_dapr_proto_internals_v1_status_proto_depIdxs,
MessageInfos: file_dapr_proto_internals_v1_status_proto_msgTypes,
}.Build()
File_dapr_proto_internals_v1_status_proto = out.File
file_dapr_proto_internals_v1_status_proto_rawDesc = nil
file_dapr_proto_internals_v1_status_proto_goTypes = nil
file_dapr_proto_internals_v1_status_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/internals/v1/status.pb.go
|
GO
|
mit
| 7,056 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/operator/v1/operator.proto
package operator
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// ResourceEventType is the type of event to a resource.
type ResourceEventType int32
const (
// UNKNOWN indicates that the event type is unknown.
ResourceEventType_UNKNOWN ResourceEventType = 0
// CREATED indicates that the resource has been created.
ResourceEventType_CREATED ResourceEventType = 1
// UPDATED indicates that the resource has been updated.
ResourceEventType_UPDATED ResourceEventType = 2
// DELETED indicates that the resource has been deleted.
ResourceEventType_DELETED ResourceEventType = 3
)
// Enum value maps for ResourceEventType.
var (
ResourceEventType_name = map[int32]string{
0: "UNKNOWN",
1: "CREATED",
2: "UPDATED",
3: "DELETED",
}
ResourceEventType_value = map[string]int32{
"UNKNOWN": 0,
"CREATED": 1,
"UPDATED": 2,
"DELETED": 3,
}
)
func (x ResourceEventType) Enum() *ResourceEventType {
p := new(ResourceEventType)
*p = x
return p
}
func (x ResourceEventType) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ResourceEventType) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_operator_v1_operator_proto_enumTypes[0].Descriptor()
}
func (ResourceEventType) Type() protoreflect.EnumType {
return &file_dapr_proto_operator_v1_operator_proto_enumTypes[0]
}
func (x ResourceEventType) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use ResourceEventType.Descriptor instead.
func (ResourceEventType) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{0}
}
// ListComponentsRequest is the request to get components for a sidecar in namespace.
type ListComponentsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
PodName string `protobuf:"bytes,2,opt,name=podName,proto3" json:"podName,omitempty"`
}
func (x *ListComponentsRequest) Reset() {
*x = ListComponentsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListComponentsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListComponentsRequest) ProtoMessage() {}
func (x *ListComponentsRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListComponentsRequest.ProtoReflect.Descriptor instead.
func (*ListComponentsRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{0}
}
func (x *ListComponentsRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
func (x *ListComponentsRequest) GetPodName() string {
if x != nil {
return x.PodName
}
return ""
}
// ComponentUpdateRequest is the request to get updates about new components for a given namespace.
type ComponentUpdateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
PodName string `protobuf:"bytes,2,opt,name=podName,proto3" json:"podName,omitempty"`
}
func (x *ComponentUpdateRequest) Reset() {
*x = ComponentUpdateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ComponentUpdateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ComponentUpdateRequest) ProtoMessage() {}
func (x *ComponentUpdateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ComponentUpdateRequest.ProtoReflect.Descriptor instead.
func (*ComponentUpdateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{1}
}
func (x *ComponentUpdateRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
func (x *ComponentUpdateRequest) GetPodName() string {
if x != nil {
return x.PodName
}
return ""
}
// ComponentUpdateEvent includes the updated component event.
type ComponentUpdateEvent struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Component []byte `protobuf:"bytes,1,opt,name=component,proto3" json:"component,omitempty"`
// type is the type of event.
Type ResourceEventType `protobuf:"varint,2,opt,name=type,proto3,enum=dapr.proto.operator.v1.ResourceEventType" json:"type,omitempty"`
}
func (x *ComponentUpdateEvent) Reset() {
*x = ComponentUpdateEvent{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ComponentUpdateEvent) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ComponentUpdateEvent) ProtoMessage() {}
func (x *ComponentUpdateEvent) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ComponentUpdateEvent.ProtoReflect.Descriptor instead.
func (*ComponentUpdateEvent) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{2}
}
func (x *ComponentUpdateEvent) GetComponent() []byte {
if x != nil {
return x.Component
}
return nil
}
func (x *ComponentUpdateEvent) GetType() ResourceEventType {
if x != nil {
return x.Type
}
return ResourceEventType_UNKNOWN
}
// ListComponentResponse includes the list of available components.
type ListComponentResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Components [][]byte `protobuf:"bytes,1,rep,name=components,proto3" json:"components,omitempty"`
}
func (x *ListComponentResponse) Reset() {
*x = ListComponentResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListComponentResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListComponentResponse) ProtoMessage() {}
func (x *ListComponentResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListComponentResponse.ProtoReflect.Descriptor instead.
func (*ListComponentResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{3}
}
func (x *ListComponentResponse) GetComponents() [][]byte {
if x != nil {
return x.Components
}
return nil
}
// GetConfigurationRequest is the request message to get the configuration.
type GetConfigurationRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
PodName string `protobuf:"bytes,3,opt,name=podName,proto3" json:"podName,omitempty"`
}
func (x *GetConfigurationRequest) Reset() {
*x = GetConfigurationRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetConfigurationRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetConfigurationRequest) ProtoMessage() {}
func (x *GetConfigurationRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetConfigurationRequest.ProtoReflect.Descriptor instead.
func (*GetConfigurationRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{4}
}
func (x *GetConfigurationRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *GetConfigurationRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
func (x *GetConfigurationRequest) GetPodName() string {
if x != nil {
return x.PodName
}
return ""
}
// GetConfigurationResponse includes the requested configuration.
type GetConfigurationResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Configuration []byte `protobuf:"bytes,1,opt,name=configuration,proto3" json:"configuration,omitempty"`
}
func (x *GetConfigurationResponse) Reset() {
*x = GetConfigurationResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetConfigurationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetConfigurationResponse) ProtoMessage() {}
func (x *GetConfigurationResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetConfigurationResponse.ProtoReflect.Descriptor instead.
func (*GetConfigurationResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{5}
}
func (x *GetConfigurationResponse) GetConfiguration() []byte {
if x != nil {
return x.Configuration
}
return nil
}
// ListSubscriptionsResponse includes pub/sub subscriptions.
type ListSubscriptionsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Subscriptions [][]byte `protobuf:"bytes,1,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"`
}
func (x *ListSubscriptionsResponse) Reset() {
*x = ListSubscriptionsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListSubscriptionsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListSubscriptionsResponse) ProtoMessage() {}
func (x *ListSubscriptionsResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListSubscriptionsResponse.ProtoReflect.Descriptor instead.
func (*ListSubscriptionsResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{6}
}
func (x *ListSubscriptionsResponse) GetSubscriptions() [][]byte {
if x != nil {
return x.Subscriptions
}
return nil
}
// SubscriptionUpdateRequest is the request to get updates about new
// subscriptions for a given namespace.
type SubscriptionUpdateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
PodName string `protobuf:"bytes,2,opt,name=podName,proto3" json:"podName,omitempty"`
}
func (x *SubscriptionUpdateRequest) Reset() {
*x = SubscriptionUpdateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscriptionUpdateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscriptionUpdateRequest) ProtoMessage() {}
func (x *SubscriptionUpdateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscriptionUpdateRequest.ProtoReflect.Descriptor instead.
func (*SubscriptionUpdateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{7}
}
func (x *SubscriptionUpdateRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
func (x *SubscriptionUpdateRequest) GetPodName() string {
if x != nil {
return x.PodName
}
return ""
}
// SubscriptionUpdateEvent includes the updated subscription event.
type SubscriptionUpdateEvent struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Subscription []byte `protobuf:"bytes,1,opt,name=subscription,proto3" json:"subscription,omitempty"`
// type is the type of event.
Type ResourceEventType `protobuf:"varint,2,opt,name=type,proto3,enum=dapr.proto.operator.v1.ResourceEventType" json:"type,omitempty"`
}
func (x *SubscriptionUpdateEvent) Reset() {
*x = SubscriptionUpdateEvent{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscriptionUpdateEvent) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscriptionUpdateEvent) ProtoMessage() {}
func (x *SubscriptionUpdateEvent) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscriptionUpdateEvent.ProtoReflect.Descriptor instead.
func (*SubscriptionUpdateEvent) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{8}
}
func (x *SubscriptionUpdateEvent) GetSubscription() []byte {
if x != nil {
return x.Subscription
}
return nil
}
func (x *SubscriptionUpdateEvent) GetType() ResourceEventType {
if x != nil {
return x.Type
}
return ResourceEventType_UNKNOWN
}
// GetResiliencyRequest is the request to get a resiliency configuration.
type GetResiliencyRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
}
func (x *GetResiliencyRequest) Reset() {
*x = GetResiliencyRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetResiliencyRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetResiliencyRequest) ProtoMessage() {}
func (x *GetResiliencyRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetResiliencyRequest.ProtoReflect.Descriptor instead.
func (*GetResiliencyRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{9}
}
func (x *GetResiliencyRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *GetResiliencyRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
// GetResiliencyResponse includes the requested resiliency configuration.
type GetResiliencyResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Resiliency []byte `protobuf:"bytes,1,opt,name=resiliency,proto3" json:"resiliency,omitempty"`
}
func (x *GetResiliencyResponse) Reset() {
*x = GetResiliencyResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetResiliencyResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetResiliencyResponse) ProtoMessage() {}
func (x *GetResiliencyResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetResiliencyResponse.ProtoReflect.Descriptor instead.
func (*GetResiliencyResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{10}
}
func (x *GetResiliencyResponse) GetResiliency() []byte {
if x != nil {
return x.Resiliency
}
return nil
}
// ListResiliencyRequest is the requests to get resiliency configurations for a sidecar namespace.
type ListResiliencyRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
}
func (x *ListResiliencyRequest) Reset() {
*x = ListResiliencyRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListResiliencyRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListResiliencyRequest) ProtoMessage() {}
func (x *ListResiliencyRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListResiliencyRequest.ProtoReflect.Descriptor instead.
func (*ListResiliencyRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{11}
}
func (x *ListResiliencyRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
// ListResiliencyResponse includes the list of available resiliency configurations.
type ListResiliencyResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Resiliencies [][]byte `protobuf:"bytes,1,rep,name=resiliencies,proto3" json:"resiliencies,omitempty"`
}
func (x *ListResiliencyResponse) Reset() {
*x = ListResiliencyResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListResiliencyResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListResiliencyResponse) ProtoMessage() {}
func (x *ListResiliencyResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[12]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListResiliencyResponse.ProtoReflect.Descriptor instead.
func (*ListResiliencyResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{12}
}
func (x *ListResiliencyResponse) GetResiliencies() [][]byte {
if x != nil {
return x.Resiliencies
}
return nil
}
type ListSubscriptionsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
PodName string `protobuf:"bytes,1,opt,name=podName,proto3" json:"podName,omitempty"`
Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
}
func (x *ListSubscriptionsRequest) Reset() {
*x = ListSubscriptionsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListSubscriptionsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListSubscriptionsRequest) ProtoMessage() {}
func (x *ListSubscriptionsRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[13]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListSubscriptionsRequest.ProtoReflect.Descriptor instead.
func (*ListSubscriptionsRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{13}
}
func (x *ListSubscriptionsRequest) GetPodName() string {
if x != nil {
return x.PodName
}
return ""
}
func (x *ListSubscriptionsRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
// GetHTTPEndpointRequest is the request to get an http endpoint configuration.
type GetHTTPEndpointRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
}
func (x *GetHTTPEndpointRequest) Reset() {
*x = GetHTTPEndpointRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetHTTPEndpointRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetHTTPEndpointRequest) ProtoMessage() {}
func (x *GetHTTPEndpointRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[14]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetHTTPEndpointRequest.ProtoReflect.Descriptor instead.
func (*GetHTTPEndpointRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{14}
}
func (x *GetHTTPEndpointRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *GetHTTPEndpointRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
// GetHTTPEndpointResponse includes the requested http endpoint configuration.
type GetHTTPEndpointResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
HttpEndpoint []byte `protobuf:"bytes,1,opt,name=http_endpoint,json=httpEndpoint,proto3" json:"http_endpoint,omitempty"`
}
func (x *GetHTTPEndpointResponse) Reset() {
*x = GetHTTPEndpointResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetHTTPEndpointResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetHTTPEndpointResponse) ProtoMessage() {}
func (x *GetHTTPEndpointResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[15]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetHTTPEndpointResponse.ProtoReflect.Descriptor instead.
func (*GetHTTPEndpointResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{15}
}
func (x *GetHTTPEndpointResponse) GetHttpEndpoint() []byte {
if x != nil {
return x.HttpEndpoint
}
return nil
}
// ListHTTPEndpointsResponse includes the list of available http endpoint configurations.
type ListHTTPEndpointsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
HttpEndpoints [][]byte `protobuf:"bytes,1,rep,name=http_endpoints,json=httpEndpoints,proto3" json:"http_endpoints,omitempty"`
}
func (x *ListHTTPEndpointsResponse) Reset() {
*x = ListHTTPEndpointsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListHTTPEndpointsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListHTTPEndpointsResponse) ProtoMessage() {}
func (x *ListHTTPEndpointsResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[16]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListHTTPEndpointsResponse.ProtoReflect.Descriptor instead.
func (*ListHTTPEndpointsResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{16}
}
func (x *ListHTTPEndpointsResponse) GetHttpEndpoints() [][]byte {
if x != nil {
return x.HttpEndpoints
}
return nil
}
type ListHTTPEndpointsRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
}
func (x *ListHTTPEndpointsRequest) Reset() {
*x = ListHTTPEndpointsRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListHTTPEndpointsRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListHTTPEndpointsRequest) ProtoMessage() {}
func (x *ListHTTPEndpointsRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[17]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListHTTPEndpointsRequest.ProtoReflect.Descriptor instead.
func (*ListHTTPEndpointsRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{17}
}
func (x *ListHTTPEndpointsRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
// HTTPEndpointsUpdateRequest is the request to get updates about new http endpoints for a given namespace.
type HTTPEndpointUpdateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Namespace string `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace,omitempty"`
PodName string `protobuf:"bytes,2,opt,name=pod_name,json=podName,proto3" json:"pod_name,omitempty"`
}
func (x *HTTPEndpointUpdateRequest) Reset() {
*x = HTTPEndpointUpdateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HTTPEndpointUpdateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HTTPEndpointUpdateRequest) ProtoMessage() {}
func (x *HTTPEndpointUpdateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[18]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HTTPEndpointUpdateRequest.ProtoReflect.Descriptor instead.
func (*HTTPEndpointUpdateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{18}
}
func (x *HTTPEndpointUpdateRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
func (x *HTTPEndpointUpdateRequest) GetPodName() string {
if x != nil {
return x.PodName
}
return ""
}
// HTTPEndpointsUpdateEvent includes the updated http endpoint event.
type HTTPEndpointUpdateEvent struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
HttpEndpoints []byte `protobuf:"bytes,1,opt,name=http_endpoints,json=httpEndpoints,proto3" json:"http_endpoints,omitempty"`
}
func (x *HTTPEndpointUpdateEvent) Reset() {
*x = HTTPEndpointUpdateEvent{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HTTPEndpointUpdateEvent) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HTTPEndpointUpdateEvent) ProtoMessage() {}
func (x *HTTPEndpointUpdateEvent) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_operator_v1_operator_proto_msgTypes[19]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HTTPEndpointUpdateEvent.ProtoReflect.Descriptor instead.
func (*HTTPEndpointUpdateEvent) Descriptor() ([]byte, []int) {
return file_dapr_proto_operator_v1_operator_proto_rawDescGZIP(), []int{19}
}
func (x *HTTPEndpointUpdateEvent) GetHttpEndpoints() []byte {
if x != nil {
return x.HttpEndpoints
}
return nil
}
var File_dapr_proto_operator_v1_operator_proto protoreflect.FileDescriptor
var file_dapr_proto_operator_v1_operator_proto_rawDesc = []byte{
0x0a, 0x25, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x70, 0x65,
0x72, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x76, 0x31, 0x2f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x16, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x1a,
0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x4f, 0x0a, 0x15,
0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
0x61, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x50, 0x0a,
0x16, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73,
0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65,
0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22,
0x73, 0x0a, 0x14, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61,
0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f,
0x6e, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x12, 0x3d, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73,
0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04,
0x74, 0x79, 0x70, 0x65, 0x22, 0x37, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a,
0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
0x0c, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x65, 0x0a,
0x17, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09,
0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f,
0x64, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64,
0x4e, 0x61, 0x6d, 0x65, 0x22, 0x40, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x24, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x41, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75,
0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x73, 0x75, 0x62, 0x73,
0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x53, 0x0a, 0x19, 0x53, 0x75, 0x62,
0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73,
0x70, 0x61, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x7c,
0x0a, 0x17, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70,
0x64, 0x61, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x22, 0x0a, 0x0c, 0x73, 0x75, 0x62,
0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
0x0c, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3d, 0x0a,
0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f,
0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x76, 0x65,
0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x48, 0x0a, 0x14,
0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65,
0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d,
0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x37, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73,
0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x1e, 0x0a, 0x0a, 0x72, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0c, 0x52, 0x0a, 0x72, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x22,
0x35, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63,
0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65,
0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d,
0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x3c, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65,
0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x22, 0x0a, 0x0c, 0x72, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73,
0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e,
0x63, 0x69, 0x65, 0x73, 0x22, 0x52, 0x0a, 0x18, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75, 0x62, 0x73,
0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61,
0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e,
0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x22, 0x4a, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x48,
0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73,
0x70, 0x61, 0x63, 0x65, 0x22, 0x3e, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x48, 0x54, 0x54, 0x50, 0x45,
0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
0x23, 0x0a, 0x0d, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x68, 0x74, 0x74, 0x70, 0x45, 0x6e, 0x64, 0x70,
0x6f, 0x69, 0x6e, 0x74, 0x22, 0x42, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x54, 0x54, 0x50,
0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x25, 0x0a, 0x0e, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69,
0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x68, 0x74, 0x74, 0x70, 0x45,
0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x38, 0x0a, 0x18, 0x4c, 0x69, 0x73, 0x74,
0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63,
0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
0x63, 0x65, 0x22, 0x54, 0x0a, 0x19, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69,
0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x19, 0x0a,
0x08, 0x70, 0x6f, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x07, 0x70, 0x6f, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x40, 0x0a, 0x17, 0x48, 0x54, 0x54, 0x50,
0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x76,
0x65, 0x6e, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x68, 0x74, 0x74, 0x70, 0x5f, 0x65, 0x6e, 0x64, 0x70,
0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x68, 0x74, 0x74,
0x70, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x2a, 0x47, 0x0a, 0x11, 0x52, 0x65,
0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07,
0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x50, 0x44,
0x41, 0x54, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45,
0x44, 0x10, 0x03, 0x32, 0xa5, 0x09, 0x0a, 0x08, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72,
0x12, 0x73, 0x0a, 0x0f, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64,
0x61, 0x74, 0x65, 0x12, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e,
0x74, 0x22, 0x00, 0x30, 0x01, 0x12, 0x70, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31,
0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e,
0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x77, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f,
0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
0x12, 0x60, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x31, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61,
0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63,
0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x12, 0x6e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x52, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65,
0x6e, 0x63, 0x79, 0x12, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74,
0x52, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f,
0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65,
0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x12, 0x71, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x69, 0x6c, 0x69,
0x65, 0x6e, 0x63, 0x79, 0x12, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69,
0x73, 0x74, 0x52, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73,
0x74, 0x52, 0x65, 0x73, 0x69, 0x6c, 0x69, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7c, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75, 0x62,
0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x32, 0x12, 0x30, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72,
0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x75, 0x62, 0x73,
0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x7c, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x31, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e,
0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x55,
0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x00, 0x30,
0x01, 0x12, 0x7a, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64,
0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x30, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e,
0x4c, 0x69, 0x73, 0x74, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74,
0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76,
0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69,
0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7c, 0x0a,
0x12, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x70, 0x64,
0x61, 0x74, 0x65, 0x12, 0x31, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x54, 0x54,
0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e,
0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61,
0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x22, 0x00, 0x30, 0x01, 0x42, 0x35, 0x5a, 0x33, 0x67,
0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64,
0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6f, 0x70,
0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x6f, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_operator_v1_operator_proto_rawDescOnce sync.Once
file_dapr_proto_operator_v1_operator_proto_rawDescData = file_dapr_proto_operator_v1_operator_proto_rawDesc
)
func file_dapr_proto_operator_v1_operator_proto_rawDescGZIP() []byte {
file_dapr_proto_operator_v1_operator_proto_rawDescOnce.Do(func() {
file_dapr_proto_operator_v1_operator_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_operator_v1_operator_proto_rawDescData)
})
return file_dapr_proto_operator_v1_operator_proto_rawDescData
}
var file_dapr_proto_operator_v1_operator_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_dapr_proto_operator_v1_operator_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_dapr_proto_operator_v1_operator_proto_goTypes = []interface{}{
(ResourceEventType)(0), // 0: dapr.proto.operator.v1.ResourceEventType
(*ListComponentsRequest)(nil), // 1: dapr.proto.operator.v1.ListComponentsRequest
(*ComponentUpdateRequest)(nil), // 2: dapr.proto.operator.v1.ComponentUpdateRequest
(*ComponentUpdateEvent)(nil), // 3: dapr.proto.operator.v1.ComponentUpdateEvent
(*ListComponentResponse)(nil), // 4: dapr.proto.operator.v1.ListComponentResponse
(*GetConfigurationRequest)(nil), // 5: dapr.proto.operator.v1.GetConfigurationRequest
(*GetConfigurationResponse)(nil), // 6: dapr.proto.operator.v1.GetConfigurationResponse
(*ListSubscriptionsResponse)(nil), // 7: dapr.proto.operator.v1.ListSubscriptionsResponse
(*SubscriptionUpdateRequest)(nil), // 8: dapr.proto.operator.v1.SubscriptionUpdateRequest
(*SubscriptionUpdateEvent)(nil), // 9: dapr.proto.operator.v1.SubscriptionUpdateEvent
(*GetResiliencyRequest)(nil), // 10: dapr.proto.operator.v1.GetResiliencyRequest
(*GetResiliencyResponse)(nil), // 11: dapr.proto.operator.v1.GetResiliencyResponse
(*ListResiliencyRequest)(nil), // 12: dapr.proto.operator.v1.ListResiliencyRequest
(*ListResiliencyResponse)(nil), // 13: dapr.proto.operator.v1.ListResiliencyResponse
(*ListSubscriptionsRequest)(nil), // 14: dapr.proto.operator.v1.ListSubscriptionsRequest
(*GetHTTPEndpointRequest)(nil), // 15: dapr.proto.operator.v1.GetHTTPEndpointRequest
(*GetHTTPEndpointResponse)(nil), // 16: dapr.proto.operator.v1.GetHTTPEndpointResponse
(*ListHTTPEndpointsResponse)(nil), // 17: dapr.proto.operator.v1.ListHTTPEndpointsResponse
(*ListHTTPEndpointsRequest)(nil), // 18: dapr.proto.operator.v1.ListHTTPEndpointsRequest
(*HTTPEndpointUpdateRequest)(nil), // 19: dapr.proto.operator.v1.HTTPEndpointUpdateRequest
(*HTTPEndpointUpdateEvent)(nil), // 20: dapr.proto.operator.v1.HTTPEndpointUpdateEvent
(*emptypb.Empty)(nil), // 21: google.protobuf.Empty
}
var file_dapr_proto_operator_v1_operator_proto_depIdxs = []int32{
0, // 0: dapr.proto.operator.v1.ComponentUpdateEvent.type:type_name -> dapr.proto.operator.v1.ResourceEventType
0, // 1: dapr.proto.operator.v1.SubscriptionUpdateEvent.type:type_name -> dapr.proto.operator.v1.ResourceEventType
2, // 2: dapr.proto.operator.v1.Operator.ComponentUpdate:input_type -> dapr.proto.operator.v1.ComponentUpdateRequest
1, // 3: dapr.proto.operator.v1.Operator.ListComponents:input_type -> dapr.proto.operator.v1.ListComponentsRequest
5, // 4: dapr.proto.operator.v1.Operator.GetConfiguration:input_type -> dapr.proto.operator.v1.GetConfigurationRequest
21, // 5: dapr.proto.operator.v1.Operator.ListSubscriptions:input_type -> google.protobuf.Empty
10, // 6: dapr.proto.operator.v1.Operator.GetResiliency:input_type -> dapr.proto.operator.v1.GetResiliencyRequest
12, // 7: dapr.proto.operator.v1.Operator.ListResiliency:input_type -> dapr.proto.operator.v1.ListResiliencyRequest
14, // 8: dapr.proto.operator.v1.Operator.ListSubscriptionsV2:input_type -> dapr.proto.operator.v1.ListSubscriptionsRequest
8, // 9: dapr.proto.operator.v1.Operator.SubscriptionUpdate:input_type -> dapr.proto.operator.v1.SubscriptionUpdateRequest
18, // 10: dapr.proto.operator.v1.Operator.ListHTTPEndpoints:input_type -> dapr.proto.operator.v1.ListHTTPEndpointsRequest
19, // 11: dapr.proto.operator.v1.Operator.HTTPEndpointUpdate:input_type -> dapr.proto.operator.v1.HTTPEndpointUpdateRequest
3, // 12: dapr.proto.operator.v1.Operator.ComponentUpdate:output_type -> dapr.proto.operator.v1.ComponentUpdateEvent
4, // 13: dapr.proto.operator.v1.Operator.ListComponents:output_type -> dapr.proto.operator.v1.ListComponentResponse
6, // 14: dapr.proto.operator.v1.Operator.GetConfiguration:output_type -> dapr.proto.operator.v1.GetConfigurationResponse
7, // 15: dapr.proto.operator.v1.Operator.ListSubscriptions:output_type -> dapr.proto.operator.v1.ListSubscriptionsResponse
11, // 16: dapr.proto.operator.v1.Operator.GetResiliency:output_type -> dapr.proto.operator.v1.GetResiliencyResponse
13, // 17: dapr.proto.operator.v1.Operator.ListResiliency:output_type -> dapr.proto.operator.v1.ListResiliencyResponse
7, // 18: dapr.proto.operator.v1.Operator.ListSubscriptionsV2:output_type -> dapr.proto.operator.v1.ListSubscriptionsResponse
9, // 19: dapr.proto.operator.v1.Operator.SubscriptionUpdate:output_type -> dapr.proto.operator.v1.SubscriptionUpdateEvent
17, // 20: dapr.proto.operator.v1.Operator.ListHTTPEndpoints:output_type -> dapr.proto.operator.v1.ListHTTPEndpointsResponse
20, // 21: dapr.proto.operator.v1.Operator.HTTPEndpointUpdate:output_type -> dapr.proto.operator.v1.HTTPEndpointUpdateEvent
12, // [12:22] is the sub-list for method output_type
2, // [2:12] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_dapr_proto_operator_v1_operator_proto_init() }
func file_dapr_proto_operator_v1_operator_proto_init() {
if File_dapr_proto_operator_v1_operator_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_operator_v1_operator_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListComponentsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ComponentUpdateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ComponentUpdateEvent); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListComponentResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetConfigurationRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetConfigurationResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListSubscriptionsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscriptionUpdateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscriptionUpdateEvent); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetResiliencyRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetResiliencyResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListResiliencyRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListResiliencyResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListSubscriptionsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetHTTPEndpointRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetHTTPEndpointResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListHTTPEndpointsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListHTTPEndpointsRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HTTPEndpointUpdateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_operator_v1_operator_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HTTPEndpointUpdateEvent); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_operator_v1_operator_proto_rawDesc,
NumEnums: 1,
NumMessages: 20,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_operator_v1_operator_proto_goTypes,
DependencyIndexes: file_dapr_proto_operator_v1_operator_proto_depIdxs,
EnumInfos: file_dapr_proto_operator_v1_operator_proto_enumTypes,
MessageInfos: file_dapr_proto_operator_v1_operator_proto_msgTypes,
}.Build()
File_dapr_proto_operator_v1_operator_proto = out.File
file_dapr_proto_operator_v1_operator_proto_rawDesc = nil
file_dapr_proto_operator_v1_operator_proto_goTypes = nil
file_dapr_proto_operator_v1_operator_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/operator/v1/operator.pb.go
|
GO
|
mit
| 63,997 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/operator/v1/operator.proto
package operator
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
Operator_ComponentUpdate_FullMethodName = "/dapr.proto.operator.v1.Operator/ComponentUpdate"
Operator_ListComponents_FullMethodName = "/dapr.proto.operator.v1.Operator/ListComponents"
Operator_GetConfiguration_FullMethodName = "/dapr.proto.operator.v1.Operator/GetConfiguration"
Operator_ListSubscriptions_FullMethodName = "/dapr.proto.operator.v1.Operator/ListSubscriptions"
Operator_GetResiliency_FullMethodName = "/dapr.proto.operator.v1.Operator/GetResiliency"
Operator_ListResiliency_FullMethodName = "/dapr.proto.operator.v1.Operator/ListResiliency"
Operator_ListSubscriptionsV2_FullMethodName = "/dapr.proto.operator.v1.Operator/ListSubscriptionsV2"
Operator_SubscriptionUpdate_FullMethodName = "/dapr.proto.operator.v1.Operator/SubscriptionUpdate"
Operator_ListHTTPEndpoints_FullMethodName = "/dapr.proto.operator.v1.Operator/ListHTTPEndpoints"
Operator_HTTPEndpointUpdate_FullMethodName = "/dapr.proto.operator.v1.Operator/HTTPEndpointUpdate"
)
// OperatorClient is the client API for Operator service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type OperatorClient interface {
// Sends events to Dapr sidecars upon component changes.
ComponentUpdate(ctx context.Context, in *ComponentUpdateRequest, opts ...grpc.CallOption) (Operator_ComponentUpdateClient, error)
// Returns a list of available components
ListComponents(ctx context.Context, in *ListComponentsRequest, opts ...grpc.CallOption) (*ListComponentResponse, error)
// Returns a given configuration by name
GetConfiguration(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error)
// Returns a list of pub/sub subscriptions
ListSubscriptions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error)
// Returns a given resiliency configuration by name
GetResiliency(ctx context.Context, in *GetResiliencyRequest, opts ...grpc.CallOption) (*GetResiliencyResponse, error)
// Returns a list of resiliency configurations
ListResiliency(ctx context.Context, in *ListResiliencyRequest, opts ...grpc.CallOption) (*ListResiliencyResponse, error)
// Returns a list of pub/sub subscriptions, ListSubscriptionsRequest to expose pod info
ListSubscriptionsV2(ctx context.Context, in *ListSubscriptionsRequest, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error)
// Sends events to Dapr sidecars upon subscription changes.
SubscriptionUpdate(ctx context.Context, in *SubscriptionUpdateRequest, opts ...grpc.CallOption) (Operator_SubscriptionUpdateClient, error)
// Returns a list of http endpoints
ListHTTPEndpoints(ctx context.Context, in *ListHTTPEndpointsRequest, opts ...grpc.CallOption) (*ListHTTPEndpointsResponse, error)
// Sends events to Dapr sidecars upon http endpoint changes.
HTTPEndpointUpdate(ctx context.Context, in *HTTPEndpointUpdateRequest, opts ...grpc.CallOption) (Operator_HTTPEndpointUpdateClient, error)
}
type operatorClient struct {
cc grpc.ClientConnInterface
}
func NewOperatorClient(cc grpc.ClientConnInterface) OperatorClient {
return &operatorClient{cc}
}
func (c *operatorClient) ComponentUpdate(ctx context.Context, in *ComponentUpdateRequest, opts ...grpc.CallOption) (Operator_ComponentUpdateClient, error) {
stream, err := c.cc.NewStream(ctx, &Operator_ServiceDesc.Streams[0], Operator_ComponentUpdate_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &operatorComponentUpdateClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Operator_ComponentUpdateClient interface {
Recv() (*ComponentUpdateEvent, error)
grpc.ClientStream
}
type operatorComponentUpdateClient struct {
grpc.ClientStream
}
func (x *operatorComponentUpdateClient) Recv() (*ComponentUpdateEvent, error) {
m := new(ComponentUpdateEvent)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *operatorClient) ListComponents(ctx context.Context, in *ListComponentsRequest, opts ...grpc.CallOption) (*ListComponentResponse, error) {
out := new(ListComponentResponse)
err := c.cc.Invoke(ctx, Operator_ListComponents_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) GetConfiguration(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) {
out := new(GetConfigurationResponse)
err := c.cc.Invoke(ctx, Operator_GetConfiguration_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) ListSubscriptions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error) {
out := new(ListSubscriptionsResponse)
err := c.cc.Invoke(ctx, Operator_ListSubscriptions_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) GetResiliency(ctx context.Context, in *GetResiliencyRequest, opts ...grpc.CallOption) (*GetResiliencyResponse, error) {
out := new(GetResiliencyResponse)
err := c.cc.Invoke(ctx, Operator_GetResiliency_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) ListResiliency(ctx context.Context, in *ListResiliencyRequest, opts ...grpc.CallOption) (*ListResiliencyResponse, error) {
out := new(ListResiliencyResponse)
err := c.cc.Invoke(ctx, Operator_ListResiliency_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) ListSubscriptionsV2(ctx context.Context, in *ListSubscriptionsRequest, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error) {
out := new(ListSubscriptionsResponse)
err := c.cc.Invoke(ctx, Operator_ListSubscriptionsV2_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) SubscriptionUpdate(ctx context.Context, in *SubscriptionUpdateRequest, opts ...grpc.CallOption) (Operator_SubscriptionUpdateClient, error) {
stream, err := c.cc.NewStream(ctx, &Operator_ServiceDesc.Streams[1], Operator_SubscriptionUpdate_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &operatorSubscriptionUpdateClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Operator_SubscriptionUpdateClient interface {
Recv() (*SubscriptionUpdateEvent, error)
grpc.ClientStream
}
type operatorSubscriptionUpdateClient struct {
grpc.ClientStream
}
func (x *operatorSubscriptionUpdateClient) Recv() (*SubscriptionUpdateEvent, error) {
m := new(SubscriptionUpdateEvent)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *operatorClient) ListHTTPEndpoints(ctx context.Context, in *ListHTTPEndpointsRequest, opts ...grpc.CallOption) (*ListHTTPEndpointsResponse, error) {
out := new(ListHTTPEndpointsResponse)
err := c.cc.Invoke(ctx, Operator_ListHTTPEndpoints_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *operatorClient) HTTPEndpointUpdate(ctx context.Context, in *HTTPEndpointUpdateRequest, opts ...grpc.CallOption) (Operator_HTTPEndpointUpdateClient, error) {
stream, err := c.cc.NewStream(ctx, &Operator_ServiceDesc.Streams[2], Operator_HTTPEndpointUpdate_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &operatorHTTPEndpointUpdateClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Operator_HTTPEndpointUpdateClient interface {
Recv() (*HTTPEndpointUpdateEvent, error)
grpc.ClientStream
}
type operatorHTTPEndpointUpdateClient struct {
grpc.ClientStream
}
func (x *operatorHTTPEndpointUpdateClient) Recv() (*HTTPEndpointUpdateEvent, error) {
m := new(HTTPEndpointUpdateEvent)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// OperatorServer is the server API for Operator service.
// All implementations should embed UnimplementedOperatorServer
// for forward compatibility
type OperatorServer interface {
// Sends events to Dapr sidecars upon component changes.
ComponentUpdate(*ComponentUpdateRequest, Operator_ComponentUpdateServer) error
// Returns a list of available components
ListComponents(context.Context, *ListComponentsRequest) (*ListComponentResponse, error)
// Returns a given configuration by name
GetConfiguration(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error)
// Returns a list of pub/sub subscriptions
ListSubscriptions(context.Context, *emptypb.Empty) (*ListSubscriptionsResponse, error)
// Returns a given resiliency configuration by name
GetResiliency(context.Context, *GetResiliencyRequest) (*GetResiliencyResponse, error)
// Returns a list of resiliency configurations
ListResiliency(context.Context, *ListResiliencyRequest) (*ListResiliencyResponse, error)
// Returns a list of pub/sub subscriptions, ListSubscriptionsRequest to expose pod info
ListSubscriptionsV2(context.Context, *ListSubscriptionsRequest) (*ListSubscriptionsResponse, error)
// Sends events to Dapr sidecars upon subscription changes.
SubscriptionUpdate(*SubscriptionUpdateRequest, Operator_SubscriptionUpdateServer) error
// Returns a list of http endpoints
ListHTTPEndpoints(context.Context, *ListHTTPEndpointsRequest) (*ListHTTPEndpointsResponse, error)
// Sends events to Dapr sidecars upon http endpoint changes.
HTTPEndpointUpdate(*HTTPEndpointUpdateRequest, Operator_HTTPEndpointUpdateServer) error
}
// UnimplementedOperatorServer should be embedded to have forward compatible implementations.
type UnimplementedOperatorServer struct {
}
func (UnimplementedOperatorServer) ComponentUpdate(*ComponentUpdateRequest, Operator_ComponentUpdateServer) error {
return status.Errorf(codes.Unimplemented, "method ComponentUpdate not implemented")
}
func (UnimplementedOperatorServer) ListComponents(context.Context, *ListComponentsRequest) (*ListComponentResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListComponents not implemented")
}
func (UnimplementedOperatorServer) GetConfiguration(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetConfiguration not implemented")
}
func (UnimplementedOperatorServer) ListSubscriptions(context.Context, *emptypb.Empty) (*ListSubscriptionsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListSubscriptions not implemented")
}
func (UnimplementedOperatorServer) GetResiliency(context.Context, *GetResiliencyRequest) (*GetResiliencyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetResiliency not implemented")
}
func (UnimplementedOperatorServer) ListResiliency(context.Context, *ListResiliencyRequest) (*ListResiliencyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListResiliency not implemented")
}
func (UnimplementedOperatorServer) ListSubscriptionsV2(context.Context, *ListSubscriptionsRequest) (*ListSubscriptionsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListSubscriptionsV2 not implemented")
}
func (UnimplementedOperatorServer) SubscriptionUpdate(*SubscriptionUpdateRequest, Operator_SubscriptionUpdateServer) error {
return status.Errorf(codes.Unimplemented, "method SubscriptionUpdate not implemented")
}
func (UnimplementedOperatorServer) ListHTTPEndpoints(context.Context, *ListHTTPEndpointsRequest) (*ListHTTPEndpointsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListHTTPEndpoints not implemented")
}
func (UnimplementedOperatorServer) HTTPEndpointUpdate(*HTTPEndpointUpdateRequest, Operator_HTTPEndpointUpdateServer) error {
return status.Errorf(codes.Unimplemented, "method HTTPEndpointUpdate not implemented")
}
// UnsafeOperatorServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to OperatorServer will
// result in compilation errors.
type UnsafeOperatorServer interface {
mustEmbedUnimplementedOperatorServer()
}
func RegisterOperatorServer(s grpc.ServiceRegistrar, srv OperatorServer) {
s.RegisterService(&Operator_ServiceDesc, srv)
}
func _Operator_ComponentUpdate_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ComponentUpdateRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(OperatorServer).ComponentUpdate(m, &operatorComponentUpdateServer{stream})
}
type Operator_ComponentUpdateServer interface {
Send(*ComponentUpdateEvent) error
grpc.ServerStream
}
type operatorComponentUpdateServer struct {
grpc.ServerStream
}
func (x *operatorComponentUpdateServer) Send(m *ComponentUpdateEvent) error {
return x.ServerStream.SendMsg(m)
}
func _Operator_ListComponents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListComponentsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).ListComponents(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_ListComponents_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).ListComponents(ctx, req.(*ListComponentsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_GetConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConfigurationRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).GetConfiguration(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_GetConfiguration_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).GetConfiguration(ctx, req.(*GetConfigurationRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_ListSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).ListSubscriptions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_ListSubscriptions_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).ListSubscriptions(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_GetResiliency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetResiliencyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).GetResiliency(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_GetResiliency_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).GetResiliency(ctx, req.(*GetResiliencyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_ListResiliency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListResiliencyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).ListResiliency(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_ListResiliency_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).ListResiliency(ctx, req.(*ListResiliencyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_ListSubscriptionsV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListSubscriptionsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).ListSubscriptionsV2(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_ListSubscriptionsV2_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).ListSubscriptionsV2(ctx, req.(*ListSubscriptionsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_SubscriptionUpdate_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SubscriptionUpdateRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(OperatorServer).SubscriptionUpdate(m, &operatorSubscriptionUpdateServer{stream})
}
type Operator_SubscriptionUpdateServer interface {
Send(*SubscriptionUpdateEvent) error
grpc.ServerStream
}
type operatorSubscriptionUpdateServer struct {
grpc.ServerStream
}
func (x *operatorSubscriptionUpdateServer) Send(m *SubscriptionUpdateEvent) error {
return x.ServerStream.SendMsg(m)
}
func _Operator_ListHTTPEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ListHTTPEndpointsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(OperatorServer).ListHTTPEndpoints(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Operator_ListHTTPEndpoints_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(OperatorServer).ListHTTPEndpoints(ctx, req.(*ListHTTPEndpointsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Operator_HTTPEndpointUpdate_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(HTTPEndpointUpdateRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(OperatorServer).HTTPEndpointUpdate(m, &operatorHTTPEndpointUpdateServer{stream})
}
type Operator_HTTPEndpointUpdateServer interface {
Send(*HTTPEndpointUpdateEvent) error
grpc.ServerStream
}
type operatorHTTPEndpointUpdateServer struct {
grpc.ServerStream
}
func (x *operatorHTTPEndpointUpdateServer) Send(m *HTTPEndpointUpdateEvent) error {
return x.ServerStream.SendMsg(m)
}
// Operator_ServiceDesc is the grpc.ServiceDesc for Operator service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Operator_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.operator.v1.Operator",
HandlerType: (*OperatorServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ListComponents",
Handler: _Operator_ListComponents_Handler,
},
{
MethodName: "GetConfiguration",
Handler: _Operator_GetConfiguration_Handler,
},
{
MethodName: "ListSubscriptions",
Handler: _Operator_ListSubscriptions_Handler,
},
{
MethodName: "GetResiliency",
Handler: _Operator_GetResiliency_Handler,
},
{
MethodName: "ListResiliency",
Handler: _Operator_ListResiliency_Handler,
},
{
MethodName: "ListSubscriptionsV2",
Handler: _Operator_ListSubscriptionsV2_Handler,
},
{
MethodName: "ListHTTPEndpoints",
Handler: _Operator_ListHTTPEndpoints_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "ComponentUpdate",
Handler: _Operator_ComponentUpdate_Handler,
ServerStreams: true,
},
{
StreamName: "SubscriptionUpdate",
Handler: _Operator_SubscriptionUpdate_Handler,
ServerStreams: true,
},
{
StreamName: "HTTPEndpointUpdate",
Handler: _Operator_HTTPEndpointUpdate_Handler,
ServerStreams: true,
},
},
Metadata: "dapr/proto/operator/v1/operator.proto",
}
|
mikeee/dapr
|
pkg/proto/operator/v1/operator_grpc.pb.go
|
GO
|
mit
| 21,736 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/placement/v1/placement.proto
package placement
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type PlacementOrder struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Tables *PlacementTables `protobuf:"bytes,1,opt,name=tables,proto3" json:"tables,omitempty"`
Operation string `protobuf:"bytes,2,opt,name=operation,proto3" json:"operation,omitempty"`
}
func (x *PlacementOrder) Reset() {
*x = PlacementOrder{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PlacementOrder) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PlacementOrder) ProtoMessage() {}
func (x *PlacementOrder) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PlacementOrder.ProtoReflect.Descriptor instead.
func (*PlacementOrder) Descriptor() ([]byte, []int) {
return file_dapr_proto_placement_v1_placement_proto_rawDescGZIP(), []int{0}
}
func (x *PlacementOrder) GetTables() *PlacementTables {
if x != nil {
return x.Tables
}
return nil
}
func (x *PlacementOrder) GetOperation() string {
if x != nil {
return x.Operation
}
return ""
}
type PlacementTables struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Entries map[string]*PlacementTable `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
// Minimum observed version of the Actor APIs supported by connected runtimes
ApiLevel uint32 `protobuf:"varint,3,opt,name=api_level,json=apiLevel,proto3" json:"api_level,omitempty"`
ReplicationFactor int64 `protobuf:"varint,4,opt,name=replication_factor,json=replicationFactor,proto3" json:"replication_factor,omitempty"`
}
func (x *PlacementTables) Reset() {
*x = PlacementTables{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PlacementTables) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PlacementTables) ProtoMessage() {}
func (x *PlacementTables) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PlacementTables.ProtoReflect.Descriptor instead.
func (*PlacementTables) Descriptor() ([]byte, []int) {
return file_dapr_proto_placement_v1_placement_proto_rawDescGZIP(), []int{1}
}
func (x *PlacementTables) GetEntries() map[string]*PlacementTable {
if x != nil {
return x.Entries
}
return nil
}
func (x *PlacementTables) GetVersion() string {
if x != nil {
return x.Version
}
return ""
}
func (x *PlacementTables) GetApiLevel() uint32 {
if x != nil {
return x.ApiLevel
}
return 0
}
func (x *PlacementTables) GetReplicationFactor() int64 {
if x != nil {
return x.ReplicationFactor
}
return 0
}
type PlacementTable struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Hosts map[uint64]string `protobuf:"bytes,1,rep,name=hosts,proto3" json:"hosts,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
SortedSet []uint64 `protobuf:"varint,2,rep,packed,name=sorted_set,json=sortedSet,proto3" json:"sorted_set,omitempty"`
LoadMap map[string]*Host `protobuf:"bytes,3,rep,name=load_map,json=loadMap,proto3" json:"load_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
TotalLoad int64 `protobuf:"varint,4,opt,name=total_load,json=totalLoad,proto3" json:"total_load,omitempty"`
}
func (x *PlacementTable) Reset() {
*x = PlacementTable{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PlacementTable) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PlacementTable) ProtoMessage() {}
func (x *PlacementTable) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PlacementTable.ProtoReflect.Descriptor instead.
func (*PlacementTable) Descriptor() ([]byte, []int) {
return file_dapr_proto_placement_v1_placement_proto_rawDescGZIP(), []int{2}
}
func (x *PlacementTable) GetHosts() map[uint64]string {
if x != nil {
return x.Hosts
}
return nil
}
func (x *PlacementTable) GetSortedSet() []uint64 {
if x != nil {
return x.SortedSet
}
return nil
}
func (x *PlacementTable) GetLoadMap() map[string]*Host {
if x != nil {
return x.LoadMap
}
return nil
}
func (x *PlacementTable) GetTotalLoad() int64 {
if x != nil {
return x.TotalLoad
}
return 0
}
type Host struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Port int64 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
Load int64 `protobuf:"varint,3,opt,name=load,proto3" json:"load,omitempty"`
Entities []string `protobuf:"bytes,4,rep,name=entities,proto3" json:"entities,omitempty"`
Id string `protobuf:"bytes,5,opt,name=id,proto3" json:"id,omitempty"`
Pod string `protobuf:"bytes,6,opt,name=pod,proto3" json:"pod,omitempty"`
// Version of the Actor APIs supported by the Dapr runtime
ApiLevel uint32 `protobuf:"varint,7,opt,name=api_level,json=apiLevel,proto3" json:"api_level,omitempty"`
Namespace string `protobuf:"bytes,8,opt,name=namespace,proto3" json:"namespace,omitempty"`
}
func (x *Host) Reset() {
*x = Host{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Host) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Host) ProtoMessage() {}
func (x *Host) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_placement_v1_placement_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Host.ProtoReflect.Descriptor instead.
func (*Host) Descriptor() ([]byte, []int) {
return file_dapr_proto_placement_v1_placement_proto_rawDescGZIP(), []int{3}
}
func (x *Host) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Host) GetPort() int64 {
if x != nil {
return x.Port
}
return 0
}
func (x *Host) GetLoad() int64 {
if x != nil {
return x.Load
}
return 0
}
func (x *Host) GetEntities() []string {
if x != nil {
return x.Entities
}
return nil
}
func (x *Host) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *Host) GetPod() string {
if x != nil {
return x.Pod
}
return ""
}
func (x *Host) GetApiLevel() uint32 {
if x != nil {
return x.ApiLevel
}
return 0
}
func (x *Host) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
var File_dapr_proto_placement_v1_placement_proto protoreflect.FileDescriptor
var file_dapr_proto_placement_v1_placement_proto_rawDesc = []byte{
0x0a, 0x27, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x6c, 0x61,
0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d,
0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x17, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e,
0x76, 0x31, 0x22, 0x70, 0x0a, 0x0e, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x4f,
0x72, 0x64, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x06, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50,
0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x52, 0x06,
0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x22, 0xad, 0x02, 0x0a, 0x0f, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65,
0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x12, 0x4f, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72,
0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74,
0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62,
0x6c, 0x65, 0x73, 0x2e, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72,
0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73,
0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, 0x69, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c,
0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x61, 0x70, 0x69, 0x4c, 0x65, 0x76, 0x65, 0x6c,
0x12, 0x2d, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x72, 0x65,
0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x1a,
0x63, 0x0a, 0x0c, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x3d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c,
0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x61, 0x63, 0x65,
0x6d, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x3a, 0x02, 0x38, 0x01, 0x22, 0xfe, 0x02, 0x0a, 0x0e, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65,
0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x48, 0x0a, 0x05, 0x68, 0x6f, 0x73, 0x74, 0x73,
0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31,
0x2e, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2e,
0x48, 0x6f, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x68, 0x6f, 0x73, 0x74,
0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x74, 0x18,
0x02, 0x20, 0x03, 0x28, 0x04, 0x52, 0x09, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x53, 0x65, 0x74,
0x12, 0x4f, 0x0a, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6d, 0x61, 0x70, 0x18, 0x03, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c, 0x61,
0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x4c, 0x6f, 0x61, 0x64,
0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x61,
0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x18,
0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4c, 0x6f, 0x61, 0x64,
0x1a, 0x38, 0x0a, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x59, 0x0a, 0x0c, 0x4c, 0x6f,
0x61, 0x64, 0x4d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x33, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65,
0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x6f, 0x73, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xbb, 0x01, 0x0a, 0x04, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x12,
0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03,
0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x03,
0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e,
0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e,
0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01,
0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x6f, 0x64, 0x18, 0x06, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x70, 0x6f, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, 0x69, 0x5f,
0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x61, 0x70, 0x69,
0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
0x61, 0x63, 0x65, 0x32, 0x6d, 0x0a, 0x09, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74,
0x12, 0x60, 0x0a, 0x10, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x44, 0x61, 0x70, 0x72, 0x53, 0x74,
0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x48,
0x6f, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x6c,
0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x22, 0x00, 0x28, 0x01,
0x30, 0x01, 0x42, 0x37, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x2f, 0x76,
0x31, 0x3b, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_placement_v1_placement_proto_rawDescOnce sync.Once
file_dapr_proto_placement_v1_placement_proto_rawDescData = file_dapr_proto_placement_v1_placement_proto_rawDesc
)
func file_dapr_proto_placement_v1_placement_proto_rawDescGZIP() []byte {
file_dapr_proto_placement_v1_placement_proto_rawDescOnce.Do(func() {
file_dapr_proto_placement_v1_placement_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_placement_v1_placement_proto_rawDescData)
})
return file_dapr_proto_placement_v1_placement_proto_rawDescData
}
var file_dapr_proto_placement_v1_placement_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_dapr_proto_placement_v1_placement_proto_goTypes = []interface{}{
(*PlacementOrder)(nil), // 0: dapr.proto.placement.v1.PlacementOrder
(*PlacementTables)(nil), // 1: dapr.proto.placement.v1.PlacementTables
(*PlacementTable)(nil), // 2: dapr.proto.placement.v1.PlacementTable
(*Host)(nil), // 3: dapr.proto.placement.v1.Host
nil, // 4: dapr.proto.placement.v1.PlacementTables.EntriesEntry
nil, // 5: dapr.proto.placement.v1.PlacementTable.HostsEntry
nil, // 6: dapr.proto.placement.v1.PlacementTable.LoadMapEntry
}
var file_dapr_proto_placement_v1_placement_proto_depIdxs = []int32{
1, // 0: dapr.proto.placement.v1.PlacementOrder.tables:type_name -> dapr.proto.placement.v1.PlacementTables
4, // 1: dapr.proto.placement.v1.PlacementTables.entries:type_name -> dapr.proto.placement.v1.PlacementTables.EntriesEntry
5, // 2: dapr.proto.placement.v1.PlacementTable.hosts:type_name -> dapr.proto.placement.v1.PlacementTable.HostsEntry
6, // 3: dapr.proto.placement.v1.PlacementTable.load_map:type_name -> dapr.proto.placement.v1.PlacementTable.LoadMapEntry
2, // 4: dapr.proto.placement.v1.PlacementTables.EntriesEntry.value:type_name -> dapr.proto.placement.v1.PlacementTable
3, // 5: dapr.proto.placement.v1.PlacementTable.LoadMapEntry.value:type_name -> dapr.proto.placement.v1.Host
3, // 6: dapr.proto.placement.v1.Placement.ReportDaprStatus:input_type -> dapr.proto.placement.v1.Host
0, // 7: dapr.proto.placement.v1.Placement.ReportDaprStatus:output_type -> dapr.proto.placement.v1.PlacementOrder
7, // [7:8] is the sub-list for method output_type
6, // [6:7] is the sub-list for method input_type
6, // [6:6] is the sub-list for extension type_name
6, // [6:6] is the sub-list for extension extendee
0, // [0:6] is the sub-list for field type_name
}
func init() { file_dapr_proto_placement_v1_placement_proto_init() }
func file_dapr_proto_placement_v1_placement_proto_init() {
if File_dapr_proto_placement_v1_placement_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_placement_v1_placement_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PlacementOrder); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_placement_v1_placement_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PlacementTables); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_placement_v1_placement_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PlacementTable); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_placement_v1_placement_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Host); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_placement_v1_placement_proto_rawDesc,
NumEnums: 0,
NumMessages: 7,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_placement_v1_placement_proto_goTypes,
DependencyIndexes: file_dapr_proto_placement_v1_placement_proto_depIdxs,
MessageInfos: file_dapr_proto_placement_v1_placement_proto_msgTypes,
}.Build()
File_dapr_proto_placement_v1_placement_proto = out.File
file_dapr_proto_placement_v1_placement_proto_rawDesc = nil
file_dapr_proto_placement_v1_placement_proto_goTypes = nil
file_dapr_proto_placement_v1_placement_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/placement/v1/placement.pb.go
|
GO
|
mit
| 21,564 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/placement/v1/placement.proto
package placement
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
Placement_ReportDaprStatus_FullMethodName = "/dapr.proto.placement.v1.Placement/ReportDaprStatus"
)
// PlacementClient is the client API for Placement service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type PlacementClient interface {
// Reports Dapr actor status and retrieves actor placement table.
ReportDaprStatus(ctx context.Context, opts ...grpc.CallOption) (Placement_ReportDaprStatusClient, error)
}
type placementClient struct {
cc grpc.ClientConnInterface
}
func NewPlacementClient(cc grpc.ClientConnInterface) PlacementClient {
return &placementClient{cc}
}
func (c *placementClient) ReportDaprStatus(ctx context.Context, opts ...grpc.CallOption) (Placement_ReportDaprStatusClient, error) {
stream, err := c.cc.NewStream(ctx, &Placement_ServiceDesc.Streams[0], Placement_ReportDaprStatus_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &placementReportDaprStatusClient{stream}
return x, nil
}
type Placement_ReportDaprStatusClient interface {
Send(*Host) error
Recv() (*PlacementOrder, error)
grpc.ClientStream
}
type placementReportDaprStatusClient struct {
grpc.ClientStream
}
func (x *placementReportDaprStatusClient) Send(m *Host) error {
return x.ClientStream.SendMsg(m)
}
func (x *placementReportDaprStatusClient) Recv() (*PlacementOrder, error) {
m := new(PlacementOrder)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// PlacementServer is the server API for Placement service.
// All implementations should embed UnimplementedPlacementServer
// for forward compatibility
type PlacementServer interface {
// Reports Dapr actor status and retrieves actor placement table.
ReportDaprStatus(Placement_ReportDaprStatusServer) error
}
// UnimplementedPlacementServer should be embedded to have forward compatible implementations.
type UnimplementedPlacementServer struct {
}
func (UnimplementedPlacementServer) ReportDaprStatus(Placement_ReportDaprStatusServer) error {
return status.Errorf(codes.Unimplemented, "method ReportDaprStatus not implemented")
}
// UnsafePlacementServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to PlacementServer will
// result in compilation errors.
type UnsafePlacementServer interface {
mustEmbedUnimplementedPlacementServer()
}
func RegisterPlacementServer(s grpc.ServiceRegistrar, srv PlacementServer) {
s.RegisterService(&Placement_ServiceDesc, srv)
}
func _Placement_ReportDaprStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(PlacementServer).ReportDaprStatus(&placementReportDaprStatusServer{stream})
}
type Placement_ReportDaprStatusServer interface {
Send(*PlacementOrder) error
Recv() (*Host, error)
grpc.ServerStream
}
type placementReportDaprStatusServer struct {
grpc.ServerStream
}
func (x *placementReportDaprStatusServer) Send(m *PlacementOrder) error {
return x.ServerStream.SendMsg(m)
}
func (x *placementReportDaprStatusServer) Recv() (*Host, error) {
m := new(Host)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Placement_ServiceDesc is the grpc.ServiceDesc for Placement service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Placement_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.placement.v1.Placement",
HandlerType: (*PlacementServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "ReportDaprStatus",
Handler: _Placement_ReportDaprStatus_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "dapr/proto/placement/v1/placement.proto",
}
|
mikeee/dapr
|
pkg/proto/placement/v1/placement_grpc.pb.go
|
GO
|
mit
| 5,010 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package proto
|
mikeee/dapr
|
pkg/proto/proto.go
|
GO
|
mit
| 575 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/runtime/v1/appcallback.proto
package runtime
import (
v1 "github.com/dapr/dapr/pkg/proto/common/v1"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
structpb "google.golang.org/protobuf/types/known/structpb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// TopicEventResponseStatus allows apps to have finer control over handling of the message.
type TopicEventResponse_TopicEventResponseStatus int32
const (
// SUCCESS is the default behavior: message is acknowledged and not retried or logged.
TopicEventResponse_SUCCESS TopicEventResponse_TopicEventResponseStatus = 0
// RETRY status signals Dapr to retry the message as part of an expected scenario (no warning is logged).
TopicEventResponse_RETRY TopicEventResponse_TopicEventResponseStatus = 1
// DROP status signals Dapr to drop the message as part of an unexpected scenario (warning is logged).
TopicEventResponse_DROP TopicEventResponse_TopicEventResponseStatus = 2
)
// Enum value maps for TopicEventResponse_TopicEventResponseStatus.
var (
TopicEventResponse_TopicEventResponseStatus_name = map[int32]string{
0: "SUCCESS",
1: "RETRY",
2: "DROP",
}
TopicEventResponse_TopicEventResponseStatus_value = map[string]int32{
"SUCCESS": 0,
"RETRY": 1,
"DROP": 2,
}
)
func (x TopicEventResponse_TopicEventResponseStatus) Enum() *TopicEventResponse_TopicEventResponseStatus {
p := new(TopicEventResponse_TopicEventResponseStatus)
*p = x
return p
}
func (x TopicEventResponse_TopicEventResponseStatus) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (TopicEventResponse_TopicEventResponseStatus) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[0].Descriptor()
}
func (TopicEventResponse_TopicEventResponseStatus) Type() protoreflect.EnumType {
return &file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[0]
}
func (x TopicEventResponse_TopicEventResponseStatus) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use TopicEventResponse_TopicEventResponseStatus.Descriptor instead.
func (TopicEventResponse_TopicEventResponseStatus) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{1, 0}
}
// BindingEventConcurrency is the kind of concurrency
type BindingEventResponse_BindingEventConcurrency int32
const (
// SEQUENTIAL sends data to output bindings specified in "to" sequentially.
BindingEventResponse_SEQUENTIAL BindingEventResponse_BindingEventConcurrency = 0
// PARALLEL sends data to output bindings specified in "to" in parallel.
BindingEventResponse_PARALLEL BindingEventResponse_BindingEventConcurrency = 1
)
// Enum value maps for BindingEventResponse_BindingEventConcurrency.
var (
BindingEventResponse_BindingEventConcurrency_name = map[int32]string{
0: "SEQUENTIAL",
1: "PARALLEL",
}
BindingEventResponse_BindingEventConcurrency_value = map[string]int32{
"SEQUENTIAL": 0,
"PARALLEL": 1,
}
)
func (x BindingEventResponse_BindingEventConcurrency) Enum() *BindingEventResponse_BindingEventConcurrency {
p := new(BindingEventResponse_BindingEventConcurrency)
*p = x
return p
}
func (x BindingEventResponse_BindingEventConcurrency) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (BindingEventResponse_BindingEventConcurrency) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[1].Descriptor()
}
func (BindingEventResponse_BindingEventConcurrency) Type() protoreflect.EnumType {
return &file_dapr_proto_runtime_v1_appcallback_proto_enumTypes[1]
}
func (x BindingEventResponse_BindingEventConcurrency) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use BindingEventResponse_BindingEventConcurrency.Descriptor instead.
func (BindingEventResponse_BindingEventConcurrency) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{8, 0}
}
// TopicEventRequest message is compatible with CloudEvent spec v1.0
// https://github.com/cloudevents/spec/blob/v1.0/spec.md
type TopicEventRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 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.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// 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.
Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
// The type of event related to the originating occurrence.
Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
// The version of the CloudEvents specification.
SpecVersion string `protobuf:"bytes,4,opt,name=spec_version,json=specVersion,proto3" json:"spec_version,omitempty"`
// The content type of data value.
DataContentType string `protobuf:"bytes,5,opt,name=data_content_type,json=dataContentType,proto3" json:"data_content_type,omitempty"`
// The content of the event.
Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"`
// The pubsub topic which publisher sent to.
Topic string `protobuf:"bytes,6,opt,name=topic,proto3" json:"topic,omitempty"`
// The name of the pubsub the publisher sent to.
PubsubName string `protobuf:"bytes,8,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// The matching path from TopicSubscription/routes (if specified) for this event.
// This value is used by OnTopicEvent to "switch" inside the handler.
Path string `protobuf:"bytes,9,opt,name=path,proto3" json:"path,omitempty"`
// The map of additional custom properties to be sent to the app. These are considered to be cloud event extensions.
Extensions *structpb.Struct `protobuf:"bytes,10,opt,name=extensions,proto3" json:"extensions,omitempty"`
}
func (x *TopicEventRequest) Reset() {
*x = TopicEventRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventRequest) ProtoMessage() {}
func (x *TopicEventRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventRequest.ProtoReflect.Descriptor instead.
func (*TopicEventRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{0}
}
func (x *TopicEventRequest) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *TopicEventRequest) GetSource() string {
if x != nil {
return x.Source
}
return ""
}
func (x *TopicEventRequest) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *TopicEventRequest) GetSpecVersion() string {
if x != nil {
return x.SpecVersion
}
return ""
}
func (x *TopicEventRequest) GetDataContentType() string {
if x != nil {
return x.DataContentType
}
return ""
}
func (x *TopicEventRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *TopicEventRequest) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *TopicEventRequest) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *TopicEventRequest) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *TopicEventRequest) GetExtensions() *structpb.Struct {
if x != nil {
return x.Extensions
}
return nil
}
// TopicEventResponse is response from app on published message
type TopicEventResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The list of output bindings.
Status TopicEventResponse_TopicEventResponseStatus `protobuf:"varint,1,opt,name=status,proto3,enum=dapr.proto.runtime.v1.TopicEventResponse_TopicEventResponseStatus" json:"status,omitempty"`
}
func (x *TopicEventResponse) Reset() {
*x = TopicEventResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventResponse) ProtoMessage() {}
func (x *TopicEventResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventResponse.ProtoReflect.Descriptor instead.
func (*TopicEventResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{1}
}
func (x *TopicEventResponse) GetStatus() TopicEventResponse_TopicEventResponseStatus {
if x != nil {
return x.Status
}
return TopicEventResponse_SUCCESS
}
// TopicEventCERequest message is compatible with CloudEvent spec v1.0
type TopicEventCERequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The unique identifier of this cloud event.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// source identifies the context in which an event happened.
Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
// The type of event related to the originating occurrence.
Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
// The version of the CloudEvents specification.
SpecVersion string `protobuf:"bytes,4,opt,name=spec_version,json=specVersion,proto3" json:"spec_version,omitempty"`
// The content type of data value.
DataContentType string `protobuf:"bytes,5,opt,name=data_content_type,json=dataContentType,proto3" json:"data_content_type,omitempty"`
// The content of the event.
Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
// Custom attributes which includes cloud event extensions.
Extensions *structpb.Struct `protobuf:"bytes,7,opt,name=extensions,proto3" json:"extensions,omitempty"`
}
func (x *TopicEventCERequest) Reset() {
*x = TopicEventCERequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventCERequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventCERequest) ProtoMessage() {}
func (x *TopicEventCERequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventCERequest.ProtoReflect.Descriptor instead.
func (*TopicEventCERequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{2}
}
func (x *TopicEventCERequest) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *TopicEventCERequest) GetSource() string {
if x != nil {
return x.Source
}
return ""
}
func (x *TopicEventCERequest) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *TopicEventCERequest) GetSpecVersion() string {
if x != nil {
return x.SpecVersion
}
return ""
}
func (x *TopicEventCERequest) GetDataContentType() string {
if x != nil {
return x.DataContentType
}
return ""
}
func (x *TopicEventCERequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *TopicEventCERequest) GetExtensions() *structpb.Struct {
if x != nil {
return x.Extensions
}
return nil
}
// TopicEventBulkRequestEntry represents a single message inside a bulk request
type TopicEventBulkRequestEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Unique identifier for the message.
EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"`
// The content of the event.
//
// Types that are assignable to Event:
//
// *TopicEventBulkRequestEntry_Bytes
// *TopicEventBulkRequestEntry_CloudEvent
Event isTopicEventBulkRequestEntry_Event `protobuf_oneof:"event"`
// content type of the event contained.
ContentType string `protobuf:"bytes,4,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
// The metadata associated with the event.
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *TopicEventBulkRequestEntry) Reset() {
*x = TopicEventBulkRequestEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventBulkRequestEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventBulkRequestEntry) ProtoMessage() {}
func (x *TopicEventBulkRequestEntry) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventBulkRequestEntry.ProtoReflect.Descriptor instead.
func (*TopicEventBulkRequestEntry) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{3}
}
func (x *TopicEventBulkRequestEntry) GetEntryId() string {
if x != nil {
return x.EntryId
}
return ""
}
func (m *TopicEventBulkRequestEntry) GetEvent() isTopicEventBulkRequestEntry_Event {
if m != nil {
return m.Event
}
return nil
}
func (x *TopicEventBulkRequestEntry) GetBytes() []byte {
if x, ok := x.GetEvent().(*TopicEventBulkRequestEntry_Bytes); ok {
return x.Bytes
}
return nil
}
func (x *TopicEventBulkRequestEntry) GetCloudEvent() *TopicEventCERequest {
if x, ok := x.GetEvent().(*TopicEventBulkRequestEntry_CloudEvent); ok {
return x.CloudEvent
}
return nil
}
func (x *TopicEventBulkRequestEntry) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
func (x *TopicEventBulkRequestEntry) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
type isTopicEventBulkRequestEntry_Event interface {
isTopicEventBulkRequestEntry_Event()
}
type TopicEventBulkRequestEntry_Bytes struct {
Bytes []byte `protobuf:"bytes,2,opt,name=bytes,proto3,oneof"`
}
type TopicEventBulkRequestEntry_CloudEvent struct {
CloudEvent *TopicEventCERequest `protobuf:"bytes,3,opt,name=cloud_event,json=cloudEvent,proto3,oneof"`
}
func (*TopicEventBulkRequestEntry_Bytes) isTopicEventBulkRequestEntry_Event() {}
func (*TopicEventBulkRequestEntry_CloudEvent) isTopicEventBulkRequestEntry_Event() {}
// TopicEventBulkRequest represents request for bulk message
type TopicEventBulkRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Unique identifier for the bulk request.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// The list of items inside this bulk request.
Entries []*TopicEventBulkRequestEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
// The metadata associated with the this bulk request.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The pubsub topic which publisher sent to.
Topic string `protobuf:"bytes,4,opt,name=topic,proto3" json:"topic,omitempty"`
// The name of the pubsub the publisher sent to.
PubsubName string `protobuf:"bytes,5,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// The type of event related to the originating occurrence.
Type string `protobuf:"bytes,6,opt,name=type,proto3" json:"type,omitempty"`
// The matching path from TopicSubscription/routes (if specified) for this event.
// This value is used by OnTopicEvent to "switch" inside the handler.
Path string `protobuf:"bytes,7,opt,name=path,proto3" json:"path,omitempty"`
}
func (x *TopicEventBulkRequest) Reset() {
*x = TopicEventBulkRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventBulkRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventBulkRequest) ProtoMessage() {}
func (x *TopicEventBulkRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventBulkRequest.ProtoReflect.Descriptor instead.
func (*TopicEventBulkRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{4}
}
func (x *TopicEventBulkRequest) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *TopicEventBulkRequest) GetEntries() []*TopicEventBulkRequestEntry {
if x != nil {
return x.Entries
}
return nil
}
func (x *TopicEventBulkRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *TopicEventBulkRequest) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *TopicEventBulkRequest) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *TopicEventBulkRequest) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *TopicEventBulkRequest) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
// TopicEventBulkResponseEntry Represents single response, as part of TopicEventBulkResponse, to be
// sent by subscibed App for the corresponding single message during bulk subscribe
type TopicEventBulkResponseEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Unique identifier associated the message.
EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"`
// The status of the response.
Status TopicEventResponse_TopicEventResponseStatus `protobuf:"varint,2,opt,name=status,proto3,enum=dapr.proto.runtime.v1.TopicEventResponse_TopicEventResponseStatus" json:"status,omitempty"`
}
func (x *TopicEventBulkResponseEntry) Reset() {
*x = TopicEventBulkResponseEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventBulkResponseEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventBulkResponseEntry) ProtoMessage() {}
func (x *TopicEventBulkResponseEntry) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventBulkResponseEntry.ProtoReflect.Descriptor instead.
func (*TopicEventBulkResponseEntry) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{5}
}
func (x *TopicEventBulkResponseEntry) GetEntryId() string {
if x != nil {
return x.EntryId
}
return ""
}
func (x *TopicEventBulkResponseEntry) GetStatus() TopicEventResponse_TopicEventResponseStatus {
if x != nil {
return x.Status
}
return TopicEventResponse_SUCCESS
}
// AppBulkResponse is response from app on published message
type TopicEventBulkResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The list of all responses for the bulk request.
Statuses []*TopicEventBulkResponseEntry `protobuf:"bytes,1,rep,name=statuses,proto3" json:"statuses,omitempty"`
}
func (x *TopicEventBulkResponse) Reset() {
*x = TopicEventBulkResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicEventBulkResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicEventBulkResponse) ProtoMessage() {}
func (x *TopicEventBulkResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicEventBulkResponse.ProtoReflect.Descriptor instead.
func (*TopicEventBulkResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{6}
}
func (x *TopicEventBulkResponse) GetStatuses() []*TopicEventBulkResponseEntry {
if x != nil {
return x.Statuses
}
return nil
}
// BindingEventRequest represents input bindings event.
type BindingEventRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The name of the input binding component.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Required. The payload that the input bindings sent
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// The metadata set by the input binging components.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BindingEventRequest) Reset() {
*x = BindingEventRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BindingEventRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BindingEventRequest) ProtoMessage() {}
func (x *BindingEventRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BindingEventRequest.ProtoReflect.Descriptor instead.
func (*BindingEventRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{7}
}
func (x *BindingEventRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *BindingEventRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *BindingEventRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// BindingEventResponse includes operations to save state or
// send data to output bindings optionally.
type BindingEventResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store where states are saved.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The state key values which will be stored in store_name.
States []*v1.StateItem `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"`
// The list of output bindings.
To []string `protobuf:"bytes,3,rep,name=to,proto3" json:"to,omitempty"`
// The content which will be sent to "to" output bindings.
Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
// The concurrency of output bindings to send data to
// "to" output bindings list. The default is SEQUENTIAL.
Concurrency BindingEventResponse_BindingEventConcurrency `protobuf:"varint,5,opt,name=concurrency,proto3,enum=dapr.proto.runtime.v1.BindingEventResponse_BindingEventConcurrency" json:"concurrency,omitempty"`
}
func (x *BindingEventResponse) Reset() {
*x = BindingEventResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BindingEventResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BindingEventResponse) ProtoMessage() {}
func (x *BindingEventResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BindingEventResponse.ProtoReflect.Descriptor instead.
func (*BindingEventResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{8}
}
func (x *BindingEventResponse) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *BindingEventResponse) GetStates() []*v1.StateItem {
if x != nil {
return x.States
}
return nil
}
func (x *BindingEventResponse) GetTo() []string {
if x != nil {
return x.To
}
return nil
}
func (x *BindingEventResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *BindingEventResponse) GetConcurrency() BindingEventResponse_BindingEventConcurrency {
if x != nil {
return x.Concurrency
}
return BindingEventResponse_SEQUENTIAL
}
// ListTopicSubscriptionsResponse is the message including the list of the subscribing topics.
type ListTopicSubscriptionsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The list of topics.
Subscriptions []*TopicSubscription `protobuf:"bytes,1,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"`
}
func (x *ListTopicSubscriptionsResponse) Reset() {
*x = ListTopicSubscriptionsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListTopicSubscriptionsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListTopicSubscriptionsResponse) ProtoMessage() {}
func (x *ListTopicSubscriptionsResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListTopicSubscriptionsResponse.ProtoReflect.Descriptor instead.
func (*ListTopicSubscriptionsResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{9}
}
func (x *ListTopicSubscriptionsResponse) GetSubscriptions() []*TopicSubscription {
if x != nil {
return x.Subscriptions
}
return nil
}
// TopicSubscription represents topic and metadata.
type TopicSubscription struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The name of the pubsub containing the topic below to subscribe to.
PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// Required. The name of topic which will be subscribed
Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
// The optional properties used for this topic's subscription e.g. session id
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The optional routing rules to match against. In the gRPC interface, OnTopicEvent
// is still invoked but the matching path is sent in the TopicEventRequest.
Routes *TopicRoutes `protobuf:"bytes,5,opt,name=routes,proto3" json:"routes,omitempty"`
// The optional dead letter queue for this topic to send events to.
DeadLetterTopic string `protobuf:"bytes,6,opt,name=dead_letter_topic,json=deadLetterTopic,proto3" json:"dead_letter_topic,omitempty"`
// The optional bulk subscribe settings for this topic.
BulkSubscribe *BulkSubscribeConfig `protobuf:"bytes,7,opt,name=bulk_subscribe,json=bulkSubscribe,proto3" json:"bulk_subscribe,omitempty"`
}
func (x *TopicSubscription) Reset() {
*x = TopicSubscription{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicSubscription) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicSubscription) ProtoMessage() {}
func (x *TopicSubscription) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicSubscription.ProtoReflect.Descriptor instead.
func (*TopicSubscription) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{10}
}
func (x *TopicSubscription) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *TopicSubscription) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *TopicSubscription) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *TopicSubscription) GetRoutes() *TopicRoutes {
if x != nil {
return x.Routes
}
return nil
}
func (x *TopicSubscription) GetDeadLetterTopic() string {
if x != nil {
return x.DeadLetterTopic
}
return ""
}
func (x *TopicSubscription) GetBulkSubscribe() *BulkSubscribeConfig {
if x != nil {
return x.BulkSubscribe
}
return nil
}
type TopicRoutes struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The list of rules for this topic.
Rules []*TopicRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
// The default path for this topic.
Default string `protobuf:"bytes,2,opt,name=default,proto3" json:"default,omitempty"`
}
func (x *TopicRoutes) Reset() {
*x = TopicRoutes{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicRoutes) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicRoutes) ProtoMessage() {}
func (x *TopicRoutes) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicRoutes.ProtoReflect.Descriptor instead.
func (*TopicRoutes) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{11}
}
func (x *TopicRoutes) GetRules() []*TopicRule {
if x != nil {
return x.Rules
}
return nil
}
func (x *TopicRoutes) GetDefault() string {
if x != nil {
return x.Default
}
return ""
}
type TopicRule struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The optional CEL expression used to match the event.
// If the match is not specified, then the route is considered
// the default.
Match string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
// The path used to identify matches for this subscription.
// This value is passed in TopicEventRequest and used by OnTopicEvent to "switch"
// inside the handler.
Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
}
func (x *TopicRule) Reset() {
*x = TopicRule{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TopicRule) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TopicRule) ProtoMessage() {}
func (x *TopicRule) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[12]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TopicRule.ProtoReflect.Descriptor instead.
func (*TopicRule) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{12}
}
func (x *TopicRule) GetMatch() string {
if x != nil {
return x.Match
}
return ""
}
func (x *TopicRule) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
// BulkSubscribeConfig is the message to pass settings for bulk subscribe
type BulkSubscribeConfig struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. Flag to enable/disable bulk subscribe
Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
// Optional. Max number of messages to be sent in a single bulk request
MaxMessagesCount int32 `protobuf:"varint,2,opt,name=max_messages_count,json=maxMessagesCount,proto3" json:"max_messages_count,omitempty"`
// Optional. Max duration to wait for messages to be sent in a single bulk request
MaxAwaitDurationMs int32 `protobuf:"varint,3,opt,name=max_await_duration_ms,json=maxAwaitDurationMs,proto3" json:"max_await_duration_ms,omitempty"`
}
func (x *BulkSubscribeConfig) Reset() {
*x = BulkSubscribeConfig{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkSubscribeConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkSubscribeConfig) ProtoMessage() {}
func (x *BulkSubscribeConfig) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[13]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkSubscribeConfig.ProtoReflect.Descriptor instead.
func (*BulkSubscribeConfig) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{13}
}
func (x *BulkSubscribeConfig) GetEnabled() bool {
if x != nil {
return x.Enabled
}
return false
}
func (x *BulkSubscribeConfig) GetMaxMessagesCount() int32 {
if x != nil {
return x.MaxMessagesCount
}
return 0
}
func (x *BulkSubscribeConfig) GetMaxAwaitDurationMs() int32 {
if x != nil {
return x.MaxAwaitDurationMs
}
return 0
}
// ListInputBindingsResponse is the message including the list of input bindings.
type ListInputBindingsResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The list of input bindings.
Bindings []string `protobuf:"bytes,1,rep,name=bindings,proto3" json:"bindings,omitempty"`
}
func (x *ListInputBindingsResponse) Reset() {
*x = ListInputBindingsResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ListInputBindingsResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ListInputBindingsResponse) ProtoMessage() {}
func (x *ListInputBindingsResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[14]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ListInputBindingsResponse.ProtoReflect.Descriptor instead.
func (*ListInputBindingsResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{14}
}
func (x *ListInputBindingsResponse) GetBindings() []string {
if x != nil {
return x.Bindings
}
return nil
}
// HealthCheckResponse is the message with the response to the health check.
// This message is currently empty as used as placeholder.
type HealthCheckResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *HealthCheckResponse) Reset() {
*x = HealthCheckResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HealthCheckResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HealthCheckResponse) ProtoMessage() {}
func (x *HealthCheckResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[15]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HealthCheckResponse.ProtoReflect.Descriptor instead.
func (*HealthCheckResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP(), []int{15}
}
var File_dapr_proto_runtime_v1_appcallback_proto protoreflect.FileDescriptor
var file_dapr_proto_runtime_v1_appcallback_proto_rawDesc = []byte{
0x0a, 0x27, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x70, 0x63, 0x61, 0x6c, 0x6c, 0x62,
0x61, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x64,
0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb6,
0x02, 0x0a, 0x11, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04,
0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65,
0x12, 0x21, 0x0a, 0x0c, 0x73, 0x70, 0x65, 0x63, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x70, 0x65, 0x63, 0x56, 0x65, 0x72, 0x73,
0x69, 0x6f, 0x6e, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6e, 0x74,
0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f,
0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12,
0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64,
0x61, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x06, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x75, 0x62,
0x73, 0x75, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61,
0x74, 0x68, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x37,
0x0a, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0a, 0x20, 0x01,
0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x65, 0x78, 0x74,
0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xae, 0x01, 0x0a, 0x12, 0x54, 0x6f, 0x70, 0x69,
0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5a,
0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x42,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45,
0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74,
0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x3c, 0x0a, 0x18, 0x54, 0x6f,
0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x55, 0x43, 0x43, 0x45, 0x53,
0x53, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x52, 0x45, 0x54, 0x52, 0x59, 0x10, 0x01, 0x12, 0x08,
0x0a, 0x04, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x02, 0x22, 0xed, 0x01, 0x0a, 0x13, 0x54, 0x6f, 0x70,
0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x45, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64,
0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65,
0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c,
0x73, 0x70, 0x65, 0x63, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01,
0x28, 0x09, 0x52, 0x0b, 0x73, 0x70, 0x65, 0x63, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
0x2a, 0x0a, 0x11, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f,
0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x61, 0x74, 0x61,
0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64,
0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12,
0x37, 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0a, 0x65, 0x78,
0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xe4, 0x02, 0x0a, 0x1a, 0x54, 0x6f, 0x70,
0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x74, 0x72, 0x79,
0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x79,
0x49, 0x64, 0x12, 0x16, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28,
0x0c, 0x48, 0x00, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x4d, 0x0a, 0x0b, 0x63, 0x6c,
0x6f, 0x75, 0x64, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65,
0x6e, 0x74, 0x43, 0x45, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0a, 0x63,
0x6c, 0x6f, 0x75, 0x64, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6e,
0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x5b, 0x0a, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3f,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e,
0x74, 0x42, 0x75, 0x6c, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x22,
0xe8, 0x02, 0x0a, 0x15, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x75,
0x6c, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x4b, 0x0a, 0x07, 0x65, 0x6e, 0x74,
0x72, 0x69, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x75, 0x6c,
0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x65,
0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x56, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x14,
0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74,
0x6f, 0x70, 0x69, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x5f, 0x6e,
0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x75, 0x62, 0x73, 0x75,
0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20,
0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74,
0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x1a, 0x3b, 0x0a,
0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x94, 0x01, 0x0a, 0x1b, 0x54,
0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e,
0x74, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x65, 0x6e,
0x74, 0x72, 0x79, 0x49, 0x64, 0x12, 0x5a, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18,
0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x42, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f,
0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,
0x73, 0x22, 0x68, 0x0a, 0x16, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42,
0x75, 0x6c, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x08, 0x73,
0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74,
0x42, 0x75, 0x6c, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x52, 0x08, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x65, 0x73, 0x22, 0xd0, 0x01, 0x0a, 0x13,
0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18,
0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x54, 0x0a, 0x08, 0x6d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65,
0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb2,
0x02, 0x0a, 0x14, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65,
0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f,
0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73,
0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74,
0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12,
0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x02, 0x74, 0x6f, 0x12,
0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64,
0x61, 0x74, 0x61, 0x12, 0x65, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e,
0x63, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x43, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65,
0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x52, 0x0b, 0x63,
0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x22, 0x37, 0x0a, 0x17, 0x42, 0x69,
0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72,
0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x45, 0x51, 0x55, 0x45, 0x4e, 0x54,
0x49, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x50, 0x41, 0x52, 0x41, 0x4c, 0x4c, 0x45,
0x4c, 0x10, 0x01, 0x22, 0x70, 0x0a, 0x1e, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63,
0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x96, 0x03, 0x0a, 0x11, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x53,
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x70,
0x75, 0x62, 0x73, 0x75, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x0a, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05,
0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70,
0x69, 0x63, 0x12, 0x52, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70,
0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73,
0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54,
0x6f, 0x70, 0x69, 0x63, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74,
0x65, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x65, 0x61, 0x64, 0x5f, 0x6c, 0x65, 0x74, 0x74, 0x65,
0x72, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x64,
0x65, 0x61, 0x64, 0x4c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x51,
0x0a, 0x0e, 0x62, 0x75, 0x6c, 0x6b, 0x5f, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65,
0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42,
0x75, 0x6c, 0x6b, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x52, 0x0d, 0x62, 0x75, 0x6c, 0x6b, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62,
0x65, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x5f,
0x0a, 0x0b, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x36, 0x0a,
0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x05,
0x72, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x22,
0x35, 0x0a, 0x09, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05,
0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x61, 0x74,
0x63, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x90, 0x01, 0x0a, 0x13, 0x42, 0x75, 0x6c, 0x6b, 0x53,
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x18,
0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f,
0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02,
0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x6d, 0x61, 0x78, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x15, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x77,
0x61, 0x69, 0x74, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x73, 0x18,
0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x12, 0x6d, 0x61, 0x78, 0x41, 0x77, 0x61, 0x69, 0x74, 0x44,
0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x22, 0x37, 0x0a, 0x19, 0x4c, 0x69, 0x73,
0x74, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e,
0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e,
0x67, 0x73, 0x22, 0x15, 0x0a, 0x13, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63,
0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x86, 0x04, 0x0a, 0x0b, 0x41, 0x70,
0x70, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x12, 0x57, 0x0a, 0x08, 0x4f, 0x6e, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x12, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76,
0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76,
0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x12, 0x69, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x53,
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x16, 0x2e, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
0x6d, 0x70, 0x74, 0x79, 0x1a, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73,
0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x65, 0x0a,
0x0c, 0x4f, 0x6e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x28, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e,
0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x70, 0x75,
0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
0x79, 0x1a, 0x30, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e,
0x70, 0x75, 0x74, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6b, 0x0a, 0x0e, 0x4f, 0x6e, 0x42, 0x69, 0x6e, 0x64, 0x69,
0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e,
0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x69, 0x6e, 0x64,
0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x32, 0x6d, 0x0a, 0x16, 0x41, 0x70, 0x70, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63,
0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x12, 0x53, 0x0a, 0x0b,
0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x12, 0x16, 0x2e, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
0x70, 0x74, 0x79, 0x1a, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x48, 0x65, 0x61, 0x6c,
0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x00, 0x32, 0x8b, 0x01, 0x0a, 0x10, 0x41, 0x70, 0x70, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63,
0x6b, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x12, 0x77, 0x0a, 0x16, 0x4f, 0x6e, 0x42, 0x75, 0x6c, 0x6b,
0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31,
0x12, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76,
0x65, 0x6e, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e,
0x74, 0x42, 0x75, 0x6c, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42,
0x79, 0x0a, 0x0a, 0x69, 0x6f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x15, 0x44,
0x61, 0x70, 0x72, 0x41, 0x70, 0x70, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x50, 0x72,
0x6f, 0x74, 0x6f, 0x73, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d,
0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x3b,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0xaa, 0x02, 0x20, 0x44, 0x61, 0x70, 0x72, 0x2e, 0x41,
0x70, 0x70, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x67,
0x65, 0x6e, 0x2e, 0x47, 0x72, 0x70, 0x63, 0x2e, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x33,
}
var (
file_dapr_proto_runtime_v1_appcallback_proto_rawDescOnce sync.Once
file_dapr_proto_runtime_v1_appcallback_proto_rawDescData = file_dapr_proto_runtime_v1_appcallback_proto_rawDesc
)
func file_dapr_proto_runtime_v1_appcallback_proto_rawDescGZIP() []byte {
file_dapr_proto_runtime_v1_appcallback_proto_rawDescOnce.Do(func() {
file_dapr_proto_runtime_v1_appcallback_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_runtime_v1_appcallback_proto_rawDescData)
})
return file_dapr_proto_runtime_v1_appcallback_proto_rawDescData
}
var file_dapr_proto_runtime_v1_appcallback_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_dapr_proto_runtime_v1_appcallback_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_dapr_proto_runtime_v1_appcallback_proto_goTypes = []interface{}{
(TopicEventResponse_TopicEventResponseStatus)(0), // 0: dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatus
(BindingEventResponse_BindingEventConcurrency)(0), // 1: dapr.proto.runtime.v1.BindingEventResponse.BindingEventConcurrency
(*TopicEventRequest)(nil), // 2: dapr.proto.runtime.v1.TopicEventRequest
(*TopicEventResponse)(nil), // 3: dapr.proto.runtime.v1.TopicEventResponse
(*TopicEventCERequest)(nil), // 4: dapr.proto.runtime.v1.TopicEventCERequest
(*TopicEventBulkRequestEntry)(nil), // 5: dapr.proto.runtime.v1.TopicEventBulkRequestEntry
(*TopicEventBulkRequest)(nil), // 6: dapr.proto.runtime.v1.TopicEventBulkRequest
(*TopicEventBulkResponseEntry)(nil), // 7: dapr.proto.runtime.v1.TopicEventBulkResponseEntry
(*TopicEventBulkResponse)(nil), // 8: dapr.proto.runtime.v1.TopicEventBulkResponse
(*BindingEventRequest)(nil), // 9: dapr.proto.runtime.v1.BindingEventRequest
(*BindingEventResponse)(nil), // 10: dapr.proto.runtime.v1.BindingEventResponse
(*ListTopicSubscriptionsResponse)(nil), // 11: dapr.proto.runtime.v1.ListTopicSubscriptionsResponse
(*TopicSubscription)(nil), // 12: dapr.proto.runtime.v1.TopicSubscription
(*TopicRoutes)(nil), // 13: dapr.proto.runtime.v1.TopicRoutes
(*TopicRule)(nil), // 14: dapr.proto.runtime.v1.TopicRule
(*BulkSubscribeConfig)(nil), // 15: dapr.proto.runtime.v1.BulkSubscribeConfig
(*ListInputBindingsResponse)(nil), // 16: dapr.proto.runtime.v1.ListInputBindingsResponse
(*HealthCheckResponse)(nil), // 17: dapr.proto.runtime.v1.HealthCheckResponse
nil, // 18: dapr.proto.runtime.v1.TopicEventBulkRequestEntry.MetadataEntry
nil, // 19: dapr.proto.runtime.v1.TopicEventBulkRequest.MetadataEntry
nil, // 20: dapr.proto.runtime.v1.BindingEventRequest.MetadataEntry
nil, // 21: dapr.proto.runtime.v1.TopicSubscription.MetadataEntry
(*structpb.Struct)(nil), // 22: google.protobuf.Struct
(*v1.StateItem)(nil), // 23: dapr.proto.common.v1.StateItem
(*v1.InvokeRequest)(nil), // 24: dapr.proto.common.v1.InvokeRequest
(*emptypb.Empty)(nil), // 25: google.protobuf.Empty
(*v1.InvokeResponse)(nil), // 26: dapr.proto.common.v1.InvokeResponse
}
var file_dapr_proto_runtime_v1_appcallback_proto_depIdxs = []int32{
22, // 0: dapr.proto.runtime.v1.TopicEventRequest.extensions:type_name -> google.protobuf.Struct
0, // 1: dapr.proto.runtime.v1.TopicEventResponse.status:type_name -> dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatus
22, // 2: dapr.proto.runtime.v1.TopicEventCERequest.extensions:type_name -> google.protobuf.Struct
4, // 3: dapr.proto.runtime.v1.TopicEventBulkRequestEntry.cloud_event:type_name -> dapr.proto.runtime.v1.TopicEventCERequest
18, // 4: dapr.proto.runtime.v1.TopicEventBulkRequestEntry.metadata:type_name -> dapr.proto.runtime.v1.TopicEventBulkRequestEntry.MetadataEntry
5, // 5: dapr.proto.runtime.v1.TopicEventBulkRequest.entries:type_name -> dapr.proto.runtime.v1.TopicEventBulkRequestEntry
19, // 6: dapr.proto.runtime.v1.TopicEventBulkRequest.metadata:type_name -> dapr.proto.runtime.v1.TopicEventBulkRequest.MetadataEntry
0, // 7: dapr.proto.runtime.v1.TopicEventBulkResponseEntry.status:type_name -> dapr.proto.runtime.v1.TopicEventResponse.TopicEventResponseStatus
7, // 8: dapr.proto.runtime.v1.TopicEventBulkResponse.statuses:type_name -> dapr.proto.runtime.v1.TopicEventBulkResponseEntry
20, // 9: dapr.proto.runtime.v1.BindingEventRequest.metadata:type_name -> dapr.proto.runtime.v1.BindingEventRequest.MetadataEntry
23, // 10: dapr.proto.runtime.v1.BindingEventResponse.states:type_name -> dapr.proto.common.v1.StateItem
1, // 11: dapr.proto.runtime.v1.BindingEventResponse.concurrency:type_name -> dapr.proto.runtime.v1.BindingEventResponse.BindingEventConcurrency
12, // 12: dapr.proto.runtime.v1.ListTopicSubscriptionsResponse.subscriptions:type_name -> dapr.proto.runtime.v1.TopicSubscription
21, // 13: dapr.proto.runtime.v1.TopicSubscription.metadata:type_name -> dapr.proto.runtime.v1.TopicSubscription.MetadataEntry
13, // 14: dapr.proto.runtime.v1.TopicSubscription.routes:type_name -> dapr.proto.runtime.v1.TopicRoutes
15, // 15: dapr.proto.runtime.v1.TopicSubscription.bulk_subscribe:type_name -> dapr.proto.runtime.v1.BulkSubscribeConfig
14, // 16: dapr.proto.runtime.v1.TopicRoutes.rules:type_name -> dapr.proto.runtime.v1.TopicRule
24, // 17: dapr.proto.runtime.v1.AppCallback.OnInvoke:input_type -> dapr.proto.common.v1.InvokeRequest
25, // 18: dapr.proto.runtime.v1.AppCallback.ListTopicSubscriptions:input_type -> google.protobuf.Empty
2, // 19: dapr.proto.runtime.v1.AppCallback.OnTopicEvent:input_type -> dapr.proto.runtime.v1.TopicEventRequest
25, // 20: dapr.proto.runtime.v1.AppCallback.ListInputBindings:input_type -> google.protobuf.Empty
9, // 21: dapr.proto.runtime.v1.AppCallback.OnBindingEvent:input_type -> dapr.proto.runtime.v1.BindingEventRequest
25, // 22: dapr.proto.runtime.v1.AppCallbackHealthCheck.HealthCheck:input_type -> google.protobuf.Empty
6, // 23: dapr.proto.runtime.v1.AppCallbackAlpha.OnBulkTopicEventAlpha1:input_type -> dapr.proto.runtime.v1.TopicEventBulkRequest
26, // 24: dapr.proto.runtime.v1.AppCallback.OnInvoke:output_type -> dapr.proto.common.v1.InvokeResponse
11, // 25: dapr.proto.runtime.v1.AppCallback.ListTopicSubscriptions:output_type -> dapr.proto.runtime.v1.ListTopicSubscriptionsResponse
3, // 26: dapr.proto.runtime.v1.AppCallback.OnTopicEvent:output_type -> dapr.proto.runtime.v1.TopicEventResponse
16, // 27: dapr.proto.runtime.v1.AppCallback.ListInputBindings:output_type -> dapr.proto.runtime.v1.ListInputBindingsResponse
10, // 28: dapr.proto.runtime.v1.AppCallback.OnBindingEvent:output_type -> dapr.proto.runtime.v1.BindingEventResponse
17, // 29: dapr.proto.runtime.v1.AppCallbackHealthCheck.HealthCheck:output_type -> dapr.proto.runtime.v1.HealthCheckResponse
8, // 30: dapr.proto.runtime.v1.AppCallbackAlpha.OnBulkTopicEventAlpha1:output_type -> dapr.proto.runtime.v1.TopicEventBulkResponse
24, // [24:31] is the sub-list for method output_type
17, // [17:24] is the sub-list for method input_type
17, // [17:17] is the sub-list for extension type_name
17, // [17:17] is the sub-list for extension extendee
0, // [0:17] is the sub-list for field type_name
}
func init() { file_dapr_proto_runtime_v1_appcallback_proto_init() }
func file_dapr_proto_runtime_v1_appcallback_proto_init() {
if File_dapr_proto_runtime_v1_appcallback_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventCERequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventBulkRequestEntry); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventBulkRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventBulkResponseEntry); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicEventBulkResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BindingEventRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BindingEventResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListTopicSubscriptionsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicSubscription); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicRoutes); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TopicRule); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkSubscribeConfig); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ListInputBindingsResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HealthCheckResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
file_dapr_proto_runtime_v1_appcallback_proto_msgTypes[3].OneofWrappers = []interface{}{
(*TopicEventBulkRequestEntry_Bytes)(nil),
(*TopicEventBulkRequestEntry_CloudEvent)(nil),
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_runtime_v1_appcallback_proto_rawDesc,
NumEnums: 2,
NumMessages: 20,
NumExtensions: 0,
NumServices: 3,
},
GoTypes: file_dapr_proto_runtime_v1_appcallback_proto_goTypes,
DependencyIndexes: file_dapr_proto_runtime_v1_appcallback_proto_depIdxs,
EnumInfos: file_dapr_proto_runtime_v1_appcallback_proto_enumTypes,
MessageInfos: file_dapr_proto_runtime_v1_appcallback_proto_msgTypes,
}.Build()
File_dapr_proto_runtime_v1_appcallback_proto = out.File
file_dapr_proto_runtime_v1_appcallback_proto_rawDesc = nil
file_dapr_proto_runtime_v1_appcallback_proto_goTypes = nil
file_dapr_proto_runtime_v1_appcallback_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/appcallback.pb.go
|
GO
|
mit
| 80,203 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/runtime/v1/appcallback.proto
package runtime
import (
context "context"
v1 "github.com/dapr/dapr/pkg/proto/common/v1"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
AppCallback_OnInvoke_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/OnInvoke"
AppCallback_ListTopicSubscriptions_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/ListTopicSubscriptions"
AppCallback_OnTopicEvent_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/OnTopicEvent"
AppCallback_ListInputBindings_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/ListInputBindings"
AppCallback_OnBindingEvent_FullMethodName = "/dapr.proto.runtime.v1.AppCallback/OnBindingEvent"
)
// AppCallbackClient is the client API for AppCallback service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AppCallbackClient interface {
// Invokes service method with InvokeRequest.
OnInvoke(ctx context.Context, in *v1.InvokeRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error)
// Lists all topics subscribed by this app.
ListTopicSubscriptions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListTopicSubscriptionsResponse, error)
// Subscribes events from Pubsub
OnTopicEvent(ctx context.Context, in *TopicEventRequest, opts ...grpc.CallOption) (*TopicEventResponse, error)
// Lists all input bindings subscribed by this app.
ListInputBindings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListInputBindingsResponse, error)
// Listens events from the input bindings
//
// User application can save the states or send the events to the output
// bindings optionally by returning BindingEventResponse.
OnBindingEvent(ctx context.Context, in *BindingEventRequest, opts ...grpc.CallOption) (*BindingEventResponse, error)
}
type appCallbackClient struct {
cc grpc.ClientConnInterface
}
func NewAppCallbackClient(cc grpc.ClientConnInterface) AppCallbackClient {
return &appCallbackClient{cc}
}
func (c *appCallbackClient) OnInvoke(ctx context.Context, in *v1.InvokeRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error) {
out := new(v1.InvokeResponse)
err := c.cc.Invoke(ctx, AppCallback_OnInvoke_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *appCallbackClient) ListTopicSubscriptions(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListTopicSubscriptionsResponse, error) {
out := new(ListTopicSubscriptionsResponse)
err := c.cc.Invoke(ctx, AppCallback_ListTopicSubscriptions_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *appCallbackClient) OnTopicEvent(ctx context.Context, in *TopicEventRequest, opts ...grpc.CallOption) (*TopicEventResponse, error) {
out := new(TopicEventResponse)
err := c.cc.Invoke(ctx, AppCallback_OnTopicEvent_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *appCallbackClient) ListInputBindings(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListInputBindingsResponse, error) {
out := new(ListInputBindingsResponse)
err := c.cc.Invoke(ctx, AppCallback_ListInputBindings_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *appCallbackClient) OnBindingEvent(ctx context.Context, in *BindingEventRequest, opts ...grpc.CallOption) (*BindingEventResponse, error) {
out := new(BindingEventResponse)
err := c.cc.Invoke(ctx, AppCallback_OnBindingEvent_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// AppCallbackServer is the server API for AppCallback service.
// All implementations should embed UnimplementedAppCallbackServer
// for forward compatibility
type AppCallbackServer interface {
// Invokes service method with InvokeRequest.
OnInvoke(context.Context, *v1.InvokeRequest) (*v1.InvokeResponse, error)
// Lists all topics subscribed by this app.
ListTopicSubscriptions(context.Context, *emptypb.Empty) (*ListTopicSubscriptionsResponse, error)
// Subscribes events from Pubsub
OnTopicEvent(context.Context, *TopicEventRequest) (*TopicEventResponse, error)
// Lists all input bindings subscribed by this app.
ListInputBindings(context.Context, *emptypb.Empty) (*ListInputBindingsResponse, error)
// Listens events from the input bindings
//
// User application can save the states or send the events to the output
// bindings optionally by returning BindingEventResponse.
OnBindingEvent(context.Context, *BindingEventRequest) (*BindingEventResponse, error)
}
// UnimplementedAppCallbackServer should be embedded to have forward compatible implementations.
type UnimplementedAppCallbackServer struct {
}
func (UnimplementedAppCallbackServer) OnInvoke(context.Context, *v1.InvokeRequest) (*v1.InvokeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnInvoke not implemented")
}
func (UnimplementedAppCallbackServer) ListTopicSubscriptions(context.Context, *emptypb.Empty) (*ListTopicSubscriptionsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListTopicSubscriptions not implemented")
}
func (UnimplementedAppCallbackServer) OnTopicEvent(context.Context, *TopicEventRequest) (*TopicEventResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnTopicEvent not implemented")
}
func (UnimplementedAppCallbackServer) ListInputBindings(context.Context, *emptypb.Empty) (*ListInputBindingsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListInputBindings not implemented")
}
func (UnimplementedAppCallbackServer) OnBindingEvent(context.Context, *BindingEventRequest) (*BindingEventResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnBindingEvent not implemented")
}
// UnsafeAppCallbackServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AppCallbackServer will
// result in compilation errors.
type UnsafeAppCallbackServer interface {
mustEmbedUnimplementedAppCallbackServer()
}
func RegisterAppCallbackServer(s grpc.ServiceRegistrar, srv AppCallbackServer) {
s.RegisterService(&AppCallback_ServiceDesc, srv)
}
func _AppCallback_OnInvoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(v1.InvokeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackServer).OnInvoke(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallback_OnInvoke_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackServer).OnInvoke(ctx, req.(*v1.InvokeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AppCallback_ListTopicSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackServer).ListTopicSubscriptions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallback_ListTopicSubscriptions_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackServer).ListTopicSubscriptions(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _AppCallback_OnTopicEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TopicEventRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackServer).OnTopicEvent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallback_OnTopicEvent_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackServer).OnTopicEvent(ctx, req.(*TopicEventRequest))
}
return interceptor(ctx, in, info, handler)
}
func _AppCallback_ListInputBindings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackServer).ListInputBindings(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallback_ListInputBindings_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackServer).ListInputBindings(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _AppCallback_OnBindingEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BindingEventRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackServer).OnBindingEvent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallback_OnBindingEvent_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackServer).OnBindingEvent(ctx, req.(*BindingEventRequest))
}
return interceptor(ctx, in, info, handler)
}
// AppCallback_ServiceDesc is the grpc.ServiceDesc for AppCallback service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AppCallback_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.runtime.v1.AppCallback",
HandlerType: (*AppCallbackServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "OnInvoke",
Handler: _AppCallback_OnInvoke_Handler,
},
{
MethodName: "ListTopicSubscriptions",
Handler: _AppCallback_ListTopicSubscriptions_Handler,
},
{
MethodName: "OnTopicEvent",
Handler: _AppCallback_OnTopicEvent_Handler,
},
{
MethodName: "ListInputBindings",
Handler: _AppCallback_ListInputBindings_Handler,
},
{
MethodName: "OnBindingEvent",
Handler: _AppCallback_OnBindingEvent_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/runtime/v1/appcallback.proto",
}
const (
AppCallbackHealthCheck_HealthCheck_FullMethodName = "/dapr.proto.runtime.v1.AppCallbackHealthCheck/HealthCheck"
)
// AppCallbackHealthCheckClient is the client API for AppCallbackHealthCheck service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AppCallbackHealthCheckClient interface {
// Health check.
HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error)
}
type appCallbackHealthCheckClient struct {
cc grpc.ClientConnInterface
}
func NewAppCallbackHealthCheckClient(cc grpc.ClientConnInterface) AppCallbackHealthCheckClient {
return &appCallbackHealthCheckClient{cc}
}
func (c *appCallbackHealthCheckClient) HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
out := new(HealthCheckResponse)
err := c.cc.Invoke(ctx, AppCallbackHealthCheck_HealthCheck_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// AppCallbackHealthCheckServer is the server API for AppCallbackHealthCheck service.
// All implementations should embed UnimplementedAppCallbackHealthCheckServer
// for forward compatibility
type AppCallbackHealthCheckServer interface {
// Health check.
HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error)
}
// UnimplementedAppCallbackHealthCheckServer should be embedded to have forward compatible implementations.
type UnimplementedAppCallbackHealthCheckServer struct {
}
func (UnimplementedAppCallbackHealthCheckServer) HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method HealthCheck not implemented")
}
// UnsafeAppCallbackHealthCheckServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AppCallbackHealthCheckServer will
// result in compilation errors.
type UnsafeAppCallbackHealthCheckServer interface {
mustEmbedUnimplementedAppCallbackHealthCheckServer()
}
func RegisterAppCallbackHealthCheckServer(s grpc.ServiceRegistrar, srv AppCallbackHealthCheckServer) {
s.RegisterService(&AppCallbackHealthCheck_ServiceDesc, srv)
}
func _AppCallbackHealthCheck_HealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackHealthCheckServer).HealthCheck(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallbackHealthCheck_HealthCheck_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackHealthCheckServer).HealthCheck(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
// AppCallbackHealthCheck_ServiceDesc is the grpc.ServiceDesc for AppCallbackHealthCheck service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AppCallbackHealthCheck_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.runtime.v1.AppCallbackHealthCheck",
HandlerType: (*AppCallbackHealthCheckServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "HealthCheck",
Handler: _AppCallbackHealthCheck_HealthCheck_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/runtime/v1/appcallback.proto",
}
const (
AppCallbackAlpha_OnBulkTopicEventAlpha1_FullMethodName = "/dapr.proto.runtime.v1.AppCallbackAlpha/OnBulkTopicEventAlpha1"
)
// AppCallbackAlphaClient is the client API for AppCallbackAlpha service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AppCallbackAlphaClient interface {
// Subscribes bulk events from Pubsub
OnBulkTopicEventAlpha1(ctx context.Context, in *TopicEventBulkRequest, opts ...grpc.CallOption) (*TopicEventBulkResponse, error)
}
type appCallbackAlphaClient struct {
cc grpc.ClientConnInterface
}
func NewAppCallbackAlphaClient(cc grpc.ClientConnInterface) AppCallbackAlphaClient {
return &appCallbackAlphaClient{cc}
}
func (c *appCallbackAlphaClient) OnBulkTopicEventAlpha1(ctx context.Context, in *TopicEventBulkRequest, opts ...grpc.CallOption) (*TopicEventBulkResponse, error) {
out := new(TopicEventBulkResponse)
err := c.cc.Invoke(ctx, AppCallbackAlpha_OnBulkTopicEventAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// AppCallbackAlphaServer is the server API for AppCallbackAlpha service.
// All implementations should embed UnimplementedAppCallbackAlphaServer
// for forward compatibility
type AppCallbackAlphaServer interface {
// Subscribes bulk events from Pubsub
OnBulkTopicEventAlpha1(context.Context, *TopicEventBulkRequest) (*TopicEventBulkResponse, error)
}
// UnimplementedAppCallbackAlphaServer should be embedded to have forward compatible implementations.
type UnimplementedAppCallbackAlphaServer struct {
}
func (UnimplementedAppCallbackAlphaServer) OnBulkTopicEventAlpha1(context.Context, *TopicEventBulkRequest) (*TopicEventBulkResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnBulkTopicEventAlpha1 not implemented")
}
// UnsafeAppCallbackAlphaServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AppCallbackAlphaServer will
// result in compilation errors.
type UnsafeAppCallbackAlphaServer interface {
mustEmbedUnimplementedAppCallbackAlphaServer()
}
func RegisterAppCallbackAlphaServer(s grpc.ServiceRegistrar, srv AppCallbackAlphaServer) {
s.RegisterService(&AppCallbackAlpha_ServiceDesc, srv)
}
func _AppCallbackAlpha_OnBulkTopicEventAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TopicEventBulkRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AppCallbackAlphaServer).OnBulkTopicEventAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AppCallbackAlpha_OnBulkTopicEventAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AppCallbackAlphaServer).OnBulkTopicEventAlpha1(ctx, req.(*TopicEventBulkRequest))
}
return interceptor(ctx, in, info, handler)
}
// AppCallbackAlpha_ServiceDesc is the grpc.ServiceDesc for AppCallbackAlpha service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AppCallbackAlpha_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.runtime.v1.AppCallbackAlpha",
HandlerType: (*AppCallbackAlphaServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "OnBulkTopicEventAlpha1",
Handler: _AppCallbackAlpha_OnBulkTopicEventAlpha1_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/runtime/v1/appcallback.proto",
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/appcallback_grpc.pb.go
|
GO
|
mit
| 18,966 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/runtime/v1/dapr.proto
package runtime
import (
v1 "github.com/dapr/dapr/pkg/proto/common/v1"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
emptypb "google.golang.org/protobuf/types/known/emptypb"
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type ActorRuntime_ActorRuntimeStatus int32
const (
// Indicates that the actor runtime is still being initialized.
ActorRuntime_INITIALIZING ActorRuntime_ActorRuntimeStatus = 0
// Indicates that the actor runtime is disabled.
// This normally happens when Dapr is started without "placement-host-address"
ActorRuntime_DISABLED ActorRuntime_ActorRuntimeStatus = 1
// Indicates the actor runtime is running, either as an actor host or client.
ActorRuntime_RUNNING ActorRuntime_ActorRuntimeStatus = 2
)
// Enum value maps for ActorRuntime_ActorRuntimeStatus.
var (
ActorRuntime_ActorRuntimeStatus_name = map[int32]string{
0: "INITIALIZING",
1: "DISABLED",
2: "RUNNING",
}
ActorRuntime_ActorRuntimeStatus_value = map[string]int32{
"INITIALIZING": 0,
"DISABLED": 1,
"RUNNING": 2,
}
)
func (x ActorRuntime_ActorRuntimeStatus) Enum() *ActorRuntime_ActorRuntimeStatus {
p := new(ActorRuntime_ActorRuntimeStatus)
*p = x
return p
}
func (x ActorRuntime_ActorRuntimeStatus) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (ActorRuntime_ActorRuntimeStatus) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[0].Descriptor()
}
func (ActorRuntime_ActorRuntimeStatus) Type() protoreflect.EnumType {
return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[0]
}
func (x ActorRuntime_ActorRuntimeStatus) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use ActorRuntime_ActorRuntimeStatus.Descriptor instead.
func (ActorRuntime_ActorRuntimeStatus) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{41, 0}
}
type UnlockResponse_Status int32
const (
UnlockResponse_SUCCESS UnlockResponse_Status = 0
UnlockResponse_LOCK_DOES_NOT_EXIST UnlockResponse_Status = 1
UnlockResponse_LOCK_BELONGS_TO_OTHERS UnlockResponse_Status = 2
UnlockResponse_INTERNAL_ERROR UnlockResponse_Status = 3
)
// Enum value maps for UnlockResponse_Status.
var (
UnlockResponse_Status_name = map[int32]string{
0: "SUCCESS",
1: "LOCK_DOES_NOT_EXIST",
2: "LOCK_BELONGS_TO_OTHERS",
3: "INTERNAL_ERROR",
}
UnlockResponse_Status_value = map[string]int32{
"SUCCESS": 0,
"LOCK_DOES_NOT_EXIST": 1,
"LOCK_BELONGS_TO_OTHERS": 2,
"INTERNAL_ERROR": 3,
}
)
func (x UnlockResponse_Status) Enum() *UnlockResponse_Status {
p := new(UnlockResponse_Status)
*p = x
return p
}
func (x UnlockResponse_Status) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (UnlockResponse_Status) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[1].Descriptor()
}
func (UnlockResponse_Status) Type() protoreflect.EnumType {
return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[1]
}
func (x UnlockResponse_Status) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use UnlockResponse_Status.Descriptor instead.
func (UnlockResponse_Status) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{60, 0}
}
type SubtleGetKeyRequest_KeyFormat int32
const (
// PEM (PKIX) (default)
SubtleGetKeyRequest_PEM SubtleGetKeyRequest_KeyFormat = 0
// JSON (JSON Web Key) as string
SubtleGetKeyRequest_JSON SubtleGetKeyRequest_KeyFormat = 1
)
// Enum value maps for SubtleGetKeyRequest_KeyFormat.
var (
SubtleGetKeyRequest_KeyFormat_name = map[int32]string{
0: "PEM",
1: "JSON",
}
SubtleGetKeyRequest_KeyFormat_value = map[string]int32{
"PEM": 0,
"JSON": 1,
}
)
func (x SubtleGetKeyRequest_KeyFormat) Enum() *SubtleGetKeyRequest_KeyFormat {
p := new(SubtleGetKeyRequest_KeyFormat)
*p = x
return p
}
func (x SubtleGetKeyRequest_KeyFormat) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (SubtleGetKeyRequest_KeyFormat) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_runtime_v1_dapr_proto_enumTypes[2].Descriptor()
}
func (SubtleGetKeyRequest_KeyFormat) Type() protoreflect.EnumType {
return &file_dapr_proto_runtime_v1_dapr_proto_enumTypes[2]
}
func (x SubtleGetKeyRequest_KeyFormat) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use SubtleGetKeyRequest_KeyFormat.Descriptor instead.
func (SubtleGetKeyRequest_KeyFormat) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{61, 0}
}
// InvokeServiceRequest represents the request message for Service invocation.
type InvokeServiceRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. Callee's app id.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Required. message which will be delivered to callee.
Message *v1.InvokeRequest `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
}
func (x *InvokeServiceRequest) Reset() {
*x = InvokeServiceRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeServiceRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeServiceRequest) ProtoMessage() {}
func (x *InvokeServiceRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeServiceRequest.ProtoReflect.Descriptor instead.
func (*InvokeServiceRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{0}
}
func (x *InvokeServiceRequest) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *InvokeServiceRequest) GetMessage() *v1.InvokeRequest {
if x != nil {
return x.Message
}
return nil
}
// GetStateRequest is the message to get key-value states from specific state store.
type GetStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The key of the desired state
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
// The read consistency of the state store.
Consistency v1.StateOptions_StateConsistency `protobuf:"varint,3,opt,name=consistency,proto3,enum=dapr.proto.common.v1.StateOptions_StateConsistency" json:"consistency,omitempty"`
// The metadata which will be sent to state store components.
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetStateRequest) Reset() {
*x = GetStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetStateRequest) ProtoMessage() {}
func (x *GetStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetStateRequest.ProtoReflect.Descriptor instead.
func (*GetStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{1}
}
func (x *GetStateRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *GetStateRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *GetStateRequest) GetConsistency() v1.StateOptions_StateConsistency {
if x != nil {
return x.Consistency
}
return v1.StateOptions_StateConsistency(0)
}
func (x *GetStateRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// GetBulkStateRequest is the message to get a list of key-value states from specific state store.
type GetBulkStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The keys to get.
Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"`
// The number of parallel operations executed on the state store for a get operation.
Parallelism int32 `protobuf:"varint,3,opt,name=parallelism,proto3" json:"parallelism,omitempty"`
// The metadata which will be sent to state store components.
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetBulkStateRequest) Reset() {
*x = GetBulkStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetBulkStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetBulkStateRequest) ProtoMessage() {}
func (x *GetBulkStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetBulkStateRequest.ProtoReflect.Descriptor instead.
func (*GetBulkStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{2}
}
func (x *GetBulkStateRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *GetBulkStateRequest) GetKeys() []string {
if x != nil {
return x.Keys
}
return nil
}
func (x *GetBulkStateRequest) GetParallelism() int32 {
if x != nil {
return x.Parallelism
}
return 0
}
func (x *GetBulkStateRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// GetBulkStateResponse is the response conveying the list of state values.
type GetBulkStateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The list of items containing the keys to get values for.
Items []*BulkStateItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
}
func (x *GetBulkStateResponse) Reset() {
*x = GetBulkStateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetBulkStateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetBulkStateResponse) ProtoMessage() {}
func (x *GetBulkStateResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetBulkStateResponse.ProtoReflect.Descriptor instead.
func (*GetBulkStateResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{3}
}
func (x *GetBulkStateResponse) GetItems() []*BulkStateItem {
if x != nil {
return x.Items
}
return nil
}
// BulkStateItem is the response item for a bulk get operation.
// Return values include the item key, data and etag.
type BulkStateItem struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// state item key
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The byte array data
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// The entity tag which represents the specific version of data.
// ETag format is defined by the corresponding data store.
Etag string `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// The error that was returned from the state store in case of a failed get operation.
Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
// The metadata which will be sent to app.
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkStateItem) Reset() {
*x = BulkStateItem{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkStateItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkStateItem) ProtoMessage() {}
func (x *BulkStateItem) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkStateItem.ProtoReflect.Descriptor instead.
func (*BulkStateItem) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{4}
}
func (x *BulkStateItem) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *BulkStateItem) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *BulkStateItem) GetEtag() string {
if x != nil {
return x.Etag
}
return ""
}
func (x *BulkStateItem) GetError() string {
if x != nil {
return x.Error
}
return ""
}
func (x *BulkStateItem) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// GetStateResponse is the response conveying the state value and etag.
type GetStateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The byte array data
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The entity tag which represents the specific version of data.
// ETag format is defined by the corresponding data store.
Etag string `protobuf:"bytes,2,opt,name=etag,proto3" json:"etag,omitempty"`
// The metadata which will be sent to app.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetStateResponse) Reset() {
*x = GetStateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetStateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetStateResponse) ProtoMessage() {}
func (x *GetStateResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetStateResponse.ProtoReflect.Descriptor instead.
func (*GetStateResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{5}
}
func (x *GetStateResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *GetStateResponse) GetEtag() string {
if x != nil {
return x.Etag
}
return ""
}
func (x *GetStateResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// DeleteStateRequest is the message to delete key-value states in the specific state store.
type DeleteStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The key of the desired state
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
// The entity tag which represents the specific version of data.
// The exact ETag format is defined by the corresponding data store.
Etag *v1.Etag `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// State operation options which includes concurrency/
// consistency/retry_policy.
Options *v1.StateOptions `protobuf:"bytes,4,opt,name=options,proto3" json:"options,omitempty"`
// The metadata which will be sent to state store components.
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *DeleteStateRequest) Reset() {
*x = DeleteStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteStateRequest) ProtoMessage() {}
func (x *DeleteStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteStateRequest.ProtoReflect.Descriptor instead.
func (*DeleteStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{6}
}
func (x *DeleteStateRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *DeleteStateRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *DeleteStateRequest) GetEtag() *v1.Etag {
if x != nil {
return x.Etag
}
return nil
}
func (x *DeleteStateRequest) GetOptions() *v1.StateOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *DeleteStateRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// DeleteBulkStateRequest is the message to delete a list of key-value states from specific state store.
type DeleteBulkStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The array of the state key values.
States []*v1.StateItem `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"`
}
func (x *DeleteBulkStateRequest) Reset() {
*x = DeleteBulkStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DeleteBulkStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DeleteBulkStateRequest) ProtoMessage() {}
func (x *DeleteBulkStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DeleteBulkStateRequest.ProtoReflect.Descriptor instead.
func (*DeleteBulkStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{7}
}
func (x *DeleteBulkStateRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *DeleteBulkStateRequest) GetStates() []*v1.StateItem {
if x != nil {
return x.States
}
return nil
}
// SaveStateRequest is the message to save multiple states into state store.
type SaveStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The array of the state key values.
States []*v1.StateItem `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"`
}
func (x *SaveStateRequest) Reset() {
*x = SaveStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SaveStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SaveStateRequest) ProtoMessage() {}
func (x *SaveStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SaveStateRequest.ProtoReflect.Descriptor instead.
func (*SaveStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{8}
}
func (x *SaveStateRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *SaveStateRequest) GetStates() []*v1.StateItem {
if x != nil {
return x.States
}
return nil
}
// QueryStateRequest is the message to query state store.
type QueryStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of state store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The query in JSON format.
Query string `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"`
// The metadata which will be sent to state store components.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *QueryStateRequest) Reset() {
*x = QueryStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *QueryStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*QueryStateRequest) ProtoMessage() {}
func (x *QueryStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use QueryStateRequest.ProtoReflect.Descriptor instead.
func (*QueryStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{9}
}
func (x *QueryStateRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *QueryStateRequest) GetQuery() string {
if x != nil {
return x.Query
}
return ""
}
func (x *QueryStateRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
type QueryStateItem struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The object key.
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// The object value.
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// The entity tag which represents the specific version of data.
// ETag format is defined by the corresponding data store.
Etag string `protobuf:"bytes,3,opt,name=etag,proto3" json:"etag,omitempty"`
// The error message indicating an error in processing of the query result.
Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
}
func (x *QueryStateItem) Reset() {
*x = QueryStateItem{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *QueryStateItem) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*QueryStateItem) ProtoMessage() {}
func (x *QueryStateItem) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[10]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use QueryStateItem.ProtoReflect.Descriptor instead.
func (*QueryStateItem) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{10}
}
func (x *QueryStateItem) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *QueryStateItem) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *QueryStateItem) GetEtag() string {
if x != nil {
return x.Etag
}
return ""
}
func (x *QueryStateItem) GetError() string {
if x != nil {
return x.Error
}
return ""
}
// QueryStateResponse is the response conveying the query results.
type QueryStateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// An array of query results.
Results []*QueryStateItem `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
// Pagination token.
Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
// The metadata which will be sent to app.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *QueryStateResponse) Reset() {
*x = QueryStateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *QueryStateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*QueryStateResponse) ProtoMessage() {}
func (x *QueryStateResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[11]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use QueryStateResponse.ProtoReflect.Descriptor instead.
func (*QueryStateResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{11}
}
func (x *QueryStateResponse) GetResults() []*QueryStateItem {
if x != nil {
return x.Results
}
return nil
}
func (x *QueryStateResponse) GetToken() string {
if x != nil {
return x.Token
}
return ""
}
func (x *QueryStateResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// PublishEventRequest is the message to publish event data to pubsub topic
type PublishEventRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the pubsub component
PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// The pubsub topic
Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
// The data which will be published to topic.
Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
// The content type for the data (optional).
DataContentType string `protobuf:"bytes,4,opt,name=data_content_type,json=dataContentType,proto3" json:"data_content_type,omitempty"`
// The metadata passing to pub components
//
// metadata property:
// - key : the key of the message.
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *PublishEventRequest) Reset() {
*x = PublishEventRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PublishEventRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PublishEventRequest) ProtoMessage() {}
func (x *PublishEventRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[12]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PublishEventRequest.ProtoReflect.Descriptor instead.
func (*PublishEventRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{12}
}
func (x *PublishEventRequest) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *PublishEventRequest) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *PublishEventRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *PublishEventRequest) GetDataContentType() string {
if x != nil {
return x.DataContentType
}
return ""
}
func (x *PublishEventRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// BulkPublishRequest is the message to bulk publish events to pubsub topic
type BulkPublishRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the pubsub component
PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// The pubsub topic
Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
// The entries which contain the individual events and associated details to be published
Entries []*BulkPublishRequestEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries,omitempty"`
// The request level metadata passing to to the pubsub components
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkPublishRequest) Reset() {
*x = BulkPublishRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishRequest) ProtoMessage() {}
func (x *BulkPublishRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[13]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishRequest.ProtoReflect.Descriptor instead.
func (*BulkPublishRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{13}
}
func (x *BulkPublishRequest) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *BulkPublishRequest) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *BulkPublishRequest) GetEntries() []*BulkPublishRequestEntry {
if x != nil {
return x.Entries
}
return nil
}
func (x *BulkPublishRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// BulkPublishRequestEntry is the message containing the event to be bulk published
type BulkPublishRequestEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The request scoped unique ID referring to this message. Used to map status in response
EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"`
// The event which will be pulished to the topic
Event []byte `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"`
// The content type for the event
ContentType string `protobuf:"bytes,3,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"`
// The event level metadata passing to the pubsub component
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *BulkPublishRequestEntry) Reset() {
*x = BulkPublishRequestEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishRequestEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishRequestEntry) ProtoMessage() {}
func (x *BulkPublishRequestEntry) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[14]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishRequestEntry.ProtoReflect.Descriptor instead.
func (*BulkPublishRequestEntry) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{14}
}
func (x *BulkPublishRequestEntry) GetEntryId() string {
if x != nil {
return x.EntryId
}
return ""
}
func (x *BulkPublishRequestEntry) GetEvent() []byte {
if x != nil {
return x.Event
}
return nil
}
func (x *BulkPublishRequestEntry) GetContentType() string {
if x != nil {
return x.ContentType
}
return ""
}
func (x *BulkPublishRequestEntry) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// BulkPublishResponse is the message returned from a BulkPublishEvent call
type BulkPublishResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The entries for different events that failed publish in the BulkPublishEvent call
FailedEntries []*BulkPublishResponseFailedEntry `protobuf:"bytes,1,rep,name=failedEntries,proto3" json:"failedEntries,omitempty"`
}
func (x *BulkPublishResponse) Reset() {
*x = BulkPublishResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishResponse) ProtoMessage() {}
func (x *BulkPublishResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[15]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishResponse.ProtoReflect.Descriptor instead.
func (*BulkPublishResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{15}
}
func (x *BulkPublishResponse) GetFailedEntries() []*BulkPublishResponseFailedEntry {
if x != nil {
return x.FailedEntries
}
return nil
}
// BulkPublishResponseFailedEntry is the message containing the entryID and error of a failed event in BulkPublishEvent call
type BulkPublishResponseFailedEntry struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The response scoped unique ID referring to this message
EntryId string `protobuf:"bytes,1,opt,name=entry_id,json=entryId,proto3" json:"entry_id,omitempty"`
// The error message if any on failure
Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
}
func (x *BulkPublishResponseFailedEntry) Reset() {
*x = BulkPublishResponseFailedEntry{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BulkPublishResponseFailedEntry) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BulkPublishResponseFailedEntry) ProtoMessage() {}
func (x *BulkPublishResponseFailedEntry) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[16]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BulkPublishResponseFailedEntry.ProtoReflect.Descriptor instead.
func (*BulkPublishResponseFailedEntry) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{16}
}
func (x *BulkPublishResponseFailedEntry) GetEntryId() string {
if x != nil {
return x.EntryId
}
return ""
}
func (x *BulkPublishResponseFailedEntry) GetError() string {
if x != nil {
return x.Error
}
return ""
}
// 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 responses.
type SubscribeTopicEventsRequestAlpha1 struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Types that are assignable to SubscribeTopicEventsRequestType:
//
// *SubscribeTopicEventsRequestAlpha1_InitialRequest
// *SubscribeTopicEventsRequestAlpha1_EventResponse
SubscribeTopicEventsRequestType isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType `protobuf_oneof:"subscribe_topic_events_request_type"`
}
func (x *SubscribeTopicEventsRequestAlpha1) Reset() {
*x = SubscribeTopicEventsRequestAlpha1{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscribeTopicEventsRequestAlpha1) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscribeTopicEventsRequestAlpha1) ProtoMessage() {}
func (x *SubscribeTopicEventsRequestAlpha1) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscribeTopicEventsRequestAlpha1.ProtoReflect.Descriptor instead.
func (*SubscribeTopicEventsRequestAlpha1) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{17}
}
func (m *SubscribeTopicEventsRequestAlpha1) GetSubscribeTopicEventsRequestType() isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType {
if m != nil {
return m.SubscribeTopicEventsRequestType
}
return nil
}
func (x *SubscribeTopicEventsRequestAlpha1) GetInitialRequest() *SubscribeTopicEventsInitialRequestAlpha1 {
if x, ok := x.GetSubscribeTopicEventsRequestType().(*SubscribeTopicEventsRequestAlpha1_InitialRequest); ok {
return x.InitialRequest
}
return nil
}
func (x *SubscribeTopicEventsRequestAlpha1) GetEventResponse() *SubscribeTopicEventsResponseAlpha1 {
if x, ok := x.GetSubscribeTopicEventsRequestType().(*SubscribeTopicEventsRequestAlpha1_EventResponse); ok {
return x.EventResponse
}
return nil
}
type isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType interface {
isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType()
}
type SubscribeTopicEventsRequestAlpha1_InitialRequest struct {
InitialRequest *SubscribeTopicEventsInitialRequestAlpha1 `protobuf:"bytes,1,opt,name=initial_request,json=initialRequest,proto3,oneof"`
}
type SubscribeTopicEventsRequestAlpha1_EventResponse struct {
EventResponse *SubscribeTopicEventsResponseAlpha1 `protobuf:"bytes,2,opt,name=event_response,json=eventResponse,proto3,oneof"`
}
func (*SubscribeTopicEventsRequestAlpha1_InitialRequest) isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType() {
}
func (*SubscribeTopicEventsRequestAlpha1_EventResponse) isSubscribeTopicEventsRequestAlpha1_SubscribeTopicEventsRequestType() {
}
// SubscribeTopicEventsInitialRequestAlpha1 is the initial message containing the
// details for subscribing to a topic via streaming.
type SubscribeTopicEventsInitialRequestAlpha1 struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the pubsub component
PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubName,proto3" json:"pubsub_name,omitempty"`
// The pubsub topic
Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
// The metadata passing to pub components
//
// metadata property:
// - key : the key of the message.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// dead_letter_topic is the topic to which messages that fail to be processed
// are sent.
DeadLetterTopic *string `protobuf:"bytes,4,opt,name=dead_letter_topic,json=deadLetterTopic,proto3,oneof" json:"dead_letter_topic,omitempty"`
}
func (x *SubscribeTopicEventsInitialRequestAlpha1) Reset() {
*x = SubscribeTopicEventsInitialRequestAlpha1{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscribeTopicEventsInitialRequestAlpha1) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscribeTopicEventsInitialRequestAlpha1) ProtoMessage() {}
func (x *SubscribeTopicEventsInitialRequestAlpha1) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscribeTopicEventsInitialRequestAlpha1.ProtoReflect.Descriptor instead.
func (*SubscribeTopicEventsInitialRequestAlpha1) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{18}
}
func (x *SubscribeTopicEventsInitialRequestAlpha1) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *SubscribeTopicEventsInitialRequestAlpha1) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *SubscribeTopicEventsInitialRequestAlpha1) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *SubscribeTopicEventsInitialRequestAlpha1) GetDeadLetterTopic() string {
if x != nil && x.DeadLetterTopic != nil {
return *x.DeadLetterTopic
}
return ""
}
// SubscribeTopicEventsResponseAlpha1 is a message containing the result of a
// subscription to a topic.
type SubscribeTopicEventsResponseAlpha1 struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// id is the unique identifier for the subscription request.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// status is the result of the subscription request.
Status *TopicEventResponse `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
}
func (x *SubscribeTopicEventsResponseAlpha1) Reset() {
*x = SubscribeTopicEventsResponseAlpha1{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscribeTopicEventsResponseAlpha1) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscribeTopicEventsResponseAlpha1) ProtoMessage() {}
func (x *SubscribeTopicEventsResponseAlpha1) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[19]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscribeTopicEventsResponseAlpha1.ProtoReflect.Descriptor instead.
func (*SubscribeTopicEventsResponseAlpha1) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{19}
}
func (x *SubscribeTopicEventsResponseAlpha1) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *SubscribeTopicEventsResponseAlpha1) GetStatus() *TopicEventResponse {
if x != nil {
return x.Status
}
return nil
}
// InvokeBindingRequest is the message to send data to output bindings
type InvokeBindingRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of the output binding to invoke.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// The data which will be sent to output binding.
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
// 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.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// The name of the operation type for the binding to invoke
Operation string `protobuf:"bytes,4,opt,name=operation,proto3" json:"operation,omitempty"`
}
func (x *InvokeBindingRequest) Reset() {
*x = InvokeBindingRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeBindingRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeBindingRequest) ProtoMessage() {}
func (x *InvokeBindingRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[20]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeBindingRequest.ProtoReflect.Descriptor instead.
func (*InvokeBindingRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{20}
}
func (x *InvokeBindingRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *InvokeBindingRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeBindingRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *InvokeBindingRequest) GetOperation() string {
if x != nil {
return x.Operation
}
return ""
}
// InvokeBindingResponse is the message returned from an output binding invocation
type InvokeBindingResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The data which will be sent to output binding.
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The metadata returned from an external system
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *InvokeBindingResponse) Reset() {
*x = InvokeBindingResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeBindingResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeBindingResponse) ProtoMessage() {}
func (x *InvokeBindingResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[21]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeBindingResponse.ProtoReflect.Descriptor instead.
func (*InvokeBindingResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{21}
}
func (x *InvokeBindingResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeBindingResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// GetSecretRequest is the message to get secret from secret store.
type GetSecretRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of secret store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The name of secret key.
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
// The metadata which will be sent to secret store components.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSecretRequest) Reset() {
*x = GetSecretRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSecretRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSecretRequest) ProtoMessage() {}
func (x *GetSecretRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[22]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSecretRequest.ProtoReflect.Descriptor instead.
func (*GetSecretRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{22}
}
func (x *GetSecretRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *GetSecretRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *GetSecretRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// GetSecretResponse is the response message to convey the requested secret.
type GetSecretResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// data is the secret value. Some secret store, such as kubernetes secret
// store, can save multiple secrets for single secret key.
Data map[string]string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetSecretResponse) Reset() {
*x = GetSecretResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetSecretResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetSecretResponse) ProtoMessage() {}
func (x *GetSecretResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[23]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetSecretResponse.ProtoReflect.Descriptor instead.
func (*GetSecretResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{23}
}
func (x *GetSecretResponse) GetData() map[string]string {
if x != nil {
return x.Data
}
return nil
}
// GetBulkSecretRequest is the message to get the secrets from secret store.
type GetBulkSecretRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of secret store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The metadata which will be sent to secret store components.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetBulkSecretRequest) Reset() {
*x = GetBulkSecretRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetBulkSecretRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetBulkSecretRequest) ProtoMessage() {}
func (x *GetBulkSecretRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[24]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetBulkSecretRequest.ProtoReflect.Descriptor instead.
func (*GetBulkSecretRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{24}
}
func (x *GetBulkSecretRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *GetBulkSecretRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// SecretResponse is a map of decrypted string/string values
type SecretResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Secrets map[string]string `protobuf:"bytes,1,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *SecretResponse) Reset() {
*x = SecretResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SecretResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SecretResponse) ProtoMessage() {}
func (x *SecretResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[25]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SecretResponse.ProtoReflect.Descriptor instead.
func (*SecretResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{25}
}
func (x *SecretResponse) GetSecrets() map[string]string {
if x != nil {
return x.Secrets
}
return nil
}
// GetBulkSecretResponse is the response message to convey the requested secrets.
type GetBulkSecretResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// data hold the secret values. Some secret store, such as kubernetes secret
// store, can save multiple secrets for single secret key.
Data map[string]*SecretResponse `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetBulkSecretResponse) Reset() {
*x = GetBulkSecretResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetBulkSecretResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetBulkSecretResponse) ProtoMessage() {}
func (x *GetBulkSecretResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[26]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetBulkSecretResponse.ProtoReflect.Descriptor instead.
func (*GetBulkSecretResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{26}
}
func (x *GetBulkSecretResponse) GetData() map[string]*SecretResponse {
if x != nil {
return x.Data
}
return nil
}
// TransactionalStateOperation is the message to execute a specified operation with a key-value pair.
type TransactionalStateOperation struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The type of operation to be executed
OperationType string `protobuf:"bytes,1,opt,name=operationType,proto3" json:"operationType,omitempty"`
// State values to be operated on
Request *v1.StateItem `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
}
func (x *TransactionalStateOperation) Reset() {
*x = TransactionalStateOperation{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[27]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TransactionalStateOperation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransactionalStateOperation) ProtoMessage() {}
func (x *TransactionalStateOperation) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[27]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransactionalStateOperation.ProtoReflect.Descriptor instead.
func (*TransactionalStateOperation) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{27}
}
func (x *TransactionalStateOperation) GetOperationType() string {
if x != nil {
return x.OperationType
}
return ""
}
func (x *TransactionalStateOperation) GetRequest() *v1.StateItem {
if x != nil {
return x.Request
}
return nil
}
// ExecuteStateTransactionRequest is the message to execute multiple operations on a specified store.
type ExecuteStateTransactionRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. name of state store.
StoreName string `protobuf:"bytes,1,opt,name=storeName,proto3" json:"storeName,omitempty"`
// Required. transactional operation list.
Operations []*TransactionalStateOperation `protobuf:"bytes,2,rep,name=operations,proto3" json:"operations,omitempty"`
// The metadata used for transactional operations.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *ExecuteStateTransactionRequest) Reset() {
*x = ExecuteStateTransactionRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[28]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ExecuteStateTransactionRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ExecuteStateTransactionRequest) ProtoMessage() {}
func (x *ExecuteStateTransactionRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[28]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ExecuteStateTransactionRequest.ProtoReflect.Descriptor instead.
func (*ExecuteStateTransactionRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{28}
}
func (x *ExecuteStateTransactionRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *ExecuteStateTransactionRequest) GetOperations() []*TransactionalStateOperation {
if x != nil {
return x.Operations
}
return nil
}
func (x *ExecuteStateTransactionRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// RegisterActorTimerRequest is the message to register a timer for an actor of a given type and id.
type RegisterActorTimerRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
DueTime string `protobuf:"bytes,4,opt,name=due_time,json=dueTime,proto3" json:"due_time,omitempty"`
Period string `protobuf:"bytes,5,opt,name=period,proto3" json:"period,omitempty"`
Callback string `protobuf:"bytes,6,opt,name=callback,proto3" json:"callback,omitempty"`
Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"`
Ttl string `protobuf:"bytes,8,opt,name=ttl,proto3" json:"ttl,omitempty"`
}
func (x *RegisterActorTimerRequest) Reset() {
*x = RegisterActorTimerRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RegisterActorTimerRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RegisterActorTimerRequest) ProtoMessage() {}
func (x *RegisterActorTimerRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[29]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RegisterActorTimerRequest.ProtoReflect.Descriptor instead.
func (*RegisterActorTimerRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{29}
}
func (x *RegisterActorTimerRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *RegisterActorTimerRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *RegisterActorTimerRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *RegisterActorTimerRequest) GetDueTime() string {
if x != nil {
return x.DueTime
}
return ""
}
func (x *RegisterActorTimerRequest) GetPeriod() string {
if x != nil {
return x.Period
}
return ""
}
func (x *RegisterActorTimerRequest) GetCallback() string {
if x != nil {
return x.Callback
}
return ""
}
func (x *RegisterActorTimerRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *RegisterActorTimerRequest) GetTtl() string {
if x != nil {
return x.Ttl
}
return ""
}
// UnregisterActorTimerRequest is the message to unregister an actor timer
type UnregisterActorTimerRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}
func (x *UnregisterActorTimerRequest) Reset() {
*x = UnregisterActorTimerRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UnregisterActorTimerRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UnregisterActorTimerRequest) ProtoMessage() {}
func (x *UnregisterActorTimerRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[30]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UnregisterActorTimerRequest.ProtoReflect.Descriptor instead.
func (*UnregisterActorTimerRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{30}
}
func (x *UnregisterActorTimerRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *UnregisterActorTimerRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *UnregisterActorTimerRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
// RegisterActorReminderRequest is the message to register a reminder for an actor of a given type and id.
type RegisterActorReminderRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
DueTime string `protobuf:"bytes,4,opt,name=due_time,json=dueTime,proto3" json:"due_time,omitempty"`
Period string `protobuf:"bytes,5,opt,name=period,proto3" json:"period,omitempty"`
Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"`
Ttl string `protobuf:"bytes,7,opt,name=ttl,proto3" json:"ttl,omitempty"`
}
func (x *RegisterActorReminderRequest) Reset() {
*x = RegisterActorReminderRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[31]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RegisterActorReminderRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RegisterActorReminderRequest) ProtoMessage() {}
func (x *RegisterActorReminderRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[31]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RegisterActorReminderRequest.ProtoReflect.Descriptor instead.
func (*RegisterActorReminderRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{31}
}
func (x *RegisterActorReminderRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *RegisterActorReminderRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *RegisterActorReminderRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *RegisterActorReminderRequest) GetDueTime() string {
if x != nil {
return x.DueTime
}
return ""
}
func (x *RegisterActorReminderRequest) GetPeriod() string {
if x != nil {
return x.Period
}
return ""
}
func (x *RegisterActorReminderRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *RegisterActorReminderRequest) GetTtl() string {
if x != nil {
return x.Ttl
}
return ""
}
// UnregisterActorReminderRequest is the message to unregister an actor reminder.
type UnregisterActorReminderRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}
func (x *UnregisterActorReminderRequest) Reset() {
*x = UnregisterActorReminderRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[32]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UnregisterActorReminderRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UnregisterActorReminderRequest) ProtoMessage() {}
func (x *UnregisterActorReminderRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[32]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UnregisterActorReminderRequest.ProtoReflect.Descriptor instead.
func (*UnregisterActorReminderRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{32}
}
func (x *UnregisterActorReminderRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *UnregisterActorReminderRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *UnregisterActorReminderRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
// GetActorStateRequest is the message to get key-value states from specific actor.
type GetActorStateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Key string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
}
func (x *GetActorStateRequest) Reset() {
*x = GetActorStateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[33]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetActorStateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetActorStateRequest) ProtoMessage() {}
func (x *GetActorStateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[33]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetActorStateRequest.ProtoReflect.Descriptor instead.
func (*GetActorStateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{33}
}
func (x *GetActorStateRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *GetActorStateRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *GetActorStateRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
// GetActorStateResponse is the response conveying the actor's state value.
type GetActorStateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
// The metadata which will be sent to app.
Metadata map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetActorStateResponse) Reset() {
*x = GetActorStateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[34]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetActorStateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetActorStateResponse) ProtoMessage() {}
func (x *GetActorStateResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[34]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetActorStateResponse.ProtoReflect.Descriptor instead.
func (*GetActorStateResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{34}
}
func (x *GetActorStateResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *GetActorStateResponse) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// ExecuteActorStateTransactionRequest is the message to execute multiple operations on a specified actor.
type ExecuteActorStateTransactionRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Operations []*TransactionalActorStateOperation `protobuf:"bytes,3,rep,name=operations,proto3" json:"operations,omitempty"`
}
func (x *ExecuteActorStateTransactionRequest) Reset() {
*x = ExecuteActorStateTransactionRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[35]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ExecuteActorStateTransactionRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ExecuteActorStateTransactionRequest) ProtoMessage() {}
func (x *ExecuteActorStateTransactionRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[35]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ExecuteActorStateTransactionRequest.ProtoReflect.Descriptor instead.
func (*ExecuteActorStateTransactionRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{35}
}
func (x *ExecuteActorStateTransactionRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *ExecuteActorStateTransactionRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *ExecuteActorStateTransactionRequest) GetOperations() []*TransactionalActorStateOperation {
if x != nil {
return x.Operations
}
return nil
}
// TransactionalActorStateOperation is the message to execute a specified operation with a key-value pair.
type TransactionalActorStateOperation struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
OperationType string `protobuf:"bytes,1,opt,name=operationType,proto3" json:"operationType,omitempty"`
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
Value *anypb.Any `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
// The metadata used for transactional operations.
//
// Common metadata property:
// - ttlInSeconds : the time to live in seconds for the stored value.
Metadata map[string]string `protobuf:"bytes,4,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *TransactionalActorStateOperation) Reset() {
*x = TransactionalActorStateOperation{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[36]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TransactionalActorStateOperation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransactionalActorStateOperation) ProtoMessage() {}
func (x *TransactionalActorStateOperation) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[36]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransactionalActorStateOperation.ProtoReflect.Descriptor instead.
func (*TransactionalActorStateOperation) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{36}
}
func (x *TransactionalActorStateOperation) GetOperationType() string {
if x != nil {
return x.OperationType
}
return ""
}
func (x *TransactionalActorStateOperation) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *TransactionalActorStateOperation) GetValue() *anypb.Any {
if x != nil {
return x.Value
}
return nil
}
func (x *TransactionalActorStateOperation) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// InvokeActorRequest is the message to call an actor.
type InvokeActorRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ActorType string `protobuf:"bytes,1,opt,name=actor_type,json=actorType,proto3" json:"actor_type,omitempty"`
ActorId string `protobuf:"bytes,2,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"`
Method string `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"`
Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
Metadata map[string]string `protobuf:"bytes,5,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *InvokeActorRequest) Reset() {
*x = InvokeActorRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[37]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeActorRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeActorRequest) ProtoMessage() {}
func (x *InvokeActorRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[37]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeActorRequest.ProtoReflect.Descriptor instead.
func (*InvokeActorRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{37}
}
func (x *InvokeActorRequest) GetActorType() string {
if x != nil {
return x.ActorType
}
return ""
}
func (x *InvokeActorRequest) GetActorId() string {
if x != nil {
return x.ActorId
}
return ""
}
func (x *InvokeActorRequest) GetMethod() string {
if x != nil {
return x.Method
}
return ""
}
func (x *InvokeActorRequest) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
func (x *InvokeActorRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// InvokeActorResponse is the method that returns an actor invocation response.
type InvokeActorResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}
func (x *InvokeActorResponse) Reset() {
*x = InvokeActorResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[38]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *InvokeActorResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*InvokeActorResponse) ProtoMessage() {}
func (x *InvokeActorResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[38]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use InvokeActorResponse.ProtoReflect.Descriptor instead.
func (*InvokeActorResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{38}
}
func (x *InvokeActorResponse) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
// GetMetadataRequest is the message for the GetMetadata request.
type GetMetadataRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *GetMetadataRequest) Reset() {
*x = GetMetadataRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[39]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetMetadataRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetMetadataRequest) ProtoMessage() {}
func (x *GetMetadataRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[39]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetMetadataRequest.ProtoReflect.Descriptor instead.
func (*GetMetadataRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{39}
}
// GetMetadataResponse is a message that is returned on GetMetadata rpc call.
type GetMetadataResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// Deprecated alias for actor_runtime.active_actors.
//
// Deprecated: Marked as deprecated in dapr/proto/runtime/v1/dapr.proto.
ActiveActorsCount []*ActiveActorsCount `protobuf:"bytes,2,rep,name=active_actors_count,json=actors,proto3" json:"active_actors_count,omitempty"`
RegisteredComponents []*RegisteredComponents `protobuf:"bytes,3,rep,name=registered_components,json=components,proto3" json:"registered_components,omitempty"`
ExtendedMetadata map[string]string `protobuf:"bytes,4,rep,name=extended_metadata,json=extended,proto3" json:"extended_metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Subscriptions []*PubsubSubscription `protobuf:"bytes,5,rep,name=subscriptions,proto3" json:"subscriptions,omitempty"`
HttpEndpoints []*MetadataHTTPEndpoint `protobuf:"bytes,6,rep,name=http_endpoints,json=httpEndpoints,proto3" json:"http_endpoints,omitempty"`
AppConnectionProperties *AppConnectionProperties `protobuf:"bytes,7,opt,name=app_connection_properties,json=appConnectionProperties,proto3" json:"app_connection_properties,omitempty"`
RuntimeVersion string `protobuf:"bytes,8,opt,name=runtime_version,json=runtimeVersion,proto3" json:"runtime_version,omitempty"`
EnabledFeatures []string `protobuf:"bytes,9,rep,name=enabled_features,json=enabledFeatures,proto3" json:"enabled_features,omitempty"`
ActorRuntime *ActorRuntime `protobuf:"bytes,10,opt,name=actor_runtime,json=actorRuntime,proto3" json:"actor_runtime,omitempty"`
}
func (x *GetMetadataResponse) Reset() {
*x = GetMetadataResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[40]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetMetadataResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetMetadataResponse) ProtoMessage() {}
func (x *GetMetadataResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[40]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetMetadataResponse.ProtoReflect.Descriptor instead.
func (*GetMetadataResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{40}
}
func (x *GetMetadataResponse) GetId() string {
if x != nil {
return x.Id
}
return ""
}
// Deprecated: Marked as deprecated in dapr/proto/runtime/v1/dapr.proto.
func (x *GetMetadataResponse) GetActiveActorsCount() []*ActiveActorsCount {
if x != nil {
return x.ActiveActorsCount
}
return nil
}
func (x *GetMetadataResponse) GetRegisteredComponents() []*RegisteredComponents {
if x != nil {
return x.RegisteredComponents
}
return nil
}
func (x *GetMetadataResponse) GetExtendedMetadata() map[string]string {
if x != nil {
return x.ExtendedMetadata
}
return nil
}
func (x *GetMetadataResponse) GetSubscriptions() []*PubsubSubscription {
if x != nil {
return x.Subscriptions
}
return nil
}
func (x *GetMetadataResponse) GetHttpEndpoints() []*MetadataHTTPEndpoint {
if x != nil {
return x.HttpEndpoints
}
return nil
}
func (x *GetMetadataResponse) GetAppConnectionProperties() *AppConnectionProperties {
if x != nil {
return x.AppConnectionProperties
}
return nil
}
func (x *GetMetadataResponse) GetRuntimeVersion() string {
if x != nil {
return x.RuntimeVersion
}
return ""
}
func (x *GetMetadataResponse) GetEnabledFeatures() []string {
if x != nil {
return x.EnabledFeatures
}
return nil
}
func (x *GetMetadataResponse) GetActorRuntime() *ActorRuntime {
if x != nil {
return x.ActorRuntime
}
return nil
}
type ActorRuntime struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Contains an enum indicating whether the actor runtime has been initialized.
RuntimeStatus ActorRuntime_ActorRuntimeStatus `protobuf:"varint,1,opt,name=runtime_status,json=runtimeStatus,proto3,enum=dapr.proto.runtime.v1.ActorRuntime_ActorRuntimeStatus" json:"runtime_status,omitempty"`
// Count of active actors per type.
ActiveActors []*ActiveActorsCount `protobuf:"bytes,2,rep,name=active_actors,json=activeActors,proto3" json:"active_actors,omitempty"`
// Indicates whether the actor runtime is ready to host actors.
HostReady bool `protobuf:"varint,3,opt,name=host_ready,json=hostReady,proto3" json:"host_ready,omitempty"`
// Custom message from the placement provider.
Placement string `protobuf:"bytes,4,opt,name=placement,proto3" json:"placement,omitempty"`
}
func (x *ActorRuntime) Reset() {
*x = ActorRuntime{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[41]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ActorRuntime) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ActorRuntime) ProtoMessage() {}
func (x *ActorRuntime) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[41]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ActorRuntime.ProtoReflect.Descriptor instead.
func (*ActorRuntime) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{41}
}
func (x *ActorRuntime) GetRuntimeStatus() ActorRuntime_ActorRuntimeStatus {
if x != nil {
return x.RuntimeStatus
}
return ActorRuntime_INITIALIZING
}
func (x *ActorRuntime) GetActiveActors() []*ActiveActorsCount {
if x != nil {
return x.ActiveActors
}
return nil
}
func (x *ActorRuntime) GetHostReady() bool {
if x != nil {
return x.HostReady
}
return false
}
func (x *ActorRuntime) GetPlacement() string {
if x != nil {
return x.Placement
}
return ""
}
type ActiveActorsCount struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
}
func (x *ActiveActorsCount) Reset() {
*x = ActiveActorsCount{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[42]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ActiveActorsCount) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ActiveActorsCount) ProtoMessage() {}
func (x *ActiveActorsCount) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[42]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ActiveActorsCount.ProtoReflect.Descriptor instead.
func (*ActiveActorsCount) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{42}
}
func (x *ActiveActorsCount) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *ActiveActorsCount) GetCount() int32 {
if x != nil {
return x.Count
}
return 0
}
type RegisteredComponents struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
Capabilities []string `protobuf:"bytes,4,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
}
func (x *RegisteredComponents) Reset() {
*x = RegisteredComponents{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[43]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RegisteredComponents) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RegisteredComponents) ProtoMessage() {}
func (x *RegisteredComponents) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[43]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RegisteredComponents.ProtoReflect.Descriptor instead.
func (*RegisteredComponents) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{43}
}
func (x *RegisteredComponents) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *RegisteredComponents) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *RegisteredComponents) GetVersion() string {
if x != nil {
return x.Version
}
return ""
}
func (x *RegisteredComponents) GetCapabilities() []string {
if x != nil {
return x.Capabilities
}
return nil
}
type MetadataHTTPEndpoint struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}
func (x *MetadataHTTPEndpoint) Reset() {
*x = MetadataHTTPEndpoint{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[44]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *MetadataHTTPEndpoint) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MetadataHTTPEndpoint) ProtoMessage() {}
func (x *MetadataHTTPEndpoint) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[44]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MetadataHTTPEndpoint.ProtoReflect.Descriptor instead.
func (*MetadataHTTPEndpoint) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{44}
}
func (x *MetadataHTTPEndpoint) GetName() string {
if x != nil {
return x.Name
}
return ""
}
type AppConnectionProperties struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Port int32 `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
Protocol string `protobuf:"bytes,2,opt,name=protocol,proto3" json:"protocol,omitempty"`
ChannelAddress string `protobuf:"bytes,3,opt,name=channel_address,json=channelAddress,proto3" json:"channel_address,omitempty"`
MaxConcurrency int32 `protobuf:"varint,4,opt,name=max_concurrency,json=maxConcurrency,proto3" json:"max_concurrency,omitempty"`
Health *AppConnectionHealthProperties `protobuf:"bytes,5,opt,name=health,proto3" json:"health,omitempty"`
}
func (x *AppConnectionProperties) Reset() {
*x = AppConnectionProperties{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[45]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AppConnectionProperties) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AppConnectionProperties) ProtoMessage() {}
func (x *AppConnectionProperties) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[45]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AppConnectionProperties.ProtoReflect.Descriptor instead.
func (*AppConnectionProperties) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{45}
}
func (x *AppConnectionProperties) GetPort() int32 {
if x != nil {
return x.Port
}
return 0
}
func (x *AppConnectionProperties) GetProtocol() string {
if x != nil {
return x.Protocol
}
return ""
}
func (x *AppConnectionProperties) GetChannelAddress() string {
if x != nil {
return x.ChannelAddress
}
return ""
}
func (x *AppConnectionProperties) GetMaxConcurrency() int32 {
if x != nil {
return x.MaxConcurrency
}
return 0
}
func (x *AppConnectionProperties) GetHealth() *AppConnectionHealthProperties {
if x != nil {
return x.Health
}
return nil
}
type AppConnectionHealthProperties struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
HealthCheckPath string `protobuf:"bytes,1,opt,name=health_check_path,json=healthCheckPath,proto3" json:"health_check_path,omitempty"`
HealthProbeInterval string `protobuf:"bytes,2,opt,name=health_probe_interval,json=healthProbeInterval,proto3" json:"health_probe_interval,omitempty"`
HealthProbeTimeout string `protobuf:"bytes,3,opt,name=health_probe_timeout,json=healthProbeTimeout,proto3" json:"health_probe_timeout,omitempty"`
HealthThreshold int32 `protobuf:"varint,4,opt,name=health_threshold,json=healthThreshold,proto3" json:"health_threshold,omitempty"`
}
func (x *AppConnectionHealthProperties) Reset() {
*x = AppConnectionHealthProperties{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[46]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *AppConnectionHealthProperties) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*AppConnectionHealthProperties) ProtoMessage() {}
func (x *AppConnectionHealthProperties) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[46]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use AppConnectionHealthProperties.ProtoReflect.Descriptor instead.
func (*AppConnectionHealthProperties) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{46}
}
func (x *AppConnectionHealthProperties) GetHealthCheckPath() string {
if x != nil {
return x.HealthCheckPath
}
return ""
}
func (x *AppConnectionHealthProperties) GetHealthProbeInterval() string {
if x != nil {
return x.HealthProbeInterval
}
return ""
}
func (x *AppConnectionHealthProperties) GetHealthProbeTimeout() string {
if x != nil {
return x.HealthProbeTimeout
}
return ""
}
func (x *AppConnectionHealthProperties) GetHealthThreshold() int32 {
if x != nil {
return x.HealthThreshold
}
return 0
}
type PubsubSubscription struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
PubsubName string `protobuf:"bytes,1,opt,name=pubsub_name,json=pubsubname,proto3" json:"pubsub_name,omitempty"`
Topic string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
Rules *PubsubSubscriptionRules `protobuf:"bytes,4,opt,name=rules,proto3" json:"rules,omitempty"`
DeadLetterTopic string `protobuf:"bytes,5,opt,name=dead_letter_topic,json=deadLetterTopic,proto3" json:"dead_letter_topic,omitempty"`
}
func (x *PubsubSubscription) Reset() {
*x = PubsubSubscription{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[47]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PubsubSubscription) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PubsubSubscription) ProtoMessage() {}
func (x *PubsubSubscription) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[47]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PubsubSubscription.ProtoReflect.Descriptor instead.
func (*PubsubSubscription) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{47}
}
func (x *PubsubSubscription) GetPubsubName() string {
if x != nil {
return x.PubsubName
}
return ""
}
func (x *PubsubSubscription) GetTopic() string {
if x != nil {
return x.Topic
}
return ""
}
func (x *PubsubSubscription) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
func (x *PubsubSubscription) GetRules() *PubsubSubscriptionRules {
if x != nil {
return x.Rules
}
return nil
}
func (x *PubsubSubscription) GetDeadLetterTopic() string {
if x != nil {
return x.DeadLetterTopic
}
return ""
}
type PubsubSubscriptionRules struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Rules []*PubsubSubscriptionRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
}
func (x *PubsubSubscriptionRules) Reset() {
*x = PubsubSubscriptionRules{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[48]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PubsubSubscriptionRules) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PubsubSubscriptionRules) ProtoMessage() {}
func (x *PubsubSubscriptionRules) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[48]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PubsubSubscriptionRules.ProtoReflect.Descriptor instead.
func (*PubsubSubscriptionRules) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{48}
}
func (x *PubsubSubscriptionRules) GetRules() []*PubsubSubscriptionRule {
if x != nil {
return x.Rules
}
return nil
}
type PubsubSubscriptionRule struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Match string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
}
func (x *PubsubSubscriptionRule) Reset() {
*x = PubsubSubscriptionRule{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[49]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PubsubSubscriptionRule) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PubsubSubscriptionRule) ProtoMessage() {}
func (x *PubsubSubscriptionRule) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[49]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PubsubSubscriptionRule.ProtoReflect.Descriptor instead.
func (*PubsubSubscriptionRule) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{49}
}
func (x *PubsubSubscriptionRule) GetMatch() string {
if x != nil {
return x.Match
}
return ""
}
func (x *PubsubSubscriptionRule) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
type SetMetadataRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}
func (x *SetMetadataRequest) Reset() {
*x = SetMetadataRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[50]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SetMetadataRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SetMetadataRequest) ProtoMessage() {}
func (x *SetMetadataRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[50]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SetMetadataRequest.ProtoReflect.Descriptor instead.
func (*SetMetadataRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{50}
}
func (x *SetMetadataRequest) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *SetMetadataRequest) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
// GetConfigurationRequest is the message to get a list of key-value configuration from specified configuration store.
type GetConfigurationRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The name of configuration store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// Optional. The key of the configuration item to fetch.
// If set, only query for the specified configuration items.
// Empty list means fetch all.
Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"`
// Optional. The metadata which will be sent to configuration store components.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetConfigurationRequest) Reset() {
*x = GetConfigurationRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[51]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetConfigurationRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetConfigurationRequest) ProtoMessage() {}
func (x *GetConfigurationRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[51]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetConfigurationRequest.ProtoReflect.Descriptor instead.
func (*GetConfigurationRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{51}
}
func (x *GetConfigurationRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *GetConfigurationRequest) GetKeys() []string {
if x != nil {
return x.Keys
}
return nil
}
func (x *GetConfigurationRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// 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.
type GetConfigurationResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Items map[string]*v1.ConfigurationItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetConfigurationResponse) Reset() {
*x = GetConfigurationResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[52]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetConfigurationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetConfigurationResponse) ProtoMessage() {}
func (x *GetConfigurationResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[52]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetConfigurationResponse.ProtoReflect.Descriptor instead.
func (*GetConfigurationResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{52}
}
func (x *GetConfigurationResponse) GetItems() map[string]*v1.ConfigurationItem {
if x != nil {
return x.Items
}
return nil
}
// SubscribeConfigurationRequest is the message to get a list of key-value configuration from specified configuration store.
type SubscribeConfigurationRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of configuration store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// Optional. The key of the configuration item to fetch.
// If set, only query for the specified configuration items.
// Empty list means fetch all.
Keys []string `protobuf:"bytes,2,rep,name=keys,proto3" json:"keys,omitempty"`
// The metadata which will be sent to configuration store components.
Metadata map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *SubscribeConfigurationRequest) Reset() {
*x = SubscribeConfigurationRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[53]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscribeConfigurationRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscribeConfigurationRequest) ProtoMessage() {}
func (x *SubscribeConfigurationRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[53]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscribeConfigurationRequest.ProtoReflect.Descriptor instead.
func (*SubscribeConfigurationRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{53}
}
func (x *SubscribeConfigurationRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *SubscribeConfigurationRequest) GetKeys() []string {
if x != nil {
return x.Keys
}
return nil
}
func (x *SubscribeConfigurationRequest) GetMetadata() map[string]string {
if x != nil {
return x.Metadata
}
return nil
}
// UnSubscribeConfigurationRequest is the message to stop watching the key-value configuration.
type UnsubscribeConfigurationRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The name of configuration store.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// The id to unsubscribe.
Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}
func (x *UnsubscribeConfigurationRequest) Reset() {
*x = UnsubscribeConfigurationRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[54]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UnsubscribeConfigurationRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UnsubscribeConfigurationRequest) ProtoMessage() {}
func (x *UnsubscribeConfigurationRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[54]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UnsubscribeConfigurationRequest.ProtoReflect.Descriptor instead.
func (*UnsubscribeConfigurationRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{54}
}
func (x *UnsubscribeConfigurationRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *UnsubscribeConfigurationRequest) GetId() string {
if x != nil {
return x.Id
}
return ""
}
type SubscribeConfigurationResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Subscribe id, used to stop subscription.
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// The list of items containing configuration values
Items map[string]*v1.ConfigurationItem `protobuf:"bytes,2,rep,name=items,proto3" json:"items,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *SubscribeConfigurationResponse) Reset() {
*x = SubscribeConfigurationResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[55]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubscribeConfigurationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubscribeConfigurationResponse) ProtoMessage() {}
func (x *SubscribeConfigurationResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[55]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubscribeConfigurationResponse.ProtoReflect.Descriptor instead.
func (*SubscribeConfigurationResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{55}
}
func (x *SubscribeConfigurationResponse) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *SubscribeConfigurationResponse) GetItems() map[string]*v1.ConfigurationItem {
if x != nil {
return x.Items
}
return nil
}
type UnsubscribeConfigurationResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
}
func (x *UnsubscribeConfigurationResponse) Reset() {
*x = UnsubscribeConfigurationResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[56]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UnsubscribeConfigurationResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UnsubscribeConfigurationResponse) ProtoMessage() {}
func (x *UnsubscribeConfigurationResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[56]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UnsubscribeConfigurationResponse.ProtoReflect.Descriptor instead.
func (*UnsubscribeConfigurationResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{56}
}
func (x *UnsubscribeConfigurationResponse) GetOk() bool {
if x != nil {
return x.Ok
}
return false
}
func (x *UnsubscribeConfigurationResponse) GetMessage() string {
if x != nil {
return x.Message
}
return ""
}
type TryLockRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The lock store name,e.g. `redis`.
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// Required. resource_id is the lock key. e.g. `order_id_111`
// It stands for "which resource I want to protect"
ResourceId string `protobuf:"bytes,2,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
// 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.
LockOwner string `protobuf:"bytes,3,opt,name=lock_owner,json=lockOwner,proto3" json:"lock_owner,omitempty"`
// Required. The time before expiry.The time unit is second.
ExpiryInSeconds int32 `protobuf:"varint,4,opt,name=expiry_in_seconds,json=expiryInSeconds,proto3" json:"expiry_in_seconds,omitempty"`
}
func (x *TryLockRequest) Reset() {
*x = TryLockRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[57]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TryLockRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TryLockRequest) ProtoMessage() {}
func (x *TryLockRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[57]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TryLockRequest.ProtoReflect.Descriptor instead.
func (*TryLockRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{57}
}
func (x *TryLockRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *TryLockRequest) GetResourceId() string {
if x != nil {
return x.ResourceId
}
return ""
}
func (x *TryLockRequest) GetLockOwner() string {
if x != nil {
return x.LockOwner
}
return ""
}
func (x *TryLockRequest) GetExpiryInSeconds() int32 {
if x != nil {
return x.ExpiryInSeconds
}
return 0
}
type TryLockResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
}
func (x *TryLockResponse) Reset() {
*x = TryLockResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[58]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TryLockResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TryLockResponse) ProtoMessage() {}
func (x *TryLockResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[58]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TryLockResponse.ProtoReflect.Descriptor instead.
func (*TryLockResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{58}
}
func (x *TryLockResponse) GetSuccess() bool {
if x != nil {
return x.Success
}
return false
}
type UnlockRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
StoreName string `protobuf:"bytes,1,opt,name=store_name,json=storeName,proto3" json:"store_name,omitempty"`
// resource_id is the lock key.
ResourceId string `protobuf:"bytes,2,opt,name=resource_id,json=resourceId,proto3" json:"resource_id,omitempty"`
LockOwner string `protobuf:"bytes,3,opt,name=lock_owner,json=lockOwner,proto3" json:"lock_owner,omitempty"`
}
func (x *UnlockRequest) Reset() {
*x = UnlockRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[59]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UnlockRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UnlockRequest) ProtoMessage() {}
func (x *UnlockRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[59]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UnlockRequest.ProtoReflect.Descriptor instead.
func (*UnlockRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{59}
}
func (x *UnlockRequest) GetStoreName() string {
if x != nil {
return x.StoreName
}
return ""
}
func (x *UnlockRequest) GetResourceId() string {
if x != nil {
return x.ResourceId
}
return ""
}
func (x *UnlockRequest) GetLockOwner() string {
if x != nil {
return x.LockOwner
}
return ""
}
type UnlockResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Status UnlockResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=dapr.proto.runtime.v1.UnlockResponse_Status" json:"status,omitempty"`
}
func (x *UnlockResponse) Reset() {
*x = UnlockResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[60]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *UnlockResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*UnlockResponse) ProtoMessage() {}
func (x *UnlockResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[60]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use UnlockResponse.ProtoReflect.Descriptor instead.
func (*UnlockResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{60}
}
func (x *UnlockResponse) GetStatus() UnlockResponse_Status {
if x != nil {
return x.Status
}
return UnlockResponse_SUCCESS
}
// SubtleGetKeyRequest is the request object for SubtleGetKeyAlpha1.
type SubtleGetKeyRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Name (or name/version) of the key to use in the key vault
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// Response format
Format SubtleGetKeyRequest_KeyFormat `protobuf:"varint,3,opt,name=format,proto3,enum=dapr.proto.runtime.v1.SubtleGetKeyRequest_KeyFormat" json:"format,omitempty"`
}
func (x *SubtleGetKeyRequest) Reset() {
*x = SubtleGetKeyRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[61]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleGetKeyRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleGetKeyRequest) ProtoMessage() {}
func (x *SubtleGetKeyRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[61]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleGetKeyRequest.ProtoReflect.Descriptor instead.
func (*SubtleGetKeyRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{61}
}
func (x *SubtleGetKeyRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleGetKeyRequest) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *SubtleGetKeyRequest) GetFormat() SubtleGetKeyRequest_KeyFormat {
if x != nil {
return x.Format
}
return SubtleGetKeyRequest_PEM
}
// SubtleGetKeyResponse is the response for SubtleGetKeyAlpha1.
type SubtleGetKeyResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name (or name/version) of the key.
// This is returned as response too in case there is a version.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Public key, encoded in the requested format
PublicKey string `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
}
func (x *SubtleGetKeyResponse) Reset() {
*x = SubtleGetKeyResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[62]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleGetKeyResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleGetKeyResponse) ProtoMessage() {}
func (x *SubtleGetKeyResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[62]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleGetKeyResponse.ProtoReflect.Descriptor instead.
func (*SubtleGetKeyResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{62}
}
func (x *SubtleGetKeyResponse) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *SubtleGetKeyResponse) GetPublicKey() string {
if x != nil {
return x.PublicKey
}
return ""
}
// SubtleEncryptRequest is the request for SubtleEncryptAlpha1.
type SubtleEncryptRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Message to encrypt.
Plaintext []byte `protobuf:"bytes,2,opt,name=plaintext,proto3" json:"plaintext,omitempty"`
// Algorithm to use, as in the JWA standard.
Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
// Name (or name/version) of the key.
KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
// Nonce / initialization vector.
// Ignored with asymmetric ciphers.
Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
// Associated Data when using AEAD ciphers (optional).
AssociatedData []byte `protobuf:"bytes,6,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"`
}
func (x *SubtleEncryptRequest) Reset() {
*x = SubtleEncryptRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[63]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleEncryptRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleEncryptRequest) ProtoMessage() {}
func (x *SubtleEncryptRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[63]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleEncryptRequest.ProtoReflect.Descriptor instead.
func (*SubtleEncryptRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{63}
}
func (x *SubtleEncryptRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleEncryptRequest) GetPlaintext() []byte {
if x != nil {
return x.Plaintext
}
return nil
}
func (x *SubtleEncryptRequest) GetAlgorithm() string {
if x != nil {
return x.Algorithm
}
return ""
}
func (x *SubtleEncryptRequest) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
func (x *SubtleEncryptRequest) GetNonce() []byte {
if x != nil {
return x.Nonce
}
return nil
}
func (x *SubtleEncryptRequest) GetAssociatedData() []byte {
if x != nil {
return x.AssociatedData
}
return nil
}
// SubtleEncryptResponse is the response for SubtleEncryptAlpha1.
type SubtleEncryptResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Encrypted ciphertext.
Ciphertext []byte `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"`
// Authentication tag.
// This is nil when not using an authenticated cipher.
Tag []byte `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
}
func (x *SubtleEncryptResponse) Reset() {
*x = SubtleEncryptResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[64]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleEncryptResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleEncryptResponse) ProtoMessage() {}
func (x *SubtleEncryptResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[64]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleEncryptResponse.ProtoReflect.Descriptor instead.
func (*SubtleEncryptResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{64}
}
func (x *SubtleEncryptResponse) GetCiphertext() []byte {
if x != nil {
return x.Ciphertext
}
return nil
}
func (x *SubtleEncryptResponse) GetTag() []byte {
if x != nil {
return x.Tag
}
return nil
}
// SubtleDecryptRequest is the request for SubtleDecryptAlpha1.
type SubtleDecryptRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Message to decrypt.
Ciphertext []byte `protobuf:"bytes,2,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"`
// Algorithm to use, as in the JWA standard.
Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
// Name (or name/version) of the key.
KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
// Nonce / initialization vector.
// Ignored with asymmetric ciphers.
Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
// Authentication tag.
// This is nil when not using an authenticated cipher.
Tag []byte `protobuf:"bytes,6,opt,name=tag,proto3" json:"tag,omitempty"`
// Associated Data when using AEAD ciphers (optional).
AssociatedData []byte `protobuf:"bytes,7,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"`
}
func (x *SubtleDecryptRequest) Reset() {
*x = SubtleDecryptRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[65]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleDecryptRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleDecryptRequest) ProtoMessage() {}
func (x *SubtleDecryptRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[65]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleDecryptRequest.ProtoReflect.Descriptor instead.
func (*SubtleDecryptRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{65}
}
func (x *SubtleDecryptRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleDecryptRequest) GetCiphertext() []byte {
if x != nil {
return x.Ciphertext
}
return nil
}
func (x *SubtleDecryptRequest) GetAlgorithm() string {
if x != nil {
return x.Algorithm
}
return ""
}
func (x *SubtleDecryptRequest) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
func (x *SubtleDecryptRequest) GetNonce() []byte {
if x != nil {
return x.Nonce
}
return nil
}
func (x *SubtleDecryptRequest) GetTag() []byte {
if x != nil {
return x.Tag
}
return nil
}
func (x *SubtleDecryptRequest) GetAssociatedData() []byte {
if x != nil {
return x.AssociatedData
}
return nil
}
// SubtleDecryptResponse is the response for SubtleDecryptAlpha1.
type SubtleDecryptResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Decrypted plaintext.
Plaintext []byte `protobuf:"bytes,1,opt,name=plaintext,proto3" json:"plaintext,omitempty"`
}
func (x *SubtleDecryptResponse) Reset() {
*x = SubtleDecryptResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[66]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleDecryptResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleDecryptResponse) ProtoMessage() {}
func (x *SubtleDecryptResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[66]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleDecryptResponse.ProtoReflect.Descriptor instead.
func (*SubtleDecryptResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{66}
}
func (x *SubtleDecryptResponse) GetPlaintext() []byte {
if x != nil {
return x.Plaintext
}
return nil
}
// SubtleWrapKeyRequest is the request for SubtleWrapKeyAlpha1.
type SubtleWrapKeyRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Key to wrap
PlaintextKey []byte `protobuf:"bytes,2,opt,name=plaintext_key,json=plaintextKey,proto3" json:"plaintext_key,omitempty"`
// Algorithm to use, as in the JWA standard.
Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
// Name (or name/version) of the key.
KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
// Nonce / initialization vector.
// Ignored with asymmetric ciphers.
Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
// Associated Data when using AEAD ciphers (optional).
AssociatedData []byte `protobuf:"bytes,6,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"`
}
func (x *SubtleWrapKeyRequest) Reset() {
*x = SubtleWrapKeyRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[67]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleWrapKeyRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleWrapKeyRequest) ProtoMessage() {}
func (x *SubtleWrapKeyRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[67]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleWrapKeyRequest.ProtoReflect.Descriptor instead.
func (*SubtleWrapKeyRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{67}
}
func (x *SubtleWrapKeyRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleWrapKeyRequest) GetPlaintextKey() []byte {
if x != nil {
return x.PlaintextKey
}
return nil
}
func (x *SubtleWrapKeyRequest) GetAlgorithm() string {
if x != nil {
return x.Algorithm
}
return ""
}
func (x *SubtleWrapKeyRequest) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
func (x *SubtleWrapKeyRequest) GetNonce() []byte {
if x != nil {
return x.Nonce
}
return nil
}
func (x *SubtleWrapKeyRequest) GetAssociatedData() []byte {
if x != nil {
return x.AssociatedData
}
return nil
}
// SubtleWrapKeyResponse is the response for SubtleWrapKeyAlpha1.
type SubtleWrapKeyResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Wrapped key.
WrappedKey []byte `protobuf:"bytes,1,opt,name=wrapped_key,json=wrappedKey,proto3" json:"wrapped_key,omitempty"`
// Authentication tag.
// This is nil when not using an authenticated cipher.
Tag []byte `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
}
func (x *SubtleWrapKeyResponse) Reset() {
*x = SubtleWrapKeyResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[68]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleWrapKeyResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleWrapKeyResponse) ProtoMessage() {}
func (x *SubtleWrapKeyResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[68]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleWrapKeyResponse.ProtoReflect.Descriptor instead.
func (*SubtleWrapKeyResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{68}
}
func (x *SubtleWrapKeyResponse) GetWrappedKey() []byte {
if x != nil {
return x.WrappedKey
}
return nil
}
func (x *SubtleWrapKeyResponse) GetTag() []byte {
if x != nil {
return x.Tag
}
return nil
}
// SubtleUnwrapKeyRequest is the request for SubtleUnwrapKeyAlpha1.
type SubtleUnwrapKeyRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Wrapped key.
WrappedKey []byte `protobuf:"bytes,2,opt,name=wrapped_key,json=wrappedKey,proto3" json:"wrapped_key,omitempty"`
// Algorithm to use, as in the JWA standard.
Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
// Name (or name/version) of the key.
KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
// Nonce / initialization vector.
// Ignored with asymmetric ciphers.
Nonce []byte `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
// Authentication tag.
// This is nil when not using an authenticated cipher.
Tag []byte `protobuf:"bytes,6,opt,name=tag,proto3" json:"tag,omitempty"`
// Associated Data when using AEAD ciphers (optional).
AssociatedData []byte `protobuf:"bytes,7,opt,name=associated_data,json=associatedData,proto3" json:"associated_data,omitempty"`
}
func (x *SubtleUnwrapKeyRequest) Reset() {
*x = SubtleUnwrapKeyRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[69]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleUnwrapKeyRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleUnwrapKeyRequest) ProtoMessage() {}
func (x *SubtleUnwrapKeyRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[69]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleUnwrapKeyRequest.ProtoReflect.Descriptor instead.
func (*SubtleUnwrapKeyRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{69}
}
func (x *SubtleUnwrapKeyRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleUnwrapKeyRequest) GetWrappedKey() []byte {
if x != nil {
return x.WrappedKey
}
return nil
}
func (x *SubtleUnwrapKeyRequest) GetAlgorithm() string {
if x != nil {
return x.Algorithm
}
return ""
}
func (x *SubtleUnwrapKeyRequest) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
func (x *SubtleUnwrapKeyRequest) GetNonce() []byte {
if x != nil {
return x.Nonce
}
return nil
}
func (x *SubtleUnwrapKeyRequest) GetTag() []byte {
if x != nil {
return x.Tag
}
return nil
}
func (x *SubtleUnwrapKeyRequest) GetAssociatedData() []byte {
if x != nil {
return x.AssociatedData
}
return nil
}
// SubtleUnwrapKeyResponse is the response for SubtleUnwrapKeyAlpha1.
type SubtleUnwrapKeyResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Key in plaintext
PlaintextKey []byte `protobuf:"bytes,1,opt,name=plaintext_key,json=plaintextKey,proto3" json:"plaintext_key,omitempty"`
}
func (x *SubtleUnwrapKeyResponse) Reset() {
*x = SubtleUnwrapKeyResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[70]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleUnwrapKeyResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleUnwrapKeyResponse) ProtoMessage() {}
func (x *SubtleUnwrapKeyResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[70]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleUnwrapKeyResponse.ProtoReflect.Descriptor instead.
func (*SubtleUnwrapKeyResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{70}
}
func (x *SubtleUnwrapKeyResponse) GetPlaintextKey() []byte {
if x != nil {
return x.PlaintextKey
}
return nil
}
// SubtleSignRequest is the request for SubtleSignAlpha1.
type SubtleSignRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Digest to sign.
Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
// Algorithm to use, as in the JWA standard.
Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
// Name (or name/version) of the key.
KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
}
func (x *SubtleSignRequest) Reset() {
*x = SubtleSignRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[71]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleSignRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleSignRequest) ProtoMessage() {}
func (x *SubtleSignRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[71]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleSignRequest.ProtoReflect.Descriptor instead.
func (*SubtleSignRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{71}
}
func (x *SubtleSignRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleSignRequest) GetDigest() []byte {
if x != nil {
return x.Digest
}
return nil
}
func (x *SubtleSignRequest) GetAlgorithm() string {
if x != nil {
return x.Algorithm
}
return ""
}
func (x *SubtleSignRequest) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
// SubtleSignResponse is the response for SubtleSignAlpha1.
type SubtleSignResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The signature that was computed
Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
}
func (x *SubtleSignResponse) Reset() {
*x = SubtleSignResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[72]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleSignResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleSignResponse) ProtoMessage() {}
func (x *SubtleSignResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[72]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleSignResponse.ProtoReflect.Descriptor instead.
func (*SubtleSignResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{72}
}
func (x *SubtleSignResponse) GetSignature() []byte {
if x != nil {
return x.Signature
}
return nil
}
// SubtleVerifyRequest is the request for SubtleVerifyAlpha1.
type SubtleVerifyRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Digest of the message.
Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
// Algorithm to use, as in the JWA standard.
Algorithm string `protobuf:"bytes,3,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
// Name (or name/version) of the key.
KeyName string `protobuf:"bytes,4,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
// Signature to verify.
Signature []byte `protobuf:"bytes,5,opt,name=signature,proto3" json:"signature,omitempty"`
}
func (x *SubtleVerifyRequest) Reset() {
*x = SubtleVerifyRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[73]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleVerifyRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleVerifyRequest) ProtoMessage() {}
func (x *SubtleVerifyRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[73]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleVerifyRequest.ProtoReflect.Descriptor instead.
func (*SubtleVerifyRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{73}
}
func (x *SubtleVerifyRequest) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *SubtleVerifyRequest) GetDigest() []byte {
if x != nil {
return x.Digest
}
return nil
}
func (x *SubtleVerifyRequest) GetAlgorithm() string {
if x != nil {
return x.Algorithm
}
return ""
}
func (x *SubtleVerifyRequest) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
func (x *SubtleVerifyRequest) GetSignature() []byte {
if x != nil {
return x.Signature
}
return nil
}
// SubtleVerifyResponse is the response for SubtleVerifyAlpha1.
type SubtleVerifyResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// True if the signature is valid.
Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
}
func (x *SubtleVerifyResponse) Reset() {
*x = SubtleVerifyResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[74]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SubtleVerifyResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SubtleVerifyResponse) ProtoMessage() {}
func (x *SubtleVerifyResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[74]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SubtleVerifyResponse.ProtoReflect.Descriptor instead.
func (*SubtleVerifyResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{74}
}
func (x *SubtleVerifyResponse) GetValid() bool {
if x != nil {
return x.Valid
}
return false
}
// EncryptRequest is the request for EncryptAlpha1.
type EncryptRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Request details. Must be present in the first message only.
Options *EncryptRequestOptions `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"`
// Chunk of data of arbitrary size.
Payload *v1.StreamPayload `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
}
func (x *EncryptRequest) Reset() {
*x = EncryptRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[75]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *EncryptRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EncryptRequest) ProtoMessage() {}
func (x *EncryptRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[75]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EncryptRequest.ProtoReflect.Descriptor instead.
func (*EncryptRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{75}
}
func (x *EncryptRequest) GetOptions() *EncryptRequestOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *EncryptRequest) GetPayload() *v1.StreamPayload {
if x != nil {
return x.Payload
}
return nil
}
// EncryptRequestOptions contains options for the first message in the EncryptAlpha1 request.
type EncryptRequestOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component. Required.
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// Name (or name/version) of the key. Required.
KeyName string `protobuf:"bytes,2,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
// Key wrapping algorithm to use. Required.
// Supported options include: A256KW (alias: AES), A128CBC, A192CBC, A256CBC, RSA-OAEP-256 (alias: RSA).
KeyWrapAlgorithm string `protobuf:"bytes,3,opt,name=key_wrap_algorithm,json=keyWrapAlgorithm,proto3" json:"key_wrap_algorithm,omitempty"`
// Cipher used to encrypt data (optional): "aes-gcm" (default) or "chacha20-poly1305"
DataEncryptionCipher string `protobuf:"bytes,10,opt,name=data_encryption_cipher,json=dataEncryptionCipher,proto3" json:"data_encryption_cipher,omitempty"`
// 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.
OmitDecryptionKeyName bool `protobuf:"varint,11,opt,name=omit_decryption_key_name,json=omitDecryptionKeyName,proto3" json:"omit_decryption_key_name,omitempty"`
// 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.
DecryptionKeyName string `protobuf:"bytes,12,opt,name=decryption_key_name,json=decryptionKeyName,proto3" json:"decryption_key_name,omitempty"`
}
func (x *EncryptRequestOptions) Reset() {
*x = EncryptRequestOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[76]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *EncryptRequestOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EncryptRequestOptions) ProtoMessage() {}
func (x *EncryptRequestOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[76]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EncryptRequestOptions.ProtoReflect.Descriptor instead.
func (*EncryptRequestOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{76}
}
func (x *EncryptRequestOptions) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *EncryptRequestOptions) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
func (x *EncryptRequestOptions) GetKeyWrapAlgorithm() string {
if x != nil {
return x.KeyWrapAlgorithm
}
return ""
}
func (x *EncryptRequestOptions) GetDataEncryptionCipher() string {
if x != nil {
return x.DataEncryptionCipher
}
return ""
}
func (x *EncryptRequestOptions) GetOmitDecryptionKeyName() bool {
if x != nil {
return x.OmitDecryptionKeyName
}
return false
}
func (x *EncryptRequestOptions) GetDecryptionKeyName() string {
if x != nil {
return x.DecryptionKeyName
}
return ""
}
// EncryptResponse is the response for EncryptAlpha1.
type EncryptResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Chunk of data.
Payload *v1.StreamPayload `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
}
func (x *EncryptResponse) Reset() {
*x = EncryptResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[77]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *EncryptResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EncryptResponse) ProtoMessage() {}
func (x *EncryptResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[77]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EncryptResponse.ProtoReflect.Descriptor instead.
func (*EncryptResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{77}
}
func (x *EncryptResponse) GetPayload() *v1.StreamPayload {
if x != nil {
return x.Payload
}
return nil
}
// DecryptRequest is the request for DecryptAlpha1.
type DecryptRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Request details. Must be present in the first message only.
Options *DecryptRequestOptions `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"`
// Chunk of data of arbitrary size.
Payload *v1.StreamPayload `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
}
func (x *DecryptRequest) Reset() {
*x = DecryptRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[78]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DecryptRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DecryptRequest) ProtoMessage() {}
func (x *DecryptRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[78]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DecryptRequest.ProtoReflect.Descriptor instead.
func (*DecryptRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{78}
}
func (x *DecryptRequest) GetOptions() *DecryptRequestOptions {
if x != nil {
return x.Options
}
return nil
}
func (x *DecryptRequest) GetPayload() *v1.StreamPayload {
if x != nil {
return x.Payload
}
return nil
}
// DecryptRequestOptions contains options for the first message in the DecryptAlpha1 request.
type DecryptRequestOptions struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Name of the component
ComponentName string `protobuf:"bytes,1,opt,name=component_name,json=componentName,proto3" json:"component_name,omitempty"`
// 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).
KeyName string `protobuf:"bytes,12,opt,name=key_name,json=keyName,proto3" json:"key_name,omitempty"`
}
func (x *DecryptRequestOptions) Reset() {
*x = DecryptRequestOptions{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[79]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DecryptRequestOptions) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DecryptRequestOptions) ProtoMessage() {}
func (x *DecryptRequestOptions) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[79]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DecryptRequestOptions.ProtoReflect.Descriptor instead.
func (*DecryptRequestOptions) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{79}
}
func (x *DecryptRequestOptions) GetComponentName() string {
if x != nil {
return x.ComponentName
}
return ""
}
func (x *DecryptRequestOptions) GetKeyName() string {
if x != nil {
return x.KeyName
}
return ""
}
// DecryptResponse is the response for DecryptAlpha1.
type DecryptResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Chunk of data.
Payload *v1.StreamPayload `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
}
func (x *DecryptResponse) Reset() {
*x = DecryptResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[80]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DecryptResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DecryptResponse) ProtoMessage() {}
func (x *DecryptResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[80]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use DecryptResponse.ProtoReflect.Descriptor instead.
func (*DecryptResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{80}
}
func (x *DecryptResponse) GetPayload() *v1.StreamPayload {
if x != nil {
return x.Payload
}
return nil
}
// GetWorkflowRequest is the request for GetWorkflowBeta1.
type GetWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance to query.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
}
func (x *GetWorkflowRequest) Reset() {
*x = GetWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[81]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetWorkflowRequest) ProtoMessage() {}
func (x *GetWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[81]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetWorkflowRequest.ProtoReflect.Descriptor instead.
func (*GetWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{81}
}
func (x *GetWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *GetWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
// GetWorkflowResponse is the response for GetWorkflowBeta1.
type GetWorkflowResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow.
WorkflowName string `protobuf:"bytes,2,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty"`
// The time at which the workflow instance was created.
CreatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
// The last time at which the workflow instance had its state changed.
LastUpdatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=last_updated_at,json=lastUpdatedAt,proto3" json:"last_updated_at,omitempty"`
// The current status of the workflow instance, for example, "PENDING", "RUNNING", "SUSPENDED", "COMPLETED", "FAILED", and "TERMINATED".
RuntimeStatus string `protobuf:"bytes,5,opt,name=runtime_status,json=runtimeStatus,proto3" json:"runtime_status,omitempty"`
// Additional component-specific properties of the workflow instance.
Properties map[string]string `protobuf:"bytes,6,rep,name=properties,proto3" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *GetWorkflowResponse) Reset() {
*x = GetWorkflowResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[82]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetWorkflowResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetWorkflowResponse) ProtoMessage() {}
func (x *GetWorkflowResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[82]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use GetWorkflowResponse.ProtoReflect.Descriptor instead.
func (*GetWorkflowResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{82}
}
func (x *GetWorkflowResponse) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *GetWorkflowResponse) GetWorkflowName() string {
if x != nil {
return x.WorkflowName
}
return ""
}
func (x *GetWorkflowResponse) GetCreatedAt() *timestamppb.Timestamp {
if x != nil {
return x.CreatedAt
}
return nil
}
func (x *GetWorkflowResponse) GetLastUpdatedAt() *timestamppb.Timestamp {
if x != nil {
return x.LastUpdatedAt
}
return nil
}
func (x *GetWorkflowResponse) GetRuntimeStatus() string {
if x != nil {
return x.RuntimeStatus
}
return ""
}
func (x *GetWorkflowResponse) GetProperties() map[string]string {
if x != nil {
return x.Properties
}
return nil
}
// StartWorkflowRequest is the request for StartWorkflowBeta1.
type StartWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The ID to assign to the started workflow instance. If empty, a random ID is generated.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
// Name of the workflow.
WorkflowName string `protobuf:"bytes,3,opt,name=workflow_name,json=workflowName,proto3" json:"workflow_name,omitempty"`
// Additional component-specific options for starting the workflow instance.
Options map[string]string `protobuf:"bytes,4,rep,name=options,proto3" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// Input data for the workflow instance.
Input []byte `protobuf:"bytes,5,opt,name=input,proto3" json:"input,omitempty"`
}
func (x *StartWorkflowRequest) Reset() {
*x = StartWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[83]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StartWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StartWorkflowRequest) ProtoMessage() {}
func (x *StartWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[83]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StartWorkflowRequest.ProtoReflect.Descriptor instead.
func (*StartWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{83}
}
func (x *StartWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *StartWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
func (x *StartWorkflowRequest) GetWorkflowName() string {
if x != nil {
return x.WorkflowName
}
return ""
}
func (x *StartWorkflowRequest) GetOptions() map[string]string {
if x != nil {
return x.Options
}
return nil
}
func (x *StartWorkflowRequest) GetInput() []byte {
if x != nil {
return x.Input
}
return nil
}
// StartWorkflowResponse is the response for StartWorkflowBeta1.
type StartWorkflowResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the started workflow instance.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
}
func (x *StartWorkflowResponse) Reset() {
*x = StartWorkflowResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[84]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *StartWorkflowResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*StartWorkflowResponse) ProtoMessage() {}
func (x *StartWorkflowResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[84]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use StartWorkflowResponse.ProtoReflect.Descriptor instead.
func (*StartWorkflowResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{84}
}
func (x *StartWorkflowResponse) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
// TerminateWorkflowRequest is the request for TerminateWorkflowBeta1.
type TerminateWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance to terminate.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
}
func (x *TerminateWorkflowRequest) Reset() {
*x = TerminateWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[85]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TerminateWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TerminateWorkflowRequest) ProtoMessage() {}
func (x *TerminateWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[85]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TerminateWorkflowRequest.ProtoReflect.Descriptor instead.
func (*TerminateWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{85}
}
func (x *TerminateWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *TerminateWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
// PauseWorkflowRequest is the request for PauseWorkflowBeta1.
type PauseWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance to pause.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
}
func (x *PauseWorkflowRequest) Reset() {
*x = PauseWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[86]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PauseWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PauseWorkflowRequest) ProtoMessage() {}
func (x *PauseWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[86]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PauseWorkflowRequest.ProtoReflect.Descriptor instead.
func (*PauseWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{86}
}
func (x *PauseWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *PauseWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
// ResumeWorkflowRequest is the request for ResumeWorkflowBeta1.
type ResumeWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance to resume.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
}
func (x *ResumeWorkflowRequest) Reset() {
*x = ResumeWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[87]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ResumeWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ResumeWorkflowRequest) ProtoMessage() {}
func (x *ResumeWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[87]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ResumeWorkflowRequest.ProtoReflect.Descriptor instead.
func (*ResumeWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{87}
}
func (x *ResumeWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *ResumeWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
// RaiseEventWorkflowRequest is the request for RaiseEventWorkflowBeta1.
type RaiseEventWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance to raise an event for.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
// Name of the event.
EventName string `protobuf:"bytes,3,opt,name=event_name,json=eventName,proto3" json:"event_name,omitempty"`
// Data associated with the event.
EventData []byte `protobuf:"bytes,4,opt,name=event_data,json=eventData,proto3" json:"event_data,omitempty"`
}
func (x *RaiseEventWorkflowRequest) Reset() {
*x = RaiseEventWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[88]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RaiseEventWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RaiseEventWorkflowRequest) ProtoMessage() {}
func (x *RaiseEventWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[88]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RaiseEventWorkflowRequest.ProtoReflect.Descriptor instead.
func (*RaiseEventWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{88}
}
func (x *RaiseEventWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *RaiseEventWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
func (x *RaiseEventWorkflowRequest) GetEventName() string {
if x != nil {
return x.EventName
}
return ""
}
func (x *RaiseEventWorkflowRequest) GetEventData() []byte {
if x != nil {
return x.EventData
}
return nil
}
// PurgeWorkflowRequest is the request for PurgeWorkflowBeta1.
type PurgeWorkflowRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// ID of the workflow instance to purge.
InstanceId string `protobuf:"bytes,1,opt,name=instance_id,json=instanceID,proto3" json:"instance_id,omitempty"`
// Name of the workflow component.
WorkflowComponent string `protobuf:"bytes,2,opt,name=workflow_component,json=workflowComponent,proto3" json:"workflow_component,omitempty"`
}
func (x *PurgeWorkflowRequest) Reset() {
*x = PurgeWorkflowRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[89]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PurgeWorkflowRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PurgeWorkflowRequest) ProtoMessage() {}
func (x *PurgeWorkflowRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[89]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PurgeWorkflowRequest.ProtoReflect.Descriptor instead.
func (*PurgeWorkflowRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{89}
}
func (x *PurgeWorkflowRequest) GetInstanceId() string {
if x != nil {
return x.InstanceId
}
return ""
}
func (x *PurgeWorkflowRequest) GetWorkflowComponent() string {
if x != nil {
return x.WorkflowComponent
}
return ""
}
// ShutdownRequest is the request for Shutdown.
type ShutdownRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *ShutdownRequest) Reset() {
*x = ShutdownRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[90]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ShutdownRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ShutdownRequest) ProtoMessage() {}
func (x *ShutdownRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_runtime_v1_dapr_proto_msgTypes[90]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ShutdownRequest.ProtoReflect.Descriptor instead.
func (*ShutdownRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP(), []int{90}
}
var File_dapr_proto_runtime_v1_dapr_proto protoreflect.FileDescriptor
var file_dapr_proto_runtime_v1_dapr_proto_rawDesc = []byte{
0x0a, 0x20, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x12, 0x15, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x1a, 0x21, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63,
0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x27, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x70, 0x70,
0x63, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x65,
0x0a, 0x14, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3d, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x07, 0x6d, 0x65,
0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xa8, 0x02, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61,
0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f,
0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73,
0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x55, 0x0a, 0x0b, 0x63, 0x6f,
0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32,
0x33, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74,
0x65, 0x6e, 0x63, 0x79, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63,
0x79, 0x12, 0x50, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53,
0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
0x22, 0xfd, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74,
0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72,
0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74,
0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18,
0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70,
0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
0x52, 0x0b, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x6d, 0x12, 0x54, 0x0a,
0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
0x38, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53,
0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
0x22, 0x52, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d,
0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e,
0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x05, 0x69,
0x74, 0x65, 0x6d, 0x73, 0x22, 0xec, 0x01, 0x0a, 0x0d, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61,
0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04,
0x65, 0x74, 0x61, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67,
0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x4e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
0x02, 0x38, 0x01, 0x22, 0xca, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04,
0x65, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67,
0x12, 0x51, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74,
0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
0x22, 0xc5, 0x02, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65,
0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f,
0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x04, 0x65, 0x74, 0x61, 0x67,
0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x74,
0x61, 0x67, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x3c, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31,
0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x53, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x70, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65,
0x74, 0x65, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d,
0x65, 0x12, 0x37, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x1f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74,
0x65, 0x6d, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0x6a, 0x0a, 0x10, 0x53, 0x61,
0x76, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d,
0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a,
0x06, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f,
0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d, 0x52, 0x06,
0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0xd9, 0x01, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79,
0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x71,
0x75, 0x65, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72,
0x79, 0x12, 0x52, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72,
0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02,
0x38, 0x01, 0x22, 0x60, 0x0a, 0x0e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65,
0x49, 0x74, 0x65, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02,
0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x74,
0x61, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x74, 0x61, 0x67, 0x12, 0x14,
0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65,
0x72, 0x72, 0x6f, 0x72, 0x22, 0xfd, 0x01, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74,
0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x07, 0x72,
0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49,
0x74, 0x65, 0x6d, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x14, 0x0a, 0x05,
0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b,
0x65, 0x6e, 0x12, 0x53, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65,
0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x3a, 0x02, 0x38, 0x01, 0x22, 0x9f, 0x02, 0x0a, 0x13, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b,
0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0a, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a,
0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f,
0x70, 0x69, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28,
0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x61, 0x74, 0x61, 0x5f,
0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01,
0x28, 0x09, 0x52, 0x0f, 0x64, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54,
0x79, 0x70, 0x65, 0x12, 0x54, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18,
0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75,
0x62, 0x6c, 0x69, 0x73, 0x68, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xa7, 0x02, 0x0a, 0x12, 0x42, 0x75, 0x6c, 0x6b, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a,
0x0b, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x0a, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14,
0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74,
0x6f, 0x70, 0x69, 0x63, 0x12, 0x48, 0x0a, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18,
0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75,
0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x12, 0x53,
0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62,
0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
0x22, 0x84, 0x02, 0x0a, 0x17, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a, 0x08,
0x65, 0x6e, 0x74, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
0x65, 0x6e, 0x74, 0x72, 0x79, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x21, 0x0a,
0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20,
0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65,
0x12, 0x58, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b,
0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61,
0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x72, 0x0a, 0x13, 0x42, 0x75, 0x6c, 0x6b, 0x50,
0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5b,
0x0a, 0x0d, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x18,
0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75,
0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x66, 0x61,
0x69, 0x6c, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x22, 0x51, 0x0a, 0x1e, 0x42,
0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x19, 0x0a,
0x08, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x07, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f,
0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x9a,
0x02, 0x0a, 0x21, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x6f, 0x70, 0x69,
0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x6c,
0x70, 0x68, 0x61, 0x31, 0x12, 0x6a, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f,
0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3f, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54,
0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61,
0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x48, 0x00,
0x52, 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x62, 0x0a, 0x0e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45,
0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x41, 0x6c, 0x70,
0x68, 0x61, 0x31, 0x48, 0x00, 0x52, 0x0d, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x42, 0x25, 0x0a, 0x23, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62,
0x65, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x5f, 0x72,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0xd0, 0x02, 0x0a, 0x28,
0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76,
0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x75, 0x62, 0x73,
0x75, 0x62, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70,
0x75, 0x62, 0x73, 0x75, 0x62, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70,
0x69, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x12,
0x69, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x4d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x62, 0x65, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e,
0x69, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x70, 0x68,
0x61, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2f, 0x0a, 0x11, 0x64, 0x65,
0x61, 0x64, 0x5f, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18,
0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0f, 0x64, 0x65, 0x61, 0x64, 0x4c, 0x65, 0x74,
0x74, 0x65, 0x72, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x88, 0x01, 0x01, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x64, 0x65, 0x61,
0x64, 0x5f, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x22, 0x77,
0x0a, 0x22, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x6f, 0x70, 0x69, 0x63,
0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x41, 0x6c,
0x70, 0x68, 0x61, 0x31, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x02, 0x69, 0x64, 0x12, 0x41, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70,
0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52,
0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xf0, 0x01, 0x0a, 0x14, 0x49, 0x6e, 0x76, 0x6f,
0x6b, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01,
0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x55, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12,
0x1c, 0x0a, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01,
0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x3b, 0x0a,
0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xc0, 0x01, 0x0a, 0x15, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01,
0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x56, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61,
0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xd3, 0x01,
0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d,
0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x51, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18,
0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65,
0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
0x02, 0x38, 0x01, 0x22, 0x94, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x04, 0x64, 0x61, 0x74,
0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e,
0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74,
0x61, 0x1a, 0x37, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10,
0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79,
0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xc9, 0x01, 0x0a, 0x14, 0x47,
0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d,
0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61,
0x6d, 0x65, 0x12, 0x55, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74,
0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52,
0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9a, 0x01, 0x0a, 0x0e, 0x53, 0x65, 0x63, 0x72, 0x65,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x07, 0x73, 0x65, 0x63,
0x72, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x2e, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07,
0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x73, 0x1a, 0x3a, 0x0a, 0x0c, 0x53, 0x65, 0x63, 0x72, 0x65,
0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a,
0x02, 0x38, 0x01, 0x22, 0xc3, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53,
0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a,
0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x63, 0x72, 0x65,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e,
0x74, 0x72, 0x79, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x5e, 0x0a, 0x09, 0x44, 0x61, 0x74,
0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e,
0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x7e, 0x0a, 0x1b, 0x54, 0x72, 0x61,
0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x39,
0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x1f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d,
0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x49, 0x74, 0x65, 0x6d,
0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xb0, 0x02, 0x0a, 0x1e, 0x45, 0x78,
0x65, 0x63, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09,
0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x52, 0x0a, 0x0a, 0x6f, 0x70,
0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5f,
0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x43, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65,
0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a,
0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xde, 0x01, 0x0a,
0x19, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x69,
0x6d, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63,
0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
0x61, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74,
0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74,
0x6f, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01,
0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x64, 0x75, 0x65, 0x5f,
0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x75, 0x65, 0x54,
0x69, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x05, 0x20,
0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x63,
0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63,
0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18,
0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x10, 0x0a, 0x03, 0x74,
0x74, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74, 0x74, 0x6c, 0x22, 0x6b, 0x0a,
0x1b, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72,
0x54, 0x69, 0x6d, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x09, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61,
0x63, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61,
0x63, 0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03,
0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xc5, 0x01, 0x0a, 0x1c, 0x52,
0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x6d, 0x69,
0x6e, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61,
0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x09, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63,
0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63,
0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20,
0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x64, 0x75, 0x65,
0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x64, 0x75, 0x65,
0x54, 0x69, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x05,
0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x12, 0x0a, 0x04,
0x64, 0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61,
0x12, 0x10, 0x0a, 0x03, 0x74, 0x74, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x74,
0x74, 0x6c, 0x22, 0x6e, 0x0a, 0x1e, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79,
0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x54,
0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x12,
0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x22, 0x62, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74,
0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63,
0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
0x61, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74,
0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74,
0x6f, 0x72, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0xc0, 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x41, 0x63,
0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04,
0x64, 0x61, 0x74, 0x61, 0x12, 0x56, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
0x65, 0x74, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d,
0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb8, 0x01, 0x0a, 0x23, 0x45, 0x78,
0x65, 0x63, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54,
0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65,
0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x57, 0x0a, 0x0a, 0x6f,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x22, 0xa6, 0x02, 0x0a, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65,
0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x70, 0x65,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x2a, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x61, 0x0a,
0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
0x45, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74,
0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4f,
0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x8c, 0x02,
0x0a, 0x12, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x79,
0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x54,
0x79, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x49, 0x64, 0x12, 0x16,
0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06,
0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04,
0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x53, 0x0a, 0x08, 0x6d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a,
0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x29, 0x0a, 0x13,
0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x14, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4d, 0x65,
0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xab, 0x06,
0x0a, 0x13, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x51, 0x0a, 0x13, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f,
0x61, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x76,
0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x02, 0x18, 0x01,
0x52, 0x06, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x56, 0x0a, 0x15, 0x72, 0x65, 0x67, 0x69,
0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e,
0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x73, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73,
0x12, 0x65, 0x0a, 0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x74,
0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x40, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64,
0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x65,
0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x4f, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63,
0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53, 0x75, 0x62,
0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x73, 0x75, 0x62, 0x73, 0x63,
0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x52, 0x0a, 0x0e, 0x68, 0x74, 0x74, 0x70,
0x5f, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0d, 0x68,
0x74, 0x74, 0x70, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x6a, 0x0a, 0x19,
0x61, 0x70, 0x70, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x70,
0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x70, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x52,
0x17, 0x61, 0x70, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72,
0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
0x6e, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x5f, 0x66, 0x65, 0x61,
0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x61,
0x62, 0x6c, 0x65, 0x64, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x0d,
0x61, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x0a, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74, 0x6f,
0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x52, 0x0c, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x52,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x1a, 0x43, 0x0a, 0x15, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64,
0x65, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12,
0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65,
0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xbc, 0x02, 0x0a, 0x0c,
0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x5d, 0x0a, 0x0e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0e, 0x32, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74,
0x6f, 0x72, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0d, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x4d, 0x0a, 0x0d, 0x61,
0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03,
0x28, 0x0b, 0x32, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x76,
0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x0c, 0x61, 0x63,
0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x6f,
0x73, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09,
0x68, 0x6f, 0x73, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x6c, 0x61,
0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x6c,
0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x41, 0x0a, 0x12, 0x41, 0x63, 0x74, 0x6f, 0x72,
0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x10, 0x0a,
0x0c, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x4c, 0x49, 0x5a, 0x49, 0x4e, 0x47, 0x10, 0x00, 0x12,
0x0c, 0x0a, 0x08, 0x44, 0x49, 0x53, 0x41, 0x42, 0x4c, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a,
0x07, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x22, 0x3d, 0x0a, 0x11, 0x41, 0x63,
0x74, 0x69, 0x76, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12,
0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74,
0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01,
0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x7c, 0x0a, 0x14, 0x52, 0x65, 0x67,
0x69, 0x73, 0x74, 0x65, 0x72, 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20,
0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72,
0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73,
0x69, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
0x69, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62,
0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x2a, 0x0a, 0x14, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x48, 0x54, 0x54, 0x50, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12,
0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
0x61, 0x6d, 0x65, 0x22, 0xe9, 0x01, 0x0a, 0x17, 0x41, 0x70, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65,
0x63, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x12,
0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x70,
0x6f, 0x72, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12,
0x27, 0x0a, 0x0f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65,
0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65,
0x6c, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x78, 0x5f,
0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28,
0x05, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63,
0x79, 0x12, 0x4c, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x70, 0x70, 0x43, 0x6f, 0x6e,
0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x50, 0x72, 0x6f,
0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x52, 0x06, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x22,
0xdc, 0x01, 0x0a, 0x1d, 0x41, 0x70, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
0x6e, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65,
0x73, 0x12, 0x2a, 0x0a, 0x11, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x5f, 0x63, 0x68, 0x65, 0x63,
0x6b, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x68, 0x65,
0x61, 0x6c, 0x74, 0x68, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x50, 0x61, 0x74, 0x68, 0x12, 0x32, 0x0a,
0x15, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x5f, 0x70, 0x72, 0x6f, 0x62, 0x65, 0x5f, 0x69, 0x6e,
0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x68, 0x65,
0x61, 0x6c, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61,
0x6c, 0x12, 0x30, 0x0a, 0x14, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x5f, 0x70, 0x72, 0x6f, 0x62,
0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
0x12, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x54, 0x69, 0x6d, 0x65,
0x6f, 0x75, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x68, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x5f, 0x74, 0x68,
0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x68,
0x65, 0x61, 0x6c, 0x74, 0x68, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x22, 0xcf,
0x02, 0x0a, 0x12, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x5f,
0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x75, 0x62, 0x73,
0x75, 0x62, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x53, 0x0a, 0x08,
0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53, 0x75, 0x62,
0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
0x61, 0x12, 0x44, 0x0a, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53,
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73,
0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x64, 0x65, 0x61, 0x64, 0x5f,
0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x05, 0x20, 0x01,
0x28, 0x09, 0x52, 0x0f, 0x64, 0x65, 0x61, 0x64, 0x4c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x54, 0x6f,
0x70, 0x69, 0x63, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45,
0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01,
0x22, 0x5e, 0x0a, 0x17, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x43, 0x0a, 0x05, 0x72,
0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73,
0x22, 0x42, 0x0a, 0x16, 0x50, 0x75, 0x62, 0x73, 0x75, 0x62, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61,
0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68,
0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
0x70, 0x61, 0x74, 0x68, 0x22, 0x3c, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05,
0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x22, 0xe3, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d,
0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a,
0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x65, 0x79,
0x73, 0x12, 0x58, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20,
0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72,
0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03,
0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14,
0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xcf, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74,
0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01,
0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74,
0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x1a, 0x61, 0x0a, 0x0a, 0x49, 0x74, 0x65, 0x6d, 0x73,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65, 0x6d, 0x52,
0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xef, 0x01, 0x0a, 0x1d, 0x53,
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a,
0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6b,
0x65, 0x79, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x12,
0x5e, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x03, 0x28,
0x0b, 0x32, 0x42, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a,
0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79,
0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b,
0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x50, 0x0a, 0x1f,
0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x0e,
0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0xeb,
0x01, 0x0a, 0x1e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69,
0x64, 0x12, 0x56, 0x0a, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x40, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x45, 0x6e, 0x74,
0x72, 0x79, 0x52, 0x05, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x1a, 0x61, 0x0a, 0x0a, 0x49, 0x74, 0x65,
0x6d, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x05, 0x76, 0x61, 0x6c,
0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e,
0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x74, 0x65,
0x6d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4c, 0x0a, 0x20,
0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69,
0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b,
0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x9b, 0x01, 0x0a, 0x0e, 0x54,
0x72, 0x79, 0x4c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b,
0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0a, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a,
0x0a, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28,
0x09, 0x52, 0x09, 0x6c, 0x6f, 0x63, 0x6b, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x11,
0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x5f, 0x69, 0x6e, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64,
0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x49,
0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0x2b, 0x0a, 0x0f, 0x54, 0x72, 0x79, 0x4c,
0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73,
0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75,
0x63, 0x63, 0x65, 0x73, 0x73, 0x22, 0x6e, 0x0a, 0x0d, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f,
0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72,
0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63,
0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x65, 0x73, 0x6f,
0x75, 0x72, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6f,
0x77, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6c, 0x6f, 0x63, 0x6b,
0x4f, 0x77, 0x6e, 0x65, 0x72, 0x22, 0xb6, 0x01, 0x0a, 0x0e, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74,
0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e,
0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5e,
0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x55, 0x43, 0x43,
0x45, 0x53, 0x53, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x44, 0x4f,
0x45, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x10, 0x01, 0x12, 0x1a,
0x0a, 0x16, 0x4c, 0x4f, 0x43, 0x4b, 0x5f, 0x42, 0x45, 0x4c, 0x4f, 0x4e, 0x47, 0x53, 0x5f, 0x54,
0x4f, 0x5f, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x53, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x49, 0x4e,
0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x03, 0x22, 0xbe,
0x01, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a,
0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
0x65, 0x12, 0x4c, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28,
0x0e, 0x32, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65,
0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4b, 0x65,
0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x22,
0x1e, 0x0a, 0x09, 0x4b, 0x65, 0x79, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x07, 0x0a, 0x03,
0x50, 0x45, 0x4d, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4a, 0x53, 0x4f, 0x4e, 0x10, 0x01, 0x22,
0x49, 0x0a, 0x14, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x70,
0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x22, 0xd3, 0x01, 0x0a, 0x14, 0x53,
0x75, 0x62, 0x74, 0x6c, 0x65, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x6c,
0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x70,
0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f,
0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x6c, 0x67,
0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x4e, 0x61, 0x6d,
0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c,
0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x73, 0x73, 0x6f, 0x63,
0x69, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c,
0x52, 0x0e, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61,
0x22, 0x49, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x69, 0x70,
0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63,
0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x74, 0x61, 0x67, 0x22, 0xe7, 0x01, 0x0a, 0x14,
0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63,
0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61,
0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79,
0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79,
0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20,
0x01, 0x28, 0x0c, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61,
0x67, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x27, 0x0a, 0x0f,
0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18,
0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65,
0x64, 0x44, 0x61, 0x74, 0x61, 0x22, 0x35, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x44,
0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c,
0x0a, 0x09, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
0x0c, 0x52, 0x09, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x22, 0xda, 0x01, 0x0a,
0x14, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x57, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d,
0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0c, 0x52, 0x0c, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x4b, 0x65,
0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x03,
0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12,
0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f,
0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65,
0x12, 0x27, 0x0a, 0x0f, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64,
0x61, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x6f, 0x63,
0x69, 0x61, 0x74, 0x65, 0x64, 0x44, 0x61, 0x74, 0x61, 0x22, 0x4a, 0x0a, 0x15, 0x53, 0x75, 0x62,
0x74, 0x6c, 0x65, 0x57, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x6b, 0x65,
0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x64,
0x4b, 0x65, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
0x52, 0x03, 0x74, 0x61, 0x67, 0x22, 0xea, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65,
0x55, 0x6e, 0x77, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x77, 0x72, 0x61, 0x70, 0x70,
0x65, 0x64, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x77, 0x72,
0x61, 0x70, 0x70, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f,
0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x6c, 0x67,
0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x4e, 0x61, 0x6d,
0x65, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c,
0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x74, 0x61, 0x67, 0x18, 0x06,
0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x74, 0x61, 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x73, 0x73,
0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01,
0x28, 0x0c, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x44, 0x61,
0x74, 0x61, 0x22, 0x3e, 0x0a, 0x17, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x55, 0x6e, 0x77, 0x72,
0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a,
0x0d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x4b,
0x65, 0x79, 0x22, 0x8b, 0x01, 0x0a, 0x11, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x53, 0x69, 0x67,
0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12,
0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72,
0x69, 0x74, 0x68, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x6c, 0x67, 0x6f,
0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6e, 0x61, 0x6d,
0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x4e, 0x61, 0x6d, 0x65,
0x22, 0x32, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74,
0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61,
0x74, 0x75, 0x72, 0x65, 0x22, 0xab, 0x01, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x56,
0x65, 0x72, 0x69, 0x66, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01,
0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e,
0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61,
0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79,
0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79,
0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
0x72, 0x65, 0x22, 0x2c, 0x0a, 0x14, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x56, 0x65, 0x72, 0x69,
0x66, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64,
0x22, 0x97, 0x01, 0x0a, 0x0e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x63,
0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3d, 0x0a, 0x07, 0x70,
0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61,
0x64, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xa6, 0x02, 0x0a, 0x15, 0x45,
0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4f, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6b,
0x65, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b,
0x65, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6b, 0x65, 0x79, 0x5f, 0x77, 0x72,
0x61, 0x70, 0x5f, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x03, 0x20, 0x01,
0x28, 0x09, 0x52, 0x10, 0x6b, 0x65, 0x79, 0x57, 0x72, 0x61, 0x70, 0x41, 0x6c, 0x67, 0x6f, 0x72,
0x69, 0x74, 0x68, 0x6d, 0x12, 0x34, 0x0a, 0x16, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x65, 0x6e, 0x63,
0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x18, 0x0a,
0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x12, 0x37, 0x0a, 0x18, 0x6f, 0x6d,
0x69, 0x74, 0x5f, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6b, 0x65,
0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x6f, 0x6d,
0x69, 0x74, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x4e,
0x61, 0x6d, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09,
0x52, 0x11, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x4e,
0x61, 0x6d, 0x65, 0x22, 0x50, 0x0a, 0x0f, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61,
0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53,
0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x07, 0x70, 0x61,
0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x97, 0x01, 0x0a, 0x0e, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70,
0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
0x12, 0x3d, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
0x0b, 0x32, 0x23, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63,
0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50,
0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22,
0x59, 0x0a, 0x15, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70,
0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12,
0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28,
0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x50, 0x0a, 0x0f, 0x44, 0x65,
0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3d, 0x0a,
0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d,
0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x50, 0x61, 0x79, 0x6c,
0x6f, 0x61, 0x64, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x64, 0x0a, 0x12,
0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69,
0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
0x65, 0x49, 0x44, 0x12, 0x2d, 0x0a, 0x12, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x22, 0x9c, 0x03, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c,
0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e,
0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x77,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
0x28, 0x09, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x61, 0x6d, 0x65,
0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x03,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x42, 0x0a, 0x0f, 0x6c,
0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x04,
0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12,
0x25, 0x0a, 0x0e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75,
0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x5a, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72,
0x74, 0x69, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65,
0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69,
0x65, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38,
0x01, 0x22, 0xb1, 0x02, 0x0a, 0x14, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66,
0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e,
0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x2d, 0x0a, 0x12, 0x77,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f,
0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x77, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0c, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x4e, 0x61, 0x6d, 0x65, 0x12,
0x52, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x38, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4f, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01,
0x28, 0x0c, 0x52, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x1a, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76,
0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x38, 0x0a, 0x15, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f,
0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x22,
0x6a, 0x0a, 0x18, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b,
0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x69,
0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
0x52, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x2d, 0x0a, 0x12,
0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65,
0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c,
0x6f, 0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x22, 0x66, 0x0a, 0x14, 0x50,
0x61, 0x75, 0x73, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f,
0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e,
0x63, 0x65, 0x49, 0x44, 0x12, 0x2d, 0x0a, 0x12, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77,
0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x22, 0x67, 0x0a, 0x15, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x57, 0x6f, 0x72,
0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b,
0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x2d, 0x0a,
0x12, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66,
0x6c, 0x6f, 0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x22, 0xa9, 0x01, 0x0a,
0x19, 0x52, 0x61, 0x69, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66,
0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e,
0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x2d, 0x0a, 0x12, 0x77,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f,
0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x76,
0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
0x65, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x76, 0x65,
0x6e, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x65,
0x76, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x66, 0x0a, 0x14, 0x50, 0x75, 0x72, 0x67,
0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49,
0x44, 0x12, 0x2d, 0x0a, 0x12, 0x77, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x77,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x22, 0x11, 0x0a, 0x0f, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x32, 0xf6, 0x2d, 0x0a, 0x04, 0x44, 0x61, 0x70, 0x72, 0x12, 0x64, 0x0a, 0x0d,
0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x2b, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x53, 0x65, 0x72, 0x76,
0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x76,
0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x22, 0x00, 0x12, 0x5d, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x26,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x00, 0x12, 0x69, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74,
0x65, 0x12, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c,
0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61,
0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x09,
0x53, 0x61, 0x76, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x10,
0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31,
0x12, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74,
0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74,
0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44,
0x65, 0x6c, 0x65, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0f, 0x44,
0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2d,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x75, 0x6c,
0x6b, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x6a, 0x0a, 0x17, 0x45, 0x78, 0x65, 0x63, 0x75,
0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75,
0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
0x79, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0c, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x45, 0x76,
0x65, 0x6e, 0x74, 0x12, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c,
0x69, 0x73, 0x68, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x71, 0x0a, 0x16, 0x42, 0x75, 0x6c,
0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x41, 0x6c, 0x70,
0x68, 0x61, 0x31, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b,
0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x75, 0x6c, 0x6b, 0x50, 0x75, 0x62, 0x6c, 0x69,
0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x86, 0x01, 0x0a,
0x1a, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x45,
0x76, 0x65, 0x6e, 0x74, 0x73, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x38, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x6f, 0x70,
0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x41,
0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f,
0x70, 0x69, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22,
0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x6c, 0x0a, 0x0d, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x42,
0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49,
0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f,
0x6b, 0x65, 0x42, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74,
0x12, 0x27, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72,
0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b,
0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
0x65, 0x74, 0x42, 0x75, 0x6c, 0x6b, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x42,
0x75, 0x6c, 0x6b, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x12, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x41,
0x63, 0x74, 0x6f, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x72, 0x12, 0x30, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x54,
0x69, 0x6d, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x14, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73,
0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x72, 0x12, 0x32, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
0x41, 0x63, 0x74, 0x6f, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x15, 0x52,
0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x6d, 0x69,
0x6e, 0x64, 0x65, 0x72, 0x12, 0x33, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67,
0x69, 0x73, 0x74, 0x65, 0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64,
0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
0x79, 0x22, 0x00, 0x12, 0x6a, 0x0a, 0x17, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x35,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
0x72, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12,
0x6c, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65,
0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x6f,
0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74,
0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x74, 0x0a,
0x1c, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61,
0x74, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3a, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x41, 0x63, 0x74,
0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69,
0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
0x79, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x0b, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x41, 0x63, 0x74,
0x6f, 0x72, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b,
0x65, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x41, 0x63, 0x74, 0x6f,
0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7b, 0x0a, 0x16, 0x47,
0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41,
0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65,
0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65,
0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x43,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
0x8f, 0x01, 0x0a, 0x1c, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31,
0x12, 0x34, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53,
0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30,
0x01, 0x12, 0x89, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x34, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x35, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63,
0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x93, 0x01,
0x0a, 0x1e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e,
0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31,
0x12, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63,
0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x8d, 0x01, 0x0a, 0x18, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72,
0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x12, 0x36, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63,
0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x6f, 0x6e, 0x66,
0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x0d, 0x54, 0x72, 0x79, 0x4c, 0x6f, 0x63, 0x6b, 0x41, 0x6c,
0x70, 0x68, 0x61, 0x31, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x79,
0x4c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x54, 0x72, 0x79, 0x4c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x0c, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x41,
0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x24, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e,
0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x55, 0x6e, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0d, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x41,
0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e,
0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x30, 0x01, 0x12, 0x62, 0x0a, 0x0d, 0x44, 0x65, 0x63, 0x72,
0x79, 0x70, 0x74, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x25, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x26, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74,
0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x30, 0x01, 0x12, 0x66, 0x0a, 0x0b,
0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x29, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
0x73, 0x65, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0b, 0x53, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x64,
0x61, 0x74, 0x61, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x74, 0x4d,
0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16,
0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x74,
0x6c, 0x65, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2a,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x47, 0x65, 0x74,
0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x47, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x74, 0x6c,
0x65, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2b,
0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74,
0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x45, 0x6e, 0x63,
0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70,
0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70, 0x0a, 0x13, 0x53, 0x75, 0x62,
0x74, 0x6c, 0x65, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31,
0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x44,
0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x44, 0x65, 0x63, 0x72,
0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x70, 0x0a, 0x13, 0x53,
0x75, 0x62, 0x74, 0x6c, 0x65, 0x57, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x41, 0x6c, 0x70, 0x68,
0x61, 0x31, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c,
0x65, 0x57, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x57, 0x72,
0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x76, 0x0a,
0x15, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x55, 0x6e, 0x77, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79,
0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53,
0x75, 0x62, 0x74, 0x6c, 0x65, 0x55, 0x6e, 0x77, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75,
0x62, 0x74, 0x6c, 0x65, 0x55, 0x6e, 0x77, 0x72, 0x61, 0x70, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x67, 0x0a, 0x10, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x53,
0x69, 0x67, 0x6e, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x28, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74,
0x6c, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6d,
0x0a, 0x12, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x41, 0x6c,
0x70, 0x68, 0x61, 0x31, 0x12, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62,
0x74, 0x6c, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x1a, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x56,
0x65, 0x72, 0x69, 0x66, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x72, 0x0a,
0x13, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x41, 0x6c,
0x70, 0x68, 0x61, 0x31, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61,
0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
0x00, 0x12, 0x6c, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77,
0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47,
0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x2a, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72,
0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12,
0x5c, 0x0a, 0x13, 0x50, 0x75, 0x72, 0x67, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77,
0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50,
0x75, 0x72, 0x67, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x64, 0x0a,
0x17, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c,
0x6f, 0x77, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31,
0x2e, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c,
0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
0x79, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x13, 0x50, 0x61, 0x75, 0x73, 0x65, 0x57, 0x6f, 0x72, 0x6b,
0x66, 0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x50, 0x61, 0x75, 0x73, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22,
0x00, 0x12, 0x5e, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66,
0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76,
0x31, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22,
0x00, 0x12, 0x66, 0x0a, 0x18, 0x52, 0x61, 0x69, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x57,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x12, 0x30, 0x2e,
0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69,
0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x61, 0x69, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74,
0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x71, 0x0a, 0x12, 0x53, 0x74, 0x61,
0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74, 0x61, 0x31, 0x12,
0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57, 0x6f, 0x72,
0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x64,
0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d,
0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c,
0x6f, 0x77, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6b, 0x0a, 0x10,
0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74, 0x61, 0x31,
0x12, 0x29, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b,
0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x64, 0x61,
0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65,
0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x12, 0x50, 0x75, 0x72,
0x67, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74, 0x61, 0x31, 0x12,
0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x72, 0x67, 0x65, 0x57, 0x6f, 0x72,
0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x16, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e,
0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74, 0x61, 0x31,
0x12, 0x2f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75,
0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61,
0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x12, 0x50,
0x61, 0x75, 0x73, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74, 0x61,
0x31, 0x12, 0x2b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72,
0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x75, 0x73, 0x65, 0x57,
0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16,
0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x5d, 0x0a, 0x13, 0x52, 0x65, 0x73, 0x75,
0x6d, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74, 0x61, 0x31, 0x12,
0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e,
0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x57, 0x6f,
0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x65, 0x0a, 0x17, 0x52, 0x61, 0x69, 0x73, 0x65,
0x45, 0x76, 0x65, 0x6e, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x42, 0x65, 0x74,
0x61, 0x31, 0x12, 0x30, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x61, 0x69, 0x73, 0x65,
0x45, 0x76, 0x65, 0x6e, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x66, 0x6c, 0x6f, 0x77, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x12, 0x4c,
0x0a, 0x08, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x26, 0x2e, 0x64, 0x61, 0x70,
0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2e,
0x76, 0x31, 0x2e, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x42, 0x69, 0x0a, 0x0a,
0x69, 0x6f, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x44, 0x61, 0x70, 0x72,
0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x6b, 0x67,
0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76,
0x31, 0x3b, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0xaa, 0x02, 0x1b, 0x44, 0x61, 0x70, 0x72,
0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x67, 0x65, 0x6e, 0x2e,
0x47, 0x72, 0x70, 0x63, 0x2e, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_dapr_proto_runtime_v1_dapr_proto_rawDescOnce sync.Once
file_dapr_proto_runtime_v1_dapr_proto_rawDescData = file_dapr_proto_runtime_v1_dapr_proto_rawDesc
)
func file_dapr_proto_runtime_v1_dapr_proto_rawDescGZIP() []byte {
file_dapr_proto_runtime_v1_dapr_proto_rawDescOnce.Do(func() {
file_dapr_proto_runtime_v1_dapr_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_runtime_v1_dapr_proto_rawDescData)
})
return file_dapr_proto_runtime_v1_dapr_proto_rawDescData
}
var file_dapr_proto_runtime_v1_dapr_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_dapr_proto_runtime_v1_dapr_proto_msgTypes = make([]protoimpl.MessageInfo, 121)
var file_dapr_proto_runtime_v1_dapr_proto_goTypes = []interface{}{
(ActorRuntime_ActorRuntimeStatus)(0), // 0: dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus
(UnlockResponse_Status)(0), // 1: dapr.proto.runtime.v1.UnlockResponse.Status
(SubtleGetKeyRequest_KeyFormat)(0), // 2: dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat
(*InvokeServiceRequest)(nil), // 3: dapr.proto.runtime.v1.InvokeServiceRequest
(*GetStateRequest)(nil), // 4: dapr.proto.runtime.v1.GetStateRequest
(*GetBulkStateRequest)(nil), // 5: dapr.proto.runtime.v1.GetBulkStateRequest
(*GetBulkStateResponse)(nil), // 6: dapr.proto.runtime.v1.GetBulkStateResponse
(*BulkStateItem)(nil), // 7: dapr.proto.runtime.v1.BulkStateItem
(*GetStateResponse)(nil), // 8: dapr.proto.runtime.v1.GetStateResponse
(*DeleteStateRequest)(nil), // 9: dapr.proto.runtime.v1.DeleteStateRequest
(*DeleteBulkStateRequest)(nil), // 10: dapr.proto.runtime.v1.DeleteBulkStateRequest
(*SaveStateRequest)(nil), // 11: dapr.proto.runtime.v1.SaveStateRequest
(*QueryStateRequest)(nil), // 12: dapr.proto.runtime.v1.QueryStateRequest
(*QueryStateItem)(nil), // 13: dapr.proto.runtime.v1.QueryStateItem
(*QueryStateResponse)(nil), // 14: dapr.proto.runtime.v1.QueryStateResponse
(*PublishEventRequest)(nil), // 15: dapr.proto.runtime.v1.PublishEventRequest
(*BulkPublishRequest)(nil), // 16: dapr.proto.runtime.v1.BulkPublishRequest
(*BulkPublishRequestEntry)(nil), // 17: dapr.proto.runtime.v1.BulkPublishRequestEntry
(*BulkPublishResponse)(nil), // 18: dapr.proto.runtime.v1.BulkPublishResponse
(*BulkPublishResponseFailedEntry)(nil), // 19: dapr.proto.runtime.v1.BulkPublishResponseFailedEntry
(*SubscribeTopicEventsRequestAlpha1)(nil), // 20: dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1
(*SubscribeTopicEventsInitialRequestAlpha1)(nil), // 21: dapr.proto.runtime.v1.SubscribeTopicEventsInitialRequestAlpha1
(*SubscribeTopicEventsResponseAlpha1)(nil), // 22: dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1
(*InvokeBindingRequest)(nil), // 23: dapr.proto.runtime.v1.InvokeBindingRequest
(*InvokeBindingResponse)(nil), // 24: dapr.proto.runtime.v1.InvokeBindingResponse
(*GetSecretRequest)(nil), // 25: dapr.proto.runtime.v1.GetSecretRequest
(*GetSecretResponse)(nil), // 26: dapr.proto.runtime.v1.GetSecretResponse
(*GetBulkSecretRequest)(nil), // 27: dapr.proto.runtime.v1.GetBulkSecretRequest
(*SecretResponse)(nil), // 28: dapr.proto.runtime.v1.SecretResponse
(*GetBulkSecretResponse)(nil), // 29: dapr.proto.runtime.v1.GetBulkSecretResponse
(*TransactionalStateOperation)(nil), // 30: dapr.proto.runtime.v1.TransactionalStateOperation
(*ExecuteStateTransactionRequest)(nil), // 31: dapr.proto.runtime.v1.ExecuteStateTransactionRequest
(*RegisterActorTimerRequest)(nil), // 32: dapr.proto.runtime.v1.RegisterActorTimerRequest
(*UnregisterActorTimerRequest)(nil), // 33: dapr.proto.runtime.v1.UnregisterActorTimerRequest
(*RegisterActorReminderRequest)(nil), // 34: dapr.proto.runtime.v1.RegisterActorReminderRequest
(*UnregisterActorReminderRequest)(nil), // 35: dapr.proto.runtime.v1.UnregisterActorReminderRequest
(*GetActorStateRequest)(nil), // 36: dapr.proto.runtime.v1.GetActorStateRequest
(*GetActorStateResponse)(nil), // 37: dapr.proto.runtime.v1.GetActorStateResponse
(*ExecuteActorStateTransactionRequest)(nil), // 38: dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest
(*TransactionalActorStateOperation)(nil), // 39: dapr.proto.runtime.v1.TransactionalActorStateOperation
(*InvokeActorRequest)(nil), // 40: dapr.proto.runtime.v1.InvokeActorRequest
(*InvokeActorResponse)(nil), // 41: dapr.proto.runtime.v1.InvokeActorResponse
(*GetMetadataRequest)(nil), // 42: dapr.proto.runtime.v1.GetMetadataRequest
(*GetMetadataResponse)(nil), // 43: dapr.proto.runtime.v1.GetMetadataResponse
(*ActorRuntime)(nil), // 44: dapr.proto.runtime.v1.ActorRuntime
(*ActiveActorsCount)(nil), // 45: dapr.proto.runtime.v1.ActiveActorsCount
(*RegisteredComponents)(nil), // 46: dapr.proto.runtime.v1.RegisteredComponents
(*MetadataHTTPEndpoint)(nil), // 47: dapr.proto.runtime.v1.MetadataHTTPEndpoint
(*AppConnectionProperties)(nil), // 48: dapr.proto.runtime.v1.AppConnectionProperties
(*AppConnectionHealthProperties)(nil), // 49: dapr.proto.runtime.v1.AppConnectionHealthProperties
(*PubsubSubscription)(nil), // 50: dapr.proto.runtime.v1.PubsubSubscription
(*PubsubSubscriptionRules)(nil), // 51: dapr.proto.runtime.v1.PubsubSubscriptionRules
(*PubsubSubscriptionRule)(nil), // 52: dapr.proto.runtime.v1.PubsubSubscriptionRule
(*SetMetadataRequest)(nil), // 53: dapr.proto.runtime.v1.SetMetadataRequest
(*GetConfigurationRequest)(nil), // 54: dapr.proto.runtime.v1.GetConfigurationRequest
(*GetConfigurationResponse)(nil), // 55: dapr.proto.runtime.v1.GetConfigurationResponse
(*SubscribeConfigurationRequest)(nil), // 56: dapr.proto.runtime.v1.SubscribeConfigurationRequest
(*UnsubscribeConfigurationRequest)(nil), // 57: dapr.proto.runtime.v1.UnsubscribeConfigurationRequest
(*SubscribeConfigurationResponse)(nil), // 58: dapr.proto.runtime.v1.SubscribeConfigurationResponse
(*UnsubscribeConfigurationResponse)(nil), // 59: dapr.proto.runtime.v1.UnsubscribeConfigurationResponse
(*TryLockRequest)(nil), // 60: dapr.proto.runtime.v1.TryLockRequest
(*TryLockResponse)(nil), // 61: dapr.proto.runtime.v1.TryLockResponse
(*UnlockRequest)(nil), // 62: dapr.proto.runtime.v1.UnlockRequest
(*UnlockResponse)(nil), // 63: dapr.proto.runtime.v1.UnlockResponse
(*SubtleGetKeyRequest)(nil), // 64: dapr.proto.runtime.v1.SubtleGetKeyRequest
(*SubtleGetKeyResponse)(nil), // 65: dapr.proto.runtime.v1.SubtleGetKeyResponse
(*SubtleEncryptRequest)(nil), // 66: dapr.proto.runtime.v1.SubtleEncryptRequest
(*SubtleEncryptResponse)(nil), // 67: dapr.proto.runtime.v1.SubtleEncryptResponse
(*SubtleDecryptRequest)(nil), // 68: dapr.proto.runtime.v1.SubtleDecryptRequest
(*SubtleDecryptResponse)(nil), // 69: dapr.proto.runtime.v1.SubtleDecryptResponse
(*SubtleWrapKeyRequest)(nil), // 70: dapr.proto.runtime.v1.SubtleWrapKeyRequest
(*SubtleWrapKeyResponse)(nil), // 71: dapr.proto.runtime.v1.SubtleWrapKeyResponse
(*SubtleUnwrapKeyRequest)(nil), // 72: dapr.proto.runtime.v1.SubtleUnwrapKeyRequest
(*SubtleUnwrapKeyResponse)(nil), // 73: dapr.proto.runtime.v1.SubtleUnwrapKeyResponse
(*SubtleSignRequest)(nil), // 74: dapr.proto.runtime.v1.SubtleSignRequest
(*SubtleSignResponse)(nil), // 75: dapr.proto.runtime.v1.SubtleSignResponse
(*SubtleVerifyRequest)(nil), // 76: dapr.proto.runtime.v1.SubtleVerifyRequest
(*SubtleVerifyResponse)(nil), // 77: dapr.proto.runtime.v1.SubtleVerifyResponse
(*EncryptRequest)(nil), // 78: dapr.proto.runtime.v1.EncryptRequest
(*EncryptRequestOptions)(nil), // 79: dapr.proto.runtime.v1.EncryptRequestOptions
(*EncryptResponse)(nil), // 80: dapr.proto.runtime.v1.EncryptResponse
(*DecryptRequest)(nil), // 81: dapr.proto.runtime.v1.DecryptRequest
(*DecryptRequestOptions)(nil), // 82: dapr.proto.runtime.v1.DecryptRequestOptions
(*DecryptResponse)(nil), // 83: dapr.proto.runtime.v1.DecryptResponse
(*GetWorkflowRequest)(nil), // 84: dapr.proto.runtime.v1.GetWorkflowRequest
(*GetWorkflowResponse)(nil), // 85: dapr.proto.runtime.v1.GetWorkflowResponse
(*StartWorkflowRequest)(nil), // 86: dapr.proto.runtime.v1.StartWorkflowRequest
(*StartWorkflowResponse)(nil), // 87: dapr.proto.runtime.v1.StartWorkflowResponse
(*TerminateWorkflowRequest)(nil), // 88: dapr.proto.runtime.v1.TerminateWorkflowRequest
(*PauseWorkflowRequest)(nil), // 89: dapr.proto.runtime.v1.PauseWorkflowRequest
(*ResumeWorkflowRequest)(nil), // 90: dapr.proto.runtime.v1.ResumeWorkflowRequest
(*RaiseEventWorkflowRequest)(nil), // 91: dapr.proto.runtime.v1.RaiseEventWorkflowRequest
(*PurgeWorkflowRequest)(nil), // 92: dapr.proto.runtime.v1.PurgeWorkflowRequest
(*ShutdownRequest)(nil), // 93: dapr.proto.runtime.v1.ShutdownRequest
nil, // 94: dapr.proto.runtime.v1.GetStateRequest.MetadataEntry
nil, // 95: dapr.proto.runtime.v1.GetBulkStateRequest.MetadataEntry
nil, // 96: dapr.proto.runtime.v1.BulkStateItem.MetadataEntry
nil, // 97: dapr.proto.runtime.v1.GetStateResponse.MetadataEntry
nil, // 98: dapr.proto.runtime.v1.DeleteStateRequest.MetadataEntry
nil, // 99: dapr.proto.runtime.v1.QueryStateRequest.MetadataEntry
nil, // 100: dapr.proto.runtime.v1.QueryStateResponse.MetadataEntry
nil, // 101: dapr.proto.runtime.v1.PublishEventRequest.MetadataEntry
nil, // 102: dapr.proto.runtime.v1.BulkPublishRequest.MetadataEntry
nil, // 103: dapr.proto.runtime.v1.BulkPublishRequestEntry.MetadataEntry
nil, // 104: dapr.proto.runtime.v1.SubscribeTopicEventsInitialRequestAlpha1.MetadataEntry
nil, // 105: dapr.proto.runtime.v1.InvokeBindingRequest.MetadataEntry
nil, // 106: dapr.proto.runtime.v1.InvokeBindingResponse.MetadataEntry
nil, // 107: dapr.proto.runtime.v1.GetSecretRequest.MetadataEntry
nil, // 108: dapr.proto.runtime.v1.GetSecretResponse.DataEntry
nil, // 109: dapr.proto.runtime.v1.GetBulkSecretRequest.MetadataEntry
nil, // 110: dapr.proto.runtime.v1.SecretResponse.SecretsEntry
nil, // 111: dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntry
nil, // 112: dapr.proto.runtime.v1.ExecuteStateTransactionRequest.MetadataEntry
nil, // 113: dapr.proto.runtime.v1.GetActorStateResponse.MetadataEntry
nil, // 114: dapr.proto.runtime.v1.TransactionalActorStateOperation.MetadataEntry
nil, // 115: dapr.proto.runtime.v1.InvokeActorRequest.MetadataEntry
nil, // 116: dapr.proto.runtime.v1.GetMetadataResponse.ExtendedMetadataEntry
nil, // 117: dapr.proto.runtime.v1.PubsubSubscription.MetadataEntry
nil, // 118: dapr.proto.runtime.v1.GetConfigurationRequest.MetadataEntry
nil, // 119: dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntry
nil, // 120: dapr.proto.runtime.v1.SubscribeConfigurationRequest.MetadataEntry
nil, // 121: dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntry
nil, // 122: dapr.proto.runtime.v1.GetWorkflowResponse.PropertiesEntry
nil, // 123: dapr.proto.runtime.v1.StartWorkflowRequest.OptionsEntry
(*v1.InvokeRequest)(nil), // 124: dapr.proto.common.v1.InvokeRequest
(v1.StateOptions_StateConsistency)(0), // 125: dapr.proto.common.v1.StateOptions.StateConsistency
(*v1.Etag)(nil), // 126: dapr.proto.common.v1.Etag
(*v1.StateOptions)(nil), // 127: dapr.proto.common.v1.StateOptions
(*v1.StateItem)(nil), // 128: dapr.proto.common.v1.StateItem
(*TopicEventResponse)(nil), // 129: dapr.proto.runtime.v1.TopicEventResponse
(*anypb.Any)(nil), // 130: google.protobuf.Any
(*v1.StreamPayload)(nil), // 131: dapr.proto.common.v1.StreamPayload
(*timestamppb.Timestamp)(nil), // 132: google.protobuf.Timestamp
(*v1.ConfigurationItem)(nil), // 133: dapr.proto.common.v1.ConfigurationItem
(*v1.InvokeResponse)(nil), // 134: dapr.proto.common.v1.InvokeResponse
(*emptypb.Empty)(nil), // 135: google.protobuf.Empty
(*TopicEventRequest)(nil), // 136: dapr.proto.runtime.v1.TopicEventRequest
}
var file_dapr_proto_runtime_v1_dapr_proto_depIdxs = []int32{
124, // 0: dapr.proto.runtime.v1.InvokeServiceRequest.message:type_name -> dapr.proto.common.v1.InvokeRequest
125, // 1: dapr.proto.runtime.v1.GetStateRequest.consistency:type_name -> dapr.proto.common.v1.StateOptions.StateConsistency
94, // 2: dapr.proto.runtime.v1.GetStateRequest.metadata:type_name -> dapr.proto.runtime.v1.GetStateRequest.MetadataEntry
95, // 3: dapr.proto.runtime.v1.GetBulkStateRequest.metadata:type_name -> dapr.proto.runtime.v1.GetBulkStateRequest.MetadataEntry
7, // 4: dapr.proto.runtime.v1.GetBulkStateResponse.items:type_name -> dapr.proto.runtime.v1.BulkStateItem
96, // 5: dapr.proto.runtime.v1.BulkStateItem.metadata:type_name -> dapr.proto.runtime.v1.BulkStateItem.MetadataEntry
97, // 6: dapr.proto.runtime.v1.GetStateResponse.metadata:type_name -> dapr.proto.runtime.v1.GetStateResponse.MetadataEntry
126, // 7: dapr.proto.runtime.v1.DeleteStateRequest.etag:type_name -> dapr.proto.common.v1.Etag
127, // 8: dapr.proto.runtime.v1.DeleteStateRequest.options:type_name -> dapr.proto.common.v1.StateOptions
98, // 9: dapr.proto.runtime.v1.DeleteStateRequest.metadata:type_name -> dapr.proto.runtime.v1.DeleteStateRequest.MetadataEntry
128, // 10: dapr.proto.runtime.v1.DeleteBulkStateRequest.states:type_name -> dapr.proto.common.v1.StateItem
128, // 11: dapr.proto.runtime.v1.SaveStateRequest.states:type_name -> dapr.proto.common.v1.StateItem
99, // 12: dapr.proto.runtime.v1.QueryStateRequest.metadata:type_name -> dapr.proto.runtime.v1.QueryStateRequest.MetadataEntry
13, // 13: dapr.proto.runtime.v1.QueryStateResponse.results:type_name -> dapr.proto.runtime.v1.QueryStateItem
100, // 14: dapr.proto.runtime.v1.QueryStateResponse.metadata:type_name -> dapr.proto.runtime.v1.QueryStateResponse.MetadataEntry
101, // 15: dapr.proto.runtime.v1.PublishEventRequest.metadata:type_name -> dapr.proto.runtime.v1.PublishEventRequest.MetadataEntry
17, // 16: dapr.proto.runtime.v1.BulkPublishRequest.entries:type_name -> dapr.proto.runtime.v1.BulkPublishRequestEntry
102, // 17: dapr.proto.runtime.v1.BulkPublishRequest.metadata:type_name -> dapr.proto.runtime.v1.BulkPublishRequest.MetadataEntry
103, // 18: dapr.proto.runtime.v1.BulkPublishRequestEntry.metadata:type_name -> dapr.proto.runtime.v1.BulkPublishRequestEntry.MetadataEntry
19, // 19: dapr.proto.runtime.v1.BulkPublishResponse.failedEntries:type_name -> dapr.proto.runtime.v1.BulkPublishResponseFailedEntry
21, // 20: dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.initial_request:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsInitialRequestAlpha1
22, // 21: dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1.event_response:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1
104, // 22: dapr.proto.runtime.v1.SubscribeTopicEventsInitialRequestAlpha1.metadata:type_name -> dapr.proto.runtime.v1.SubscribeTopicEventsInitialRequestAlpha1.MetadataEntry
129, // 23: dapr.proto.runtime.v1.SubscribeTopicEventsResponseAlpha1.status:type_name -> dapr.proto.runtime.v1.TopicEventResponse
105, // 24: dapr.proto.runtime.v1.InvokeBindingRequest.metadata:type_name -> dapr.proto.runtime.v1.InvokeBindingRequest.MetadataEntry
106, // 25: dapr.proto.runtime.v1.InvokeBindingResponse.metadata:type_name -> dapr.proto.runtime.v1.InvokeBindingResponse.MetadataEntry
107, // 26: dapr.proto.runtime.v1.GetSecretRequest.metadata:type_name -> dapr.proto.runtime.v1.GetSecretRequest.MetadataEntry
108, // 27: dapr.proto.runtime.v1.GetSecretResponse.data:type_name -> dapr.proto.runtime.v1.GetSecretResponse.DataEntry
109, // 28: dapr.proto.runtime.v1.GetBulkSecretRequest.metadata:type_name -> dapr.proto.runtime.v1.GetBulkSecretRequest.MetadataEntry
110, // 29: dapr.proto.runtime.v1.SecretResponse.secrets:type_name -> dapr.proto.runtime.v1.SecretResponse.SecretsEntry
111, // 30: dapr.proto.runtime.v1.GetBulkSecretResponse.data:type_name -> dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntry
128, // 31: dapr.proto.runtime.v1.TransactionalStateOperation.request:type_name -> dapr.proto.common.v1.StateItem
30, // 32: dapr.proto.runtime.v1.ExecuteStateTransactionRequest.operations:type_name -> dapr.proto.runtime.v1.TransactionalStateOperation
112, // 33: dapr.proto.runtime.v1.ExecuteStateTransactionRequest.metadata:type_name -> dapr.proto.runtime.v1.ExecuteStateTransactionRequest.MetadataEntry
113, // 34: dapr.proto.runtime.v1.GetActorStateResponse.metadata:type_name -> dapr.proto.runtime.v1.GetActorStateResponse.MetadataEntry
39, // 35: dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest.operations:type_name -> dapr.proto.runtime.v1.TransactionalActorStateOperation
130, // 36: dapr.proto.runtime.v1.TransactionalActorStateOperation.value:type_name -> google.protobuf.Any
114, // 37: dapr.proto.runtime.v1.TransactionalActorStateOperation.metadata:type_name -> dapr.proto.runtime.v1.TransactionalActorStateOperation.MetadataEntry
115, // 38: dapr.proto.runtime.v1.InvokeActorRequest.metadata:type_name -> dapr.proto.runtime.v1.InvokeActorRequest.MetadataEntry
45, // 39: dapr.proto.runtime.v1.GetMetadataResponse.active_actors_count:type_name -> dapr.proto.runtime.v1.ActiveActorsCount
46, // 40: dapr.proto.runtime.v1.GetMetadataResponse.registered_components:type_name -> dapr.proto.runtime.v1.RegisteredComponents
116, // 41: dapr.proto.runtime.v1.GetMetadataResponse.extended_metadata:type_name -> dapr.proto.runtime.v1.GetMetadataResponse.ExtendedMetadataEntry
50, // 42: dapr.proto.runtime.v1.GetMetadataResponse.subscriptions:type_name -> dapr.proto.runtime.v1.PubsubSubscription
47, // 43: dapr.proto.runtime.v1.GetMetadataResponse.http_endpoints:type_name -> dapr.proto.runtime.v1.MetadataHTTPEndpoint
48, // 44: dapr.proto.runtime.v1.GetMetadataResponse.app_connection_properties:type_name -> dapr.proto.runtime.v1.AppConnectionProperties
44, // 45: dapr.proto.runtime.v1.GetMetadataResponse.actor_runtime:type_name -> dapr.proto.runtime.v1.ActorRuntime
0, // 46: dapr.proto.runtime.v1.ActorRuntime.runtime_status:type_name -> dapr.proto.runtime.v1.ActorRuntime.ActorRuntimeStatus
45, // 47: dapr.proto.runtime.v1.ActorRuntime.active_actors:type_name -> dapr.proto.runtime.v1.ActiveActorsCount
49, // 48: dapr.proto.runtime.v1.AppConnectionProperties.health:type_name -> dapr.proto.runtime.v1.AppConnectionHealthProperties
117, // 49: dapr.proto.runtime.v1.PubsubSubscription.metadata:type_name -> dapr.proto.runtime.v1.PubsubSubscription.MetadataEntry
51, // 50: dapr.proto.runtime.v1.PubsubSubscription.rules:type_name -> dapr.proto.runtime.v1.PubsubSubscriptionRules
52, // 51: dapr.proto.runtime.v1.PubsubSubscriptionRules.rules:type_name -> dapr.proto.runtime.v1.PubsubSubscriptionRule
118, // 52: dapr.proto.runtime.v1.GetConfigurationRequest.metadata:type_name -> dapr.proto.runtime.v1.GetConfigurationRequest.MetadataEntry
119, // 53: dapr.proto.runtime.v1.GetConfigurationResponse.items:type_name -> dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntry
120, // 54: dapr.proto.runtime.v1.SubscribeConfigurationRequest.metadata:type_name -> dapr.proto.runtime.v1.SubscribeConfigurationRequest.MetadataEntry
121, // 55: dapr.proto.runtime.v1.SubscribeConfigurationResponse.items:type_name -> dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntry
1, // 56: dapr.proto.runtime.v1.UnlockResponse.status:type_name -> dapr.proto.runtime.v1.UnlockResponse.Status
2, // 57: dapr.proto.runtime.v1.SubtleGetKeyRequest.format:type_name -> dapr.proto.runtime.v1.SubtleGetKeyRequest.KeyFormat
79, // 58: dapr.proto.runtime.v1.EncryptRequest.options:type_name -> dapr.proto.runtime.v1.EncryptRequestOptions
131, // 59: dapr.proto.runtime.v1.EncryptRequest.payload:type_name -> dapr.proto.common.v1.StreamPayload
131, // 60: dapr.proto.runtime.v1.EncryptResponse.payload:type_name -> dapr.proto.common.v1.StreamPayload
82, // 61: dapr.proto.runtime.v1.DecryptRequest.options:type_name -> dapr.proto.runtime.v1.DecryptRequestOptions
131, // 62: dapr.proto.runtime.v1.DecryptRequest.payload:type_name -> dapr.proto.common.v1.StreamPayload
131, // 63: dapr.proto.runtime.v1.DecryptResponse.payload:type_name -> dapr.proto.common.v1.StreamPayload
132, // 64: dapr.proto.runtime.v1.GetWorkflowResponse.created_at:type_name -> google.protobuf.Timestamp
132, // 65: dapr.proto.runtime.v1.GetWorkflowResponse.last_updated_at:type_name -> google.protobuf.Timestamp
122, // 66: dapr.proto.runtime.v1.GetWorkflowResponse.properties:type_name -> dapr.proto.runtime.v1.GetWorkflowResponse.PropertiesEntry
123, // 67: dapr.proto.runtime.v1.StartWorkflowRequest.options:type_name -> dapr.proto.runtime.v1.StartWorkflowRequest.OptionsEntry
28, // 68: dapr.proto.runtime.v1.GetBulkSecretResponse.DataEntry.value:type_name -> dapr.proto.runtime.v1.SecretResponse
133, // 69: dapr.proto.runtime.v1.GetConfigurationResponse.ItemsEntry.value:type_name -> dapr.proto.common.v1.ConfigurationItem
133, // 70: dapr.proto.runtime.v1.SubscribeConfigurationResponse.ItemsEntry.value:type_name -> dapr.proto.common.v1.ConfigurationItem
3, // 71: dapr.proto.runtime.v1.Dapr.InvokeService:input_type -> dapr.proto.runtime.v1.InvokeServiceRequest
4, // 72: dapr.proto.runtime.v1.Dapr.GetState:input_type -> dapr.proto.runtime.v1.GetStateRequest
5, // 73: dapr.proto.runtime.v1.Dapr.GetBulkState:input_type -> dapr.proto.runtime.v1.GetBulkStateRequest
11, // 74: dapr.proto.runtime.v1.Dapr.SaveState:input_type -> dapr.proto.runtime.v1.SaveStateRequest
12, // 75: dapr.proto.runtime.v1.Dapr.QueryStateAlpha1:input_type -> dapr.proto.runtime.v1.QueryStateRequest
9, // 76: dapr.proto.runtime.v1.Dapr.DeleteState:input_type -> dapr.proto.runtime.v1.DeleteStateRequest
10, // 77: dapr.proto.runtime.v1.Dapr.DeleteBulkState:input_type -> dapr.proto.runtime.v1.DeleteBulkStateRequest
31, // 78: dapr.proto.runtime.v1.Dapr.ExecuteStateTransaction:input_type -> dapr.proto.runtime.v1.ExecuteStateTransactionRequest
15, // 79: dapr.proto.runtime.v1.Dapr.PublishEvent:input_type -> dapr.proto.runtime.v1.PublishEventRequest
16, // 80: dapr.proto.runtime.v1.Dapr.BulkPublishEventAlpha1:input_type -> dapr.proto.runtime.v1.BulkPublishRequest
20, // 81: dapr.proto.runtime.v1.Dapr.SubscribeTopicEventsAlpha1:input_type -> dapr.proto.runtime.v1.SubscribeTopicEventsRequestAlpha1
23, // 82: dapr.proto.runtime.v1.Dapr.InvokeBinding:input_type -> dapr.proto.runtime.v1.InvokeBindingRequest
25, // 83: dapr.proto.runtime.v1.Dapr.GetSecret:input_type -> dapr.proto.runtime.v1.GetSecretRequest
27, // 84: dapr.proto.runtime.v1.Dapr.GetBulkSecret:input_type -> dapr.proto.runtime.v1.GetBulkSecretRequest
32, // 85: dapr.proto.runtime.v1.Dapr.RegisterActorTimer:input_type -> dapr.proto.runtime.v1.RegisterActorTimerRequest
33, // 86: dapr.proto.runtime.v1.Dapr.UnregisterActorTimer:input_type -> dapr.proto.runtime.v1.UnregisterActorTimerRequest
34, // 87: dapr.proto.runtime.v1.Dapr.RegisterActorReminder:input_type -> dapr.proto.runtime.v1.RegisterActorReminderRequest
35, // 88: dapr.proto.runtime.v1.Dapr.UnregisterActorReminder:input_type -> dapr.proto.runtime.v1.UnregisterActorReminderRequest
36, // 89: dapr.proto.runtime.v1.Dapr.GetActorState:input_type -> dapr.proto.runtime.v1.GetActorStateRequest
38, // 90: dapr.proto.runtime.v1.Dapr.ExecuteActorStateTransaction:input_type -> dapr.proto.runtime.v1.ExecuteActorStateTransactionRequest
40, // 91: dapr.proto.runtime.v1.Dapr.InvokeActor:input_type -> dapr.proto.runtime.v1.InvokeActorRequest
54, // 92: dapr.proto.runtime.v1.Dapr.GetConfigurationAlpha1:input_type -> dapr.proto.runtime.v1.GetConfigurationRequest
54, // 93: dapr.proto.runtime.v1.Dapr.GetConfiguration:input_type -> dapr.proto.runtime.v1.GetConfigurationRequest
56, // 94: dapr.proto.runtime.v1.Dapr.SubscribeConfigurationAlpha1:input_type -> dapr.proto.runtime.v1.SubscribeConfigurationRequest
56, // 95: dapr.proto.runtime.v1.Dapr.SubscribeConfiguration:input_type -> dapr.proto.runtime.v1.SubscribeConfigurationRequest
57, // 96: dapr.proto.runtime.v1.Dapr.UnsubscribeConfigurationAlpha1:input_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationRequest
57, // 97: dapr.proto.runtime.v1.Dapr.UnsubscribeConfiguration:input_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationRequest
60, // 98: dapr.proto.runtime.v1.Dapr.TryLockAlpha1:input_type -> dapr.proto.runtime.v1.TryLockRequest
62, // 99: dapr.proto.runtime.v1.Dapr.UnlockAlpha1:input_type -> dapr.proto.runtime.v1.UnlockRequest
78, // 100: dapr.proto.runtime.v1.Dapr.EncryptAlpha1:input_type -> dapr.proto.runtime.v1.EncryptRequest
81, // 101: dapr.proto.runtime.v1.Dapr.DecryptAlpha1:input_type -> dapr.proto.runtime.v1.DecryptRequest
42, // 102: dapr.proto.runtime.v1.Dapr.GetMetadata:input_type -> dapr.proto.runtime.v1.GetMetadataRequest
53, // 103: dapr.proto.runtime.v1.Dapr.SetMetadata:input_type -> dapr.proto.runtime.v1.SetMetadataRequest
64, // 104: dapr.proto.runtime.v1.Dapr.SubtleGetKeyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleGetKeyRequest
66, // 105: dapr.proto.runtime.v1.Dapr.SubtleEncryptAlpha1:input_type -> dapr.proto.runtime.v1.SubtleEncryptRequest
68, // 106: dapr.proto.runtime.v1.Dapr.SubtleDecryptAlpha1:input_type -> dapr.proto.runtime.v1.SubtleDecryptRequest
70, // 107: dapr.proto.runtime.v1.Dapr.SubtleWrapKeyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleWrapKeyRequest
72, // 108: dapr.proto.runtime.v1.Dapr.SubtleUnwrapKeyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleUnwrapKeyRequest
74, // 109: dapr.proto.runtime.v1.Dapr.SubtleSignAlpha1:input_type -> dapr.proto.runtime.v1.SubtleSignRequest
76, // 110: dapr.proto.runtime.v1.Dapr.SubtleVerifyAlpha1:input_type -> dapr.proto.runtime.v1.SubtleVerifyRequest
86, // 111: dapr.proto.runtime.v1.Dapr.StartWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.StartWorkflowRequest
84, // 112: dapr.proto.runtime.v1.Dapr.GetWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.GetWorkflowRequest
92, // 113: dapr.proto.runtime.v1.Dapr.PurgeWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.PurgeWorkflowRequest
88, // 114: dapr.proto.runtime.v1.Dapr.TerminateWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.TerminateWorkflowRequest
89, // 115: dapr.proto.runtime.v1.Dapr.PauseWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.PauseWorkflowRequest
90, // 116: dapr.proto.runtime.v1.Dapr.ResumeWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.ResumeWorkflowRequest
91, // 117: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowAlpha1:input_type -> dapr.proto.runtime.v1.RaiseEventWorkflowRequest
86, // 118: dapr.proto.runtime.v1.Dapr.StartWorkflowBeta1:input_type -> dapr.proto.runtime.v1.StartWorkflowRequest
84, // 119: dapr.proto.runtime.v1.Dapr.GetWorkflowBeta1:input_type -> dapr.proto.runtime.v1.GetWorkflowRequest
92, // 120: dapr.proto.runtime.v1.Dapr.PurgeWorkflowBeta1:input_type -> dapr.proto.runtime.v1.PurgeWorkflowRequest
88, // 121: dapr.proto.runtime.v1.Dapr.TerminateWorkflowBeta1:input_type -> dapr.proto.runtime.v1.TerminateWorkflowRequest
89, // 122: dapr.proto.runtime.v1.Dapr.PauseWorkflowBeta1:input_type -> dapr.proto.runtime.v1.PauseWorkflowRequest
90, // 123: dapr.proto.runtime.v1.Dapr.ResumeWorkflowBeta1:input_type -> dapr.proto.runtime.v1.ResumeWorkflowRequest
91, // 124: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowBeta1:input_type -> dapr.proto.runtime.v1.RaiseEventWorkflowRequest
93, // 125: dapr.proto.runtime.v1.Dapr.Shutdown:input_type -> dapr.proto.runtime.v1.ShutdownRequest
134, // 126: dapr.proto.runtime.v1.Dapr.InvokeService:output_type -> dapr.proto.common.v1.InvokeResponse
8, // 127: dapr.proto.runtime.v1.Dapr.GetState:output_type -> dapr.proto.runtime.v1.GetStateResponse
6, // 128: dapr.proto.runtime.v1.Dapr.GetBulkState:output_type -> dapr.proto.runtime.v1.GetBulkStateResponse
135, // 129: dapr.proto.runtime.v1.Dapr.SaveState:output_type -> google.protobuf.Empty
14, // 130: dapr.proto.runtime.v1.Dapr.QueryStateAlpha1:output_type -> dapr.proto.runtime.v1.QueryStateResponse
135, // 131: dapr.proto.runtime.v1.Dapr.DeleteState:output_type -> google.protobuf.Empty
135, // 132: dapr.proto.runtime.v1.Dapr.DeleteBulkState:output_type -> google.protobuf.Empty
135, // 133: dapr.proto.runtime.v1.Dapr.ExecuteStateTransaction:output_type -> google.protobuf.Empty
135, // 134: dapr.proto.runtime.v1.Dapr.PublishEvent:output_type -> google.protobuf.Empty
18, // 135: dapr.proto.runtime.v1.Dapr.BulkPublishEventAlpha1:output_type -> dapr.proto.runtime.v1.BulkPublishResponse
136, // 136: dapr.proto.runtime.v1.Dapr.SubscribeTopicEventsAlpha1:output_type -> dapr.proto.runtime.v1.TopicEventRequest
24, // 137: dapr.proto.runtime.v1.Dapr.InvokeBinding:output_type -> dapr.proto.runtime.v1.InvokeBindingResponse
26, // 138: dapr.proto.runtime.v1.Dapr.GetSecret:output_type -> dapr.proto.runtime.v1.GetSecretResponse
29, // 139: dapr.proto.runtime.v1.Dapr.GetBulkSecret:output_type -> dapr.proto.runtime.v1.GetBulkSecretResponse
135, // 140: dapr.proto.runtime.v1.Dapr.RegisterActorTimer:output_type -> google.protobuf.Empty
135, // 141: dapr.proto.runtime.v1.Dapr.UnregisterActorTimer:output_type -> google.protobuf.Empty
135, // 142: dapr.proto.runtime.v1.Dapr.RegisterActorReminder:output_type -> google.protobuf.Empty
135, // 143: dapr.proto.runtime.v1.Dapr.UnregisterActorReminder:output_type -> google.protobuf.Empty
37, // 144: dapr.proto.runtime.v1.Dapr.GetActorState:output_type -> dapr.proto.runtime.v1.GetActorStateResponse
135, // 145: dapr.proto.runtime.v1.Dapr.ExecuteActorStateTransaction:output_type -> google.protobuf.Empty
41, // 146: dapr.proto.runtime.v1.Dapr.InvokeActor:output_type -> dapr.proto.runtime.v1.InvokeActorResponse
55, // 147: dapr.proto.runtime.v1.Dapr.GetConfigurationAlpha1:output_type -> dapr.proto.runtime.v1.GetConfigurationResponse
55, // 148: dapr.proto.runtime.v1.Dapr.GetConfiguration:output_type -> dapr.proto.runtime.v1.GetConfigurationResponse
58, // 149: dapr.proto.runtime.v1.Dapr.SubscribeConfigurationAlpha1:output_type -> dapr.proto.runtime.v1.SubscribeConfigurationResponse
58, // 150: dapr.proto.runtime.v1.Dapr.SubscribeConfiguration:output_type -> dapr.proto.runtime.v1.SubscribeConfigurationResponse
59, // 151: dapr.proto.runtime.v1.Dapr.UnsubscribeConfigurationAlpha1:output_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationResponse
59, // 152: dapr.proto.runtime.v1.Dapr.UnsubscribeConfiguration:output_type -> dapr.proto.runtime.v1.UnsubscribeConfigurationResponse
61, // 153: dapr.proto.runtime.v1.Dapr.TryLockAlpha1:output_type -> dapr.proto.runtime.v1.TryLockResponse
63, // 154: dapr.proto.runtime.v1.Dapr.UnlockAlpha1:output_type -> dapr.proto.runtime.v1.UnlockResponse
80, // 155: dapr.proto.runtime.v1.Dapr.EncryptAlpha1:output_type -> dapr.proto.runtime.v1.EncryptResponse
83, // 156: dapr.proto.runtime.v1.Dapr.DecryptAlpha1:output_type -> dapr.proto.runtime.v1.DecryptResponse
43, // 157: dapr.proto.runtime.v1.Dapr.GetMetadata:output_type -> dapr.proto.runtime.v1.GetMetadataResponse
135, // 158: dapr.proto.runtime.v1.Dapr.SetMetadata:output_type -> google.protobuf.Empty
65, // 159: dapr.proto.runtime.v1.Dapr.SubtleGetKeyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleGetKeyResponse
67, // 160: dapr.proto.runtime.v1.Dapr.SubtleEncryptAlpha1:output_type -> dapr.proto.runtime.v1.SubtleEncryptResponse
69, // 161: dapr.proto.runtime.v1.Dapr.SubtleDecryptAlpha1:output_type -> dapr.proto.runtime.v1.SubtleDecryptResponse
71, // 162: dapr.proto.runtime.v1.Dapr.SubtleWrapKeyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleWrapKeyResponse
73, // 163: dapr.proto.runtime.v1.Dapr.SubtleUnwrapKeyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleUnwrapKeyResponse
75, // 164: dapr.proto.runtime.v1.Dapr.SubtleSignAlpha1:output_type -> dapr.proto.runtime.v1.SubtleSignResponse
77, // 165: dapr.proto.runtime.v1.Dapr.SubtleVerifyAlpha1:output_type -> dapr.proto.runtime.v1.SubtleVerifyResponse
87, // 166: dapr.proto.runtime.v1.Dapr.StartWorkflowAlpha1:output_type -> dapr.proto.runtime.v1.StartWorkflowResponse
85, // 167: dapr.proto.runtime.v1.Dapr.GetWorkflowAlpha1:output_type -> dapr.proto.runtime.v1.GetWorkflowResponse
135, // 168: dapr.proto.runtime.v1.Dapr.PurgeWorkflowAlpha1:output_type -> google.protobuf.Empty
135, // 169: dapr.proto.runtime.v1.Dapr.TerminateWorkflowAlpha1:output_type -> google.protobuf.Empty
135, // 170: dapr.proto.runtime.v1.Dapr.PauseWorkflowAlpha1:output_type -> google.protobuf.Empty
135, // 171: dapr.proto.runtime.v1.Dapr.ResumeWorkflowAlpha1:output_type -> google.protobuf.Empty
135, // 172: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowAlpha1:output_type -> google.protobuf.Empty
87, // 173: dapr.proto.runtime.v1.Dapr.StartWorkflowBeta1:output_type -> dapr.proto.runtime.v1.StartWorkflowResponse
85, // 174: dapr.proto.runtime.v1.Dapr.GetWorkflowBeta1:output_type -> dapr.proto.runtime.v1.GetWorkflowResponse
135, // 175: dapr.proto.runtime.v1.Dapr.PurgeWorkflowBeta1:output_type -> google.protobuf.Empty
135, // 176: dapr.proto.runtime.v1.Dapr.TerminateWorkflowBeta1:output_type -> google.protobuf.Empty
135, // 177: dapr.proto.runtime.v1.Dapr.PauseWorkflowBeta1:output_type -> google.protobuf.Empty
135, // 178: dapr.proto.runtime.v1.Dapr.ResumeWorkflowBeta1:output_type -> google.protobuf.Empty
135, // 179: dapr.proto.runtime.v1.Dapr.RaiseEventWorkflowBeta1:output_type -> google.protobuf.Empty
135, // 180: dapr.proto.runtime.v1.Dapr.Shutdown:output_type -> google.protobuf.Empty
126, // [126:181] is the sub-list for method output_type
71, // [71:126] is the sub-list for method input_type
71, // [71:71] is the sub-list for extension type_name
71, // [71:71] is the sub-list for extension extendee
0, // [0:71] is the sub-list for field type_name
}
func init() { file_dapr_proto_runtime_v1_dapr_proto_init() }
func file_dapr_proto_runtime_v1_dapr_proto_init() {
if File_dapr_proto_runtime_v1_dapr_proto != nil {
return
}
file_dapr_proto_runtime_v1_appcallback_proto_init()
if !protoimpl.UnsafeEnabled {
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeServiceRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetBulkStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetBulkStateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkStateItem); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetStateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DeleteBulkStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SaveStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*QueryStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*QueryStateItem); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*QueryStateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PublishEventRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishRequestEntry); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BulkPublishResponseFailedEntry); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscribeTopicEventsRequestAlpha1); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscribeTopicEventsInitialRequestAlpha1); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscribeTopicEventsResponseAlpha1); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeBindingRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeBindingResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSecretRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetSecretResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetBulkSecretRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SecretResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetBulkSecretResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TransactionalStateOperation); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ExecuteStateTransactionRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RegisterActorTimerRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UnregisterActorTimerRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RegisterActorReminderRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UnregisterActorReminderRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetActorStateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetActorStateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ExecuteActorStateTransactionRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TransactionalActorStateOperation); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeActorRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*InvokeActorResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetMetadataRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetMetadataResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ActorRuntime); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ActiveActorsCount); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RegisteredComponents); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MetadataHTTPEndpoint); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AppConnectionProperties); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*AppConnectionHealthProperties); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PubsubSubscription); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PubsubSubscriptionRules); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PubsubSubscriptionRule); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SetMetadataRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetConfigurationRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetConfigurationResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscribeConfigurationRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UnsubscribeConfigurationRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubscribeConfigurationResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UnsubscribeConfigurationResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TryLockRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TryLockResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UnlockRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*UnlockResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleGetKeyRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleGetKeyResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleEncryptRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleEncryptResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleDecryptRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleDecryptResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleWrapKeyRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleWrapKeyResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleUnwrapKeyRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleUnwrapKeyResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleSignRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleSignResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleVerifyRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SubtleVerifyResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*EncryptRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*EncryptRequestOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*EncryptResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DecryptRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DecryptRequestOptions); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DecryptResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetWorkflowResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StartWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*StartWorkflowResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TerminateWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PauseWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ResumeWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RaiseEventWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PurgeWorkflowRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ShutdownRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[17].OneofWrappers = []interface{}{
(*SubscribeTopicEventsRequestAlpha1_InitialRequest)(nil),
(*SubscribeTopicEventsRequestAlpha1_EventResponse)(nil),
}
file_dapr_proto_runtime_v1_dapr_proto_msgTypes[18].OneofWrappers = []interface{}{}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_runtime_v1_dapr_proto_rawDesc,
NumEnums: 3,
NumMessages: 121,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_runtime_v1_dapr_proto_goTypes,
DependencyIndexes: file_dapr_proto_runtime_v1_dapr_proto_depIdxs,
EnumInfos: file_dapr_proto_runtime_v1_dapr_proto_enumTypes,
MessageInfos: file_dapr_proto_runtime_v1_dapr_proto_msgTypes,
}.Build()
File_dapr_proto_runtime_v1_dapr_proto = out.File
file_dapr_proto_runtime_v1_dapr_proto_rawDesc = nil
file_dapr_proto_runtime_v1_dapr_proto_goTypes = nil
file_dapr_proto_runtime_v1_dapr_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/dapr.pb.go
|
GO
|
mit
| 384,503 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package runtime
import (
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/types/known/anypb"
commonv1pb "github.com/dapr/dapr/pkg/proto/common/v1"
internalv1pb "github.com/dapr/dapr/pkg/proto/internals/v1"
)
// This file contains additional, hand-written methods added to the generated objects.
func (x *InvokeActorRequest) ToInternalInvokeRequest() *internalv1pb.InternalInvokeRequest {
if x == nil {
return nil
}
r := &internalv1pb.InternalInvokeRequest{
Ver: internalv1pb.APIVersion_V1,
Message: &commonv1pb.InvokeRequest{
Method: x.Method,
},
}
if len(x.Data) > 0 {
r.Message.Data = &anypb.Any{
Value: x.Data,
}
}
if x.ActorType != "" && x.ActorId != "" {
r.Actor = &internalv1pb.Actor{
ActorType: x.ActorType,
ActorId: x.ActorId,
}
}
if len(x.Metadata) > 0 {
r.Metadata = make(map[string]*internalv1pb.ListStringValue, len(x.Metadata))
for k, v := range x.Metadata {
r.Metadata[k] = &internalv1pb.ListStringValue{
Values: []string{v},
}
}
}
return r
}
// WorkflowRequests is an interface for all a number of *WorkflowRequest structs.
type WorkflowRequests interface {
// SetWorkflowComponent sets the value of the WorkflowComponent property.
SetWorkflowComponent(val string)
// SetInstanceId sets the value of the InstanceId property.
SetInstanceId(val string)
}
func (x *GetWorkflowRequest) SetWorkflowComponent(val string) {
if x != nil {
x.WorkflowComponent = val
}
}
func (x *GetWorkflowRequest) SetInstanceId(val string) {
if x != nil {
x.InstanceId = val
}
}
func (x *TerminateWorkflowRequest) SetWorkflowComponent(val string) {
if x != nil {
x.WorkflowComponent = val
}
}
func (x *TerminateWorkflowRequest) SetInstanceId(val string) {
if x != nil {
x.InstanceId = val
}
}
func (x *PauseWorkflowRequest) SetWorkflowComponent(val string) {
if x != nil {
x.WorkflowComponent = val
}
}
func (x *PauseWorkflowRequest) SetInstanceId(val string) {
if x != nil {
x.InstanceId = val
}
}
func (x *ResumeWorkflowRequest) SetWorkflowComponent(val string) {
if x != nil {
x.WorkflowComponent = val
}
}
func (x *ResumeWorkflowRequest) SetInstanceId(val string) {
if x != nil {
x.InstanceId = val
}
}
func (x *PurgeWorkflowRequest) SetWorkflowComponent(val string) {
if x != nil {
x.WorkflowComponent = val
}
}
func (x *PurgeWorkflowRequest) SetInstanceId(val string) {
if x != nil {
x.InstanceId = val
}
}
// SubtleCryptoRequests is an interface for all Subtle*Request structs.
type SubtleCryptoRequests interface {
// SetComponentName sets the value of the ComponentName property.
SetComponentName(name string)
}
func (x *SubtleGetKeyRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
func (x *SubtleEncryptRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
func (x *SubtleDecryptRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
func (x *SubtleWrapKeyRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
func (x *SubtleUnwrapKeyRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
func (x *SubtleSignRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
func (x *SubtleVerifyRequest) SetComponentName(name string) {
if x != nil {
x.ComponentName = name
}
}
// CryptoRequests is an interface for EncryptRequest and DecryptRequest.
type CryptoRequests interface {
proto.Message
// SetPayload sets the payload.
SetPayload(payload *commonv1pb.StreamPayload)
// GetPayload returns the payload.
GetPayload() *commonv1pb.StreamPayload
// Reset the object.
Reset()
// SetOptions sets the Options property.
SetOptions(opts proto.Message)
// HasOptions returns true if the Options property is not empty.
HasOptions() bool
}
func (x *EncryptRequest) SetPayload(payload *commonv1pb.StreamPayload) {
if x == nil {
return
}
x.Payload = payload
}
func (x *EncryptRequest) SetOptions(opts proto.Message) {
if x == nil {
return
}
x.Options = opts.(*EncryptRequestOptions)
}
func (x *EncryptRequest) HasOptions() bool {
return x != nil && x.Options != nil
}
func (x *DecryptRequest) SetPayload(payload *commonv1pb.StreamPayload) {
if x == nil {
return
}
x.Payload = payload
}
func (x *DecryptRequest) SetOptions(opts proto.Message) {
if x == nil {
return
}
x.Options = opts.(*DecryptRequestOptions)
}
func (x *DecryptRequest) HasOptions() bool {
return x != nil && x.Options != nil
}
// CryptoResponses is an interface for EncryptResponse and DecryptResponse.
type CryptoResponses interface {
proto.Message
// SetPayload sets the payload.
SetPayload(payload *commonv1pb.StreamPayload)
// GetPayload returns the payload.
GetPayload() *commonv1pb.StreamPayload
// Reset the object.
Reset()
}
func (x *EncryptResponse) SetPayload(payload *commonv1pb.StreamPayload) {
if x == nil {
return
}
x.Payload = payload
}
func (x *DecryptResponse) SetPayload(payload *commonv1pb.StreamPayload) {
if x == nil {
return
}
x.Payload = payload
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/dapr_additional.go
|
GO
|
mit
| 5,696 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/runtime/v1/dapr.proto
package runtime
import (
context "context"
v1 "github.com/dapr/dapr/pkg/proto/common/v1"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
Dapr_InvokeService_FullMethodName = "/dapr.proto.runtime.v1.Dapr/InvokeService"
Dapr_GetState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetState"
Dapr_GetBulkState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetBulkState"
Dapr_SaveState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SaveState"
Dapr_QueryStateAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/QueryStateAlpha1"
Dapr_DeleteState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DeleteState"
Dapr_DeleteBulkState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DeleteBulkState"
Dapr_ExecuteStateTransaction_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ExecuteStateTransaction"
Dapr_PublishEvent_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PublishEvent"
Dapr_BulkPublishEventAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/BulkPublishEventAlpha1"
Dapr_SubscribeTopicEventsAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubscribeTopicEventsAlpha1"
Dapr_InvokeBinding_FullMethodName = "/dapr.proto.runtime.v1.Dapr/InvokeBinding"
Dapr_GetSecret_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetSecret"
Dapr_GetBulkSecret_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetBulkSecret"
Dapr_RegisterActorTimer_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RegisterActorTimer"
Dapr_UnregisterActorTimer_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnregisterActorTimer"
Dapr_RegisterActorReminder_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RegisterActorReminder"
Dapr_UnregisterActorReminder_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnregisterActorReminder"
Dapr_GetActorState_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetActorState"
Dapr_ExecuteActorStateTransaction_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ExecuteActorStateTransaction"
Dapr_InvokeActor_FullMethodName = "/dapr.proto.runtime.v1.Dapr/InvokeActor"
Dapr_GetConfigurationAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetConfigurationAlpha1"
Dapr_GetConfiguration_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetConfiguration"
Dapr_SubscribeConfigurationAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubscribeConfigurationAlpha1"
Dapr_SubscribeConfiguration_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubscribeConfiguration"
Dapr_UnsubscribeConfigurationAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfigurationAlpha1"
Dapr_UnsubscribeConfiguration_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnsubscribeConfiguration"
Dapr_TryLockAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/TryLockAlpha1"
Dapr_UnlockAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/UnlockAlpha1"
Dapr_EncryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/EncryptAlpha1"
Dapr_DecryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/DecryptAlpha1"
Dapr_GetMetadata_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetMetadata"
Dapr_SetMetadata_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SetMetadata"
Dapr_SubtleGetKeyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleGetKeyAlpha1"
Dapr_SubtleEncryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleEncryptAlpha1"
Dapr_SubtleDecryptAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleDecryptAlpha1"
Dapr_SubtleWrapKeyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleWrapKeyAlpha1"
Dapr_SubtleUnwrapKeyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleUnwrapKeyAlpha1"
Dapr_SubtleSignAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleSignAlpha1"
Dapr_SubtleVerifyAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/SubtleVerifyAlpha1"
Dapr_StartWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/StartWorkflowAlpha1"
Dapr_GetWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetWorkflowAlpha1"
Dapr_PurgeWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowAlpha1"
Dapr_TerminateWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowAlpha1"
Dapr_PauseWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PauseWorkflowAlpha1"
Dapr_ResumeWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowAlpha1"
Dapr_RaiseEventWorkflowAlpha1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowAlpha1"
Dapr_StartWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/StartWorkflowBeta1"
Dapr_GetWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/GetWorkflowBeta1"
Dapr_PurgeWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PurgeWorkflowBeta1"
Dapr_TerminateWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/TerminateWorkflowBeta1"
Dapr_PauseWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/PauseWorkflowBeta1"
Dapr_ResumeWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/ResumeWorkflowBeta1"
Dapr_RaiseEventWorkflowBeta1_FullMethodName = "/dapr.proto.runtime.v1.Dapr/RaiseEventWorkflowBeta1"
Dapr_Shutdown_FullMethodName = "/dapr.proto.runtime.v1.Dapr/Shutdown"
)
// DaprClient is the client API for Dapr service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type DaprClient interface {
// Invokes a method on a remote Dapr app.
// Deprecated: Use proxy mode service invocation instead.
InvokeService(ctx context.Context, in *InvokeServiceRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error)
// Gets the state for a specific key.
GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error)
// Gets a bulk of state items for a list of keys
GetBulkState(ctx context.Context, in *GetBulkStateRequest, opts ...grpc.CallOption) (*GetBulkStateResponse, error)
// Saves the state for a specific key.
SaveState(ctx context.Context, in *SaveStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Queries the state.
QueryStateAlpha1(ctx context.Context, in *QueryStateRequest, opts ...grpc.CallOption) (*QueryStateResponse, error)
// Deletes the state for a specific key.
DeleteState(ctx context.Context, in *DeleteStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Deletes a bulk of state items for a list of keys
DeleteBulkState(ctx context.Context, in *DeleteBulkStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Executes transactions for a specified store
ExecuteStateTransaction(ctx context.Context, in *ExecuteStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Publishes events to the specific topic.
PublishEvent(ctx context.Context, in *PublishEventRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Bulk Publishes multiple events to the specified topic.
BulkPublishEventAlpha1(ctx context.Context, in *BulkPublishRequest, opts ...grpc.CallOption) (*BulkPublishResponse, error)
// SubscribeTopicEventsAlpha1 subscribes to a PubSub topic and receives topic
// events from it.
SubscribeTopicEventsAlpha1(ctx context.Context, opts ...grpc.CallOption) (Dapr_SubscribeTopicEventsAlpha1Client, error)
// Invokes binding data to specific output bindings
InvokeBinding(ctx context.Context, in *InvokeBindingRequest, opts ...grpc.CallOption) (*InvokeBindingResponse, error)
// Gets secrets from secret stores.
GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error)
// Gets a bulk of secrets
GetBulkSecret(ctx context.Context, in *GetBulkSecretRequest, opts ...grpc.CallOption) (*GetBulkSecretResponse, error)
// Register an actor timer.
RegisterActorTimer(ctx context.Context, in *RegisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Unregister an actor timer.
UnregisterActorTimer(ctx context.Context, in *UnregisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Register an actor reminder.
RegisterActorReminder(ctx context.Context, in *RegisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Unregister an actor reminder.
UnregisterActorReminder(ctx context.Context, in *UnregisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Gets the state for a specific actor.
GetActorState(ctx context.Context, in *GetActorStateRequest, opts ...grpc.CallOption) (*GetActorStateResponse, error)
// Executes state transactions for a specified actor
ExecuteActorStateTransaction(ctx context.Context, in *ExecuteActorStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// InvokeActor calls a method on an actor.
InvokeActor(ctx context.Context, in *InvokeActorRequest, opts ...grpc.CallOption) (*InvokeActorResponse, error)
// GetConfiguration gets configuration from configuration store.
GetConfigurationAlpha1(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error)
// GetConfiguration gets configuration from configuration store.
GetConfiguration(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error)
// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream
SubscribeConfigurationAlpha1(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (Dapr_SubscribeConfigurationAlpha1Client, error)
// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream
SubscribeConfiguration(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (Dapr_SubscribeConfigurationClient, error)
// UnSubscribeConfiguration unsubscribe the subscription of configuration
UnsubscribeConfigurationAlpha1(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error)
// UnSubscribeConfiguration unsubscribe the subscription of configuration
UnsubscribeConfiguration(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error)
// TryLockAlpha1 tries to get a lock with an expiry.
TryLockAlpha1(ctx context.Context, in *TryLockRequest, opts ...grpc.CallOption) (*TryLockResponse, error)
// UnlockAlpha1 unlocks a lock.
UnlockAlpha1(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error)
// EncryptAlpha1 encrypts a message using the Dapr encryption scheme and a key stored in the vault.
EncryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (Dapr_EncryptAlpha1Client, error)
// DecryptAlpha1 decrypts a message using the Dapr encryption scheme and a key stored in the vault.
DecryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (Dapr_DecryptAlpha1Client, error)
// Gets metadata of the sidecar
GetMetadata(ctx context.Context, in *GetMetadataRequest, opts ...grpc.CallOption) (*GetMetadataResponse, error)
// Sets value in extended metadata of the sidecar
SetMetadata(ctx context.Context, in *SetMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// SubtleGetKeyAlpha1 returns the public part of an asymmetric key stored in the vault.
SubtleGetKeyAlpha1(ctx context.Context, in *SubtleGetKeyRequest, opts ...grpc.CallOption) (*SubtleGetKeyResponse, error)
// SubtleEncryptAlpha1 encrypts a small message using a key stored in the vault.
SubtleEncryptAlpha1(ctx context.Context, in *SubtleEncryptRequest, opts ...grpc.CallOption) (*SubtleEncryptResponse, error)
// SubtleDecryptAlpha1 decrypts a small message using a key stored in the vault.
SubtleDecryptAlpha1(ctx context.Context, in *SubtleDecryptRequest, opts ...grpc.CallOption) (*SubtleDecryptResponse, error)
// SubtleWrapKeyAlpha1 wraps a key using a key stored in the vault.
SubtleWrapKeyAlpha1(ctx context.Context, in *SubtleWrapKeyRequest, opts ...grpc.CallOption) (*SubtleWrapKeyResponse, error)
// SubtleUnwrapKeyAlpha1 unwraps a key using a key stored in the vault.
SubtleUnwrapKeyAlpha1(ctx context.Context, in *SubtleUnwrapKeyRequest, opts ...grpc.CallOption) (*SubtleUnwrapKeyResponse, error)
// SubtleSignAlpha1 signs a message using a key stored in the vault.
SubtleSignAlpha1(ctx context.Context, in *SubtleSignRequest, opts ...grpc.CallOption) (*SubtleSignResponse, error)
// SubtleVerifyAlpha1 verifies the signature of a message using a key stored in the vault.
SubtleVerifyAlpha1(ctx context.Context, in *SubtleVerifyRequest, opts ...grpc.CallOption) (*SubtleVerifyResponse, error)
// Starts a new instance of a workflow
StartWorkflowAlpha1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error)
// Gets details about a started workflow instance
GetWorkflowAlpha1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error)
// Purge Workflow
PurgeWorkflowAlpha1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Terminates a running workflow instance
TerminateWorkflowAlpha1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Pauses a running workflow instance
PauseWorkflowAlpha1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Resumes a paused workflow instance
ResumeWorkflowAlpha1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Raise an event to a running workflow instance
RaiseEventWorkflowAlpha1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Starts a new instance of a workflow
StartWorkflowBeta1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error)
// Gets details about a started workflow instance
GetWorkflowBeta1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error)
// Purge Workflow
PurgeWorkflowBeta1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Terminates a running workflow instance
TerminateWorkflowBeta1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Pauses a running workflow instance
PauseWorkflowBeta1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Resumes a paused workflow instance
ResumeWorkflowBeta1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Raise an event to a running workflow instance
RaiseEventWorkflowBeta1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// Shutdown the sidecar
Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}
type daprClient struct {
cc grpc.ClientConnInterface
}
func NewDaprClient(cc grpc.ClientConnInterface) DaprClient {
return &daprClient{cc}
}
func (c *daprClient) InvokeService(ctx context.Context, in *InvokeServiceRequest, opts ...grpc.CallOption) (*v1.InvokeResponse, error) {
out := new(v1.InvokeResponse)
err := c.cc.Invoke(ctx, Dapr_InvokeService_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateResponse, error) {
out := new(GetStateResponse)
err := c.cc.Invoke(ctx, Dapr_GetState_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetBulkState(ctx context.Context, in *GetBulkStateRequest, opts ...grpc.CallOption) (*GetBulkStateResponse, error) {
out := new(GetBulkStateResponse)
err := c.cc.Invoke(ctx, Dapr_GetBulkState_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SaveState(ctx context.Context, in *SaveStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_SaveState_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) QueryStateAlpha1(ctx context.Context, in *QueryStateRequest, opts ...grpc.CallOption) (*QueryStateResponse, error) {
out := new(QueryStateResponse)
err := c.cc.Invoke(ctx, Dapr_QueryStateAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) DeleteState(ctx context.Context, in *DeleteStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_DeleteState_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) DeleteBulkState(ctx context.Context, in *DeleteBulkStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_DeleteBulkState_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) ExecuteStateTransaction(ctx context.Context, in *ExecuteStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_ExecuteStateTransaction_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) PublishEvent(ctx context.Context, in *PublishEventRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_PublishEvent_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) BulkPublishEventAlpha1(ctx context.Context, in *BulkPublishRequest, opts ...grpc.CallOption) (*BulkPublishResponse, error) {
out := new(BulkPublishResponse)
err := c.cc.Invoke(ctx, Dapr_BulkPublishEventAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubscribeTopicEventsAlpha1(ctx context.Context, opts ...grpc.CallOption) (Dapr_SubscribeTopicEventsAlpha1Client, error) {
stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[0], Dapr_SubscribeTopicEventsAlpha1_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &daprSubscribeTopicEventsAlpha1Client{stream}
return x, nil
}
type Dapr_SubscribeTopicEventsAlpha1Client interface {
Send(*SubscribeTopicEventsRequestAlpha1) error
Recv() (*TopicEventRequest, error)
grpc.ClientStream
}
type daprSubscribeTopicEventsAlpha1Client struct {
grpc.ClientStream
}
func (x *daprSubscribeTopicEventsAlpha1Client) Send(m *SubscribeTopicEventsRequestAlpha1) error {
return x.ClientStream.SendMsg(m)
}
func (x *daprSubscribeTopicEventsAlpha1Client) Recv() (*TopicEventRequest, error) {
m := new(TopicEventRequest)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *daprClient) InvokeBinding(ctx context.Context, in *InvokeBindingRequest, opts ...grpc.CallOption) (*InvokeBindingResponse, error) {
out := new(InvokeBindingResponse)
err := c.cc.Invoke(ctx, Dapr_InvokeBinding_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetSecret(ctx context.Context, in *GetSecretRequest, opts ...grpc.CallOption) (*GetSecretResponse, error) {
out := new(GetSecretResponse)
err := c.cc.Invoke(ctx, Dapr_GetSecret_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetBulkSecret(ctx context.Context, in *GetBulkSecretRequest, opts ...grpc.CallOption) (*GetBulkSecretResponse, error) {
out := new(GetBulkSecretResponse)
err := c.cc.Invoke(ctx, Dapr_GetBulkSecret_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) RegisterActorTimer(ctx context.Context, in *RegisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_RegisterActorTimer_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) UnregisterActorTimer(ctx context.Context, in *UnregisterActorTimerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_UnregisterActorTimer_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) RegisterActorReminder(ctx context.Context, in *RegisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_RegisterActorReminder_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) UnregisterActorReminder(ctx context.Context, in *UnregisterActorReminderRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_UnregisterActorReminder_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetActorState(ctx context.Context, in *GetActorStateRequest, opts ...grpc.CallOption) (*GetActorStateResponse, error) {
out := new(GetActorStateResponse)
err := c.cc.Invoke(ctx, Dapr_GetActorState_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) ExecuteActorStateTransaction(ctx context.Context, in *ExecuteActorStateTransactionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_ExecuteActorStateTransaction_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) InvokeActor(ctx context.Context, in *InvokeActorRequest, opts ...grpc.CallOption) (*InvokeActorResponse, error) {
out := new(InvokeActorResponse)
err := c.cc.Invoke(ctx, Dapr_InvokeActor_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetConfigurationAlpha1(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) {
out := new(GetConfigurationResponse)
err := c.cc.Invoke(ctx, Dapr_GetConfigurationAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetConfiguration(ctx context.Context, in *GetConfigurationRequest, opts ...grpc.CallOption) (*GetConfigurationResponse, error) {
out := new(GetConfigurationResponse)
err := c.cc.Invoke(ctx, Dapr_GetConfiguration_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubscribeConfigurationAlpha1(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (Dapr_SubscribeConfigurationAlpha1Client, error) {
stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[1], Dapr_SubscribeConfigurationAlpha1_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &daprSubscribeConfigurationAlpha1Client{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Dapr_SubscribeConfigurationAlpha1Client interface {
Recv() (*SubscribeConfigurationResponse, error)
grpc.ClientStream
}
type daprSubscribeConfigurationAlpha1Client struct {
grpc.ClientStream
}
func (x *daprSubscribeConfigurationAlpha1Client) Recv() (*SubscribeConfigurationResponse, error) {
m := new(SubscribeConfigurationResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *daprClient) SubscribeConfiguration(ctx context.Context, in *SubscribeConfigurationRequest, opts ...grpc.CallOption) (Dapr_SubscribeConfigurationClient, error) {
stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[2], Dapr_SubscribeConfiguration_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &daprSubscribeConfigurationClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Dapr_SubscribeConfigurationClient interface {
Recv() (*SubscribeConfigurationResponse, error)
grpc.ClientStream
}
type daprSubscribeConfigurationClient struct {
grpc.ClientStream
}
func (x *daprSubscribeConfigurationClient) Recv() (*SubscribeConfigurationResponse, error) {
m := new(SubscribeConfigurationResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *daprClient) UnsubscribeConfigurationAlpha1(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error) {
out := new(UnsubscribeConfigurationResponse)
err := c.cc.Invoke(ctx, Dapr_UnsubscribeConfigurationAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) UnsubscribeConfiguration(ctx context.Context, in *UnsubscribeConfigurationRequest, opts ...grpc.CallOption) (*UnsubscribeConfigurationResponse, error) {
out := new(UnsubscribeConfigurationResponse)
err := c.cc.Invoke(ctx, Dapr_UnsubscribeConfiguration_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) TryLockAlpha1(ctx context.Context, in *TryLockRequest, opts ...grpc.CallOption) (*TryLockResponse, error) {
out := new(TryLockResponse)
err := c.cc.Invoke(ctx, Dapr_TryLockAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) UnlockAlpha1(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error) {
out := new(UnlockResponse)
err := c.cc.Invoke(ctx, Dapr_UnlockAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) EncryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (Dapr_EncryptAlpha1Client, error) {
stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[3], Dapr_EncryptAlpha1_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &daprEncryptAlpha1Client{stream}
return x, nil
}
type Dapr_EncryptAlpha1Client interface {
Send(*EncryptRequest) error
Recv() (*EncryptResponse, error)
grpc.ClientStream
}
type daprEncryptAlpha1Client struct {
grpc.ClientStream
}
func (x *daprEncryptAlpha1Client) Send(m *EncryptRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *daprEncryptAlpha1Client) Recv() (*EncryptResponse, error) {
m := new(EncryptResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *daprClient) DecryptAlpha1(ctx context.Context, opts ...grpc.CallOption) (Dapr_DecryptAlpha1Client, error) {
stream, err := c.cc.NewStream(ctx, &Dapr_ServiceDesc.Streams[4], Dapr_DecryptAlpha1_FullMethodName, opts...)
if err != nil {
return nil, err
}
x := &daprDecryptAlpha1Client{stream}
return x, nil
}
type Dapr_DecryptAlpha1Client interface {
Send(*DecryptRequest) error
Recv() (*DecryptResponse, error)
grpc.ClientStream
}
type daprDecryptAlpha1Client struct {
grpc.ClientStream
}
func (x *daprDecryptAlpha1Client) Send(m *DecryptRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *daprDecryptAlpha1Client) Recv() (*DecryptResponse, error) {
m := new(DecryptResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *daprClient) GetMetadata(ctx context.Context, in *GetMetadataRequest, opts ...grpc.CallOption) (*GetMetadataResponse, error) {
out := new(GetMetadataResponse)
err := c.cc.Invoke(ctx, Dapr_GetMetadata_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SetMetadata(ctx context.Context, in *SetMetadataRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_SetMetadata_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleGetKeyAlpha1(ctx context.Context, in *SubtleGetKeyRequest, opts ...grpc.CallOption) (*SubtleGetKeyResponse, error) {
out := new(SubtleGetKeyResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleGetKeyAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleEncryptAlpha1(ctx context.Context, in *SubtleEncryptRequest, opts ...grpc.CallOption) (*SubtleEncryptResponse, error) {
out := new(SubtleEncryptResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleEncryptAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleDecryptAlpha1(ctx context.Context, in *SubtleDecryptRequest, opts ...grpc.CallOption) (*SubtleDecryptResponse, error) {
out := new(SubtleDecryptResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleDecryptAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleWrapKeyAlpha1(ctx context.Context, in *SubtleWrapKeyRequest, opts ...grpc.CallOption) (*SubtleWrapKeyResponse, error) {
out := new(SubtleWrapKeyResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleWrapKeyAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleUnwrapKeyAlpha1(ctx context.Context, in *SubtleUnwrapKeyRequest, opts ...grpc.CallOption) (*SubtleUnwrapKeyResponse, error) {
out := new(SubtleUnwrapKeyResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleUnwrapKeyAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleSignAlpha1(ctx context.Context, in *SubtleSignRequest, opts ...grpc.CallOption) (*SubtleSignResponse, error) {
out := new(SubtleSignResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleSignAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) SubtleVerifyAlpha1(ctx context.Context, in *SubtleVerifyRequest, opts ...grpc.CallOption) (*SubtleVerifyResponse, error) {
out := new(SubtleVerifyResponse)
err := c.cc.Invoke(ctx, Dapr_SubtleVerifyAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) StartWorkflowAlpha1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error) {
out := new(StartWorkflowResponse)
err := c.cc.Invoke(ctx, Dapr_StartWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetWorkflowAlpha1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error) {
out := new(GetWorkflowResponse)
err := c.cc.Invoke(ctx, Dapr_GetWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) PurgeWorkflowAlpha1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_PurgeWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) TerminateWorkflowAlpha1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_TerminateWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) PauseWorkflowAlpha1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_PauseWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) ResumeWorkflowAlpha1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_ResumeWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) RaiseEventWorkflowAlpha1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_RaiseEventWorkflowAlpha1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) StartWorkflowBeta1(ctx context.Context, in *StartWorkflowRequest, opts ...grpc.CallOption) (*StartWorkflowResponse, error) {
out := new(StartWorkflowResponse)
err := c.cc.Invoke(ctx, Dapr_StartWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) GetWorkflowBeta1(ctx context.Context, in *GetWorkflowRequest, opts ...grpc.CallOption) (*GetWorkflowResponse, error) {
out := new(GetWorkflowResponse)
err := c.cc.Invoke(ctx, Dapr_GetWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) PurgeWorkflowBeta1(ctx context.Context, in *PurgeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_PurgeWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) TerminateWorkflowBeta1(ctx context.Context, in *TerminateWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_TerminateWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) PauseWorkflowBeta1(ctx context.Context, in *PauseWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_PauseWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) ResumeWorkflowBeta1(ctx context.Context, in *ResumeWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_ResumeWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) RaiseEventWorkflowBeta1(ctx context.Context, in *RaiseEventWorkflowRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_RaiseEventWorkflowBeta1_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *daprClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
out := new(emptypb.Empty)
err := c.cc.Invoke(ctx, Dapr_Shutdown_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// DaprServer is the server API for Dapr service.
// All implementations should embed UnimplementedDaprServer
// for forward compatibility
type DaprServer interface {
// Invokes a method on a remote Dapr app.
// Deprecated: Use proxy mode service invocation instead.
InvokeService(context.Context, *InvokeServiceRequest) (*v1.InvokeResponse, error)
// Gets the state for a specific key.
GetState(context.Context, *GetStateRequest) (*GetStateResponse, error)
// Gets a bulk of state items for a list of keys
GetBulkState(context.Context, *GetBulkStateRequest) (*GetBulkStateResponse, error)
// Saves the state for a specific key.
SaveState(context.Context, *SaveStateRequest) (*emptypb.Empty, error)
// Queries the state.
QueryStateAlpha1(context.Context, *QueryStateRequest) (*QueryStateResponse, error)
// Deletes the state for a specific key.
DeleteState(context.Context, *DeleteStateRequest) (*emptypb.Empty, error)
// Deletes a bulk of state items for a list of keys
DeleteBulkState(context.Context, *DeleteBulkStateRequest) (*emptypb.Empty, error)
// Executes transactions for a specified store
ExecuteStateTransaction(context.Context, *ExecuteStateTransactionRequest) (*emptypb.Empty, error)
// Publishes events to the specific topic.
PublishEvent(context.Context, *PublishEventRequest) (*emptypb.Empty, error)
// Bulk Publishes multiple events to the specified topic.
BulkPublishEventAlpha1(context.Context, *BulkPublishRequest) (*BulkPublishResponse, error)
// SubscribeTopicEventsAlpha1 subscribes to a PubSub topic and receives topic
// events from it.
SubscribeTopicEventsAlpha1(Dapr_SubscribeTopicEventsAlpha1Server) error
// Invokes binding data to specific output bindings
InvokeBinding(context.Context, *InvokeBindingRequest) (*InvokeBindingResponse, error)
// Gets secrets from secret stores.
GetSecret(context.Context, *GetSecretRequest) (*GetSecretResponse, error)
// Gets a bulk of secrets
GetBulkSecret(context.Context, *GetBulkSecretRequest) (*GetBulkSecretResponse, error)
// Register an actor timer.
RegisterActorTimer(context.Context, *RegisterActorTimerRequest) (*emptypb.Empty, error)
// Unregister an actor timer.
UnregisterActorTimer(context.Context, *UnregisterActorTimerRequest) (*emptypb.Empty, error)
// Register an actor reminder.
RegisterActorReminder(context.Context, *RegisterActorReminderRequest) (*emptypb.Empty, error)
// Unregister an actor reminder.
UnregisterActorReminder(context.Context, *UnregisterActorReminderRequest) (*emptypb.Empty, error)
// Gets the state for a specific actor.
GetActorState(context.Context, *GetActorStateRequest) (*GetActorStateResponse, error)
// Executes state transactions for a specified actor
ExecuteActorStateTransaction(context.Context, *ExecuteActorStateTransactionRequest) (*emptypb.Empty, error)
// InvokeActor calls a method on an actor.
InvokeActor(context.Context, *InvokeActorRequest) (*InvokeActorResponse, error)
// GetConfiguration gets configuration from configuration store.
GetConfigurationAlpha1(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error)
// GetConfiguration gets configuration from configuration store.
GetConfiguration(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error)
// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream
SubscribeConfigurationAlpha1(*SubscribeConfigurationRequest, Dapr_SubscribeConfigurationAlpha1Server) error
// SubscribeConfiguration gets configuration from configuration store and subscribe the updates event by grpc stream
SubscribeConfiguration(*SubscribeConfigurationRequest, Dapr_SubscribeConfigurationServer) error
// UnSubscribeConfiguration unsubscribe the subscription of configuration
UnsubscribeConfigurationAlpha1(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error)
// UnSubscribeConfiguration unsubscribe the subscription of configuration
UnsubscribeConfiguration(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error)
// TryLockAlpha1 tries to get a lock with an expiry.
TryLockAlpha1(context.Context, *TryLockRequest) (*TryLockResponse, error)
// UnlockAlpha1 unlocks a lock.
UnlockAlpha1(context.Context, *UnlockRequest) (*UnlockResponse, error)
// EncryptAlpha1 encrypts a message using the Dapr encryption scheme and a key stored in the vault.
EncryptAlpha1(Dapr_EncryptAlpha1Server) error
// DecryptAlpha1 decrypts a message using the Dapr encryption scheme and a key stored in the vault.
DecryptAlpha1(Dapr_DecryptAlpha1Server) error
// Gets metadata of the sidecar
GetMetadata(context.Context, *GetMetadataRequest) (*GetMetadataResponse, error)
// Sets value in extended metadata of the sidecar
SetMetadata(context.Context, *SetMetadataRequest) (*emptypb.Empty, error)
// SubtleGetKeyAlpha1 returns the public part of an asymmetric key stored in the vault.
SubtleGetKeyAlpha1(context.Context, *SubtleGetKeyRequest) (*SubtleGetKeyResponse, error)
// SubtleEncryptAlpha1 encrypts a small message using a key stored in the vault.
SubtleEncryptAlpha1(context.Context, *SubtleEncryptRequest) (*SubtleEncryptResponse, error)
// SubtleDecryptAlpha1 decrypts a small message using a key stored in the vault.
SubtleDecryptAlpha1(context.Context, *SubtleDecryptRequest) (*SubtleDecryptResponse, error)
// SubtleWrapKeyAlpha1 wraps a key using a key stored in the vault.
SubtleWrapKeyAlpha1(context.Context, *SubtleWrapKeyRequest) (*SubtleWrapKeyResponse, error)
// SubtleUnwrapKeyAlpha1 unwraps a key using a key stored in the vault.
SubtleUnwrapKeyAlpha1(context.Context, *SubtleUnwrapKeyRequest) (*SubtleUnwrapKeyResponse, error)
// SubtleSignAlpha1 signs a message using a key stored in the vault.
SubtleSignAlpha1(context.Context, *SubtleSignRequest) (*SubtleSignResponse, error)
// SubtleVerifyAlpha1 verifies the signature of a message using a key stored in the vault.
SubtleVerifyAlpha1(context.Context, *SubtleVerifyRequest) (*SubtleVerifyResponse, error)
// Starts a new instance of a workflow
StartWorkflowAlpha1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error)
// Gets details about a started workflow instance
GetWorkflowAlpha1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error)
// Purge Workflow
PurgeWorkflowAlpha1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error)
// Terminates a running workflow instance
TerminateWorkflowAlpha1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error)
// Pauses a running workflow instance
PauseWorkflowAlpha1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error)
// Resumes a paused workflow instance
ResumeWorkflowAlpha1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error)
// Raise an event to a running workflow instance
RaiseEventWorkflowAlpha1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error)
// Starts a new instance of a workflow
StartWorkflowBeta1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error)
// Gets details about a started workflow instance
GetWorkflowBeta1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error)
// Purge Workflow
PurgeWorkflowBeta1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error)
// Terminates a running workflow instance
TerminateWorkflowBeta1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error)
// Pauses a running workflow instance
PauseWorkflowBeta1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error)
// Resumes a paused workflow instance
ResumeWorkflowBeta1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error)
// Raise an event to a running workflow instance
RaiseEventWorkflowBeta1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error)
// Shutdown the sidecar
Shutdown(context.Context, *ShutdownRequest) (*emptypb.Empty, error)
}
// UnimplementedDaprServer should be embedded to have forward compatible implementations.
type UnimplementedDaprServer struct {
}
func (UnimplementedDaprServer) InvokeService(context.Context, *InvokeServiceRequest) (*v1.InvokeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method InvokeService not implemented")
}
func (UnimplementedDaprServer) GetState(context.Context, *GetStateRequest) (*GetStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetState not implemented")
}
func (UnimplementedDaprServer) GetBulkState(context.Context, *GetBulkStateRequest) (*GetBulkStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetBulkState not implemented")
}
func (UnimplementedDaprServer) SaveState(context.Context, *SaveStateRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method SaveState not implemented")
}
func (UnimplementedDaprServer) QueryStateAlpha1(context.Context, *QueryStateRequest) (*QueryStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method QueryStateAlpha1 not implemented")
}
func (UnimplementedDaprServer) DeleteState(context.Context, *DeleteStateRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method DeleteState not implemented")
}
func (UnimplementedDaprServer) DeleteBulkState(context.Context, *DeleteBulkStateRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method DeleteBulkState not implemented")
}
func (UnimplementedDaprServer) ExecuteStateTransaction(context.Context, *ExecuteStateTransactionRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method ExecuteStateTransaction not implemented")
}
func (UnimplementedDaprServer) PublishEvent(context.Context, *PublishEventRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method PublishEvent not implemented")
}
func (UnimplementedDaprServer) BulkPublishEventAlpha1(context.Context, *BulkPublishRequest) (*BulkPublishResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BulkPublishEventAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubscribeTopicEventsAlpha1(Dapr_SubscribeTopicEventsAlpha1Server) error {
return status.Errorf(codes.Unimplemented, "method SubscribeTopicEventsAlpha1 not implemented")
}
func (UnimplementedDaprServer) InvokeBinding(context.Context, *InvokeBindingRequest) (*InvokeBindingResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method InvokeBinding not implemented")
}
func (UnimplementedDaprServer) GetSecret(context.Context, *GetSecretRequest) (*GetSecretResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetSecret not implemented")
}
func (UnimplementedDaprServer) GetBulkSecret(context.Context, *GetBulkSecretRequest) (*GetBulkSecretResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetBulkSecret not implemented")
}
func (UnimplementedDaprServer) RegisterActorTimer(context.Context, *RegisterActorTimerRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method RegisterActorTimer not implemented")
}
func (UnimplementedDaprServer) UnregisterActorTimer(context.Context, *UnregisterActorTimerRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method UnregisterActorTimer not implemented")
}
func (UnimplementedDaprServer) RegisterActorReminder(context.Context, *RegisterActorReminderRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method RegisterActorReminder not implemented")
}
func (UnimplementedDaprServer) UnregisterActorReminder(context.Context, *UnregisterActorReminderRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method UnregisterActorReminder not implemented")
}
func (UnimplementedDaprServer) GetActorState(context.Context, *GetActorStateRequest) (*GetActorStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetActorState not implemented")
}
func (UnimplementedDaprServer) ExecuteActorStateTransaction(context.Context, *ExecuteActorStateTransactionRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method ExecuteActorStateTransaction not implemented")
}
func (UnimplementedDaprServer) InvokeActor(context.Context, *InvokeActorRequest) (*InvokeActorResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method InvokeActor not implemented")
}
func (UnimplementedDaprServer) GetConfigurationAlpha1(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetConfigurationAlpha1 not implemented")
}
func (UnimplementedDaprServer) GetConfiguration(context.Context, *GetConfigurationRequest) (*GetConfigurationResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetConfiguration not implemented")
}
func (UnimplementedDaprServer) SubscribeConfigurationAlpha1(*SubscribeConfigurationRequest, Dapr_SubscribeConfigurationAlpha1Server) error {
return status.Errorf(codes.Unimplemented, "method SubscribeConfigurationAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubscribeConfiguration(*SubscribeConfigurationRequest, Dapr_SubscribeConfigurationServer) error {
return status.Errorf(codes.Unimplemented, "method SubscribeConfiguration not implemented")
}
func (UnimplementedDaprServer) UnsubscribeConfigurationAlpha1(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UnsubscribeConfigurationAlpha1 not implemented")
}
func (UnimplementedDaprServer) UnsubscribeConfiguration(context.Context, *UnsubscribeConfigurationRequest) (*UnsubscribeConfigurationResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UnsubscribeConfiguration not implemented")
}
func (UnimplementedDaprServer) TryLockAlpha1(context.Context, *TryLockRequest) (*TryLockResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method TryLockAlpha1 not implemented")
}
func (UnimplementedDaprServer) UnlockAlpha1(context.Context, *UnlockRequest) (*UnlockResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UnlockAlpha1 not implemented")
}
func (UnimplementedDaprServer) EncryptAlpha1(Dapr_EncryptAlpha1Server) error {
return status.Errorf(codes.Unimplemented, "method EncryptAlpha1 not implemented")
}
func (UnimplementedDaprServer) DecryptAlpha1(Dapr_DecryptAlpha1Server) error {
return status.Errorf(codes.Unimplemented, "method DecryptAlpha1 not implemented")
}
func (UnimplementedDaprServer) GetMetadata(context.Context, *GetMetadataRequest) (*GetMetadataResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetMetadata not implemented")
}
func (UnimplementedDaprServer) SetMetadata(context.Context, *SetMetadataRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetMetadata not implemented")
}
func (UnimplementedDaprServer) SubtleGetKeyAlpha1(context.Context, *SubtleGetKeyRequest) (*SubtleGetKeyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleGetKeyAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubtleEncryptAlpha1(context.Context, *SubtleEncryptRequest) (*SubtleEncryptResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleEncryptAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubtleDecryptAlpha1(context.Context, *SubtleDecryptRequest) (*SubtleDecryptResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleDecryptAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubtleWrapKeyAlpha1(context.Context, *SubtleWrapKeyRequest) (*SubtleWrapKeyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleWrapKeyAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubtleUnwrapKeyAlpha1(context.Context, *SubtleUnwrapKeyRequest) (*SubtleUnwrapKeyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleUnwrapKeyAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubtleSignAlpha1(context.Context, *SubtleSignRequest) (*SubtleSignResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleSignAlpha1 not implemented")
}
func (UnimplementedDaprServer) SubtleVerifyAlpha1(context.Context, *SubtleVerifyRequest) (*SubtleVerifyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubtleVerifyAlpha1 not implemented")
}
func (UnimplementedDaprServer) StartWorkflowAlpha1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method StartWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) GetWorkflowAlpha1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) PurgeWorkflowAlpha1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method PurgeWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) TerminateWorkflowAlpha1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method TerminateWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) PauseWorkflowAlpha1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method PauseWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) ResumeWorkflowAlpha1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method ResumeWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) RaiseEventWorkflowAlpha1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method RaiseEventWorkflowAlpha1 not implemented")
}
func (UnimplementedDaprServer) StartWorkflowBeta1(context.Context, *StartWorkflowRequest) (*StartWorkflowResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method StartWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) GetWorkflowBeta1(context.Context, *GetWorkflowRequest) (*GetWorkflowResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) PurgeWorkflowBeta1(context.Context, *PurgeWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method PurgeWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) TerminateWorkflowBeta1(context.Context, *TerminateWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method TerminateWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) PauseWorkflowBeta1(context.Context, *PauseWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method PauseWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) ResumeWorkflowBeta1(context.Context, *ResumeWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method ResumeWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) RaiseEventWorkflowBeta1(context.Context, *RaiseEventWorkflowRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method RaiseEventWorkflowBeta1 not implemented")
}
func (UnimplementedDaprServer) Shutdown(context.Context, *ShutdownRequest) (*emptypb.Empty, error) {
return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented")
}
// UnsafeDaprServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DaprServer will
// result in compilation errors.
type UnsafeDaprServer interface {
mustEmbedUnimplementedDaprServer()
}
func RegisterDaprServer(s grpc.ServiceRegistrar, srv DaprServer) {
s.RegisterService(&Dapr_ServiceDesc, srv)
}
func _Dapr_InvokeService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InvokeServiceRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).InvokeService(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_InvokeService_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).InvokeService(ctx, req.(*InvokeServiceRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetState_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetState(ctx, req.(*GetStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetBulkState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBulkStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetBulkState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetBulkState_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetBulkState(ctx, req.(*GetBulkStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SaveState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SaveStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SaveState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SaveState_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SaveState(ctx, req.(*SaveStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_QueryStateAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).QueryStateAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_QueryStateAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).QueryStateAlpha1(ctx, req.(*QueryStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_DeleteState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).DeleteState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_DeleteState_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).DeleteState(ctx, req.(*DeleteStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_DeleteBulkState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DeleteBulkStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).DeleteBulkState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_DeleteBulkState_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).DeleteBulkState(ctx, req.(*DeleteBulkStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_ExecuteStateTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ExecuteStateTransactionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).ExecuteStateTransaction(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_ExecuteStateTransaction_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).ExecuteStateTransaction(ctx, req.(*ExecuteStateTransactionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_PublishEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PublishEventRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).PublishEvent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_PublishEvent_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).PublishEvent(ctx, req.(*PublishEventRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_BulkPublishEventAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BulkPublishRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).BulkPublishEventAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_BulkPublishEventAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).BulkPublishEventAlpha1(ctx, req.(*BulkPublishRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubscribeTopicEventsAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(DaprServer).SubscribeTopicEventsAlpha1(&daprSubscribeTopicEventsAlpha1Server{stream})
}
type Dapr_SubscribeTopicEventsAlpha1Server interface {
Send(*TopicEventRequest) error
Recv() (*SubscribeTopicEventsRequestAlpha1, error)
grpc.ServerStream
}
type daprSubscribeTopicEventsAlpha1Server struct {
grpc.ServerStream
}
func (x *daprSubscribeTopicEventsAlpha1Server) Send(m *TopicEventRequest) error {
return x.ServerStream.SendMsg(m)
}
func (x *daprSubscribeTopicEventsAlpha1Server) Recv() (*SubscribeTopicEventsRequestAlpha1, error) {
m := new(SubscribeTopicEventsRequestAlpha1)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _Dapr_InvokeBinding_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InvokeBindingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).InvokeBinding(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_InvokeBinding_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).InvokeBinding(ctx, req.(*InvokeBindingRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSecretRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetSecret(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetSecret_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetSecret(ctx, req.(*GetSecretRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetBulkSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetBulkSecretRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetBulkSecret(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetBulkSecret_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetBulkSecret(ctx, req.(*GetBulkSecretRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_RegisterActorTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RegisterActorTimerRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).RegisterActorTimer(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_RegisterActorTimer_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).RegisterActorTimer(ctx, req.(*RegisterActorTimerRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_UnregisterActorTimer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UnregisterActorTimerRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).UnregisterActorTimer(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_UnregisterActorTimer_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).UnregisterActorTimer(ctx, req.(*UnregisterActorTimerRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_RegisterActorReminder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RegisterActorReminderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).RegisterActorReminder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_RegisterActorReminder_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).RegisterActorReminder(ctx, req.(*RegisterActorReminderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_UnregisterActorReminder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UnregisterActorReminderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).UnregisterActorReminder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_UnregisterActorReminder_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).UnregisterActorReminder(ctx, req.(*UnregisterActorReminderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetActorState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetActorStateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetActorState(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetActorState_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetActorState(ctx, req.(*GetActorStateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_ExecuteActorStateTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ExecuteActorStateTransactionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).ExecuteActorStateTransaction(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_ExecuteActorStateTransaction_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).ExecuteActorStateTransaction(ctx, req.(*ExecuteActorStateTransactionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_InvokeActor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InvokeActorRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).InvokeActor(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_InvokeActor_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).InvokeActor(ctx, req.(*InvokeActorRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetConfigurationAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConfigurationRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetConfigurationAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetConfigurationAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetConfigurationAlpha1(ctx, req.(*GetConfigurationRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConfigurationRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetConfiguration(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetConfiguration_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetConfiguration(ctx, req.(*GetConfigurationRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubscribeConfigurationAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SubscribeConfigurationRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(DaprServer).SubscribeConfigurationAlpha1(m, &daprSubscribeConfigurationAlpha1Server{stream})
}
type Dapr_SubscribeConfigurationAlpha1Server interface {
Send(*SubscribeConfigurationResponse) error
grpc.ServerStream
}
type daprSubscribeConfigurationAlpha1Server struct {
grpc.ServerStream
}
func (x *daprSubscribeConfigurationAlpha1Server) Send(m *SubscribeConfigurationResponse) error {
return x.ServerStream.SendMsg(m)
}
func _Dapr_SubscribeConfiguration_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SubscribeConfigurationRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(DaprServer).SubscribeConfiguration(m, &daprSubscribeConfigurationServer{stream})
}
type Dapr_SubscribeConfigurationServer interface {
Send(*SubscribeConfigurationResponse) error
grpc.ServerStream
}
type daprSubscribeConfigurationServer struct {
grpc.ServerStream
}
func (x *daprSubscribeConfigurationServer) Send(m *SubscribeConfigurationResponse) error {
return x.ServerStream.SendMsg(m)
}
func _Dapr_UnsubscribeConfigurationAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UnsubscribeConfigurationRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).UnsubscribeConfigurationAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_UnsubscribeConfigurationAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).UnsubscribeConfigurationAlpha1(ctx, req.(*UnsubscribeConfigurationRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_UnsubscribeConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UnsubscribeConfigurationRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).UnsubscribeConfiguration(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_UnsubscribeConfiguration_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).UnsubscribeConfiguration(ctx, req.(*UnsubscribeConfigurationRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_TryLockAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TryLockRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).TryLockAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_TryLockAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).TryLockAlpha1(ctx, req.(*TryLockRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_UnlockAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UnlockRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).UnlockAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_UnlockAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).UnlockAlpha1(ctx, req.(*UnlockRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_EncryptAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(DaprServer).EncryptAlpha1(&daprEncryptAlpha1Server{stream})
}
type Dapr_EncryptAlpha1Server interface {
Send(*EncryptResponse) error
Recv() (*EncryptRequest, error)
grpc.ServerStream
}
type daprEncryptAlpha1Server struct {
grpc.ServerStream
}
func (x *daprEncryptAlpha1Server) Send(m *EncryptResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *daprEncryptAlpha1Server) Recv() (*EncryptRequest, error) {
m := new(EncryptRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _Dapr_DecryptAlpha1_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(DaprServer).DecryptAlpha1(&daprDecryptAlpha1Server{stream})
}
type Dapr_DecryptAlpha1Server interface {
Send(*DecryptResponse) error
Recv() (*DecryptRequest, error)
grpc.ServerStream
}
type daprDecryptAlpha1Server struct {
grpc.ServerStream
}
func (x *daprDecryptAlpha1Server) Send(m *DecryptResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *daprDecryptAlpha1Server) Recv() (*DecryptRequest, error) {
m := new(DecryptRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _Dapr_GetMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetMetadataRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetMetadata(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetMetadata_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetMetadata(ctx, req.(*GetMetadataRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SetMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetMetadataRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SetMetadata(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SetMetadata_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SetMetadata(ctx, req.(*SetMetadataRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleGetKeyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleGetKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleGetKeyAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleGetKeyAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleGetKeyAlpha1(ctx, req.(*SubtleGetKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleEncryptAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleEncryptRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleEncryptAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleEncryptAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleEncryptAlpha1(ctx, req.(*SubtleEncryptRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleDecryptAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleDecryptRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleDecryptAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleDecryptAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleDecryptAlpha1(ctx, req.(*SubtleDecryptRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleWrapKeyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleWrapKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleWrapKeyAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleWrapKeyAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleWrapKeyAlpha1(ctx, req.(*SubtleWrapKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleUnwrapKeyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleUnwrapKeyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleUnwrapKeyAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleUnwrapKeyAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleUnwrapKeyAlpha1(ctx, req.(*SubtleUnwrapKeyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleSignAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleSignRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleSignAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleSignAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleSignAlpha1(ctx, req.(*SubtleSignRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_SubtleVerifyAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubtleVerifyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).SubtleVerifyAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_SubtleVerifyAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).SubtleVerifyAlpha1(ctx, req.(*SubtleVerifyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_StartWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StartWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).StartWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_StartWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).StartWorkflowAlpha1(ctx, req.(*StartWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetWorkflowAlpha1(ctx, req.(*GetWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_PurgeWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PurgeWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).PurgeWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_PurgeWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).PurgeWorkflowAlpha1(ctx, req.(*PurgeWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_TerminateWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TerminateWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).TerminateWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_TerminateWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).TerminateWorkflowAlpha1(ctx, req.(*TerminateWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_PauseWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PauseWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).PauseWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_PauseWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).PauseWorkflowAlpha1(ctx, req.(*PauseWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_ResumeWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ResumeWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).ResumeWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_ResumeWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).ResumeWorkflowAlpha1(ctx, req.(*ResumeWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_RaiseEventWorkflowAlpha1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RaiseEventWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).RaiseEventWorkflowAlpha1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_RaiseEventWorkflowAlpha1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).RaiseEventWorkflowAlpha1(ctx, req.(*RaiseEventWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_StartWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StartWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).StartWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_StartWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).StartWorkflowBeta1(ctx, req.(*StartWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_GetWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).GetWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_GetWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).GetWorkflowBeta1(ctx, req.(*GetWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_PurgeWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PurgeWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).PurgeWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_PurgeWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).PurgeWorkflowBeta1(ctx, req.(*PurgeWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_TerminateWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TerminateWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).TerminateWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_TerminateWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).TerminateWorkflowBeta1(ctx, req.(*TerminateWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_PauseWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PauseWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).PauseWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_PauseWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).PauseWorkflowBeta1(ctx, req.(*PauseWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_ResumeWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ResumeWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).ResumeWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_ResumeWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).ResumeWorkflowBeta1(ctx, req.(*ResumeWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_RaiseEventWorkflowBeta1_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RaiseEventWorkflowRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).RaiseEventWorkflowBeta1(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_RaiseEventWorkflowBeta1_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).RaiseEventWorkflowBeta1(ctx, req.(*RaiseEventWorkflowRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Dapr_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ShutdownRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DaprServer).Shutdown(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: Dapr_Shutdown_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DaprServer).Shutdown(ctx, req.(*ShutdownRequest))
}
return interceptor(ctx, in, info, handler)
}
// Dapr_ServiceDesc is the grpc.ServiceDesc for Dapr service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Dapr_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.runtime.v1.Dapr",
HandlerType: (*DaprServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "InvokeService",
Handler: _Dapr_InvokeService_Handler,
},
{
MethodName: "GetState",
Handler: _Dapr_GetState_Handler,
},
{
MethodName: "GetBulkState",
Handler: _Dapr_GetBulkState_Handler,
},
{
MethodName: "SaveState",
Handler: _Dapr_SaveState_Handler,
},
{
MethodName: "QueryStateAlpha1",
Handler: _Dapr_QueryStateAlpha1_Handler,
},
{
MethodName: "DeleteState",
Handler: _Dapr_DeleteState_Handler,
},
{
MethodName: "DeleteBulkState",
Handler: _Dapr_DeleteBulkState_Handler,
},
{
MethodName: "ExecuteStateTransaction",
Handler: _Dapr_ExecuteStateTransaction_Handler,
},
{
MethodName: "PublishEvent",
Handler: _Dapr_PublishEvent_Handler,
},
{
MethodName: "BulkPublishEventAlpha1",
Handler: _Dapr_BulkPublishEventAlpha1_Handler,
},
{
MethodName: "InvokeBinding",
Handler: _Dapr_InvokeBinding_Handler,
},
{
MethodName: "GetSecret",
Handler: _Dapr_GetSecret_Handler,
},
{
MethodName: "GetBulkSecret",
Handler: _Dapr_GetBulkSecret_Handler,
},
{
MethodName: "RegisterActorTimer",
Handler: _Dapr_RegisterActorTimer_Handler,
},
{
MethodName: "UnregisterActorTimer",
Handler: _Dapr_UnregisterActorTimer_Handler,
},
{
MethodName: "RegisterActorReminder",
Handler: _Dapr_RegisterActorReminder_Handler,
},
{
MethodName: "UnregisterActorReminder",
Handler: _Dapr_UnregisterActorReminder_Handler,
},
{
MethodName: "GetActorState",
Handler: _Dapr_GetActorState_Handler,
},
{
MethodName: "ExecuteActorStateTransaction",
Handler: _Dapr_ExecuteActorStateTransaction_Handler,
},
{
MethodName: "InvokeActor",
Handler: _Dapr_InvokeActor_Handler,
},
{
MethodName: "GetConfigurationAlpha1",
Handler: _Dapr_GetConfigurationAlpha1_Handler,
},
{
MethodName: "GetConfiguration",
Handler: _Dapr_GetConfiguration_Handler,
},
{
MethodName: "UnsubscribeConfigurationAlpha1",
Handler: _Dapr_UnsubscribeConfigurationAlpha1_Handler,
},
{
MethodName: "UnsubscribeConfiguration",
Handler: _Dapr_UnsubscribeConfiguration_Handler,
},
{
MethodName: "TryLockAlpha1",
Handler: _Dapr_TryLockAlpha1_Handler,
},
{
MethodName: "UnlockAlpha1",
Handler: _Dapr_UnlockAlpha1_Handler,
},
{
MethodName: "GetMetadata",
Handler: _Dapr_GetMetadata_Handler,
},
{
MethodName: "SetMetadata",
Handler: _Dapr_SetMetadata_Handler,
},
{
MethodName: "SubtleGetKeyAlpha1",
Handler: _Dapr_SubtleGetKeyAlpha1_Handler,
},
{
MethodName: "SubtleEncryptAlpha1",
Handler: _Dapr_SubtleEncryptAlpha1_Handler,
},
{
MethodName: "SubtleDecryptAlpha1",
Handler: _Dapr_SubtleDecryptAlpha1_Handler,
},
{
MethodName: "SubtleWrapKeyAlpha1",
Handler: _Dapr_SubtleWrapKeyAlpha1_Handler,
},
{
MethodName: "SubtleUnwrapKeyAlpha1",
Handler: _Dapr_SubtleUnwrapKeyAlpha1_Handler,
},
{
MethodName: "SubtleSignAlpha1",
Handler: _Dapr_SubtleSignAlpha1_Handler,
},
{
MethodName: "SubtleVerifyAlpha1",
Handler: _Dapr_SubtleVerifyAlpha1_Handler,
},
{
MethodName: "StartWorkflowAlpha1",
Handler: _Dapr_StartWorkflowAlpha1_Handler,
},
{
MethodName: "GetWorkflowAlpha1",
Handler: _Dapr_GetWorkflowAlpha1_Handler,
},
{
MethodName: "PurgeWorkflowAlpha1",
Handler: _Dapr_PurgeWorkflowAlpha1_Handler,
},
{
MethodName: "TerminateWorkflowAlpha1",
Handler: _Dapr_TerminateWorkflowAlpha1_Handler,
},
{
MethodName: "PauseWorkflowAlpha1",
Handler: _Dapr_PauseWorkflowAlpha1_Handler,
},
{
MethodName: "ResumeWorkflowAlpha1",
Handler: _Dapr_ResumeWorkflowAlpha1_Handler,
},
{
MethodName: "RaiseEventWorkflowAlpha1",
Handler: _Dapr_RaiseEventWorkflowAlpha1_Handler,
},
{
MethodName: "StartWorkflowBeta1",
Handler: _Dapr_StartWorkflowBeta1_Handler,
},
{
MethodName: "GetWorkflowBeta1",
Handler: _Dapr_GetWorkflowBeta1_Handler,
},
{
MethodName: "PurgeWorkflowBeta1",
Handler: _Dapr_PurgeWorkflowBeta1_Handler,
},
{
MethodName: "TerminateWorkflowBeta1",
Handler: _Dapr_TerminateWorkflowBeta1_Handler,
},
{
MethodName: "PauseWorkflowBeta1",
Handler: _Dapr_PauseWorkflowBeta1_Handler,
},
{
MethodName: "ResumeWorkflowBeta1",
Handler: _Dapr_ResumeWorkflowBeta1_Handler,
},
{
MethodName: "RaiseEventWorkflowBeta1",
Handler: _Dapr_RaiseEventWorkflowBeta1_Handler,
},
{
MethodName: "Shutdown",
Handler: _Dapr_Shutdown_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "SubscribeTopicEventsAlpha1",
Handler: _Dapr_SubscribeTopicEventsAlpha1_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "SubscribeConfigurationAlpha1",
Handler: _Dapr_SubscribeConfigurationAlpha1_Handler,
ServerStreams: true,
},
{
StreamName: "SubscribeConfiguration",
Handler: _Dapr_SubscribeConfiguration_Handler,
ServerStreams: true,
},
{
StreamName: "EncryptAlpha1",
Handler: _Dapr_EncryptAlpha1_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "DecryptAlpha1",
Handler: _Dapr_DecryptAlpha1_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "dapr/proto/runtime/v1/dapr.proto",
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/dapr_grpc.pb.go
|
GO
|
mit
| 99,064 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package runtime
import (
diagConsts "github.com/dapr/dapr/pkg/diagnostics/consts"
)
// This file contains additional, hand-written methods added to the generated objects.
func (x *InvokeServiceRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCServiceInvocationService
m[diagConsts.NetPeerNameSpanAttributeKey] = x.GetId()
m[diagConsts.DaprAPISpanNameInternal] = "CallLocal/" + x.GetId() + "/" + x.GetMessage().GetMethod()
}
func (x *PublishEventRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.MessagingSystemSpanAttributeKey] = diagConsts.PubsubBuildingBlockType
m[diagConsts.MessagingDestinationSpanAttributeKey] = x.GetTopic()
m[diagConsts.MessagingDestinationKindSpanAttributeKey] = diagConsts.MessagingDestinationTopicKind
}
func (x *BulkPublishRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.MessagingSystemSpanAttributeKey] = diagConsts.PubsubBuildingBlockType
m[diagConsts.MessagingDestinationSpanAttributeKey] = x.GetTopic()
m[diagConsts.MessagingDestinationKindSpanAttributeKey] = diagConsts.MessagingDestinationTopicKind
}
func (x *InvokeBindingRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.DBNameSpanAttributeKey] = x.GetName()
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.DBSystemSpanAttributeKey] = diagConsts.BindingBuildingBlockType
m[diagConsts.DBStatementSpanAttributeKey] = rpcMethod
m[diagConsts.DBConnectionStringSpanAttributeKey] = diagConsts.BindingBuildingBlockType
}
func (x *GetStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.DBNameSpanAttributeKey] = x.GetStoreName()
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.DBSystemSpanAttributeKey] = diagConsts.StateBuildingBlockType
m[diagConsts.DBStatementSpanAttributeKey] = rpcMethod
m[diagConsts.DBConnectionStringSpanAttributeKey] = diagConsts.StateBuildingBlockType
}
func (x *SaveStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.DBNameSpanAttributeKey] = x.GetStoreName()
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.DBSystemSpanAttributeKey] = diagConsts.StateBuildingBlockType
m[diagConsts.DBStatementSpanAttributeKey] = rpcMethod
m[diagConsts.DBConnectionStringSpanAttributeKey] = diagConsts.StateBuildingBlockType
}
func (x *DeleteStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.DBNameSpanAttributeKey] = x.GetStoreName()
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.DBSystemSpanAttributeKey] = diagConsts.StateBuildingBlockType
m[diagConsts.DBStatementSpanAttributeKey] = rpcMethod
m[diagConsts.DBConnectionStringSpanAttributeKey] = diagConsts.StateBuildingBlockType
}
func (x *GetSecretRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
m[diagConsts.DBNameSpanAttributeKey] = x.GetStoreName()
m[diagConsts.GrpcServiceSpanAttributeKey] = diagConsts.DaprGRPCDaprService
m[diagConsts.DBSystemSpanAttributeKey] = diagConsts.SecretBuildingBlockType
m[diagConsts.DBStatementSpanAttributeKey] = rpcMethod
m[diagConsts.DBConnectionStringSpanAttributeKey] = diagConsts.SecretBuildingBlockType
}
func (*DecryptRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*DeleteBulkStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*EncryptRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*ExecuteActorStateTransactionRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*ExecuteStateTransactionRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*GetActorStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*GetBulkSecretRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*GetBulkStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*GetConfigurationRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*GetMetadataRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*GetWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*InvokeActorRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*PauseWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*PurgeWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*QueryStateRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*RaiseEventWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*RegisterActorReminderRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*RegisterActorTimerRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*ResumeWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SetMetadataRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*ShutdownRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*StartWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubscribeConfigurationRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubscribeTopicEventsInitialRequestAlpha1) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubscribeTopicEventsRequestAlpha1) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODOalph
}
func (*SubscribeTopicEventsRequestAlpha1_InitialRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleDecryptRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleEncryptRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleGetKeyRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleSignRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleUnwrapKeyRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleVerifyRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*SubtleWrapKeyRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*TerminateWorkflowRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*TryLockRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*UnlockRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*UnregisterActorReminderRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*UnregisterActorTimerRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
func (*UnsubscribeConfigurationRequest) AppendSpanAttributes(rpcMethod string, m map[string]string) {
// TODO
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/dapr_tracing.go
|
GO
|
mit
| 8,222 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package runtime
import (
"go/ast"
"go/parser"
"go/token"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/exp/slices"
)
// Tests that all requests messages include the "AppendSpanAttribute" method.
func TestRequestsIncludeAppendSpanAttribute(t *testing.T) {
fset := token.NewFileSet()
// First, get the list of all structs whose name ends in "Request" from the "dapr.pb.go" file
node, err := parser.ParseFile(fset, "dapr.pb.go", nil, 0)
require.NoError(t, err)
allRequests := make([]string, 0)
for _, decl := range node.Decls {
genDecl, ok := decl.(*ast.GenDecl)
if !ok || genDecl.Tok != token.TYPE {
continue
}
for _, spec := range genDecl.Specs {
// Get structs only
typeSpec, ok := spec.(*ast.TypeSpec)
if !ok {
continue
}
_, ok = typeSpec.Type.(*ast.StructType)
if !ok {
continue
}
// Only get structs whose name ends in "Request"
if strings.HasSuffix(typeSpec.Name.Name, "Request") {
allRequests = append(allRequests, typeSpec.Name.Name)
}
}
}
// Now, check that all the structs that were found implement the "AppendSpanAttributes" method in the "dapr_tracing.go" file
node, err = parser.ParseFile(fset, "dapr_tracing.go", nil, 0)
require.NoError(t, err)
haveMethods := make([]string, 0, len(allRequests))
for _, decl := range node.Decls {
// Get all functions
funcDecl, ok := decl.(*ast.FuncDecl)
if !ok {
continue
}
// Filters for functions that:
// - Have a receiver (i.e. are properties of an object)
// - Are named "AppendSpanAttributes"
// - Accept 2 arguments of type (string, map[string]string)
// - Have no returned values
if funcDecl.Name == nil || funcDecl.Name.Name != "AppendSpanAttributes" ||
funcDecl.Type == nil || funcDecl.Recv == nil {
continue
}
typ := funcDecl.Type
if typ.Params == nil || len(typ.Params.List) != 2 || typ.Results != nil {
continue
}
params := typ.Params.List
// params[0] must be a string
identType, ok := params[0].Type.(*ast.Ident)
if !ok || identType.Name != "string" {
continue
}
// params[1] must be a map[string]string
mapType, ok := params[1].Type.(*ast.MapType)
if !ok {
continue
}
keyType, ok := mapType.Key.(*ast.Ident)
if !ok || keyType.Name != "string" {
continue
}
valueType, ok := mapType.Value.(*ast.Ident)
if !ok || valueType.Name != "string" {
continue
}
// Check the receiver
recv := funcDecl.Recv.List
if len(recv) == 0 {
continue
}
starExpr, ok := recv[0].Type.(*ast.StarExpr)
if !ok {
continue
}
ident, ok := starExpr.X.(*ast.Ident)
if !ok {
continue
}
// We have the name; if it ends in "Request", we are golden
if strings.HasSuffix(ident.Name, "Request") {
haveMethods = append(haveMethods, ident.Name)
}
}
// Compare the lists
slices.Sort(allRequests)
slices.Sort(haveMethods)
assert.Equal(t, allRequests, haveMethods, "Some Request structs are missing the `AppendSpanAttributes(rpcMethod string, m map[string]string)` method")
}
|
mikeee/dapr
|
pkg/proto/runtime/v1/dapr_tracing_test.go
|
GO
|
mit
| 3,636 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.32.0
// protoc v4.24.4
// source: dapr/proto/sentry/v1/sentry.proto
package sentry
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
timestamppb "google.golang.org/protobuf/types/known/timestamppb"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type SignCertificateRequest_TokenValidator int32
const (
// Not specified - use the default value.
SignCertificateRequest_UNKNOWN SignCertificateRequest_TokenValidator = 0
// Insecure validator (default on self-hosted).
SignCertificateRequest_INSECURE SignCertificateRequest_TokenValidator = 1
// Kubernetes validator (default on Kubernetes).
SignCertificateRequest_KUBERNETES SignCertificateRequest_TokenValidator = 2
// JWKS validator.
SignCertificateRequest_JWKS SignCertificateRequest_TokenValidator = 3
)
// Enum value maps for SignCertificateRequest_TokenValidator.
var (
SignCertificateRequest_TokenValidator_name = map[int32]string{
0: "UNKNOWN",
1: "INSECURE",
2: "KUBERNETES",
3: "JWKS",
}
SignCertificateRequest_TokenValidator_value = map[string]int32{
"UNKNOWN": 0,
"INSECURE": 1,
"KUBERNETES": 2,
"JWKS": 3,
}
)
func (x SignCertificateRequest_TokenValidator) Enum() *SignCertificateRequest_TokenValidator {
p := new(SignCertificateRequest_TokenValidator)
*p = x
return p
}
func (x SignCertificateRequest_TokenValidator) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (SignCertificateRequest_TokenValidator) Descriptor() protoreflect.EnumDescriptor {
return file_dapr_proto_sentry_v1_sentry_proto_enumTypes[0].Descriptor()
}
func (SignCertificateRequest_TokenValidator) Type() protoreflect.EnumType {
return &file_dapr_proto_sentry_v1_sentry_proto_enumTypes[0]
}
func (x SignCertificateRequest_TokenValidator) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use SignCertificateRequest_TokenValidator.Descriptor instead.
func (SignCertificateRequest_TokenValidator) EnumDescriptor() ([]byte, []int) {
return file_dapr_proto_sentry_v1_sentry_proto_rawDescGZIP(), []int{0, 0}
}
type SignCertificateRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
TrustDomain string `protobuf:"bytes,3,opt,name=trust_domain,json=trustDomain,proto3" json:"trust_domain,omitempty"`
Namespace string `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"`
// A PEM-encoded x509 CSR.
CertificateSigningRequest []byte `protobuf:"bytes,5,opt,name=certificate_signing_request,json=certificateSigningRequest,proto3" json:"certificate_signing_request,omitempty"`
// Name of the validator to use, if not the default for the environemtn.
TokenValidator SignCertificateRequest_TokenValidator `protobuf:"varint,6,opt,name=token_validator,json=tokenValidator,proto3,enum=dapr.proto.sentry.v1.SignCertificateRequest_TokenValidator" json:"token_validator,omitempty"`
}
func (x *SignCertificateRequest) Reset() {
*x = SignCertificateRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_sentry_v1_sentry_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SignCertificateRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SignCertificateRequest) ProtoMessage() {}
func (x *SignCertificateRequest) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_sentry_v1_sentry_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SignCertificateRequest.ProtoReflect.Descriptor instead.
func (*SignCertificateRequest) Descriptor() ([]byte, []int) {
return file_dapr_proto_sentry_v1_sentry_proto_rawDescGZIP(), []int{0}
}
func (x *SignCertificateRequest) GetId() string {
if x != nil {
return x.Id
}
return ""
}
func (x *SignCertificateRequest) GetToken() string {
if x != nil {
return x.Token
}
return ""
}
func (x *SignCertificateRequest) GetTrustDomain() string {
if x != nil {
return x.TrustDomain
}
return ""
}
func (x *SignCertificateRequest) GetNamespace() string {
if x != nil {
return x.Namespace
}
return ""
}
func (x *SignCertificateRequest) GetCertificateSigningRequest() []byte {
if x != nil {
return x.CertificateSigningRequest
}
return nil
}
func (x *SignCertificateRequest) GetTokenValidator() SignCertificateRequest_TokenValidator {
if x != nil {
return x.TokenValidator
}
return SignCertificateRequest_UNKNOWN
}
type SignCertificateResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// A PEM-encoded x509 Certificate.
WorkloadCertificate []byte `protobuf:"bytes,1,opt,name=workload_certificate,json=workloadCertificate,proto3" json:"workload_certificate,omitempty"`
// A list of PEM-encoded x509 Certificates that establish the trust chain
// between the workload certificate and the well-known trust root cert.
TrustChainCertificates [][]byte `protobuf:"bytes,2,rep,name=trust_chain_certificates,json=trustChainCertificates,proto3" json:"trust_chain_certificates,omitempty"`
ValidUntil *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=valid_until,json=validUntil,proto3" json:"valid_until,omitempty"`
}
func (x *SignCertificateResponse) Reset() {
*x = SignCertificateResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_dapr_proto_sentry_v1_sentry_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SignCertificateResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SignCertificateResponse) ProtoMessage() {}
func (x *SignCertificateResponse) ProtoReflect() protoreflect.Message {
mi := &file_dapr_proto_sentry_v1_sentry_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SignCertificateResponse.ProtoReflect.Descriptor instead.
func (*SignCertificateResponse) Descriptor() ([]byte, []int) {
return file_dapr_proto_sentry_v1_sentry_proto_rawDescGZIP(), []int{1}
}
func (x *SignCertificateResponse) GetWorkloadCertificate() []byte {
if x != nil {
return x.WorkloadCertificate
}
return nil
}
func (x *SignCertificateResponse) GetTrustChainCertificates() [][]byte {
if x != nil {
return x.TrustChainCertificates
}
return nil
}
func (x *SignCertificateResponse) GetValidUntil() *timestamppb.Timestamp {
if x != nil {
return x.ValidUntil
}
return nil
}
var File_dapr_proto_sentry_v1_sentry_proto protoreflect.FileDescriptor
var file_dapr_proto_sentry_v1_sentry_proto_rawDesc = []byte{
0x0a, 0x21, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x65, 0x6e,
0x74, 0x72, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x12, 0x14, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
0x73, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73,
0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xec, 0x02, 0x0a, 0x16, 0x53,
0x69, 0x67, 0x6e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65,
0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x74,
0x72, 0x75, 0x73, 0x74, 0x5f, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0b, 0x74, 0x72, 0x75, 0x73, 0x74, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x12, 0x1c,
0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28,
0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x3e, 0x0a, 0x1b,
0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x69, 0x67, 0x6e,
0x69, 0x6e, 0x67, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28,
0x0c, 0x52, 0x19, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x69,
0x67, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x64, 0x0a, 0x0f,
0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x18,
0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3b, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69, 0x67,
0x6e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
0x6f, 0x72, 0x52, 0x0e, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
0x6f, 0x72, 0x22, 0x45, 0x0a, 0x0e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x61, 0x6c, 0x69, 0x64,
0x61, 0x74, 0x6f, 0x72, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10,
0x00, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x4e, 0x53, 0x45, 0x43, 0x55, 0x52, 0x45, 0x10, 0x01, 0x12,
0x0e, 0x0a, 0x0a, 0x4b, 0x55, 0x42, 0x45, 0x52, 0x4e, 0x45, 0x54, 0x45, 0x53, 0x10, 0x02, 0x12,
0x08, 0x0a, 0x04, 0x4a, 0x57, 0x4b, 0x53, 0x10, 0x03, 0x22, 0xc3, 0x01, 0x0a, 0x17, 0x53, 0x69,
0x67, 0x6e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x14, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61,
0x64, 0x5f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20,
0x01, 0x28, 0x0c, 0x52, 0x13, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x43, 0x65, 0x72,
0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x38, 0x0a, 0x18, 0x74, 0x72, 0x75, 0x73,
0x74, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63,
0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x16, 0x74, 0x72, 0x75, 0x73,
0x74, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x75, 0x6e, 0x74, 0x69,
0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
0x61, 0x6d, 0x70, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x55, 0x6e, 0x74, 0x69, 0x6c, 0x32,
0x76, 0x0a, 0x02, 0x43, 0x41, 0x12, 0x70, 0x0a, 0x0f, 0x53, 0x69, 0x67, 0x6e, 0x43, 0x65, 0x72,
0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x2c, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x2e,
0x53, 0x69, 0x67, 0x6e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x64, 0x61, 0x70, 0x72, 0x2e, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69,
0x67, 0x6e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73,
0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x31, 0x5a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75,
0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f, 0x64, 0x61, 0x70, 0x72, 0x2f,
0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x79,
0x2f, 0x76, 0x31, 0x3b, 0x73, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x33,
}
var (
file_dapr_proto_sentry_v1_sentry_proto_rawDescOnce sync.Once
file_dapr_proto_sentry_v1_sentry_proto_rawDescData = file_dapr_proto_sentry_v1_sentry_proto_rawDesc
)
func file_dapr_proto_sentry_v1_sentry_proto_rawDescGZIP() []byte {
file_dapr_proto_sentry_v1_sentry_proto_rawDescOnce.Do(func() {
file_dapr_proto_sentry_v1_sentry_proto_rawDescData = protoimpl.X.CompressGZIP(file_dapr_proto_sentry_v1_sentry_proto_rawDescData)
})
return file_dapr_proto_sentry_v1_sentry_proto_rawDescData
}
var file_dapr_proto_sentry_v1_sentry_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_dapr_proto_sentry_v1_sentry_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_dapr_proto_sentry_v1_sentry_proto_goTypes = []interface{}{
(SignCertificateRequest_TokenValidator)(0), // 0: dapr.proto.sentry.v1.SignCertificateRequest.TokenValidator
(*SignCertificateRequest)(nil), // 1: dapr.proto.sentry.v1.SignCertificateRequest
(*SignCertificateResponse)(nil), // 2: dapr.proto.sentry.v1.SignCertificateResponse
(*timestamppb.Timestamp)(nil), // 3: google.protobuf.Timestamp
}
var file_dapr_proto_sentry_v1_sentry_proto_depIdxs = []int32{
0, // 0: dapr.proto.sentry.v1.SignCertificateRequest.token_validator:type_name -> dapr.proto.sentry.v1.SignCertificateRequest.TokenValidator
3, // 1: dapr.proto.sentry.v1.SignCertificateResponse.valid_until:type_name -> google.protobuf.Timestamp
1, // 2: dapr.proto.sentry.v1.CA.SignCertificate:input_type -> dapr.proto.sentry.v1.SignCertificateRequest
2, // 3: dapr.proto.sentry.v1.CA.SignCertificate:output_type -> dapr.proto.sentry.v1.SignCertificateResponse
3, // [3:4] is the sub-list for method output_type
2, // [2:3] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_dapr_proto_sentry_v1_sentry_proto_init() }
func file_dapr_proto_sentry_v1_sentry_proto_init() {
if File_dapr_proto_sentry_v1_sentry_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_dapr_proto_sentry_v1_sentry_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SignCertificateRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_dapr_proto_sentry_v1_sentry_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SignCertificateResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_dapr_proto_sentry_v1_sentry_proto_rawDesc,
NumEnums: 1,
NumMessages: 2,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_dapr_proto_sentry_v1_sentry_proto_goTypes,
DependencyIndexes: file_dapr_proto_sentry_v1_sentry_proto_depIdxs,
EnumInfos: file_dapr_proto_sentry_v1_sentry_proto_enumTypes,
MessageInfos: file_dapr_proto_sentry_v1_sentry_proto_msgTypes,
}.Build()
File_dapr_proto_sentry_v1_sentry_proto = out.File
file_dapr_proto_sentry_v1_sentry_proto_rawDesc = nil
file_dapr_proto_sentry_v1_sentry_proto_goTypes = nil
file_dapr_proto_sentry_v1_sentry_proto_depIdxs = nil
}
|
mikeee/dapr
|
pkg/proto/sentry/v1/sentry.pb.go
|
GO
|
mit
| 16,640 |
//
//Copyright 2021 The Dapr Authors
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc v4.24.4
// source: dapr/proto/sentry/v1/sentry.proto
package sentry
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
const (
CA_SignCertificate_FullMethodName = "/dapr.proto.sentry.v1.CA/SignCertificate"
)
// CAClient is the client API for CA service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type CAClient interface {
// A request for a time-bound certificate to be signed.
//
// The requesting side must provide an id for both loosely based
// And strong based identities.
SignCertificate(ctx context.Context, in *SignCertificateRequest, opts ...grpc.CallOption) (*SignCertificateResponse, error)
}
type cAClient struct {
cc grpc.ClientConnInterface
}
func NewCAClient(cc grpc.ClientConnInterface) CAClient {
return &cAClient{cc}
}
func (c *cAClient) SignCertificate(ctx context.Context, in *SignCertificateRequest, opts ...grpc.CallOption) (*SignCertificateResponse, error) {
out := new(SignCertificateResponse)
err := c.cc.Invoke(ctx, CA_SignCertificate_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// CAServer is the server API for CA service.
// All implementations should embed UnimplementedCAServer
// for forward compatibility
type CAServer interface {
// A request for a time-bound certificate to be signed.
//
// The requesting side must provide an id for both loosely based
// And strong based identities.
SignCertificate(context.Context, *SignCertificateRequest) (*SignCertificateResponse, error)
}
// UnimplementedCAServer should be embedded to have forward compatible implementations.
type UnimplementedCAServer struct {
}
func (UnimplementedCAServer) SignCertificate(context.Context, *SignCertificateRequest) (*SignCertificateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SignCertificate not implemented")
}
// UnsafeCAServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to CAServer will
// result in compilation errors.
type UnsafeCAServer interface {
mustEmbedUnimplementedCAServer()
}
func RegisterCAServer(s grpc.ServiceRegistrar, srv CAServer) {
s.RegisterService(&CA_ServiceDesc, srv)
}
func _CA_SignCertificate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SignCertificateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CAServer).SignCertificate(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: CA_SignCertificate_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CAServer).SignCertificate(ctx, req.(*SignCertificateRequest))
}
return interceptor(ctx, in, info, handler)
}
// CA_ServiceDesc is the grpc.ServiceDesc for CA service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CA_ServiceDesc = grpc.ServiceDesc{
ServiceName: "dapr.proto.sentry.v1.CA",
HandlerType: (*CAServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "SignCertificate",
Handler: _CA_SignCertificate_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "dapr/proto/sentry/v1/sentry.proto",
}
|
mikeee/dapr
|
pkg/proto/sentry/v1/sentry_grpc.pb.go
|
GO
|
mit
| 4,456 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package breaker
import (
"errors"
"fmt"
"time"
"github.com/sony/gobreaker"
"github.com/dapr/dapr/pkg/expr"
"github.com/dapr/kit/logger"
)
// CircuitBreaker represents the configuration for how
// a circuit breaker behaves.
type CircuitBreaker struct {
// Name is the circuit breaker name.
Name string
// The maximum number of requests allowed to pass through when
// the circuit breaker is half-open.
// Default is 1.
MaxRequests uint32 `mapstructure:"maxRequests"`
// The cyclic period of the closed state for the circuit breaker
// to clear the internal counts. If 0, the circuit breaker doesn't
// clear internal counts during the closed state.
// Default is 0s.
Interval time.Duration `mapstructure:"interval"`
// The period of the open state, after which the state of the
// circuit breaker becomes half-open.
// Default is 60s.
Timeout time.Duration `mapstructure:"timeout"`
// Trip is a CEL expression evaluated with the circuit breaker's
// internal counts whenever a request fails in the closed state.
// If it evaluates to true, the circuit breaker will be placed
// into the open state.
// Default is consecutiveFailures > 5.
Trip *expr.Expr `mapstructure:"trip"`
breaker *gobreaker.CircuitBreaker
}
var (
ErrOpenState = gobreaker.ErrOpenState
ErrTooManyRequests = gobreaker.ErrTooManyRequests
)
type CircuitBreakerState string
const (
StateClosed CircuitBreakerState = "closed"
StateOpen CircuitBreakerState = "open"
StateHalfOpen CircuitBreakerState = "half-open"
StateUnknown CircuitBreakerState = "unknown"
)
// IsErrorPermanent returns true if `err` should be treated as a
// permanent error that cannot be retried.
func IsErrorPermanent(err error) bool {
return errors.Is(err, ErrOpenState) || errors.Is(err, ErrTooManyRequests)
}
// Initialize creates the underlying circuit breaker using the
// configuration fields.
func (c *CircuitBreaker) Initialize(log logger.Logger) {
var tripFn func(counts gobreaker.Counts) bool
if c.Trip != nil {
tripFn = func(counts gobreaker.Counts) bool {
result, err := c.Trip.Eval(map[string]interface{}{
"requests": int64(counts.Requests),
"totalSuccesses": int64(counts.TotalSuccesses),
"totalFailures": int64(counts.TotalFailures),
"consecutiveSuccesses": int64(counts.ConsecutiveSuccesses),
"consecutiveFailures": int64(counts.ConsecutiveFailures),
})
if err != nil {
// We cannot assume it is safe to trip if the eval
// returns an error.
return false
}
if boolResult, ok := result.(bool); ok {
return boolResult
}
return false
}
}
c.breaker = gobreaker.NewCircuitBreaker(gobreaker.Settings{ //nolint:exhaustivestruct
Name: c.Name,
MaxRequests: c.MaxRequests,
Interval: c.Interval,
Timeout: c.Timeout,
ReadyToTrip: tripFn,
OnStateChange: func(name string, from, to gobreaker.State) {
log.Infof("Circuit breaker %q changed state from %s to %s", name, from, to)
},
})
}
// Execute invokes `oper` if the circuit breaker is in a closed state
// or for an allowed call in the half-open state. It is a wrapper around the gobreaker
// library that is used here.
// The circuit breaker shorts if the connection is in open state or if there are too many
// requests in the half-open state. In both cases, the error returned is wrapped with
// ErrOpenState or ErrTooManyRequests defined in this package. The result of the operation
// in those scenarios will by nil/zero.
// In all other scenarios the result, error returned is the result, error returned by the
// operation.
func (c *CircuitBreaker) Execute(oper func() (any, error)) (any, error) {
res, err := c.breaker.Execute(oper)
// Wrap the error so we don't have to reference the external package in other places.
switch {
case errors.Is(err, gobreaker.ErrOpenState):
return res, ErrOpenState
case errors.Is(err, gobreaker.ErrTooManyRequests):
return res, ErrTooManyRequests
default:
// Handles the case where err is nil or something else other than
// the cases listed above.
return res, err //nolint:wrapcheck
}
}
// String implements fmt.Stringer and is used for debugging.
func (c *CircuitBreaker) String() string {
return fmt.Sprintf(
"name='%s' namRequests='%d' interval='%v' timeout='%v' trip='%v'",
c.Name, c.MaxRequests, c.Interval, c.Timeout, c.Trip,
)
}
// State returns the current state of the circuit breaker.
func (c *CircuitBreaker) State() CircuitBreakerState {
if c.breaker == nil {
return StateUnknown
}
switch c.breaker.State() {
case gobreaker.StateClosed:
return StateClosed
case gobreaker.StateOpen:
return StateOpen
case gobreaker.StateHalfOpen:
return StateHalfOpen
default:
return StateUnknown
}
}
|
mikeee/dapr
|
pkg/resiliency/breaker/circuitbreaker.go
|
GO
|
mit
| 5,317 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package breaker_test
import (
"errors"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dapr/dapr/pkg/expr"
"github.com/dapr/dapr/pkg/resiliency/breaker"
"github.com/dapr/kit/logger"
)
func TestCircuitBreaker(t *testing.T) {
t.Parallel()
log := logger.NewLogger("test")
var trip expr.Expr
err := trip.DecodeString("consecutiveFailures > 2")
require.NoError(t, err)
cb := breaker.CircuitBreaker{
Name: "test",
Trip: &trip,
Timeout: 100 * time.Millisecond,
}
assert.Equal(t, breaker.StateUnknown, cb.State())
cb.Initialize(log)
assert.Equal(t, breaker.StateClosed, cb.State())
for i := 0; i < 3; i++ {
cb.Execute(func() (any, error) {
return nil, errors.New("test")
})
}
res, err := cb.Execute(func() (any, error) {
return "❌", nil
})
assert.Equal(t, breaker.StateOpen, cb.State())
require.EqualError(t, err, "circuit breaker is open")
assert.Nil(t, res)
time.Sleep(500 * time.Millisecond)
assert.Equal(t, breaker.StateHalfOpen, cb.State())
res, err = cb.Execute(func() (any, error) {
return 42, nil
})
require.NoError(t, err)
assert.Equal(t, 42, res)
}
|
mikeee/dapr
|
pkg/resiliency/breaker/circuitbreaker_test.go
|
GO
|
mit
| 1,733 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package resiliency
// NoOp is a true bypass implementation of `Provider`.
type NoOp struct{}
// RoutePolicy returns a NoOp policy definition for a route.
func (NoOp) RoutePolicy(name string) *PolicyDefinition {
return nil
}
// EndpointPolicy returns a NoOp policy definition for a service endpoint.
func (NoOp) EndpointPolicy(service string, endpoint string) *PolicyDefinition {
return nil
}
// ActorPreLockPolicy returns a NoOp policy definition for an actor instance.
func (NoOp) ActorPreLockPolicy(actorType string, id string) *PolicyDefinition {
return nil
}
// ActorPostLockPolicy returns a NoOp policy definition for an actor instance.
func (NoOp) ActorPostLockPolicy(actorType string, id string) *PolicyDefinition {
return nil
}
// ComponentInboundPolicy returns a NoOp inbound policy definition for a component.
func (NoOp) ComponentInboundPolicy(name string, componentName ComponentType) *PolicyDefinition {
return nil
}
// ComponentOutboundPolicy returns a NoOp outbound policy definition for a component.
func (NoOp) ComponentOutboundPolicy(name string, componentName ComponentType) *PolicyDefinition {
return nil
}
// BuildInPolicy returns a NoOp policy definition for a built-in policy.
func (NoOp) BuiltInPolicy(name BuiltInPolicyName) *PolicyDefinition {
return nil
}
func (NoOp) PolicyDefined(target string, policyType PolicyType) bool {
return true
}
|
mikeee/dapr
|
pkg/resiliency/noop.go
|
GO
|
mit
| 1,946 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package resiliency
import (
"context"
"errors"
"sync/atomic"
"testing"
"github.com/stretchr/testify/assert"
)
func TestNoOp(t *testing.T) {
ctx := context.Background()
policy := NoOp{}
tests := []struct {
name string
fn func(ctx context.Context) Runner[any]
err error
}{
{
name: "route",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.RoutePolicy("test"))
},
},
{
name: "route error",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.RoutePolicy("test"))
},
err: errors.New("route error"),
},
{
name: "endpoint",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.EndpointPolicy("test", "test"))
},
},
{
name: "endpoint error",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.EndpointPolicy("test", "test"))
},
err: errors.New("endpoint error"),
},
{
name: "actor",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.ActorPreLockPolicy("test", "test"))
},
},
{
name: "actor error",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.ActorPreLockPolicy("test", "test"))
},
err: errors.New("actor error"),
},
{
name: "component output",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.ComponentOutboundPolicy("test", "Statestore"))
},
},
{
name: "component outbound error",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.ComponentOutboundPolicy("test", "Statestore"))
},
err: errors.New("component outbound error"),
},
{
name: "component inbound",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.ComponentInboundPolicy("test", "Statestore"))
},
},
{
name: "component inbound error",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.ComponentInboundPolicy("test", "Statestore"))
},
err: errors.New("component inbound error"),
},
{
name: "built-in",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.BuiltInPolicy(BuiltInServiceRetries))
},
},
{
name: "built-in error",
fn: func(ctx context.Context) Runner[any] {
return NewRunner[any](ctx, policy.BuiltInPolicy(BuiltInServiceRetries))
},
err: errors.New("built-in error"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
runner := tt.fn(ctx)
called := atomic.Bool{}
_, err := runner(func(passedCtx context.Context) (any, error) {
assert.Equal(t, ctx, passedCtx)
called.Store(true)
return nil, tt.err
})
assert.Equal(t, tt.err, err)
assert.True(t, called.Load())
})
}
}
|
mikeee/dapr
|
pkg/resiliency/noop_test.go
|
GO
|
mit
| 3,398 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package resiliency
import (
"context"
"errors"
"fmt"
"io"
"reflect"
"sync/atomic"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/dapr/dapr/pkg/resiliency/breaker"
"github.com/dapr/kit/logger"
"github.com/dapr/kit/retry"
)
type (
// Operation represents a function to invoke with resiliency policies applied.
Operation[T any] func(ctx context.Context) (T, error)
// Runner represents a function to invoke `oper` with resiliency policies applied.
Runner[T any] func(oper Operation[T]) (T, error)
)
type doneCh[T any] struct {
res T
err error
}
type attemptsCtxKey struct{}
// PolicyDefinition contains a definition for a policy, used to create a Runner.
type PolicyDefinition struct {
log logger.Logger
name string
t time.Duration
r *retry.Config
cb *breaker.CircuitBreaker
addTimeoutActivatedMetric func()
addRetryActivatedMetric func()
addCBStateChangedMetric func()
}
// NewPolicyDefinition returns a PolicyDefinition object with the given parameters.
func NewPolicyDefinition(log logger.Logger, name string, t time.Duration, r *retry.Config, cb *breaker.CircuitBreaker) *PolicyDefinition {
return &PolicyDefinition{
log: log,
name: name,
t: t,
r: r,
cb: cb,
}
}
// String implements fmt.Stringer and is used for debugging.
func (p PolicyDefinition) String() string {
return fmt.Sprintf(
"Policy: name='%s' timeout='%v' retry=(%v) circuitBreaker=(%v)",
p.name, p.t, p.r, p.cb,
)
}
// HasRetries returns true if the policy is configured to have more than 1 retry.
func (p PolicyDefinition) HasRetries() bool {
return p.r != nil && p.r.MaxRetries != 0
}
type RunnerOpts[T any] struct {
// The disposer is a function which is invoked when the operation fails, including due to timing out in a background goroutine. It receives the value returned by the operation function as long as it's non-zero (e.g. non-nil for pointer types).
// The disposer can be used to perform cleanup tasks on values returned by the operation function that would otherwise leak (because they're not returned by the result of the runner).
Disposer func(T)
// The accumulator is a function that is invoked synchronously when an operation completes without timing out, whether successfully or not. It receives the value returned by the operation function as long as it's non-zero (e.g. non-nil for pointer types).
// The accumulator can be used to collect intermediate results and not just the final ones, for example in case of working with batched operations.
Accumulator func(T)
}
// NewRunner returns a policy runner that encapsulates the configured resiliency policies in a simple execution wrapper.
// We can't implement this as a method of the Resiliency struct because we can't yet use generic methods in structs.
func NewRunner[T any](ctx context.Context, def *PolicyDefinition) Runner[T] {
return NewRunnerWithOptions(ctx, def, RunnerOpts[T]{})
}
// NewRunnerWithOptions is like NewRunner but allows setting additional options
func NewRunnerWithOptions[T any](ctx context.Context, def *PolicyDefinition, opts RunnerOpts[T]) Runner[T] {
if def == nil {
return func(oper Operation[T]) (T, error) {
rRes, rErr := oper(ctx)
if opts.Accumulator != nil && !isZero(rRes) {
opts.Accumulator(rRes)
}
return rRes, rErr
}
}
var zero T
timeoutMetricsActivated := atomic.Bool{}
return func(oper Operation[T]) (T, error) {
operation := oper
if def.t > 0 {
// Handle timeout
operCopy := operation
operation = func(ctx context.Context) (T, error) {
ctx, cancel := context.WithTimeout(ctx, def.t)
defer cancel()
done := make(chan doneCh[T], 1)
go func() {
rRes, rErr := operCopy(ctx)
// If the channel is full, it means we had a timeout
select {
case done <- doneCh[T]{rRes, rErr}:
// No timeout, all good
default:
// The operation has timed out
// Invoke the disposer if we have a non-zero return value
// Note that in case of timeouts we do not invoke the accumulator
if opts.Disposer != nil && !isZero(rRes) {
opts.Disposer(rRes)
}
}
}()
select {
case v := <-done:
return v.res, v.err
case <-ctx.Done():
// Because done has a capacity of 1, adding a message on the channel signals that there was a timeout
// However, the response may have arrived in the meanwhile, so we need to also check if something was added
select {
case done <- doneCh[T]{}:
// All good, nothing to do here
default:
// The response arrived at the same time as the context deadline, and the channel has a message
v := <-done
// Invoke the disposer if the return value is non-zero
// Note that in case of timeouts we do not invoke the accumulator
if opts.Disposer != nil && !isZero(v.res) {
opts.Disposer(v.res)
}
}
if def.addTimeoutActivatedMetric != nil && timeoutMetricsActivated.CompareAndSwap(false, true) {
def.addTimeoutActivatedMetric()
}
return zero, ctx.Err()
}
}
}
if opts.Accumulator != nil {
operCopy := operation
operation = func(ctx context.Context) (T, error) {
rRes, rErr := operCopy(ctx)
if !isZero(rRes) {
opts.Accumulator(rRes)
}
return rRes, rErr
}
}
if def.cb != nil {
operCopy := operation
operation = func(ctx context.Context) (T, error) {
prevState := def.cb.State()
resAny, err := def.cb.Execute(func() (any, error) {
return operCopy(ctx)
})
if def.addCBStateChangedMetric != nil && prevState != def.cb.State() {
def.addCBStateChangedMetric()
}
if def.r != nil && breaker.IsErrorPermanent(err) {
// Break out of retry
err = backoff.Permanent(err)
}
res, ok := resAny.(T)
if !ok && resAny != nil {
err = errors.New("cannot cast response to specific type")
if def.r != nil {
// Break out of retry
err = backoff.Permanent(err)
}
}
return res, err
}
}
if def.r == nil {
return operation(ctx)
}
// Use retry/back off
b := def.r.NewBackOffWithContext(ctx)
attempts := atomic.Int32{}
return retry.NotifyRecoverWithData(
func() (T, error) {
attempt := attempts.Add(1)
opCtx := context.WithValue(ctx, attemptsCtxKey{}, attempt)
rRes, rErr := operation(opCtx)
// In case of an error, if we have a disposer we invoke it with the return value, then reset the return value
if rErr != nil && opts.Disposer != nil && !isZero(rRes) {
opts.Disposer(rRes)
rRes = zero
}
return rRes, rErr
},
b,
func(opErr error, d time.Duration) {
if def.addRetryActivatedMetric != nil {
def.addRetryActivatedMetric()
}
def.log.Warnf("Error processing operation %s. Retrying in %v…", def.name, d)
def.log.Debugf("Error for operation %s was: %v", def.name, opErr)
},
func() {
def.log.Infof("Recovered processing operation %s after %d attempts", def.name, attempts.Load())
},
)
}
}
// DisposerCloser is a Disposer function for RunnerOpts that invokes Close() on the object.
func DisposerCloser[T io.Closer](obj T) {
_ = obj.Close()
}
// GetAttempt returns the attempt number from a context
// Attempts are numbered from 1 onwards.
// If the context doesn't have an attempt number, returns 0
func GetAttempt(ctx context.Context) int32 {
v := ctx.Value(attemptsCtxKey{})
attempt, ok := v.(int32)
if !ok {
return 0
}
return attempt
}
func isZero(val any) bool {
return reflect.ValueOf(val).IsZero()
}
|
mikeee/dapr
|
pkg/resiliency/policy.go
|
GO
|
mit
| 8,206 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package resiliency
import (
"context"
"errors"
"fmt"
"sync/atomic"
"testing"
"time"
"github.com/cenkalti/backoff/v4"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/exp/slices"
"github.com/dapr/dapr/pkg/resiliency/breaker"
"github.com/dapr/kit/logger"
"github.com/dapr/kit/retry"
)
var testLog = logger.NewLogger("dapr.resiliency.test")
// Example of using NewRunnerWithOptions with an Accumulator function
func ExampleNewRunnerWithOptions_accumulator() {
// Example polocy definition
policyDef := &PolicyDefinition{
log: testLog,
name: "retry",
t: 10 * time.Millisecond,
r: &retry.Config{MaxRetries: 6},
}
// Handler function
val := atomic.Int32{}
fn := func(ctx context.Context) (int32, error) {
v := val.Add(1)
// When the value is "2", we add a sleep that will trip the timeout
// As a consequence, the accumulator is not called, so the value "2" should not be included in the result
if v == 2 {
time.Sleep(50 * time.Millisecond)
}
// Make this method be executed 4 times in total
if v <= 3 {
return v, errors.New("continue")
}
return v, nil
}
// Invoke the policy and collect all received values
received := []int32{}
policy := NewRunnerWithOptions(context.Background(), policyDef, RunnerOpts[int32]{
Accumulator: func(i int32) {
// Safe to use non-atomic operations in the next line because "received" is not used in the operation function ("fn")
received = append(received, i)
},
})
// When using accumulators, the result only contains the last value and is normally ignored
res, err := policy(fn)
fmt.Println(res, err, received)
// Output: 4 <nil> [1 3 4]
}
// Example of using NewRunnerWithOptions with a Disposer function
func ExampleNewRunnerWithOptions_disposer() {
// Example polocy definition
policyDef := &PolicyDefinition{
log: testLog,
name: "retry",
t: 10 * time.Millisecond,
r: &retry.Config{MaxRetries: 6},
}
// Handler function
counter := atomic.Int32{}
fn := func(ctx context.Context) (int32, error) {
v := counter.Add(1)
// When the value is "2", we add a sleep that will trip the timeout
if v == 2 {
time.Sleep(50 * time.Millisecond)
}
if v <= 3 {
return v, errors.New("continue")
}
return v, nil
}
// Invoke the policy and collect all disposed values
disposerCalled := make(chan int32, 5)
policy := NewRunnerWithOptions(context.Background(), policyDef, RunnerOpts[int32]{
Disposer: func(val int32) {
// Dispose the object as needed, for example calling things like:
// val.Close()
// Use a buffered channel here because the disposer method should not block
disposerCalled <- val
},
})
// Execute the policy
res, err := policy(fn)
// The disposer should be 3 times called with values 1, 2, 3
disposed := []int32{}
for i := 0; i < 3; i++ {
disposed = append(disposed, <-disposerCalled)
}
slices.Sort(disposed)
fmt.Println(res, err, disposed)
// Output: 4 <nil> [1 2 3]
}
func TestPolicy(t *testing.T) {
retryValue := retry.DefaultConfig()
cbValue := breaker.CircuitBreaker{
Name: "test",
Interval: 10 * time.Millisecond,
Timeout: 10 * time.Millisecond,
}
cbValue.Initialize(testLog)
tests := map[string]*struct {
t time.Duration
r *retry.Config
cb *breaker.CircuitBreaker
}{
"empty": {},
"all": {
t: 10 * time.Millisecond,
r: &retryValue,
cb: &cbValue,
},
"nil policy": nil,
}
ctx := context.Background()
for name, tt := range tests {
t.Run(name, func(t *testing.T) {
called := atomic.Bool{}
fn := func(ctx context.Context) (any, error) {
called.Store(true)
return nil, nil
}
var policyDef *PolicyDefinition
if tt != nil {
policyDef = &PolicyDefinition{
log: testLog,
name: name,
t: tt.t,
r: tt.r,
cb: tt.cb,
}
}
policy := NewRunner[any](ctx, policyDef)
policy(fn)
assert.True(t, called.Load())
})
}
}
func TestPolicyTimeout(t *testing.T) {
tests := []struct {
name string
sleepTime time.Duration
timeout time.Duration
expected bool
}{
{
name: "Timeout expires",
sleepTime: time.Millisecond * 100,
timeout: time.Millisecond * 10,
expected: false,
},
{
name: "Timeout OK",
sleepTime: time.Millisecond * 10,
timeout: time.Millisecond * 100,
expected: true,
},
}
for i := range tests {
test := tests[i]
t.Run(test.name, func(t *testing.T) {
called := atomic.Bool{}
fn := func(ctx context.Context) (any, error) {
time.Sleep(test.sleepTime)
called.Store(true)
return nil, nil
}
policy := NewRunner[any](context.Background(), &PolicyDefinition{
log: testLog,
name: "timeout",
t: test.timeout,
})
policy(fn)
assert.Equal(t, test.expected, called.Load())
})
}
}
func TestPolicyRetry(t *testing.T) {
tests := []struct {
name string
maxCalls int32
maxRetries int64
expected int32
}{
{
name: "Retries succeed",
maxCalls: 5,
maxRetries: 6,
expected: 6,
},
{
name: "Retries fail",
maxCalls: 5,
maxRetries: 2,
expected: 3,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
called := atomic.Int32{}
maxCalls := test.maxCalls
fn := func(ctx context.Context) (struct{}, error) {
v := called.Add(1)
attempt := GetAttempt(ctx)
if attempt != v {
return struct{}{}, backoff.Permanent(fmt.Errorf("expected attempt in context to be %d but got %d", v, attempt))
}
if v <= maxCalls {
return struct{}{}, fmt.Errorf("called (%d) vs Max (%d)", v-1, maxCalls)
}
return struct{}{}, nil
}
policy := NewRunner[struct{}](context.Background(), &PolicyDefinition{
log: testLog,
name: "retry",
t: 10 * time.Millisecond,
r: &retry.Config{MaxRetries: test.maxRetries},
})
_, err := policy(fn)
if err != nil {
assert.NotContains(t, err.Error(), "expected attempt in context to be")
}
assert.Equal(t, test.expected, called.Load())
})
}
}
func TestPolicyAccumulator(t *testing.T) {
val := atomic.Int32{}
fnCalled := atomic.Int32{}
fn := func(ctx context.Context) (int32, error) {
fnCalled.Add(1)
v := val.Load()
if v == 0 || v == 2 {
// Because the accumulator isn't called when "val" is 0 or 2, we need to increment "val" here
val.Add(1)
}
// When the value is "2", we add a sleep that will trip the timeout
// As a consequence, the accumulator is not called, so the value "2" should not be included in the result
if v == 2 {
time.Sleep(50 * time.Millisecond)
}
if v <= 3 {
return v, errors.New("continue")
}
return v, nil
}
received := []int32{}
policyDef := &PolicyDefinition{
log: testLog,
name: "retry",
t: 10 * time.Millisecond,
r: &retry.Config{MaxRetries: 6},
}
var accumulatorCalled int
policy := NewRunnerWithOptions(context.Background(), policyDef, RunnerOpts[int32]{
Accumulator: func(i int32) {
// Only reason for incrementing "val" here is to have something to check for race conditions with "go test -race"
val.Add(1)
// Safe to use non-atomic operations in the next line because "received" is not used in the operation function ("fn")
received = append(received, i)
accumulatorCalled++
},
})
res, err := policy(fn)
// Sleep a bit to ensure that things in the background aren't continuing
time.Sleep(100 * time.Millisecond)
require.NoError(t, err)
// res should contain only the last result, i.e. 4
assert.Equal(t, int32(4), res)
assert.Equal(t, 3, accumulatorCalled)
assert.Equal(t, int32(5), fnCalled.Load())
assert.Equal(t, []int32{1, 3, 4}, received)
}
func TestPolicyDisposer(t *testing.T) {
counter := atomic.Int32{}
fn := func(ctx context.Context) (int32, error) {
v := counter.Add(1)
// When the value is "2", we add a sleep that will trip the timeout
if v == 2 {
time.Sleep(50 * time.Millisecond)
}
if v <= 3 {
return v, errors.New("continue")
}
return v, nil
}
disposerCalled := make(chan int32, 5)
policyDef := &PolicyDefinition{
log: testLog,
name: "retry",
t: 10 * time.Millisecond,
r: &retry.Config{MaxRetries: 5},
}
policy := NewRunnerWithOptions(context.Background(), policyDef, RunnerOpts[int32]{
Disposer: func(i int32) {
disposerCalled <- i
},
})
res, err := policy(fn)
require.NoError(t, err)
// res should contain only the last result, i.e. 4
assert.Equal(t, int32(4), res)
// The disposer should be 3 times called with values 1, 2, 3
disposed := []int32{}
for i := 0; i < 3; i++ {
disposed = append(disposed, <-disposerCalled)
}
// Shouldn't have more messages coming in
select {
case <-time.After(100 * time.Millisecond):
// all good
case <-disposerCalled:
t.Error("received an extra message we were not expecting")
}
slices.Sort(disposed)
assert.Equal(t, []int32{1, 2, 3}, disposed)
}
|
mikeee/dapr
|
pkg/resiliency/policy_test.go
|
GO
|
mit
| 9,498 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package resiliency
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"strconv"
"sync"
"time"
grpcRetry "github.com/grpc-ecosystem/go-grpc-middleware/retry"
lru "github.com/hashicorp/golang-lru/v2"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"sigs.k8s.io/yaml"
resiliencyV1alpha "github.com/dapr/dapr/pkg/apis/resiliency/v1alpha1"
diag "github.com/dapr/dapr/pkg/diagnostics"
operatorv1pb "github.com/dapr/dapr/pkg/proto/operator/v1"
"github.com/dapr/dapr/pkg/resiliency/breaker"
"github.com/dapr/kit/config"
"github.com/dapr/kit/logger"
"github.com/dapr/kit/retry"
"github.com/dapr/kit/utils"
)
const (
operatorRetryCount = 100
operatorTimePerRetry = time.Second * 5
defaultEndpointCacheSize = 100
defaultActorCacheSize = 5000
BuiltInServiceRetries BuiltInPolicyName = "DaprBuiltInServiceRetries"
BuiltInActorRetries BuiltInPolicyName = "DaprBuiltInActorRetries"
BuiltInActorReminderRetries BuiltInPolicyName = "DaprBuiltInActorReminderRetries"
BuiltInActorNotFoundRetries BuiltInPolicyName = "DaprBuiltInActorNotFoundRetries"
BuiltInInitializationRetries BuiltInPolicyName = "DaprBuiltInInitializationRetries"
DefaultRetryTemplate DefaultPolicyTemplate = "Default%sRetryPolicy"
DefaultTimeoutTemplate DefaultPolicyTemplate = "Default%sTimeoutPolicy"
DefaultCircuitBreakerTemplate DefaultPolicyTemplate = "Default%sCircuitBreakerPolicy"
Endpoint PolicyTypeName = "App"
Component PolicyTypeName = "Component"
Actor PolicyTypeName = "Actor"
Binding ComponentType = "Binding"
Configuration ComponentType = "Configuration"
Lock ComponentType = "Lock"
Pubsub ComponentType = "Pubsub"
Crypto ComponentType = "Crypto"
Secretstore ComponentType = "Secretstore"
Statestore ComponentType = "Statestore"
Inbound ComponentDirection = "Inbound"
Outbound ComponentDirection = "Outbound"
)
// ActorCircuitBreakerScope indicates the scope of the circuit breaker for an actor.
type ActorCircuitBreakerScope int
const (
// ActorCircuitBreakerScopeType indicates the type scope (less granular).
ActorCircuitBreakerScopeType ActorCircuitBreakerScope = iota
// ActorCircuitBreakerScopeID indicates the type+id scope (more granular).
ActorCircuitBreakerScopeID
// ActorCircuitBreakerScopeBoth indicates both type and type+id are used for scope.
ActorCircuitBreakerScopeBoth // Usage is TODO.
resiliencyKind = "Resiliency"
)
type (
// Provider is the interface for returning a `*PolicyDefinition` for the various
// resiliency scenarios in the runtime.
Provider interface {
// EndpointPolicy returns the policy for a service endpoint.
EndpointPolicy(service string, endpoint string) *PolicyDefinition
// ActorPolicy returns the policy for an actor instance to be used before the lock is acquired.
ActorPreLockPolicy(actorType string, id string) *PolicyDefinition
// ActorPolicy returns the policy for an actor instance to be used after the lock is acquired.
ActorPostLockPolicy(actorType string, id string) *PolicyDefinition
// ComponentOutboundPolicy returns the outbound policy for a component.
ComponentOutboundPolicy(name string, componentType ComponentType) *PolicyDefinition
// ComponentInboundPolicy returns the inbound policy for a component.
ComponentInboundPolicy(name string, componentType ComponentType) *PolicyDefinition
// BuiltInPolicy are used to replace existing retries in Dapr which may not bind specifically to one of the above categories.
BuiltInPolicy(name BuiltInPolicyName) *PolicyDefinition
// PolicyDefined returns true if there's policy that applies to the target.
PolicyDefined(target string, policyType PolicyType) (exists bool)
}
// Resiliency encapsulates configuration for timeouts, retries, and circuit breakers.
// It maps services, actors, components, and routes to each of these configurations.
// Lastly, it maintains circuit breaker state across invocations.
Resiliency struct {
name string
namespace string
log logger.Logger
timeouts map[string]time.Duration
retries map[string]*retry.Config
circuitBreakers map[string]*breaker.CircuitBreaker
actorCBCaches map[string]*lru.Cache[string, *breaker.CircuitBreaker]
actorCBsCachesMu sync.RWMutex
serviceCBs map[string]*lru.Cache[string, *breaker.CircuitBreaker]
serviceCBsMu sync.RWMutex
componentCBs *circuitBreakerInstances
apps map[string]PolicyNames
actors map[string]ActorPolicies
components map[string]ComponentPolicyNames
}
// circuitBreakerInstances stores circuit breaker state for components
// that have ephemeral instances (actors, service endpoints).
circuitBreakerInstances struct {
sync.RWMutex
cbs map[string]*breaker.CircuitBreaker
}
// ComponentPolicyNames contains the policies for component input and output.
ComponentPolicyNames struct {
Inbound PolicyNames
Outbound PolicyNames
}
// PolicyNames contains the policy names for a timeout, retry, and circuit breaker.
// Empty values mean that no policy is configured.
PolicyNames struct {
Timeout string
Retry string
CircuitBreaker string
}
// Actors have different behavior before and after locking.
ActorPolicies struct {
PreLockPolicies ActorPreLockPolicyNames
PostLockPolicies ActorPostLockPolicyNames
}
// Policy used before an actor is locked. It does not include a timeout as we want to wait forever for the actor.
ActorPreLockPolicyNames struct {
Retry string
CircuitBreaker string
CircuitBreakerScope ActorCircuitBreakerScope
}
// Policy used after an actor is locked. It only uses timeout as retry/circuit breaker is handled before locking.
ActorPostLockPolicyNames struct {
Timeout string
}
DefaultPolicyTemplate string
BuiltInPolicyName string
PolicyTypeName string
// PolicyTypes have to return an array of their possible levels.
// Ex. [App], [Actor], [Component, Inbound|Outbound, ComponentType]
PolicyType interface {
getPolicyLevels() []string
getPolicyTypeName() PolicyTypeName
}
EndpointPolicy struct{}
ActorPolicy struct{}
ComponentType string
ComponentDirection string
ComponentPolicy struct {
componentType ComponentType
componentDirection ComponentDirection
}
)
// Ensure `*Resiliency` satisfies the `Provider` interface.
var _ = (Provider)((*Resiliency)(nil))
// LoadLocalResiliency loads resiliency configurations from local folders.
func LoadLocalResiliency(log logger.Logger, runtimeID string, paths ...string) []*resiliencyV1alpha.Resiliency {
configs := []*resiliencyV1alpha.Resiliency{}
for _, path := range paths {
loaded := loadLocalResiliencyPath(log, runtimeID, path)
if len(loaded) > 0 {
configs = append(configs, loaded...)
}
}
return configs
}
func loadLocalResiliencyPath(log logger.Logger, runtimeID string, path string) []*resiliencyV1alpha.Resiliency {
_, err := os.Stat(path)
if os.IsNotExist(err) {
return nil
}
files, err := os.ReadDir(path)
if err != nil {
log.Errorf("Failed to read resiliency files from path %s: %v", path, err)
return nil
}
configs := make([]*resiliencyV1alpha.Resiliency, 0, len(files))
type typeInfo struct {
metav1.TypeMeta `json:",inline"`
}
for _, file := range files {
if !utils.IsYaml(file.Name()) {
log.Warnf("A non-YAML resiliency file %s was detected, it will not be loaded", file.Name())
continue
}
filePath := filepath.Join(path, file.Name())
b, err := os.ReadFile(filePath)
if err != nil {
log.Errorf("Could not read resiliency file %s: %v", file.Name(), err)
continue
}
var ti typeInfo
if err = yaml.Unmarshal(b, &ti); err != nil {
log.Errorf("Could not determine resource type: %v", err)
continue
}
if ti.Kind != resiliencyKind {
continue
}
var resiliency resiliencyV1alpha.Resiliency
if err = yaml.Unmarshal(b, &resiliency); err != nil {
log.Errorf("Could not parse resiliency file %s: %v", file.Name(), err)
continue
}
configs = append(configs, &resiliency)
}
return filterResiliencyConfigs(configs, runtimeID)
}
// LoadKubernetesResiliency loads resiliency configurations from the Kubernetes operator.
func LoadKubernetesResiliency(log logger.Logger, runtimeID, namespace string, operatorClient operatorv1pb.OperatorClient) []*resiliencyV1alpha.Resiliency {
resp, err := operatorClient.ListResiliency(context.Background(), &operatorv1pb.ListResiliencyRequest{
Namespace: namespace,
}, grpcRetry.WithMax(operatorRetryCount), grpcRetry.WithPerRetryTimeout(operatorTimePerRetry))
if err != nil {
log.Errorf("Error listing resiliency policies: %v", err)
return nil
}
if resp.GetResiliencies() == nil {
log.Debug("No resiliency policies found")
return nil
}
configs := make([]*resiliencyV1alpha.Resiliency, 0, len(resp.GetResiliencies()))
for _, b := range resp.GetResiliencies() {
var resiliency resiliencyV1alpha.Resiliency
if err = yaml.Unmarshal(b, &resiliency); err != nil {
log.Errorf("Could not parse resiliency: %v", err)
continue
}
configs = append(configs, &resiliency)
}
return filterResiliencyConfigs(configs, runtimeID)
}
// FromConfigurations creates a resiliency provider and decodes the configurations from `c`.
func FromConfigurations(log logger.Logger, c ...*resiliencyV1alpha.Resiliency) *Resiliency {
r := New(log)
// Add the default policies into the overall resiliency first. This allows customers to overwrite them if desired.
r.addBuiltInPolicies()
for _, config := range c {
log.Infof("Loading Resiliency configuration: %s", config.Name)
log.Debugf("Resiliency configuration (%s): %+v", config.Name, config)
if err := r.DecodeConfiguration(config); err != nil {
log.Errorf("Could not read resiliency policy %s: %w", &config.ObjectMeta.Name, err)
continue
}
diag.DefaultResiliencyMonitoring.PolicyLoaded(config.Name, config.Namespace)
}
return r
}
// New creates a new Resiliency.
func New(log logger.Logger) *Resiliency {
return &Resiliency{
log: log,
timeouts: make(map[string]time.Duration),
retries: make(map[string]*retry.Config),
circuitBreakers: make(map[string]*breaker.CircuitBreaker),
actorCBCaches: make(map[string]*lru.Cache[string, *breaker.CircuitBreaker]),
serviceCBs: make(map[string]*lru.Cache[string, *breaker.CircuitBreaker]),
componentCBs: &circuitBreakerInstances{
cbs: make(map[string]*breaker.CircuitBreaker, 10),
},
apps: make(map[string]PolicyNames),
actors: make(map[string]ActorPolicies),
components: make(map[string]ComponentPolicyNames),
}
}
// DecodeConfiguration reads in a single resiliency configuration.
func (r *Resiliency) DecodeConfiguration(c *resiliencyV1alpha.Resiliency) error {
if c == nil {
return nil
}
r.name = c.Name
r.namespace = c.Namespace
if err := r.decodePolicies(c); err != nil {
return err
}
return r.decodeTargets(c)
}
// Adds policies that cover the existing retries in Dapr like service invocation.
func (r *Resiliency) addBuiltInPolicies() {
// Cover retries for remote service invocation, but don't overwrite anything that is already present.
if _, ok := r.retries[string(BuiltInServiceRetries)]; !ok {
r.retries[string(BuiltInServiceRetries)] = &retry.Config{
Policy: retry.PolicyConstant,
// Note: If this value changes to 0, don't forget to disable "Replay" in direct messaging
MaxRetries: 3,
Duration: time.Second,
}
}
// Cover retries for remote actor invocation, but don't overwrite anything that is already present.
if _, ok := r.retries[string(BuiltInActorRetries)]; !ok {
r.retries[string(BuiltInActorRetries)] = &retry.Config{
Policy: retry.PolicyConstant,
MaxRetries: 3,
Duration: time.Second,
}
}
// Cover retries for actor reminder operations, but don't overwrite anything that is already present.
if _, ok := r.retries[string(BuiltInActorReminderRetries)]; !ok {
r.retries[string(BuiltInActorReminderRetries)] = &retry.Config{
Policy: retry.PolicyExponential,
InitialInterval: 500 * time.Millisecond,
RandomizationFactor: 0.5,
Multiplier: 1.5,
MaxInterval: 60 * time.Second,
MaxElapsedTime: 15 * time.Minute,
}
}
// Cover retries for initialization, but don't overwrite anything that is already present.
if _, ok := r.retries[string(BuiltInInitializationRetries)]; !ok {
r.retries[string(BuiltInInitializationRetries)] = &retry.Config{
Policy: retry.PolicyExponential,
InitialInterval: time.Millisecond * 500,
MaxRetries: 3,
MaxInterval: time.Second,
MaxElapsedTime: time.Second * 10,
Duration: time.Second * 2,
Multiplier: 1.5,
RandomizationFactor: 0.5,
}
}
if _, ok := r.retries[string(BuiltInActorNotFoundRetries)]; !ok {
r.retries[string(BuiltInActorNotFoundRetries)] = &retry.Config{
Policy: retry.PolicyConstant,
MaxRetries: 5,
Duration: time.Second,
}
}
}
func (r *Resiliency) decodePolicies(c *resiliencyV1alpha.Resiliency) (err error) {
policies := c.Spec.Policies
for name, t := range policies.Timeouts {
if r.timeouts[name], err = parseDuration(t); err != nil {
return fmt.Errorf("invalid duration %q, %s: %w", name, t, err)
}
}
for name, t := range policies.Retries {
rc := retry.DefaultConfig()
m, err := toMap(t)
if err != nil {
return err
}
if err = retry.DecodeConfig(&rc, m); err != nil {
return fmt.Errorf("invalid retry configuration %q: %w", name, err)
}
if !r.isProtectedPolicy(name) {
if r.isBuiltInPolicy(name) && rc.MaxRetries < 3 {
r.log.Warnf("Attempted override of %s did not meet minimum retry count, resetting to 3.", name)
rc.MaxRetries = 3
}
r.retries[name] = &rc
} else {
r.log.Warnf("Attempted to override protected policy %s which is not allowed. Ignoring provided policy and using default.", name)
}
}
for name, t := range policies.CircuitBreakers {
var cb breaker.CircuitBreaker
m, err := toMap(t)
if err != nil {
return err
}
if err = config.Decode(m, &cb); err != nil {
return fmt.Errorf("invalid retry configuration %q: %w", name, err)
}
cb.Name = name
cb.Initialize(r.log)
r.circuitBreakers[name] = &cb
}
return nil
}
func (r *Resiliency) decodeTargets(c *resiliencyV1alpha.Resiliency) (err error) {
targets := c.Spec.Targets
for name, t := range targets.Apps {
r.apps[name] = PolicyNames{
Timeout: t.Timeout,
Retry: t.Retry,
CircuitBreaker: t.CircuitBreaker,
}
if t.CircuitBreakerCacheSize == 0 {
t.CircuitBreakerCacheSize = defaultEndpointCacheSize
}
r.serviceCBs[name], err = lru.New[string, *breaker.CircuitBreaker](t.CircuitBreakerCacheSize)
if err != nil {
return err
}
}
for name, t := range targets.Actors {
if t.CircuitBreakerScope == "" && t.CircuitBreaker != "" {
return fmt.Errorf("actor circuit breakers must include scope")
}
if t.CircuitBreaker != "" {
scope, cErr := ParseActorCircuitBreakerScope(t.CircuitBreakerScope)
if cErr != nil {
return cErr
}
r.actors[name] = ActorPolicies{
PreLockPolicies: ActorPreLockPolicyNames{
Retry: t.Retry,
CircuitBreaker: t.CircuitBreaker,
CircuitBreakerScope: scope,
},
PostLockPolicies: ActorPostLockPolicyNames{
Timeout: t.Timeout,
},
}
} else {
r.actors[name] = ActorPolicies{
PreLockPolicies: ActorPreLockPolicyNames{
Retry: t.Retry,
CircuitBreaker: "",
},
PostLockPolicies: ActorPostLockPolicyNames{
Timeout: t.Timeout,
},
}
}
if t.CircuitBreakerCacheSize == 0 {
t.CircuitBreakerCacheSize = defaultActorCacheSize
}
r.actorCBCaches[name], err = lru.New[string, *breaker.CircuitBreaker](t.CircuitBreakerCacheSize)
if err != nil {
return err
}
}
for name, t := range targets.Components {
r.components[name] = ComponentPolicyNames{
Inbound: PolicyNames{
Timeout: t.Inbound.Timeout,
Retry: t.Inbound.Retry,
CircuitBreaker: t.Inbound.CircuitBreaker,
},
Outbound: PolicyNames{
Timeout: t.Outbound.Timeout,
Retry: t.Outbound.Retry,
CircuitBreaker: t.Outbound.CircuitBreaker,
},
}
}
return nil
}
func (r *Resiliency) isBuiltInPolicy(name string) bool {
switch name {
case string(BuiltInServiceRetries):
fallthrough
case string(BuiltInActorRetries):
fallthrough
case string(BuiltInActorReminderRetries):
fallthrough
case string(BuiltInInitializationRetries):
fallthrough
case string(BuiltInActorNotFoundRetries):
return true
default:
return false
}
}
func (r *Resiliency) isProtectedPolicy(name string) bool {
switch name {
case string(BuiltInActorNotFoundRetries):
return true
default:
return false
}
}
// addMetricsToPolicy adds metrics for resiliency policies for count on instantiation and activation for each policy that is defined.
func (r *Resiliency) addMetricsToPolicy(policyDef *PolicyDefinition, target string, direction diag.PolicyFlowDirection) {
if policyDef.t != 0 {
diag.DefaultResiliencyMonitoring.PolicyExecuted(r.name, r.namespace, diag.TimeoutPolicy, direction, target)
policyDef.addTimeoutActivatedMetric = func() {
diag.DefaultResiliencyMonitoring.PolicyActivated(r.name, r.namespace, diag.TimeoutPolicy, direction, target)
}
}
if policyDef.r != nil {
diag.DefaultResiliencyMonitoring.PolicyExecuted(r.name, r.namespace, diag.RetryPolicy, direction, target)
policyDef.addRetryActivatedMetric = func() {
diag.DefaultResiliencyMonitoring.PolicyActivated(r.name, r.namespace, diag.RetryPolicy, direction, target)
}
}
if policyDef.cb != nil {
diag.DefaultResiliencyMonitoring.PolicyWithStatusExecuted(r.name, r.namespace, diag.CircuitBreakerPolicy, direction, target, string(policyDef.cb.State()))
policyDef.addCBStateChangedMetric = func() {
diag.DefaultResiliencyMonitoring.PolicyWithStatusActivated(r.name, r.namespace, diag.CircuitBreakerPolicy, direction, target, string(policyDef.cb.State()))
}
}
}
// EndpointPolicy returns the policy for a service endpoint.
func (r *Resiliency) EndpointPolicy(app string, endpoint string) *PolicyDefinition {
policyDef := &PolicyDefinition{
log: r.log,
name: "endpoint[" + app + ", " + endpoint + "]",
}
policyNames, ok := r.apps[app]
if ok {
r.log.Debugf("Found Endpoint Policy for %s: %+v", app, policyNames)
if policyNames.Timeout != "" {
policyDef.t = r.timeouts[policyNames.Timeout]
}
if policyNames.Retry != "" {
policyDef.r = r.retries[policyNames.Retry]
}
if policyNames.CircuitBreaker != "" {
template, ok := r.circuitBreakers[policyNames.CircuitBreaker]
if ok {
cache, ok := r.serviceCBs[app]
if ok {
policyDef.cb, ok = cache.Get(endpoint)
if !ok || policyDef.cb == nil {
policyDef.cb = newCB(endpoint, template, r.log)
cache.Add(endpoint, policyDef.cb)
}
}
}
}
} else {
if defaultNames, ok := r.getDefaultPolicy(EndpointPolicy{}); ok {
r.log.Debugf("Found Default Policy for Endpoint %s: %+v", app, defaultNames)
if defaultNames.Retry != "" {
policyDef.r = r.retries[defaultNames.Retry]
}
if defaultNames.Timeout != "" {
policyDef.t = r.timeouts[defaultNames.Timeout]
}
if defaultNames.CircuitBreaker != "" {
template, ok := r.circuitBreakers[defaultNames.CircuitBreaker]
if ok {
serviceCBCache, err := r.getServiceCBCache(app)
if err != nil {
r.log.Errorf("error getting default circuit breaker cache for app %s: %s", app, err)
}
policyDef.cb = r.getCBFromCache(serviceCBCache, endpoint, template)
}
}
}
}
r.addMetricsToPolicy(policyDef, diag.ResiliencyAppTarget(app), diag.OutboundPolicyFlowDirection)
return policyDef
}
func newCB(cbName string, template *breaker.CircuitBreaker, l logger.Logger) *breaker.CircuitBreaker {
cb := &breaker.CircuitBreaker{
Name: cbName,
MaxRequests: template.MaxRequests,
Interval: template.Interval,
Timeout: template.Timeout,
Trip: template.Trip,
}
cb.Initialize(l)
return cb
}
func (r *Resiliency) getServiceCBCache(app string) (*lru.Cache[string, *breaker.CircuitBreaker], error) {
r.serviceCBsMu.RLock()
cache, ok := r.serviceCBs[app]
r.serviceCBsMu.RUnlock()
if ok {
return cache, nil
}
r.serviceCBsMu.Lock()
defer r.serviceCBsMu.Unlock()
cache, ok = r.serviceCBs[app] // double check in case another goroutine created the cache
if ok {
return cache, nil
}
cache, err := lru.New[string, *breaker.CircuitBreaker](defaultEndpointCacheSize)
if err != nil {
return nil, err
}
r.serviceCBs[app] = cache
return cache, nil
}
func (r *Resiliency) getActorCBCache(app string) (*lru.Cache[string, *breaker.CircuitBreaker], error) {
r.actorCBsCachesMu.RLock()
cache, ok := r.actorCBCaches[app]
r.actorCBsCachesMu.RUnlock()
if ok {
return cache, nil
}
r.actorCBsCachesMu.Lock()
defer r.actorCBsCachesMu.Unlock()
cache, ok = r.actorCBCaches[app] // double check in case another goroutine created the cache
if ok {
return cache, nil
}
cache, err := lru.New[string, *breaker.CircuitBreaker](defaultEndpointCacheSize)
if err != nil {
return nil, err
}
r.actorCBCaches[app] = cache
return cache, nil
}
func (r *Resiliency) getCBFromCache(cache *lru.Cache[string, *breaker.CircuitBreaker], key string, template *breaker.CircuitBreaker) *breaker.CircuitBreaker {
if cache == nil {
return newCB(key, template, r.log)
}
cb, ok := cache.Get(key)
if !ok || cb == nil {
r.serviceCBsMu.Lock()
defer r.serviceCBsMu.Unlock()
cb, ok = cache.Get(key)
if ok && cb != nil {
return cb
}
cb = newCB(key, template, r.log)
cache.Add(key, cb)
}
return cb
}
// ActorPreLockPolicy returns the policy for an actor instance to be used before an actor lock is acquired.
func (r *Resiliency) ActorPreLockPolicy(actorType string, id string) *PolicyDefinition {
policyDef := &PolicyDefinition{
log: r.log,
name: "actor[" + actorType + ", " + id + "]",
}
actorPolicies, ok := r.actors[actorType]
if policyNames := actorPolicies.PreLockPolicies; ok {
r.log.Debugf("Found Actor Policy for type %s: %+v", actorType, policyNames)
if policyNames.Retry != "" {
policyDef.r = r.retries[policyNames.Retry]
}
if policyNames.CircuitBreaker != "" {
template, ok := r.circuitBreakers[policyNames.CircuitBreaker]
if ok {
cache, ok := r.actorCBCaches[actorType]
if ok {
var key string
if policyNames.CircuitBreakerScope == ActorCircuitBreakerScopeType {
key = actorType
} else {
key = actorType + "-" + id
}
policyDef.cb, ok = cache.Get(key)
if !ok || policyDef.cb == nil {
policyDef.cb = newCB(key, template, r.log)
cache.Add(key, policyDef.cb)
}
}
}
}
} else {
if defaultNames, ok := r.getDefaultPolicy(ActorPolicy{}); ok {
r.log.Debugf("Found Default Policy for Actor type %s: %+v", actorType, defaultNames)
if defaultNames.Retry != "" {
policyDef.r = r.retries[defaultNames.Retry]
}
if defaultNames.CircuitBreaker != "" {
template, ok := r.circuitBreakers[defaultNames.CircuitBreaker]
if ok {
actorCBCache, err := r.getActorCBCache(actorType)
if err != nil {
r.log.Errorf("error getting default circuit breaker cache for actor type %s: %v", actorType, err)
}
policyDef.cb = r.getCBFromCache(actorCBCache, actorType, template)
}
}
}
}
r.addMetricsToPolicy(policyDef, diag.ResiliencyActorTarget(actorType), diag.OutboundPolicyFlowDirection)
return policyDef
}
// ActorPostLockPolicy returns the policy for an actor instance to be used after an actor lock is acquired.
func (r *Resiliency) ActorPostLockPolicy(actorType string, id string) *PolicyDefinition {
policyDef := &PolicyDefinition{
log: r.log,
name: "actor[" + actorType + ", " + id + "]",
}
actorPolicies, ok := r.actors[actorType]
if policyNames := actorPolicies.PostLockPolicies; ok {
r.log.Debugf("Found Actor Policy for type %s: %+v", actorType, policyNames)
if policyNames.Timeout != "" {
policyDef.t = r.timeouts[policyNames.Timeout]
}
} else {
if defaultPolicies, ok := r.getDefaultPolicy(ActorPolicy{}); ok {
r.log.Debugf("Found Default Policy for Actor type %s: %+v", actorType, defaultPolicies)
if defaultPolicies.Timeout != "" {
policyDef.t = r.timeouts[defaultPolicies.Timeout]
}
}
}
r.addMetricsToPolicy(policyDef, diag.ResiliencyActorTarget(actorType), diag.OutboundPolicyFlowDirection)
return policyDef
}
// ComponentOutboundPolicy returns the outbound policy for a component.
func (r *Resiliency) ComponentOutboundPolicy(name string, componentType ComponentType) *PolicyDefinition {
policyDef := &PolicyDefinition{
log: r.log,
name: "component[" + name + "] output",
}
componentPolicies, ok := r.components[name]
if ok {
r.log.Debugf("Found Component Outbound Policy for component %s: %+v", name, componentPolicies.Outbound)
if componentPolicies.Outbound.Timeout != "" {
policyDef.t = r.timeouts[componentPolicies.Outbound.Timeout]
}
if componentPolicies.Outbound.Retry != "" {
policyDef.r = r.retries[componentPolicies.Outbound.Retry]
}
if componentPolicies.Outbound.CircuitBreaker != "" {
template := r.circuitBreakers[componentPolicies.Outbound.CircuitBreaker]
policyDef.cb = r.componentCBs.Get(r.log, name, template)
}
} else {
if defaultPolicies, ok := r.getDefaultPolicy(ComponentPolicy{componentType: componentType, componentDirection: "Outbound"}); ok {
r.log.Debugf("Found Default Policy for Component: %s: %+v", name, defaultPolicies)
if defaultPolicies.Timeout != "" {
policyDef.t = r.timeouts[defaultPolicies.Timeout]
}
if defaultPolicies.Retry != "" {
policyDef.r = r.retries[defaultPolicies.Retry]
}
if defaultPolicies.CircuitBreaker != "" {
template := r.circuitBreakers[defaultPolicies.CircuitBreaker]
policyDef.cb = r.componentCBs.Get(r.log, name, template)
}
}
}
r.addMetricsToPolicy(policyDef, diag.ResiliencyComponentTarget(name, string(componentType)), diag.OutboundPolicyFlowDirection)
return policyDef
}
// ComponentInboundPolicy returns the inbound policy for a component.
func (r *Resiliency) ComponentInboundPolicy(name string, componentType ComponentType) *PolicyDefinition {
policyDef := &PolicyDefinition{
log: r.log,
name: "component[" + name + "] input",
}
componentPolicies, ok := r.components[name]
if ok {
r.log.Debugf("Found Component Inbound Policy for component %s: %+v", name, componentPolicies.Inbound)
if componentPolicies.Inbound.Timeout != "" {
policyDef.t = r.timeouts[componentPolicies.Inbound.Timeout]
}
if componentPolicies.Inbound.Retry != "" {
policyDef.r = r.retries[componentPolicies.Inbound.Retry]
}
if componentPolicies.Inbound.CircuitBreaker != "" {
template := r.circuitBreakers[componentPolicies.Inbound.CircuitBreaker]
policyDef.cb = r.componentCBs.Get(r.log, name, template)
}
} else {
if defaultPolicies, ok := r.getDefaultPolicy(ComponentPolicy{componentType: componentType, componentDirection: Inbound}); ok {
r.log.Debugf("Found Default Policy for Component: %s: %+v", name, defaultPolicies)
if defaultPolicies.Timeout != "" {
policyDef.t = r.timeouts[defaultPolicies.Timeout]
}
if defaultPolicies.Retry != "" {
policyDef.r = r.retries[defaultPolicies.Retry]
}
if defaultPolicies.CircuitBreaker != "" {
template := r.circuitBreakers[defaultPolicies.CircuitBreaker]
policyDef.cb = r.componentCBs.Get(r.log, name, template)
}
}
}
r.addMetricsToPolicy(policyDef, diag.ResiliencyComponentTarget(name, string(componentType)), diag.InboundPolicyFlowDirection)
return policyDef
}
// BuiltInPolicy returns a policy that represents a specific built-in retry scenario.
func (r *Resiliency) BuiltInPolicy(name BuiltInPolicyName) *PolicyDefinition {
nameStr := string(name)
return &PolicyDefinition{
log: r.log,
name: nameStr,
r: r.retries[nameStr],
}
}
// PolicyDefined returns true if there's policy that applies to the target.
func (r *Resiliency) PolicyDefined(target string, policyType PolicyType) (exists bool) {
switch policyType.getPolicyTypeName() {
case Endpoint:
_, exists = r.apps[target]
case Component:
_, exists = r.components[target]
case Actor:
_, exists = r.actors[target]
}
return exists
}
func (r *Resiliency) getDefaultPolicy(policyType PolicyType) (PolicyNames, bool) {
policyNames := PolicyNames{
Retry: r.getDefaultRetryPolicy(policyType),
Timeout: r.getDefaultTimeoutPolicy(policyType),
CircuitBreaker: r.getDefaultCircuitBreakerPolicy(policyType),
}
return policyNames, (policyNames.Retry != "" || policyNames.Timeout != "" || policyNames.CircuitBreaker != "")
}
func (r *Resiliency) getDefaultRetryPolicy(policyType PolicyType) string {
typeTemplates, topLevelTemplate := r.expandPolicyTemplate(policyType, DefaultRetryTemplate)
for _, typeTemplate := range typeTemplates {
if _, ok := r.retries[typeTemplate]; ok {
return typeTemplate
}
}
if _, ok := r.retries[topLevelTemplate]; ok {
return topLevelTemplate
}
return ""
}
func (r *Resiliency) getDefaultTimeoutPolicy(policyType PolicyType) string {
typeTemplates, topLevelTemplate := r.expandPolicyTemplate(policyType, DefaultTimeoutTemplate)
for _, typeTemplate := range typeTemplates {
if _, ok := r.timeouts[typeTemplate]; ok {
return typeTemplate
}
}
if _, ok := r.timeouts[topLevelTemplate]; ok {
return topLevelTemplate
}
return ""
}
func (r *Resiliency) getDefaultCircuitBreakerPolicy(policyType PolicyType) string {
typeTemplates, topLevelTemplate := r.expandPolicyTemplate(policyType, DefaultCircuitBreakerTemplate)
for _, typeTemplate := range typeTemplates {
if _, ok := r.circuitBreakers[typeTemplate]; ok {
return typeTemplate
}
}
if _, ok := r.circuitBreakers[topLevelTemplate]; ok {
return topLevelTemplate
}
return ""
}
func (r *Resiliency) expandPolicyTemplate(policyType PolicyType, template DefaultPolicyTemplate) ([]string, string) {
policyLevels := policyType.getPolicyLevels()
typeTemplates := make([]string, len(policyLevels))
for i, level := range policyLevels {
typeTemplates[i] = fmt.Sprintf(string(template), level)
}
return typeTemplates, fmt.Sprintf(string(template), "")
}
// Get returns a cached circuit breaker if one exists.
// Otherwise, it returns a new circuit breaker based on the provided template.
func (e *circuitBreakerInstances) Get(log logger.Logger, instanceName string, template *breaker.CircuitBreaker) *breaker.CircuitBreaker {
e.RLock()
cb, ok := e.cbs[instanceName]
e.RUnlock()
if ok {
return cb
}
// Must create a new object
e.Lock()
defer e.Unlock()
// Check again in case another goroutine created the object while we were waiting for the lock
cb, ok = e.cbs[instanceName]
if ok {
return cb
}
cb = newCB(template.Name+"-"+instanceName, template, log)
e.cbs[instanceName] = cb
return cb
}
// Remove deletes a circuit break from the cache.
func (e *circuitBreakerInstances) Remove(name string) {
e.Lock()
delete(e.cbs, name)
e.Unlock()
}
func toMap(val interface{}) (interface{}, error) {
jsonBytes, err := json.Marshal(val)
if err != nil {
return nil, err
}
var v interface{}
err = json.Unmarshal(jsonBytes, &v)
return v, err
}
func parseDuration(val string) (time.Duration, error) {
if i, err := strconv.ParseInt(val, 10, 64); err == nil {
return time.Duration(i) * time.Millisecond, nil
}
return time.ParseDuration(val)
}
// ParseActorCircuitBreakerScope parses a string to a `ActorCircuitBreakerScope`.
func ParseActorCircuitBreakerScope(val string) (ActorCircuitBreakerScope, error) {
switch val {
case "type":
return ActorCircuitBreakerScopeType, nil
case "id":
return ActorCircuitBreakerScopeID, nil
case "both":
return ActorCircuitBreakerScopeBoth, nil
}
return ActorCircuitBreakerScope(0), fmt.Errorf("unknown circuit breaker scope %q", val)
}
// IsTimeExceeded returns true if the context timeout has elapsed.
func IsTimeoutExeceeded(err error) bool {
return errors.Is(err, context.DeadlineExceeded)
}
// IsCircuitBreakerError returns true if the error is cicuit breaker open or too many requests in half-open state.
func IsCircuitBreakerError(err error) bool {
return errors.Is(err, breaker.ErrOpenState) || errors.Is(err, breaker.ErrTooManyRequests)
}
func filterResiliencyConfigs(resiliences []*resiliencyV1alpha.Resiliency, runtimeID string) []*resiliencyV1alpha.Resiliency {
filteredResiliencies := make([]*resiliencyV1alpha.Resiliency, 0)
for _, resiliency := range resiliences {
if len(resiliency.Scopes) == 0 {
filteredResiliencies = append(filteredResiliencies, resiliency)
continue
}
for _, scope := range resiliency.Scopes {
if scope == runtimeID {
filteredResiliencies = append(filteredResiliencies, resiliency)
break
}
}
}
return filteredResiliencies
}
func (EndpointPolicy) getPolicyLevels() []string {
return []string{"App"}
}
func (EndpointPolicy) getPolicyTypeName() PolicyTypeName {
return Endpoint
}
func (ActorPolicy) getPolicyLevels() []string {
return []string{"Actor"}
}
func (ActorPolicy) getPolicyTypeName() PolicyTypeName {
return Actor
}
func (p ComponentPolicy) getPolicyLevels() []string {
return []string{
string(p.componentType) + "Component" + string(p.componentDirection),
"Component" + string(p.componentDirection),
"Component",
}
}
func (ComponentPolicy) getPolicyTypeName() PolicyTypeName {
return Component
}
var ComponentInboundPolicy = ComponentPolicy{
componentDirection: Inbound,
}
var ComponentOutboundPolicy = ComponentPolicy{
componentDirection: Outbound,
}
|
mikeee/dapr
|
pkg/resiliency/resiliency.go
|
GO
|
mit
| 34,714 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package resiliency
import (
"context"
"encoding/json"
"errors"
"fmt"
"net"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/phayes/freeport"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
resiliencyV1alpha "github.com/dapr/dapr/pkg/apis/resiliency/v1alpha1"
operatorv1pb "github.com/dapr/dapr/pkg/proto/operator/v1"
"github.com/dapr/kit/logger"
"github.com/dapr/kit/ptr"
)
type mockOperator struct {
operatorv1pb.UnimplementedOperatorServer
}
var log = logger.NewLogger("dapr.test")
func (mockOperator) ListResiliency(context.Context, *operatorv1pb.ListResiliencyRequest) (*operatorv1pb.ListResiliencyResponse, error) {
resiliency := resiliencyV1alpha.Resiliency{
TypeMeta: v1.TypeMeta{
Kind: "Resiliency",
},
ObjectMeta: v1.ObjectMeta{
Name: "resiliency",
},
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Timeouts: map[string]string{
"general": "5s",
},
Retries: map[string]resiliencyV1alpha.Retry{
"pubsubRetry": {
Policy: "constant",
Duration: "5s",
MaxRetries: ptr.Of(10),
},
},
CircuitBreakers: map[string]resiliencyV1alpha.CircuitBreaker{
"pubsubCB": {
Interval: "8s",
Timeout: "45s",
Trip: "consecutiveFailures > 8",
MaxRequests: 1,
},
},
},
Targets: resiliencyV1alpha.Targets{
Apps: map[string]resiliencyV1alpha.EndpointPolicyNames{
"appB": {
Timeout: "general",
Retry: "general",
CircuitBreaker: "general",
CircuitBreakerCacheSize: 100,
},
},
Actors: map[string]resiliencyV1alpha.ActorPolicyNames{
"myActorType": {
Timeout: "general",
Retry: "general",
CircuitBreaker: "general",
CircuitBreakerScope: "both",
CircuitBreakerCacheSize: 5000,
},
},
Components: map[string]resiliencyV1alpha.ComponentPolicyNames{
"statestore1": {
Outbound: resiliencyV1alpha.PolicyNames{
Timeout: "general",
Retry: "general",
CircuitBreaker: "general",
},
},
},
},
},
}
resiliencyBytes, _ := json.Marshal(resiliency)
resiliencyWithScope := resiliencyV1alpha.Resiliency{
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Timeouts: map[string]string{
"general": "5s",
},
Retries: map[string]resiliencyV1alpha.Retry{
"pubsubRetry": {
Policy: "constant",
Duration: "5s",
MaxRetries: ptr.Of(10),
},
},
CircuitBreakers: map[string]resiliencyV1alpha.CircuitBreaker{
"pubsubCB": {
Interval: "8s",
Timeout: "45s",
Trip: "consecutiveFailures > 8",
MaxRequests: 1,
},
},
},
Targets: resiliencyV1alpha.Targets{
Apps: map[string]resiliencyV1alpha.EndpointPolicyNames{
"appB": {
Timeout: "general",
Retry: "general",
CircuitBreaker: "general",
CircuitBreakerCacheSize: 100,
},
},
Actors: map[string]resiliencyV1alpha.ActorPolicyNames{
"myActorType": {
Timeout: "general",
Retry: "general",
CircuitBreaker: "general",
CircuitBreakerScope: "both",
CircuitBreakerCacheSize: 5000,
},
},
Components: map[string]resiliencyV1alpha.ComponentPolicyNames{
"statestore1": {
Outbound: resiliencyV1alpha.PolicyNames{
Timeout: "general",
Retry: "general",
CircuitBreaker: "general",
},
},
},
},
},
Scopes: []string{"app1", "app2"},
}
resiliencyWithScopesBytes, _ := json.Marshal(resiliencyWithScope)
return &operatorv1pb.ListResiliencyResponse{
Resiliencies: [][]byte{
resiliencyBytes,
resiliencyWithScopesBytes,
},
}, nil
}
func getOperatorClient(address string) operatorv1pb.OperatorClient {
conn, _ := grpc.Dial(address, grpc.WithTransportCredentials(insecure.NewCredentials()))
return operatorv1pb.NewOperatorClient(conn)
}
func TestPoliciesForTargets(t *testing.T) {
ctx := context.Background()
configs := LoadLocalResiliency(log, "default", "./testdata")
assert.Len(t, configs, 1)
r := FromConfigurations(log, configs...)
tests := []struct {
name string
create func(r *Resiliency) Runner[any]
}{
{
name: "component",
create: func(r *Resiliency) Runner[any] {
return NewRunner[any](ctx, r.ComponentOutboundPolicy("statestore1", "Statestore"))
},
},
{
name: "endpoint",
create: func(r *Resiliency) Runner[any] {
return NewRunner[any](ctx, r.EndpointPolicy("appB", "127.0.0.1:3500"))
},
},
{
name: "actor",
create: func(r *Resiliency) Runner[any] {
return NewRunner[any](ctx, r.ActorPreLockPolicy("myActorType", "id"))
},
},
{
name: "actor post lock",
create: func(r *Resiliency) Runner[any] {
return NewRunner[any](ctx, r.ActorPostLockPolicy("myActorType", "id"))
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := tt.create(r)
called := atomic.Bool{}
_, err := p(func(ctx context.Context) (any, error) {
called.Store(true)
return nil, nil
})
require.NoError(t, err)
assert.True(t, called.Load())
})
}
}
func TestLoadKubernetesResiliency(t *testing.T) {
port, _ := freeport.GetFreePort()
lis, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
require.NoError(t, err)
s := grpc.NewServer()
operatorv1pb.RegisterOperatorServer(s, &mockOperator{})
defer s.Stop()
go func() {
s.Serve(lis)
}()
time.Sleep(time.Second * 1)
resiliency := LoadKubernetesResiliency(log, "default", "default",
getOperatorClient(fmt.Sprintf("localhost:%d", port)))
assert.NotNil(t, resiliency)
assert.Len(t, resiliency, 1)
assert.Equal(t, "Resiliency", resiliency[0].TypeMeta.Kind)
assert.Equal(t, "resiliency", resiliency[0].ObjectMeta.Name)
}
func TestLoadStandaloneResiliency(t *testing.T) {
t.Run("test load resiliency", func(t *testing.T) {
configs := LoadLocalResiliency(log, "app1", "./testdata")
assert.NotNil(t, configs)
assert.Len(t, configs, 2)
assert.Equal(t, "Resiliency", configs[0].Kind)
assert.Equal(t, "resiliency", configs[0].Name)
assert.Equal(t, "Resiliency", configs[1].Kind)
assert.Equal(t, "resiliency", configs[1].Name)
})
t.Run("test load resiliency skips other types", func(t *testing.T) {
configs := LoadLocalResiliency(log, "app1", "../components")
assert.NotNil(t, configs)
assert.Empty(t, configs)
})
}
func TestParseActorCircuitBreakerScope(t *testing.T) {
tests := []struct {
input string
output ActorCircuitBreakerScope
err string
}{
{
input: "type",
output: ActorCircuitBreakerScopeType,
},
{
input: "id",
output: ActorCircuitBreakerScopeID,
},
{
input: "both",
output: ActorCircuitBreakerScopeBoth,
},
{
input: "unknown",
err: "unknown circuit breaker scope \"unknown\"",
},
}
for _, tt := range tests {
t.Run(tt.input, func(t *testing.T) {
actual, err := ParseActorCircuitBreakerScope(tt.input)
if tt.err == "" {
require.NoError(t, err)
assert.Equal(t, tt.output, actual)
} else {
require.EqualError(t, err, tt.err)
}
})
}
}
func TestParseMaxRetries(t *testing.T) {
configs := LoadLocalResiliency(log, "app1", "./testdata")
require.NotNil(t, configs)
require.Len(t, configs, 2)
require.NotNil(t, configs[0])
r := FromConfigurations(log, configs[0])
require.NotEmpty(t, r.retries)
require.NotNil(t, r.retries["noRetry"])
require.NotNil(t, r.retries["retryForever"])
require.NotNil(t, r.retries["missingMaxRetries"])
require.NotNil(t, r.retries["important"])
// important has "maxRetries: 30"
assert.Equal(t, int64(30), r.retries["important"].MaxRetries)
// noRetry has "maxRetries: 0" (no retries)
assert.Equal(t, int64(0), r.retries["noRetry"].MaxRetries)
// retryForever has "maxRetries: -1" (retry forever)
assert.Equal(t, int64(-1), r.retries["retryForever"].MaxRetries)
// missingMaxRetries has no "maxRetries" so should default to -1
assert.Equal(t, int64(-1), r.retries["missingMaxRetries"].MaxRetries)
}
func TestResiliencyScopeIsRespected(t *testing.T) {
port, _ := freeport.GetFreePort()
lis, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
require.NoError(t, err)
s := grpc.NewServer()
operatorv1pb.RegisterOperatorServer(s, &mockOperator{})
defer s.Stop()
go func() {
s.Serve(lis)
}()
time.Sleep(time.Second * 1)
resiliencies := LoadLocalResiliency(log, "app1", "./testdata")
assert.Len(t, resiliencies, 2)
resiliencies = LoadKubernetesResiliency(log, "app2", "default", getOperatorClient(fmt.Sprintf("localhost:%d", port)))
assert.Len(t, resiliencies, 2)
resiliencies = LoadLocalResiliency(log, "app2", "./testdata")
assert.Len(t, resiliencies, 2)
resiliencies = LoadLocalResiliency(log, "app3", "./testdata")
assert.Len(t, resiliencies, 1)
}
func TestBuiltInPoliciesAreCreated(t *testing.T) {
r := FromConfigurations(log)
assert.NotNil(t, r.retries[string(BuiltInServiceRetries)])
retry := r.retries[string(BuiltInServiceRetries)]
assert.Equal(t, int64(3), retry.MaxRetries)
assert.Equal(t, time.Second, retry.Duration)
}
func TestResiliencyHasTargetDefined(t *testing.T) {
r := &resiliencyV1alpha.Resiliency{
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Timeouts: map[string]string{
"myTimeout": "2s",
},
CircuitBreakers: map[string]resiliencyV1alpha.CircuitBreaker{
"myCB1": {
Interval: "1s",
Timeout: "5s",
Trip: "consecutiveFailures > 1",
MaxRequests: 1,
},
"myCB2": {
Interval: "2s",
Timeout: "10s",
Trip: "consecutiveFailures > 2",
MaxRequests: 2,
},
},
Retries: map[string]resiliencyV1alpha.Retry{
"myRetry": {
Policy: "constant",
Duration: "5s",
MaxRetries: ptr.Of(3),
},
},
},
Targets: resiliencyV1alpha.Targets{
Apps: map[string]resiliencyV1alpha.EndpointPolicyNames{
"definedApp": {
Timeout: "myTimeout",
CircuitBreaker: "myCB1",
},
},
Actors: map[string]resiliencyV1alpha.ActorPolicyNames{
"definedActor": {
Timeout: "myTimeout",
},
},
Components: map[string]resiliencyV1alpha.ComponentPolicyNames{
"definedComponent": {
Inbound: resiliencyV1alpha.PolicyNames{
Timeout: "myTimeout",
CircuitBreaker: "myCB1",
},
Outbound: resiliencyV1alpha.PolicyNames{
Timeout: "myTimeout",
CircuitBreaker: "myCB2",
Retry: "myRetry",
},
},
},
},
},
}
config := FromConfigurations(log, r)
assert.False(t, config.PolicyDefined("badApp", EndpointPolicy{}))
assert.False(t, config.PolicyDefined("badActor", ActorPolicy{}))
assert.False(t, config.PolicyDefined("badComponent", ComponentInboundPolicy))
assert.False(t, config.PolicyDefined("badComponent", ComponentOutboundPolicy))
assert.True(t, config.PolicyDefined("definedApp", EndpointPolicy{}))
assert.True(t, config.PolicyDefined("definedActor", ActorPolicy{}))
assert.True(t, config.PolicyDefined("definedComponent", ComponentPolicy{}))
assert.True(t, config.PolicyDefined("definedComponent", ComponentOutboundPolicy))
assert.True(t, config.PolicyDefined("definedComponent", ComponentInboundPolicy))
}
func TestResiliencyHasBuiltInPolicy(t *testing.T) {
r := FromConfigurations(log)
assert.NotNil(t, r)
builtins := []BuiltInPolicyName{
BuiltInServiceRetries,
BuiltInActorRetries,
BuiltInActorReminderRetries,
BuiltInInitializationRetries,
}
for _, n := range builtins {
p := r.BuiltInPolicy(n)
_ = assert.NotNil(t, p) &&
assert.NotNil(t, p.r)
}
}
func TestResiliencyCannotLowerBuiltInRetriesPastThree(t *testing.T) {
config := &resiliencyV1alpha.Resiliency{
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Retries: map[string]resiliencyV1alpha.Retry{
string(BuiltInServiceRetries): {
Policy: "constant",
Duration: "5s",
MaxRetries: ptr.Of(1),
},
},
},
},
}
r := FromConfigurations(log, config)
assert.NotNil(t, r)
assert.Equal(t, int64(3), r.retries[string(BuiltInServiceRetries)].MaxRetries)
}
func TestResiliencyProtectedPolicyCannotBeChanged(t *testing.T) {
config := &resiliencyV1alpha.Resiliency{
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Retries: map[string]resiliencyV1alpha.Retry{
string(BuiltInActorNotFoundRetries): {
Policy: "constant",
Duration: "5s",
MaxRetries: ptr.Of(10),
},
},
},
},
}
r := FromConfigurations(log, config)
assert.NotNil(t, r)
assert.Equal(t, int64(5), r.retries[string(BuiltInActorNotFoundRetries)].MaxRetries)
}
func TestResiliencyIsBuiltInPolicy(t *testing.T) {
r := FromConfigurations(log)
assert.NotNil(t, r)
assert.True(t, r.isBuiltInPolicy(string(BuiltInServiceRetries)))
assert.True(t, r.isBuiltInPolicy(string(BuiltInActorRetries)))
assert.True(t, r.isBuiltInPolicy(string(BuiltInActorReminderRetries)))
assert.True(t, r.isBuiltInPolicy(string(BuiltInActorNotFoundRetries)))
assert.True(t, r.isBuiltInPolicy(string(BuiltInInitializationRetries)))
assert.False(t, r.isBuiltInPolicy("Not a built in"))
}
func TestResiliencyIsProtectedPolicy(t *testing.T) {
r := FromConfigurations(log)
assert.True(t, r.isProtectedPolicy(string(BuiltInActorNotFoundRetries)))
assert.False(t, r.isProtectedPolicy(string(BuiltInActorRetries)))
assert.False(t, r.isProtectedPolicy("Random name"))
}
func TestDefaultPolicyInterpolation(t *testing.T) {
r := FromConfigurations(log)
// Retry
typePolicies, topPolicy := r.expandPolicyTemplate(&EndpointPolicy{}, DefaultRetryTemplate)
assert.Len(t, typePolicies, 1)
assert.Equal(t, "DefaultAppRetryPolicy", typePolicies[0])
assert.Equal(t, "DefaultRetryPolicy", topPolicy)
// Timeout
typePolicies, topPolicy = r.expandPolicyTemplate(&ActorPolicy{}, DefaultTimeoutTemplate)
assert.Len(t, typePolicies, 1)
assert.Equal(t, "DefaultActorTimeoutPolicy", typePolicies[0])
assert.Equal(t, "DefaultTimeoutPolicy", topPolicy)
// Circuit Breaker (also testing component policy type)
typePolicies, topPolicy = r.expandPolicyTemplate(&ComponentPolicy{componentType: "Statestore", componentDirection: "Outbound"},
DefaultCircuitBreakerTemplate)
assert.Len(t, typePolicies, 3)
assert.Equal(t, "DefaultStatestoreComponentOutboundCircuitBreakerPolicy", typePolicies[0])
assert.Equal(t, "DefaultComponentOutboundCircuitBreakerPolicy", typePolicies[1])
assert.Equal(t, "DefaultComponentCircuitBreakerPolicy", typePolicies[2])
assert.Equal(t, "DefaultCircuitBreakerPolicy", topPolicy)
}
func TestGetDefaultPolicy(t *testing.T) {
config := &resiliencyV1alpha.Resiliency{
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Retries: map[string]resiliencyV1alpha.Retry{
fmt.Sprintf(string(DefaultRetryTemplate), "App"): {
Policy: "constant",
Duration: "5s",
MaxRetries: ptr.Of(10),
},
fmt.Sprintf(string(DefaultRetryTemplate), ""): {
Policy: "constant",
Duration: "1s",
MaxRetries: ptr.Of(5),
},
},
Timeouts: map[string]string{
fmt.Sprintf(string(DefaultTimeoutTemplate), "Actor"): "300s",
fmt.Sprintf(string(DefaultTimeoutTemplate), ""): "60s",
},
CircuitBreakers: map[string]resiliencyV1alpha.CircuitBreaker{
fmt.Sprintf(string(DefaultCircuitBreakerTemplate), "Component"): {
MaxRequests: 1,
Interval: "30s",
Trip: "consecutiveFailures > 1",
Timeout: "60s",
},
fmt.Sprintf(string(DefaultCircuitBreakerTemplate), ""): {
MaxRequests: 1,
Interval: "30s",
Trip: "consecutiveFailures > 1",
Timeout: "60s",
},
},
},
},
}
r := FromConfigurations(log, config)
retryName := r.getDefaultRetryPolicy(&EndpointPolicy{})
assert.Equal(t, "DefaultAppRetryPolicy", retryName)
retryName = r.getDefaultRetryPolicy(&ActorPolicy{})
assert.Equal(t, "DefaultRetryPolicy", retryName)
timeoutName := r.getDefaultTimeoutPolicy(&ActorPolicy{})
assert.Equal(t, "DefaultActorTimeoutPolicy", timeoutName)
timeoutName = r.getDefaultTimeoutPolicy(&ComponentPolicy{})
assert.Equal(t, "DefaultTimeoutPolicy", timeoutName)
cbName := r.getDefaultCircuitBreakerPolicy(&ComponentPolicy{})
assert.Equal(t, "DefaultComponentCircuitBreakerPolicy", cbName)
cbName = r.getDefaultCircuitBreakerPolicy(&EndpointPolicy{})
assert.Equal(t, "DefaultCircuitBreakerPolicy", cbName)
// Delete the top-level defaults and make sure we return an empty string if nothing is defined.
delete(r.retries, "DefaultRetryPolicy")
delete(r.timeouts, "DefaultTimeoutPolicy")
delete(r.circuitBreakers, "DefaultCircuitBreakerPolicy")
retryName = r.getDefaultRetryPolicy(&ActorPolicy{})
assert.Equal(t, "", retryName)
timeoutName = r.getDefaultTimeoutPolicy(&ComponentPolicy{})
assert.Equal(t, "", timeoutName)
cbName = r.getDefaultCircuitBreakerPolicy(&EndpointPolicy{})
assert.Equal(t, "", cbName)
}
func TestDefaultPoliciesAreUsedIfNoTargetPolicyExists(t *testing.T) {
config := &resiliencyV1alpha.Resiliency{
Spec: resiliencyV1alpha.ResiliencySpec{
Policies: resiliencyV1alpha.Policies{
Retries: map[string]resiliencyV1alpha.Retry{
"testRetry": {
Policy: "constant",
Duration: "10ms",
MaxRetries: ptr.Of(5),
},
fmt.Sprintf(string(DefaultRetryTemplate), "App"): {
Policy: "constant",
Duration: "10ms",
MaxRetries: ptr.Of(10),
},
fmt.Sprintf(string(DefaultRetryTemplate), ""): {
Policy: "constant",
Duration: "10ms",
MaxRetries: ptr.Of(3),
},
},
Timeouts: map[string]string{
fmt.Sprintf(string(DefaultTimeoutTemplate), ""): "100ms",
},
CircuitBreakers: map[string]resiliencyV1alpha.CircuitBreaker{
fmt.Sprintf(string(DefaultCircuitBreakerTemplate), ""): {
Trip: "consecutiveFailures > 1",
MaxRequests: 1,
Timeout: "60s",
},
fmt.Sprintf(string(DefaultCircuitBreakerTemplate), "App"): {
Trip: "consecutiveFailures > 15",
MaxRequests: 1,
Timeout: "60s",
},
},
},
Targets: resiliencyV1alpha.Targets{
Apps: map[string]resiliencyV1alpha.EndpointPolicyNames{
"testApp": {
Retry: "testRetry",
},
},
},
},
}
r := FromConfigurations(log, config)
// Targeted App
policy := NewRunner[any](context.Background(),
r.EndpointPolicy("testApp", "localhost"),
)
count := atomic.Int64{}
policy(func(ctx context.Context) (any, error) {
count.Add(1)
return nil, errors.New("Forced failure")
})
assert.Equal(t, int64(6), count.Load())
// Generic App
concurrentPolicyExec(t, func(idx int) *PolicyDefinition {
return r.EndpointPolicy(fmt.Sprintf("noMatchingTarget-%d", idx), "localhost")
}, 11) // App has a CB that trips after 15 failure, so we don't trip it but still do all the 10 default retries
// execute concurrent to get coverage
concurrentPolicyExec(t, func(idx int) *PolicyDefinition {
return r.ActorPreLockPolicy(fmt.Sprintf("actorType-%d", idx), "actorID")
}, 2) // actorType is not a known target, so we get 1 retry + original call as default circuit breaker trips (consecutiveFailures > 1)
// One last one for ActorPostLock which just includes timeouts.
policy = NewRunner[any](context.Background(),
r.ActorPostLockPolicy("actorType", "actorID"),
)
count.Store(0)
start := time.Now()
_, err := policy(func(ctx context.Context) (any, error) {
count.Add(1)
time.Sleep(time.Second * 5)
return nil, errors.New("Forced failure")
})
assert.Less(t, time.Since(start), time.Second*5)
assert.Equal(t, int64(1), count.Load()) // Post lock policies don't have a retry, only pre lock do.
assert.NotEqual(t, "Forced failure", err.Error()) // We should've timed out instead.
}
func concurrentPolicyExec(t *testing.T, policyDefFn func(idx int) *PolicyDefinition, wantCount int64) {
t.Helper()
wg := sync.WaitGroup{}
wg.Add(10)
for i := 0; i < 10; i++ {
go func(i int) {
defer wg.Done()
// Not defined
policy := NewRunner[any](context.Background(), policyDefFn(i))
count := atomic.Int64{}
count.Store(0)
policy(func(ctx context.Context) (any, error) {
count.Add(1)
return nil, errors.New("forced failure")
})
assert.Equal(t, wantCount, count.Load())
}(i)
}
wg.Wait()
}
|
mikeee/dapr
|
pkg/resiliency/resiliency_test.go
|
GO
|
mit
| 21,436 |
apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
name: resiliency
spec:
policies:
# Timeouts are simple named durations.
timeouts:
general: 5s
important: 60s
largeResponse: 10s
# Retries are named templates for and are instantiated for life of the operation.
retries:
serviceRetry:
policy: constant
duration: 5s
maxRetries: 10
actorRetry:
policy: constant
duration: 5s
maxRetries: 10
stateRetry:
policy: constant
duration: 5s
maxRetries: 10
pubsubRetry:
policy: constant
duration: 5s
maxRetries: 10
retryForever:
policy: exponential
maxInterval: 15s
maxRetries: -1 # Retry indefinitely
noRetry:
policy: constant
maxRetries: 0 # No retries
missingMaxRetries:
policy: constant
important:
policy: constant
duration: 5s
maxRetries: 30
someOperation:
policy: exponential
maxInterval: 15s
largeResponse:
policy: constant
duration: 5s
maxRetries: 3
# Circuit breakers are automatically instantiated per component, service endpoint, and application route.
# using these settings as a template. See logic below under `buildingBlocks`.
# Circuit breakers maintain counters that can live as long as the Dapr sidecar.
circuitBreakers:
serviceCB:
maxRequests: 1
interval: 8s
timeout: 45s
trip: consecutiveFailures > 8
stateCB:
maxRequests: 1
interval: 8s
timeout: 45s
trip: consecutiveFailures > 8
actorCB:
maxRequests: 1
interval: 8s
timeout: 45s
trip: consecutiveFailures > 8
pubsubCB:
maxRequests: 1
interval: 8s
timeout: 45s
trip: consecutiveFailures > 8
# This section specifies default policies for:
# * service invocation
# * requests to components
# * events sent to routes
targets:
apps:
appB:
timeout: general
retry: serviceRetry
# Circuit breakers for services are scoped per endpoint (e.g. hostname + port).
# When a breaker is tripped, that route is removed from load balancing for the configured `timeout` duration.
circuitBreaker: serviceCB
actors:
myActorType:
timeout: general
retry: actorRetry
# Circuit breakers for actors are scoped by type, id, or both.
# When a breaker is tripped, that type or id is removed from the placement table for the configured `timeout` duration.
circuitBreaker: actorCB
circuitBreakerScope: both
circuitBreakerCacheSize: 5000
components:
# For state stores, policies apply to saving and retrieving state.
# Watching, which is not implemented yet, is out of scope.
statestore1:
outbound:
timeout: general
retry: stateRetry
# Circuit breakers for components are scoped per component configuration/instance (e.g. redis1).
# When this breaker is tripped, all interaction to that component is prevented for the configured `timeout` duration.
circuitBreaker: stateCB
pubsub1:
outbound:
retry: pubsubRetry
circuitBreaker: pubsubCB
pubsub2:
outbound:
retry: pubsubRetry
circuitBreaker: pubsubCB
inbound:
timeout: general
retry: pubsubRetry
circuitBreaker: pubsubCB
pubsub3:
inbound:
retry: noRetry
outbound:
retry: retryForever
|
mikeee/dapr
|
pkg/resiliency/testdata/resiliency.yaml
|
YAML
|
mit
| 3,736 |
apiVersion: dapr.io/v1alpha1
kind: Resiliency
metadata:
name: resiliency
# Like in the Subscriptions CRD, scopes lists the Dapr App IDs that this
# configuration applies to.
scopes:
- app1
- app1 # duplicate to ensure we don't store it twice
- app2
spec:
policies:
# Timeouts are simple named durations.
timeouts:
general: 5s
important: 60s
largeResponse: 10s
# Retries are named templates for and are instantiated for life of the operation.
retries:
pubsubRetry:
policy: constant
duration: 5s
maxRetries: 10
retryForever:
policy: exponential
maxInterval: 15s
maxRetries: -1 # Retry indefinitely
noRetry:
policy: constant
maxRetries: 0 # No retries
missingMaxRetries:
policy: constant
important:
policy: constant
duration: 5s
maxRetries: 30
someOperation:
policy: exponential
maxInterval: 15s
largeResponse:
policy: constant
duration: 5s
maxRetries: 3
# Circuit breakers are automatically instantiated per component, service endpoint, and application route.
# using these settings as a template. See logic below under `buildingBlocks`.
# Circuit breakers maintain counters that can live as long as the Dapr sidecar.
circuitBreakers:
pubsubCB:
maxRequests: 1
interval: 8s
timeout: 45s
trip: consecutiveFailures > 8
# This section specifies default policies for:
# * service invocation
# * requests to components
# * events sent to routes
buildingBlocks:
services:
appB:
timeout: general
retry: general
# Circuit breakers for services are scoped per endpoint (e.g. hostname + port).
# When a breaker is tripped, that route is removed from load balancing for the configured `timeout` duration.
circuitBreaker: general
actors:
myActorType:
timeout: general
retry: general
# Circuit breakers for actors are scoped by type, id, or both.
# When a breaker is tripped, that type or id is removed from the placement table for the configured `timeout` duration.
circuitBreaker: general
circuitBreakerScope: both
circuitBreakerCacheSize: 5000
components:
# For state stores, policies apply to saving and retrieving state.
# Watching, which is not implemented yet, is out of scope.
statestore1:
outbound:
timeout: general
retry: general
# Circuit breakers for components are scoped per component configuration/instance (e.g. redis1).
# When this breaker is tripped, all interaction to that component is prevented for the configured `timeout` duration.
circuitBreaker: general
pubsub1:
outbound:
retry: pubsubRetry
circuitBreaker: pubsubCB
pubsub2:
outbound:
retry: pubsubRetry
circuitBreaker: pubsubCB
inbound:
timeout: general
retry: general
circuitBreaker: general
|
mikeee/dapr
|
pkg/resiliency/testdata/resiliency_scoped.yaml
|
YAML
|
mit
| 3,156 |
# responsewriter
This package contains code forked from [`github.com/urfave/negroni`](https://github.com/urfave/negroni). It includes extensive changes, including the removal of features that depend on the rest of the framework, and additions of things we need to support integrations with the rest of Dapr, such as support for user values.
Source commit: [b935227](https://github.com/urfave/negroni/tree/b935227d493b8a257f6e0b3c8d98ae576c90cd4a/)
## License
> The MIT License (MIT)
>
> Copyright (c) 2014 Jeremy Saenz
>
> Permission is hereby granted, free of charge, to any person obtaining a copy
> of this software and associated documentation files (the "Software"), to deal
> in the Software without restriction, including without limitation the rights
> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
> copies of the Software, and to permit persons to whom the Software is
> furnished to do so, subject to the following conditions:
>
> The above copyright notice and this permission notice shall be included in all
> copies or substantial portions of the Software.
>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
> SOFTWARE.
|
mikeee/dapr
|
pkg/responsewriter/README.md
|
Markdown
|
mit
| 1,579 |
/*
Copyright 2022 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package responsewriter
import (
"io"
"net/http"
)
// ResponseWriter is a wrapper around http.ResponseWriter that provides extra information about
// the response. It is recommended that middleware handlers use this construct to wrap a responsewriter
// if the functionality calls for it.
type ResponseWriter interface {
http.ResponseWriter
// Status returns the status code of the response or 0 if the response has
// not been written
Status() int
// Written returns whether or not the ResponseWriter has been written.
Written() bool
// Size returns the size of the response body.
Size() int
// Before allows for a function to be called before the ResponseWriter has been written to. This is
// useful for setting headers or any other operations that must happen before a response has been written.
Before(func(ResponseWriter))
}
type beforeFunc func(ResponseWriter)
// NewResponseWriter creates a ResponseWriter that wraps a http.ResponseWriter
func NewResponseWriter(rw http.ResponseWriter) ResponseWriter {
return &responseWriter{
ResponseWriter: rw,
}
}
// EnsureResponseWriter creates a ResponseWriter that wraps a http.ResponseWriter, unless it's already a ResponseWriter.
func EnsureResponseWriter(rw http.ResponseWriter) ResponseWriter {
rwObj, ok := rw.(ResponseWriter)
if ok {
return rwObj
}
return NewResponseWriter(rw)
}
type responseWriter struct {
http.ResponseWriter
pendingStatus int
status int
size int
beforeFuncs []beforeFunc
callingBefores bool
}
func (rw *responseWriter) WriteHeader(s int) {
if rw.Written() {
return
}
rw.pendingStatus = s
rw.callBefore()
// Any of the rw.beforeFuncs may have written a header,
// so check again to see if any work is necessary.
if rw.Written() {
return
}
rw.status = s
rw.ResponseWriter.WriteHeader(s)
}
func (rw *responseWriter) Write(b []byte) (int, error) {
if !rw.Written() {
// The status will be StatusOK if WriteHeader has not been called yet
rw.WriteHeader(http.StatusOK)
}
size, err := rw.ResponseWriter.Write(b)
rw.size += size
return size, err
}
// ReadFrom exposes underlying http.ResponseWriter to io.Copy and if it implements
// io.ReaderFrom, it can take advantage of optimizations such as sendfile, io.Copy
// with sync.Pool's buffer which is in http.(*response).ReadFrom and so on.
func (rw *responseWriter) ReadFrom(r io.Reader) (n int64, err error) {
if !rw.Written() {
// The status will be StatusOK if WriteHeader has not been called yet
rw.WriteHeader(http.StatusOK)
}
n, err = io.Copy(rw.ResponseWriter, r)
rw.size += int(n)
return
}
// Satisfy http.ResponseController support (Go 1.20+)
func (rw *responseWriter) Unwrap() http.ResponseWriter {
return rw.ResponseWriter
}
func (rw *responseWriter) Status() int {
if rw.Written() {
return rw.status
}
return rw.pendingStatus
}
func (rw *responseWriter) Size() int {
return rw.size
}
func (rw *responseWriter) Written() bool {
return rw.status != 0
}
func (rw *responseWriter) Before(before func(ResponseWriter)) {
rw.beforeFuncs = append(rw.beforeFuncs, before)
}
func (rw *responseWriter) callBefore() {
// Don't recursively call before() functions, to avoid infinite looping if
// one of them calls rw.WriteHeader again.
if rw.callingBefores {
return
}
rw.callingBefores = true
defer func() { rw.callingBefores = false }()
for i := len(rw.beforeFuncs) - 1; i >= 0; i-- {
rw.beforeFuncs[i](rw)
}
}
|
mikeee/dapr
|
pkg/responsewriter/response_writer.go
|
GO
|
mit
| 4,016 |
/*
Copyright 2022 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package responsewriter
import (
"io"
"net/http"
"net/http/httptest"
"testing"
"github.com/stretchr/testify/require"
)
func TestResponseWriterBeforeWrite(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
require.Equal(t, 0, rw.Status())
require.False(t, rw.Written())
}
func TestResponseWriterBeforeFuncHasAccessToStatus(t *testing.T) {
var status int
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
rw.Before(func(w ResponseWriter) {
status = w.Status()
})
rw.WriteHeader(http.StatusCreated)
require.Equal(t, http.StatusCreated, status)
}
func TestResponseWriterBeforeFuncCanChangeStatus(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
// Always respond with 200.
rw.Before(func(w ResponseWriter) {
w.WriteHeader(http.StatusOK)
})
rw.WriteHeader(http.StatusBadRequest)
require.Equal(t, http.StatusOK, rec.Code)
}
func TestResponseWriterBeforeFuncChangesStatusMultipleTimes(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
rw.Before(func(w ResponseWriter) {
w.WriteHeader(http.StatusInternalServerError)
})
rw.Before(func(w ResponseWriter) {
w.WriteHeader(http.StatusNotFound)
})
rw.WriteHeader(http.StatusOK)
require.Equal(t, http.StatusNotFound, rec.Code)
}
func TestResponseWriterWritingString(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
rw.Write([]byte("Hello world"))
require.Equal(t, rec.Code, rw.Status())
require.Equal(t, "Hello world", rec.Body.String())
require.Equal(t, http.StatusOK, rw.Status())
require.Equal(t, 11, rw.Size())
require.True(t, rw.Written())
}
func TestResponseWriterWritingStrings(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
rw.Write([]byte("Hello world"))
rw.Write([]byte("foo bar bat baz"))
require.Equal(t, rec.Code, rw.Status())
require.Equal(t, "Hello worldfoo bar bat baz", rec.Body.String())
require.Equal(t, http.StatusOK, rw.Status())
require.Equal(t, 26, rw.Size())
}
func TestResponseWriterWritingHeader(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
rw.WriteHeader(http.StatusNotFound)
require.Equal(t, rec.Code, rw.Status())
require.Equal(t, "", rec.Body.String())
require.Equal(t, http.StatusNotFound, rw.Status())
require.Equal(t, 0, rw.Size())
}
func TestResponseWriterWritingHeaderTwice(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
rw.WriteHeader(http.StatusNotFound)
rw.WriteHeader(http.StatusInternalServerError)
require.Equal(t, rw.Status(), rec.Code)
require.Equal(t, "", rec.Body.String())
require.Equal(t, http.StatusNotFound, rw.Status())
require.Equal(t, 0, rw.Size())
}
func TestResponseWriterBefore(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
result := ""
rw.Before(func(ResponseWriter) {
result += "foo"
})
rw.Before(func(ResponseWriter) {
result += "bar"
})
rw.WriteHeader(http.StatusNotFound)
require.Equal(t, rec.Code, rw.Status())
require.Equal(t, "", rec.Body.String())
require.Equal(t, http.StatusNotFound, rw.Status())
require.Equal(t, 0, rw.Size())
require.Equal(t, "barfoo", result)
}
func TestResponseWriterUnwrap(t *testing.T) {
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
switch v := rw.(type) {
case interface{ Unwrap() http.ResponseWriter }:
require.Equal(t, v.Unwrap(), rec)
default:
t.Error("Does not implement Unwrap()")
}
}
// mockReader only implements io.Reader without other methods like WriterTo
type mockReader struct {
readStr string
eof bool
}
func (r *mockReader) Read(p []byte) (n int, err error) {
if r.eof {
return 0, io.EOF
}
copy(p, r.readStr)
r.eof = true
return len(r.readStr), nil
}
func TestResponseWriterWithoutReadFrom(t *testing.T) {
writeString := "Hello world"
rec := httptest.NewRecorder()
rw := NewResponseWriter(rec)
n, err := io.Copy(rw, &mockReader{readStr: writeString})
require.NoError(t, err)
require.Equal(t, http.StatusOK, rw.Status())
require.True(t, rw.Written())
require.Len(t, writeString, rw.Size())
require.Len(t, writeString, int(n))
require.Equal(t, writeString, rec.Body.String())
}
type mockResponseWriterWithReadFrom struct {
*httptest.ResponseRecorder
writtenStr string
}
func (rw *mockResponseWriterWithReadFrom) ReadFrom(r io.Reader) (n int64, err error) {
bytes, err := io.ReadAll(r)
if err != nil {
return 0, err
}
rw.writtenStr = string(bytes)
rw.ResponseRecorder.Write(bytes)
return int64(len(bytes)), nil
}
func TestResponseWriterWithReadFrom(t *testing.T) {
writeString := "Hello world"
mrw := &mockResponseWriterWithReadFrom{ResponseRecorder: httptest.NewRecorder()}
rw := NewResponseWriter(mrw)
n, err := io.Copy(rw, &mockReader{readStr: writeString})
require.NoError(t, err)
require.Equal(t, http.StatusOK, rw.Status())
require.True(t, rw.Written())
require.Len(t, writeString, rw.Size())
require.Len(t, writeString, int(n))
require.Equal(t, writeString, mrw.Body.String())
require.Equal(t, writeString, mrw.writtenStr)
}
|
mikeee/dapr
|
pkg/responsewriter/response_writer_test.go
|
GO
|
mit
| 5,648 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package retry
import "time"
const (
DefaultLinearBackoffInterval = time.Second
DefaultLinearRetryCount = 3
)
|
mikeee/dapr
|
pkg/retry/retry.go
|
GO
|
mit
| 679 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package authorizer
import (
"os"
"reflect"
componentsapi "github.com/dapr/dapr/pkg/apis/components/v1alpha1"
httpendpointsapi "github.com/dapr/dapr/pkg/apis/httpEndpoint/v1alpha1"
"github.com/dapr/dapr/pkg/config"
"github.com/dapr/kit/logger"
)
var log = logger.NewLogger("dapr.runtime.authorizer")
// Type of function that determines if a component is authorized.
// The function receives the component and must return true if the component is authorized.
type ComponentAuthorizer func(component componentsapi.Component) bool
// Type of function that determines if an http endpoint is authorized.
// The function receives the http endpoint and must return true if the http endpoint is authorized.
type HTTPEndpointAuthorizer func(endpoint httpendpointsapi.HTTPEndpoint) bool
type Options struct {
ID string
GlobalConfig *config.Configuration
}
type Authorizer struct {
id string
namespace string
componentAuthorizers []ComponentAuthorizer
httpEndpointAuthorizers []HTTPEndpointAuthorizer
}
func New(opts Options) *Authorizer {
r := &Authorizer{
id: opts.ID,
namespace: os.Getenv("NAMESPACE"),
}
r.componentAuthorizers = []ComponentAuthorizer{r.namespaceComponentAuthorizer}
if opts.GlobalConfig != nil && opts.GlobalConfig.Spec.ComponentsSpec != nil && len(opts.GlobalConfig.Spec.ComponentsSpec.Deny) > 0 {
dl := newComponentDenyList(opts.GlobalConfig.Spec.ComponentsSpec.Deny)
r.componentAuthorizers = append(r.componentAuthorizers, dl.IsAllowed)
}
r.httpEndpointAuthorizers = []HTTPEndpointAuthorizer{r.namespaceHTTPEndpointAuthorizer}
return r
}
func (a *Authorizer) GetAuthorizedObjects(objects any, authorizer func(any) bool) any {
reflectValue := reflect.ValueOf(objects)
authorized := reflect.MakeSlice(reflectValue.Type(), 0, reflectValue.Len())
for i := 0; i < reflectValue.Len(); i++ {
object := reflectValue.Index(i).Interface()
if authorizer(object) {
authorized = reflect.Append(authorized, reflect.ValueOf(object))
}
}
return authorized.Interface()
}
func (a *Authorizer) IsObjectAuthorized(object any) bool {
switch obj := object.(type) {
case httpendpointsapi.HTTPEndpoint:
for _, auth := range a.httpEndpointAuthorizers {
if !auth(obj) {
return false
}
}
case componentsapi.Component:
for _, auth := range a.componentAuthorizers {
if !auth(obj) {
return false
}
}
}
return true
}
func (a *Authorizer) namespaceHTTPEndpointAuthorizer(endpoint httpendpointsapi.HTTPEndpoint) bool {
switch {
case a.namespace == "",
endpoint.ObjectMeta.Namespace == "",
(a.namespace != "" && endpoint.ObjectMeta.Namespace == a.namespace):
return endpoint.IsAppScoped(a.id)
default:
return false
}
}
func (a *Authorizer) namespaceComponentAuthorizer(comp componentsapi.Component) bool {
if a.namespace == "" || comp.ObjectMeta.Namespace == "" || (a.namespace != "" && comp.ObjectMeta.Namespace == a.namespace) {
return comp.IsAppScoped(a.id)
}
return false
}
|
mikeee/dapr
|
pkg/runtime/authorizer/authorizer.go
|
GO
|
mit
| 3,552 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package authorizer
import (
"testing"
"github.com/stretchr/testify/assert"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
componentsV1alpha1 "github.com/dapr/dapr/pkg/apis/components/v1alpha1"
httpEndpointV1alpha1 "github.com/dapr/dapr/pkg/apis/httpEndpoint/v1alpha1"
"github.com/dapr/dapr/pkg/config"
daprt "github.com/dapr/dapr/pkg/testing"
)
func TestAuthorizedComponents(t *testing.T) {
testCompName := "fakeComponent"
t.Run("standalone mode, no namespce", func(t *testing.T) {
t.Setenv("NAMESPACE", "default")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Len(t, components, 1)
assert.Equal(t, testCompName, components[0].Name)
})
t.Run("namespace mismatch", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "b"
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Empty(t, components)
})
t.Run("namespace match", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "a"
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Len(t, components, 1)
})
t.Run("in scope, namespace match", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "a"
component.Scopes = []string{daprt.TestRuntimeConfigID}
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Len(t, components, 1)
})
t.Run("not in scope, namespace match", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "a"
component.Scopes = []string{"other"}
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Empty(t, components)
})
t.Run("in scope, namespace mismatch", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "b"
component.Scopes = []string{daprt.TestRuntimeConfigID}
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Empty(t, components)
})
t.Run("not in scope, namespace mismatch", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "b"
component.Scopes = []string{"other"}
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Empty(t, components)
})
t.Run("no authorizers", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: "test",
// Namespace mismatch, should be accepted anyways
GlobalConfig: &config.Configuration{},
})
auth.componentAuthorizers = []ComponentAuthorizer{}
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
component.ObjectMeta.Namespace = "b"
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Len(t, components, 1)
assert.Equal(t, testCompName, components[0].Name)
})
t.Run("only deny all", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{},
})
auth.componentAuthorizers = []ComponentAuthorizer{
func(component componentsV1alpha1.Component) bool {
return false
},
}
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Empty(t, components)
})
t.Run("additional authorizer denies all", func(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: "test",
GlobalConfig: &config.Configuration{
Spec: config.ConfigurationSpec{},
},
})
auth.componentAuthorizers = append(auth.componentAuthorizers, func(component componentsV1alpha1.Component) bool {
return false
})
component := componentsV1alpha1.Component{}
component.ObjectMeta.Name = testCompName
componentObj := auth.GetAuthorizedObjects([]componentsV1alpha1.Component{component}, auth.IsObjectAuthorized)
components, ok := componentObj.([]componentsV1alpha1.Component)
assert.True(t, ok)
assert.Empty(t, components)
})
}
func TestAuthorizedHTTPEndpoints(t *testing.T) {
t.Setenv("NAMESPACE", "a")
auth := New(Options{
ID: daprt.TestRuntimeConfigID,
GlobalConfig: &config.Configuration{
Spec: config.ConfigurationSpec{},
},
})
endpoint := httpEndpointV1alpha1.HTTPEndpoint{
ObjectMeta: metav1.ObjectMeta{
Name: "testEndpoint",
},
Spec: httpEndpointV1alpha1.HTTPEndpointSpec{
BaseURL: "http://api.test.com",
},
}
t.Run("standalone mode, no namespace", func(t *testing.T) {
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Len(t, endpoints, 1)
assert.Equal(t, endpoint.Name, endpoints[0].Name)
})
t.Run("namespace mismatch", func(t *testing.T) {
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "b"
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Empty(t, endpoints)
})
t.Run("namespace match", func(t *testing.T) {
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "a"
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Len(t, endpoints, 1)
})
t.Run("in scope, namespace match", func(t *testing.T) {
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "a"
endpoint.Scopes = []string{daprt.TestRuntimeConfigID}
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Len(t, endpoints, 1)
})
t.Run("not in scope, namespace match", func(t *testing.T) {
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "a"
endpoint.Scopes = []string{"other"}
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Empty(t, endpoints)
})
t.Run("in scope, namespace mismatch", func(t *testing.T) {
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "b"
endpoint.Scopes = []string{daprt.TestRuntimeConfigID}
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Empty(t, endpoints)
})
t.Run("not in scope, namespace mismatch", func(t *testing.T) {
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "b"
endpoint.Scopes = []string{"other"}
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Empty(t, endpoints)
})
t.Run("no authorizers", func(t *testing.T) {
auth.httpEndpointAuthorizers = []HTTPEndpointAuthorizer{}
// Namespace mismatch, should be accepted anyways
auth.namespace = "a"
endpoint.ObjectMeta.Namespace = "b"
endpointObjs := auth.GetAuthorizedObjects([]httpEndpointV1alpha1.HTTPEndpoint{endpoint}, auth.IsObjectAuthorized)
endpoints, ok := endpointObjs.([]httpEndpointV1alpha1.HTTPEndpoint)
assert.True(t, ok)
assert.Len(t, endpoints, 1)
assert.Equal(t, endpoint.Name, endpoints[0].ObjectMeta.Name)
})
}
|
mikeee/dapr
|
pkg/runtime/authorizer/authorizer_test.go
|
GO
|
mit
| 10,821 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package authorizer
import (
"strings"
componentsV1alpha1 "github.com/dapr/dapr/pkg/apis/components/v1alpha1"
)
type componentDenyList struct {
list []componentDenyListItem
}
func newComponentDenyList(raw []string) componentDenyList {
list := make([]componentDenyListItem, len(raw))
i := 0
for _, comp := range raw {
if comp == "" {
continue
}
v := strings.Split(comp, "/")
switch len(v) {
case 1:
list[i] = componentDenyListItem{
typ: v[0],
}
i++
case 2:
list[i] = componentDenyListItem{
typ: v[0],
version: v[1],
}
i++
}
}
list = list[:i]
return componentDenyList{list}
}
func (dl componentDenyList) IsAllowed(component componentsV1alpha1.Component) bool {
if component.Spec.Type == "" || component.Spec.Version == "" {
return false
}
for _, li := range dl.list {
if li.typ == component.Spec.Type && (li.version == "" || li.version == component.Spec.Version) {
log.Warnf("component '%s' cannot be loaded because components of type '%s' are not allowed", component.Name, component.LogName())
return false
}
}
return true
}
type componentDenyListItem struct {
typ string
version string
}
|
mikeee/dapr
|
pkg/runtime/authorizer/component.go
|
GO
|
mit
| 1,737 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package authorizer
import (
"reflect"
"strings"
"testing"
componentsV1alpha1 "github.com/dapr/dapr/pkg/apis/components/v1alpha1"
)
func TestComponentDenyList(t *testing.T) {
type args struct {
raw []string
}
tests := []struct {
name string
args args
want componentDenyList
allowed map[string]bool
}{
{
name: "empty",
args: args{[]string{}},
want: componentDenyList{
list: []componentDenyListItem{},
},
allowed: map[string]bool{
"": false,
"no.version": false,
"state.foo/v1": true,
"state.foo/v2": true,
"state.bar/v1alpha1": true,
},
},
{
name: "one item, no version",
args: args{[]string{"state.foo"}},
want: componentDenyList{
list: []componentDenyListItem{
{typ: "state.foo", version: ""},
},
},
allowed: map[string]bool{
"": false,
"no.version": false,
"state.foo/v1": false,
"state.foo/v2": false,
"state.bar/v1alpha1": true,
},
},
{
name: "one item and version",
args: args{[]string{"state.foo/v2"}},
want: componentDenyList{
list: []componentDenyListItem{
{typ: "state.foo", version: "v2"},
},
},
allowed: map[string]bool{
"state.foo/v1": true,
"state.foo/v2": false,
"state.bar/v1alpha1": true,
},
},
{
name: "one item with version, one without",
args: args{[]string{"state.foo", "state.bar/v2"}},
want: componentDenyList{
list: []componentDenyListItem{
{typ: "state.foo", version: ""},
{typ: "state.bar", version: "v2"},
},
},
allowed: map[string]bool{
"state.foo/v1": false,
"state.foo/v2": false,
"state.bar/v1alpha1": true,
},
},
{
name: "invalid items",
args: args{[]string{"state.foo", "state.bar/v2", "foo/bar/v2", ""}},
want: componentDenyList{
list: []componentDenyListItem{
{typ: "state.foo", version: ""},
{typ: "state.bar", version: "v2"},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dl := newComponentDenyList(tt.args.raw)
if !reflect.DeepEqual(dl, tt.want) {
t.Errorf("newComponentDenyList() = %v, want %v", dl, tt.want)
}
if len(tt.allowed) == 0 {
return
}
for compStr, wantAllowed := range tt.allowed {
parts := strings.Split(compStr, "/")
typ := parts[0]
var ver string
if len(parts) > 1 {
ver = parts[1]
}
comp := componentsV1alpha1.Component{
Spec: componentsV1alpha1.ComponentSpec{
Type: typ,
Version: ver,
},
}
if gotAllowed := dl.IsAllowed(comp); gotAllowed != wantAllowed {
t.Errorf("IsAllowed(%v) = %v, want %v", compStr, gotAllowed, wantAllowed)
}
}
})
}
}
|
mikeee/dapr
|
pkg/runtime/authorizer/component_test.go
|
GO
|
mit
| 3,356 |
//go:build unit
// +build unit
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package authorizer
func (a *Authorizer) WithComponentAuthorizers(authorizers []ComponentAuthorizer) *Authorizer {
a.componentAuthorizers = authorizers
return a
}
func (a *Authorizer) WithAppendComponentAuthorizers(authorizers ...ComponentAuthorizer) *Authorizer {
a.componentAuthorizers = append(a.componentAuthorizers, authorizers...)
return a
}
func (a *Authorizer) WithHTTPEndpointAuthorizers(authorizers []HTTPEndpointAuthorizer) *Authorizer {
a.httpEndpointAuthorizers = authorizers
return a
}
func (a *Authorizer) WithAppendHTTPEndpointAuthorizers(authorizers ...HTTPEndpointAuthorizer) *Authorizer {
a.httpEndpointAuthorizers = append(a.httpEndpointAuthorizers, authorizers...)
return a
}
|
mikeee/dapr
|
pkg/runtime/authorizer/unit.go
|
GO
|
mit
| 1,301 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package channels
import (
"crypto/tls"
"crypto/x509"
"fmt"
"net"
"net/http"
"strconv"
"sync"
"time"
"golang.org/x/net/http2"
"github.com/dapr/dapr/pkg/api/grpc/manager"
commonapi "github.com/dapr/dapr/pkg/apis/common"
httpendpapi "github.com/dapr/dapr/pkg/apis/httpEndpoint/v1alpha1"
"github.com/dapr/dapr/pkg/channel"
channelhttp "github.com/dapr/dapr/pkg/channel/http"
compmiddlehttp "github.com/dapr/dapr/pkg/components/middleware/http"
"github.com/dapr/dapr/pkg/config"
"github.com/dapr/dapr/pkg/config/protocol"
"github.com/dapr/dapr/pkg/middleware"
"github.com/dapr/dapr/pkg/runtime/compstore"
"github.com/dapr/dapr/pkg/runtime/meta"
"github.com/dapr/dapr/pkg/runtime/registry"
"github.com/dapr/kit/logger"
)
var log = logger.NewLogger("dapr.runtime.channels")
type Options struct {
// Registry is the all-component registry.
Registry *registry.Registry
// ComponentStore is the component store.
ComponentStore *compstore.ComponentStore
// Metadata is the metadata helper.
Meta *meta.Meta
// AppConnectionConfig is the application connection configuration.
AppConnectionConfig config.AppConnectionConfig
// GlobalConfig is the global configuration.
GlobalConfig *config.Configuration
// AppMiddlware is the application middleware.
AppMiddleware middleware.HTTP
// MaxRequestBodySize is the maximum request body size, in bytes.
MaxRequestBodySize int
// ReadBufferSize is the read buffer size, in bytes
ReadBufferSize int
GRPC *manager.Manager
}
type Channels struct {
registry *compmiddlehttp.Registry
compStore *compstore.ComponentStore
meta *meta.Meta
appConnectionConfig config.AppConnectionConfig
tracingSpec *config.TracingSpec
maxRequestBodySize int
appMiddlware middleware.HTTP
httpClient *http.Client
grpc *manager.Manager
appChannel channel.AppChannel
endpChannels map[string]channel.HTTPEndpointAppChannel
httpEndpChannel channel.AppChannel
lock sync.RWMutex
}
func New(opts Options) *Channels {
return &Channels{
registry: opts.Registry.HTTPMiddlewares(),
compStore: opts.ComponentStore,
meta: opts.Meta,
appConnectionConfig: opts.AppConnectionConfig,
tracingSpec: opts.GlobalConfig.Spec.TracingSpec,
maxRequestBodySize: opts.MaxRequestBodySize,
appMiddlware: opts.AppMiddleware,
grpc: opts.GRPC,
httpClient: appHTTPClient(opts.AppConnectionConfig, opts.GlobalConfig, opts.ReadBufferSize),
endpChannels: make(map[string]channel.HTTPEndpointAppChannel),
}
}
func (c *Channels) Refresh() error {
c.lock.Lock()
defer c.lock.Unlock()
log.Debug("Refreshing channels")
httpEndpChannel, err := channelhttp.CreateHTTPChannel(c.appHTTPChannelConfig())
if err != nil {
return fmt.Errorf("failed to create external HTTP app channel: %w", err)
}
endpChannels, err := c.initEndpointChannels()
if err != nil {
return fmt.Errorf("failed to create HTTP endpoints channels: %w", err)
}
c.httpEndpChannel = httpEndpChannel
c.endpChannels = endpChannels
if c.appConnectionConfig.Port == 0 {
log.Warn("App channel is not initialized. Did you configure an app-port?")
return nil
}
var appChannel channel.AppChannel
if c.appConnectionConfig.Protocol.IsHTTP() {
// Create a HTTP channel
appChannel, err = channelhttp.CreateHTTPChannel(c.appHTTPChannelConfig())
if err != nil {
return fmt.Errorf("failed to create HTTP app channel: %w", err)
}
appChannel.(*channelhttp.Channel).SetAppHealthCheckPath(c.appConnectionConfig.HealthCheckHTTPPath)
} else {
// create gRPC app channel
appChannel, err = c.grpc.GetAppChannel()
if err != nil {
return fmt.Errorf("failed to create gRPC app channel: %w", err)
}
}
c.appChannel = appChannel
log.Debug("Channels refreshed")
return nil
}
func (c *Channels) AppChannel() channel.AppChannel {
c.lock.RLock()
defer c.lock.RUnlock()
return c.appChannel
}
func (c *Channels) HTTPEndpointsAppChannel() channel.HTTPEndpointAppChannel {
c.lock.RLock()
defer c.lock.RUnlock()
return c.httpEndpChannel
}
func (c *Channels) EndpointChannels() map[string]channel.HTTPEndpointAppChannel {
c.lock.RLock()
defer c.lock.RUnlock()
return c.endpChannels
}
func (c *Channels) AppHTTPClient() *http.Client {
return c.httpClient
}
// AppHTTPEndpoint Returns the HTTP endpoint for the app.
func (c *Channels) AppHTTPEndpoint() string {
// Application protocol is "http" or "https"
port := strconv.Itoa(c.appConnectionConfig.Port)
switch c.appConnectionConfig.Protocol {
case protocol.HTTPProtocol, protocol.H2CProtocol:
return "http://" + c.appConnectionConfig.ChannelAddress + ":" + port
case protocol.HTTPSProtocol:
return "https://" + c.appConnectionConfig.ChannelAddress + ":" + port
default:
return ""
}
}
func (c *Channels) appHTTPChannelConfig() channelhttp.ChannelConfiguration {
conf := channelhttp.ChannelConfiguration{
CompStore: c.compStore,
MaxConcurrency: c.appConnectionConfig.MaxConcurrency,
Middleware: c.appMiddlware,
TracingSpec: c.tracingSpec,
MaxRequestBodySize: c.maxRequestBodySize,
}
conf.Endpoint = c.AppHTTPEndpoint()
conf.Client = c.httpClient
return conf
}
func (c *Channels) initEndpointChannels() (map[string]channel.HTTPEndpointAppChannel, error) {
// Create dedicated app channels for known app endpoints
endpoints := c.compStore.ListHTTPEndpoints()
channels := make(map[string]channel.HTTPEndpointAppChannel, len(endpoints))
if len(endpoints) > 0 {
for _, e := range endpoints {
conf, err := c.getHTTPEndpointAppChannel(e)
if err != nil {
return nil, err
}
ch, err := channelhttp.CreateHTTPChannel(conf)
if err != nil {
return nil, err
}
channels[e.ObjectMeta.Name] = ch
}
}
return channels, nil
}
func (c *Channels) getHTTPEndpointAppChannel(endpoint httpendpapi.HTTPEndpoint) (channelhttp.ChannelConfiguration, error) {
conf := channelhttp.ChannelConfiguration{
CompStore: c.compStore,
MaxConcurrency: c.appConnectionConfig.MaxConcurrency,
Middleware: c.appMiddlware,
MaxRequestBodySize: c.maxRequestBodySize,
TracingSpec: c.tracingSpec,
}
var tlsConfig *tls.Config
if endpoint.HasTLSRootCA() {
ca := endpoint.Spec.ClientTLS.RootCA.Value.String()
caCertPool := x509.NewCertPool()
if !caCertPool.AppendCertsFromPEM([]byte(ca)) {
return channelhttp.ChannelConfiguration{}, fmt.Errorf("failed to add root cert to cert pool for http endpoint %s", endpoint.ObjectMeta.Name)
}
tlsConfig = &tls.Config{
MinVersion: tls.VersionTLS12,
RootCAs: caCertPool,
}
}
if endpoint.HasTLSPrivateKey() {
cert, err := tls.X509KeyPair([]byte(endpoint.Spec.ClientTLS.Certificate.Value.String()), []byte(endpoint.Spec.ClientTLS.PrivateKey.Value.String()))
if err != nil {
return channelhttp.ChannelConfiguration{}, fmt.Errorf("failed to load client certificate for http endpoint %s: %w", endpoint.ObjectMeta.Name, err)
}
if tlsConfig == nil {
tlsConfig = &tls.Config{MinVersion: tls.VersionTLS12}
}
tlsConfig.Certificates = []tls.Certificate{cert}
}
if endpoint.Spec.ClientTLS != nil && endpoint.Spec.ClientTLS.Renegotiation != nil {
switch *endpoint.Spec.ClientTLS.Renegotiation {
case commonapi.NegotiateNever:
tlsConfig.Renegotiation = tls.RenegotiateNever
case commonapi.NegotiateOnceAsClient:
tlsConfig.Renegotiation = tls.RenegotiateOnceAsClient
case commonapi.NegotiateFreelyAsClient:
tlsConfig.Renegotiation = tls.RenegotiateFreelyAsClient
default:
return channelhttp.ChannelConfiguration{}, fmt.Errorf("invalid renegotiation value %s for http endpoint %s", *endpoint.Spec.ClientTLS.Renegotiation, endpoint.ObjectMeta.Name)
}
}
dialer := &net.Dialer{
Timeout: 15 * time.Second,
}
tr := http.DefaultTransport.(*http.Transport).Clone()
tr.TLSHandshakeTimeout = 15 * time.Second
tr.TLSClientConfig = tlsConfig
tr.DialContext = dialer.DialContext
conf.Client = &http.Client{
Timeout: 0,
Transport: tr,
}
return conf, nil
}
// appHTTPClient Initializes the appHTTPClient property.
func appHTTPClient(connConfig config.AppConnectionConfig, globalConfig *config.Configuration, readBufferSize int) *http.Client {
var transport http.RoundTripper
if connConfig.Protocol == protocol.H2CProtocol {
// Enable HTTP/2 Cleartext transport
transport = &http2.Transport{
AllowHTTP: true, // To enable using "http" as protocol
DialTLS: func(network, addr string, _ *tls.Config) (net.Conn, error) {
// Return the TCP socket without TLS
return net.Dial(network, addr)
},
// TODO: This may not be exactly the same as "MaxResponseHeaderBytes" so check before enabling this
// MaxHeaderListSize: uint32(a.runtimeConfig.readBufferSize),
}
} else {
var tlsConfig *tls.Config
if connConfig.Protocol == protocol.HTTPSProtocol {
tlsConfig = &tls.Config{
InsecureSkipVerify: true, //nolint:gosec
MinVersion: channel.AppChannelMinTLSVersion,
}
}
ts := http.DefaultTransport.(*http.Transport).Clone()
ts.ForceAttemptHTTP2 = false
ts.TLSClientConfig = tlsConfig
ts.ReadBufferSize = readBufferSize
ts.MaxResponseHeaderBytes = int64(readBufferSize)
ts.MaxConnsPerHost = 1024
ts.MaxIdleConns = 64 // A local channel connects to a single host
ts.MaxIdleConnsPerHost = 64
transport = ts
}
// Initialize this property in the object, and then pass it to the HTTP channel and the actors runtime (for health checks)
// We want to re-use the same client so TCP sockets can be re-used efficiently across everything that communicates with the app
// This is especially useful if the app supports HTTP/2
return &http.Client{
Transport: transport,
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
}
|
mikeee/dapr
|
pkg/runtime/channels/channels.go
|
GO
|
mit
| 10,481 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package channels
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"math/big"
"net/http"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
v1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
commonapi "github.com/dapr/dapr/pkg/apis/common"
httpendpapi "github.com/dapr/dapr/pkg/apis/httpEndpoint/v1alpha1"
httpMiddlewareLoader "github.com/dapr/dapr/pkg/components/middleware/http"
"github.com/dapr/dapr/pkg/config"
"github.com/dapr/dapr/pkg/modes"
"github.com/dapr/dapr/pkg/runtime/compstore"
"github.com/dapr/dapr/pkg/runtime/meta"
"github.com/dapr/dapr/pkg/runtime/registry"
)
func TestGetHTTPEndpointAppChannel(t *testing.T) {
testPK, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
require.NoError(t, err)
testPKBytes, err := x509.MarshalPKCS8PrivateKey(testPK)
require.NoError(t, err)
testPKPEM := pem.EncodeToMemory(&pem.Block{
Type: "PRIVATE KEY", Bytes: testPKBytes,
})
cert := &x509.Certificate{
SerialNumber: big.NewInt(1),
Subject: pkix.Name{
CommonName: "test",
},
NotBefore: time.Now(),
NotAfter: time.Now().Add(time.Hour),
}
testCertBytes, err := x509.CreateCertificate(rand.Reader, cert, cert, &testPK.PublicKey, testPK)
require.NoError(t, err)
testCertPEM := pem.EncodeToMemory(&pem.Block{
Type: "CERTIFICATE", Bytes: testCertBytes,
})
t.Run("no TLS channel", func(t *testing.T) {
ch := &Channels{
compStore: compstore.New(),
meta: meta.New(meta.Options{Mode: modes.StandaloneMode}),
appConnectionConfig: config.AppConnectionConfig{
ChannelAddress: "my.app",
Protocol: "http",
Port: 0,
},
registry: registry.New(registry.NewOptions().WithHTTPMiddlewares(
httpMiddlewareLoader.NewRegistry(),
)).HTTPMiddlewares(),
}
conf, err := ch.getHTTPEndpointAppChannel(httpendpapi.HTTPEndpoint{
ObjectMeta: metav1.ObjectMeta{
Name: "test",
},
Spec: httpendpapi.HTTPEndpointSpec{},
})
require.NoError(t, err)
assert.Nil(t, conf.Client.Transport.(*http.Transport).TLSClientConfig)
})
t.Run("TLS channel with Root CA", func(t *testing.T) {
ch := &Channels{
compStore: compstore.New(),
meta: meta.New(meta.Options{Mode: modes.StandaloneMode}),
appConnectionConfig: config.AppConnectionConfig{
ChannelAddress: "my.app",
Protocol: "http",
Port: 0,
},
registry: registry.New(registry.NewOptions().WithHTTPMiddlewares(
httpMiddlewareLoader.NewRegistry(),
)).HTTPMiddlewares(),
}
conf, err := ch.getHTTPEndpointAppChannel(httpendpapi.HTTPEndpoint{
ObjectMeta: metav1.ObjectMeta{
Name: "test",
},
Spec: httpendpapi.HTTPEndpointSpec{
ClientTLS: &commonapi.TLS{
RootCA: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testCertPEM},
},
},
Certificate: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testCertPEM},
},
},
PrivateKey: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testPKPEM},
},
},
},
},
})
require.NoError(t, err)
assert.NotNil(t, conf.Client.Transport.(*http.Transport).TLSClientConfig)
})
t.Run("TLS channel without Root CA", func(t *testing.T) {
ch := &Channels{
compStore: compstore.New(),
meta: meta.New(meta.Options{Mode: modes.StandaloneMode}),
appConnectionConfig: config.AppConnectionConfig{
ChannelAddress: "my.app",
Protocol: "http",
Port: 0,
},
registry: registry.New(registry.NewOptions().WithHTTPMiddlewares(
httpMiddlewareLoader.NewRegistry(),
)).HTTPMiddlewares(),
}
conf, err := ch.getHTTPEndpointAppChannel(httpendpapi.HTTPEndpoint{
ObjectMeta: metav1.ObjectMeta{
Name: "test",
},
Spec: httpendpapi.HTTPEndpointSpec{
ClientTLS: &commonapi.TLS{
Certificate: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testCertPEM},
},
},
PrivateKey: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testPKPEM},
},
},
},
},
})
require.NoError(t, err)
assert.NotNil(t, conf.Client.Transport.(*http.Transport).TLSClientConfig)
})
t.Run("TLS channel with invalid Root CA", func(t *testing.T) {
ch := &Channels{
compStore: compstore.New(),
meta: meta.New(meta.Options{Mode: modes.StandaloneMode}),
appConnectionConfig: config.AppConnectionConfig{
ChannelAddress: "my.app",
Protocol: "http",
Port: 0,
},
registry: registry.New(registry.NewOptions().WithHTTPMiddlewares(
httpMiddlewareLoader.NewRegistry(),
)).HTTPMiddlewares(),
}
_, err := ch.getHTTPEndpointAppChannel(httpendpapi.HTTPEndpoint{
ObjectMeta: metav1.ObjectMeta{
Name: "test",
},
Spec: httpendpapi.HTTPEndpointSpec{
ClientTLS: &commonapi.TLS{
RootCA: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: []byte("asdsdsdassjkdctewzxabcdef")},
},
},
Certificate: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testCertPEM},
},
},
PrivateKey: &commonapi.TLSDocument{
Value: &commonapi.DynamicValue{
JSON: v1.JSON{Raw: testPKPEM},
},
},
},
},
})
require.Error(t, err)
})
}
|
mikeee/dapr
|
pkg/runtime/channels/channels_test.go
|
GO
|
mit
| 6,106 |
//go:build unit
// +build unit
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package channels
import "github.com/dapr/dapr/pkg/channel"
// WithAppChannel is used for testing to override the underlying app channel.
func (c *Channels) WithAppChannel(appChannel channel.AppChannel) *Channels {
c.lock.Lock()
defer c.lock.Unlock()
c.appChannel = appChannel
return c
}
// WithEndpointChannels is used for testing to override the underlying endpoint
// channels.
func (c *Channels) WithEndpointChannels(endpChannels map[string]channel.HTTPEndpointAppChannel) *Channels {
c.lock.Lock()
defer c.lock.Unlock()
c.endpChannels = endpChannels
return c
}
|
mikeee/dapr
|
pkg/runtime/channels/unittest.go
|
GO
|
mit
| 1,169 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import "github.com/dapr/components-contrib/bindings"
func (c *ComponentStore) AddInputBinding(name string, binding bindings.InputBinding) {
c.lock.Lock()
defer c.lock.Unlock()
c.inputBindings[name] = binding
}
func (c *ComponentStore) GetInputBinding(name string) (bindings.InputBinding, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
binding, ok := c.inputBindings[name]
return binding, ok
}
func (c *ComponentStore) ListInputBindings() map[string]bindings.InputBinding {
c.lock.RLock()
defer c.lock.RUnlock()
return c.inputBindings
}
func (c *ComponentStore) DeleteInputBinding(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.inputBindings, name)
}
func (c *ComponentStore) AddInputBindingRoute(name, route string) {
c.lock.Lock()
defer c.lock.Unlock()
c.inputBindingRoutes[name] = route
}
func (c *ComponentStore) GetInputBindingRoute(name string) (string, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
route, ok := c.inputBindingRoutes[name]
return route, ok
}
func (c *ComponentStore) ListInputBindingRoutes() map[string]string {
c.lock.RLock()
defer c.lock.RUnlock()
return c.inputBindingRoutes
}
func (c *ComponentStore) DeleteInputBindingRoute(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.inputBindingRoutes, name)
}
func (c *ComponentStore) AddOutputBinding(name string, binding bindings.OutputBinding) {
c.lock.Lock()
defer c.lock.Unlock()
c.outputBindings[name] = binding
}
func (c *ComponentStore) GetOutputBinding(name string) (bindings.OutputBinding, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
binding, ok := c.outputBindings[name]
return binding, ok
}
func (c *ComponentStore) ListOutputBindings() map[string]bindings.OutputBinding {
c.lock.RLock()
defer c.lock.RUnlock()
return c.outputBindings
}
func (c *ComponentStore) DeleteOutputBinding(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.outputBindings, name)
}
|
mikeee/dapr
|
pkg/runtime/compstore/binding.go
|
GO
|
mit
| 2,502 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"errors"
"fmt"
compsv1alpha1 "github.com/dapr/dapr/pkg/apis/components/v1alpha1"
)
func (c *ComponentStore) GetComponent(name string) (compsv1alpha1.Component, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
for i, comp := range c.components {
if comp.ObjectMeta.Name == name {
return c.components[i], true
}
}
return compsv1alpha1.Component{}, false
}
func (c *ComponentStore) AddPendingComponentForCommit(component compsv1alpha1.Component) error {
c.compPendingLock.Lock()
c.lock.Lock()
defer c.lock.Unlock()
if c.compPending != nil {
c.compPendingLock.Unlock()
return errors.New("pending component not yet committed")
}
for _, existing := range c.components {
if existing.Name == component.Name {
c.compPendingLock.Unlock()
return fmt.Errorf("component %s already exists", existing.Name)
}
}
c.compPending = &component
return nil
}
func (c *ComponentStore) DropPendingComponent() error {
c.lock.Lock()
defer c.lock.Unlock()
if c.compPending == nil {
return errors.New("no pending component to drop")
}
c.compPending = nil
c.compPendingLock.Unlock()
return nil
}
func (c *ComponentStore) CommitPendingComponent() error {
c.lock.Lock()
defer c.lock.Unlock()
if c.compPending == nil {
return errors.New("no pending component to commit")
}
c.components = append(c.components, *c.compPending)
c.compPending = nil
c.compPendingLock.Unlock()
return nil
}
func (c *ComponentStore) ListComponents() []compsv1alpha1.Component {
c.lock.RLock()
defer c.lock.RUnlock()
comps := make([]compsv1alpha1.Component, len(c.components))
copy(comps, c.components)
return comps
}
func (c *ComponentStore) DeleteComponent(name string) {
c.lock.Lock()
defer c.lock.Unlock()
for i, comp := range c.components {
if comp.ObjectMeta.Name == name {
c.components = append(c.components[:i], c.components[i+1:]...)
return
}
}
}
|
mikeee/dapr
|
pkg/runtime/compstore/components.go
|
GO
|
mit
| 2,479 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"sync"
"github.com/microsoft/durabletask-go/backend"
"github.com/dapr/components-contrib/bindings"
"github.com/dapr/components-contrib/configuration"
"github.com/dapr/components-contrib/crypto"
"github.com/dapr/components-contrib/lock"
"github.com/dapr/components-contrib/secretstores"
"github.com/dapr/components-contrib/state"
"github.com/dapr/components-contrib/workflows"
compsv1alpha1 "github.com/dapr/dapr/pkg/apis/components/v1alpha1"
httpEndpointV1alpha1 "github.com/dapr/dapr/pkg/apis/httpEndpoint/v1alpha1"
"github.com/dapr/dapr/pkg/config"
rtpubsub "github.com/dapr/dapr/pkg/runtime/pubsub"
)
// ComponentStore is a store of all components which have been configured for the
// runtime. The store is dynamic. Each component type is indexed by its
// Component name.
type ComponentStore struct {
lock sync.RWMutex
states map[string]state.Store
configurations map[string]configuration.Store
configurationSubscribes map[string]chan struct{}
secretsConfigurations map[string]config.SecretsScope
secrets map[string]secretstores.SecretStore
inputBindings map[string]bindings.InputBinding
inputBindingRoutes map[string]string
outputBindings map[string]bindings.OutputBinding
locks map[string]lock.Store
pubSubs map[string]*rtpubsub.PubsubItem
workflowComponents map[string]workflows.Workflow
workflowBackends map[string]backend.Backend
cryptoProviders map[string]crypto.SubtleCrypto
components []compsv1alpha1.Component
subscriptions *subscriptions
httpEndpoints []httpEndpointV1alpha1.HTTPEndpoint
actorStateStore struct {
name string
store state.Store
}
compPendingLock sync.Mutex
compPending *compsv1alpha1.Component
}
func New() *ComponentStore {
return &ComponentStore{
states: make(map[string]state.Store),
configurations: make(map[string]configuration.Store),
configurationSubscribes: make(map[string]chan struct{}),
secretsConfigurations: make(map[string]config.SecretsScope),
secrets: make(map[string]secretstores.SecretStore),
inputBindings: make(map[string]bindings.InputBinding),
inputBindingRoutes: make(map[string]string),
outputBindings: make(map[string]bindings.OutputBinding),
locks: make(map[string]lock.Store),
pubSubs: make(map[string]*rtpubsub.PubsubItem),
workflowComponents: make(map[string]workflows.Workflow),
workflowBackends: make(map[string]backend.Backend),
cryptoProviders: make(map[string]crypto.SubtleCrypto),
subscriptions: &subscriptions{
declaratives: make(map[string]*DeclarativeSubscription),
streams: make(map[string]*DeclarativeSubscription),
},
}
}
|
mikeee/dapr
|
pkg/runtime/compstore/compstore.go
|
GO
|
mit
| 3,459 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"github.com/dapr/components-contrib/configuration"
"github.com/dapr/dapr/pkg/config"
)
func (c *ComponentStore) AddConfiguration(name string, store configuration.Store) {
c.lock.Lock()
defer c.lock.Unlock()
c.configurations[name] = store
}
func (c *ComponentStore) GetConfiguration(name string) (configuration.Store, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
store, ok := c.configurations[name]
return store, ok
}
func (c *ComponentStore) ListConfigurations() map[string]configuration.Store {
c.lock.RLock()
defer c.lock.RUnlock()
return c.configurations
}
func (c *ComponentStore) ConfigurationsLen() int {
c.lock.RLock()
defer c.lock.RUnlock()
return len(c.configurations)
}
func (c *ComponentStore) DeleteConfiguration(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.configurations, name)
}
func (c *ComponentStore) AddConfigurationSubscribe(name string, ch chan struct{}) {
c.lock.Lock()
defer c.lock.Unlock()
c.configurationSubscribes[name] = ch
}
func (c *ComponentStore) GetConfigurationSubscribe(name string) (chan struct{}, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
ch, ok := c.configurationSubscribes[name]
return ch, ok
}
func (c *ComponentStore) DeleteConfigurationSubscribe(name string) {
c.lock.Lock()
defer c.lock.Unlock()
stop := c.configurationSubscribes[name]
if stop != nil {
close(stop)
}
delete(c.configurationSubscribes, name)
}
func (c *ComponentStore) DeleteAllConfigurationSubscribe() {
c.lock.Lock()
defer c.lock.Unlock()
for name, stop := range c.configurationSubscribes {
close(stop)
delete(c.configurationSubscribes, name)
}
}
func (c *ComponentStore) AddSecretsConfiguration(name string, secretsScope config.SecretsScope) {
c.lock.Lock()
defer c.lock.Unlock()
c.secretsConfigurations[name] = secretsScope
}
func (c *ComponentStore) GetSecretsConfiguration(name string) (config.SecretsScope, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
secretsScope, ok := c.secretsConfigurations[name]
return secretsScope, ok
}
func (c *ComponentStore) DeleteSecretsConfiguration(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.secretsConfigurations, name)
}
|
mikeee/dapr
|
pkg/runtime/compstore/configuration.go
|
GO
|
mit
| 2,758 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"github.com/dapr/components-contrib/crypto"
)
func (c *ComponentStore) AddCryptoProvider(name string, provider crypto.SubtleCrypto) {
c.lock.Lock()
defer c.lock.Unlock()
c.cryptoProviders[name] = provider
}
func (c *ComponentStore) GetCryptoProvider(name string) (crypto.SubtleCrypto, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
provider, ok := c.cryptoProviders[name]
return provider, ok
}
func (c *ComponentStore) ListCryptoProviders() map[string]crypto.SubtleCrypto {
c.lock.RLock()
defer c.lock.RUnlock()
return c.cryptoProviders
}
func (c *ComponentStore) DeleteCryptoProvider(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.cryptoProviders, name)
}
func (c *ComponentStore) CryptoProvidersLen() int {
c.lock.RLock()
defer c.lock.RUnlock()
return len(c.cryptoProviders)
}
|
mikeee/dapr
|
pkg/runtime/compstore/crypto.go
|
GO
|
mit
| 1,402 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import httpEndpointv1alpha1 "github.com/dapr/dapr/pkg/apis/httpEndpoint/v1alpha1"
func (c *ComponentStore) GetHTTPEndpoint(name string) (httpEndpointv1alpha1.HTTPEndpoint, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
for i, endpoint := range c.httpEndpoints {
if endpoint.ObjectMeta.Name == name {
return c.httpEndpoints[i], true
}
}
return httpEndpointv1alpha1.HTTPEndpoint{}, false
}
func (c *ComponentStore) AddHTTPEndpoint(httpEndpoint httpEndpointv1alpha1.HTTPEndpoint) {
c.lock.Lock()
defer c.lock.Unlock()
for i, endpoint := range c.httpEndpoints {
if endpoint.ObjectMeta.Name == httpEndpoint.Name {
c.httpEndpoints[i] = httpEndpoint
return
}
}
c.httpEndpoints = append(c.httpEndpoints, httpEndpoint)
}
func (c *ComponentStore) ListHTTPEndpoints() []httpEndpointv1alpha1.HTTPEndpoint {
c.lock.RLock()
defer c.lock.RUnlock()
endpoints := make([]httpEndpointv1alpha1.HTTPEndpoint, len(c.httpEndpoints))
copy(endpoints, c.httpEndpoints)
return endpoints
}
func (c *ComponentStore) DeleteHTTPEndpoint(name string) {
c.lock.Lock()
defer c.lock.Unlock()
for i, endpoint := range c.httpEndpoints {
if endpoint.ObjectMeta.Name == name {
c.httpEndpoints = append(c.httpEndpoints[:i], c.httpEndpoints[i+1:]...)
return
}
}
}
|
mikeee/dapr
|
pkg/runtime/compstore/httpEndpoint.go
|
GO
|
mit
| 1,855 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import "github.com/dapr/components-contrib/lock"
func (c *ComponentStore) AddLock(name string, store lock.Store) {
c.lock.Lock()
defer c.lock.Unlock()
c.locks[name] = store
}
func (c *ComponentStore) GetLock(name string) (lock.Store, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
store, ok := c.locks[name]
return store, ok
}
func (c *ComponentStore) ListLocks() map[string]lock.Store {
c.lock.RLock()
defer c.lock.RUnlock()
return c.locks
}
func (c *ComponentStore) DeleteLock(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.locks, name)
}
func (c *ComponentStore) LocksLen() int {
c.lock.RLock()
defer c.lock.RUnlock()
return len(c.locks)
}
|
mikeee/dapr
|
pkg/runtime/compstore/lock.go
|
GO
|
mit
| 1,256 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"github.com/dapr/components-contrib/pubsub"
rtpubsub "github.com/dapr/dapr/pkg/runtime/pubsub"
)
func (c *ComponentStore) AddPubSub(name string, item *rtpubsub.PubsubItem) {
c.lock.Lock()
defer c.lock.Unlock()
c.pubSubs[name] = item
}
func (c *ComponentStore) GetPubSub(name string) (*rtpubsub.PubsubItem, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
pubsub, ok := c.pubSubs[name]
return pubsub, ok
}
func (c *ComponentStore) GetPubSubComponent(name string) (pubsub.PubSub, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
pubsub, ok := c.pubSubs[name]
if !ok {
return nil, false
}
return pubsub.Component, ok
}
func (c *ComponentStore) ListPubSubs() map[string]*rtpubsub.PubsubItem {
c.lock.RLock()
defer c.lock.RUnlock()
return c.pubSubs
}
func (c *ComponentStore) PubSubsLen() int {
c.lock.RLock()
defer c.lock.RUnlock()
return len(c.pubSubs)
}
func (c *ComponentStore) DeletePubSub(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.pubSubs, name)
}
|
mikeee/dapr
|
pkg/runtime/compstore/pubsub.go
|
GO
|
mit
| 1,583 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import "github.com/dapr/components-contrib/secretstores"
func (c *ComponentStore) AddSecretStore(name string, store secretstores.SecretStore) {
c.lock.Lock()
defer c.lock.Unlock()
c.secrets[name] = store
}
func (c *ComponentStore) GetSecretStore(name string) (secretstores.SecretStore, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
store, ok := c.secrets[name]
return store, ok
}
func (c *ComponentStore) ListSecretStores() map[string]secretstores.SecretStore {
c.lock.RLock()
defer c.lock.RUnlock()
return c.secrets
}
func (c *ComponentStore) DeleteSecretStore(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.secrets, name)
}
func (c *ComponentStore) SecretStoresLen() int {
c.lock.RLock()
defer c.lock.RUnlock()
return len(c.secrets)
}
|
mikeee/dapr
|
pkg/runtime/compstore/secretstore.go
|
GO
|
mit
| 1,351 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"fmt"
"github.com/dapr/components-contrib/state"
)
func (c *ComponentStore) AddStateStore(name string, store state.Store) {
c.lock.Lock()
defer c.lock.Unlock()
c.states[name] = store
}
func (c *ComponentStore) AddStateStoreActor(name string, store state.Store) error {
c.lock.Lock()
defer c.lock.Unlock()
if c.actorStateStore.store != nil && c.actorStateStore.name != name {
return fmt.Errorf("detected duplicate actor state store: %s and %s", c.actorStateStore.name, name)
}
c.states[name] = store
c.actorStateStore.name = name
c.actorStateStore.store = store
return nil
}
func (c *ComponentStore) GetStateStore(name string) (state.Store, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
store, ok := c.states[name]
return store, ok
}
func (c *ComponentStore) ListStateStores() map[string]state.Store {
c.lock.RLock()
defer c.lock.RUnlock()
return c.states
}
func (c *ComponentStore) DeleteStateStore(name string) {
c.lock.Lock()
defer c.lock.Unlock()
if c.actorStateStore.name == name {
c.actorStateStore.name = ""
c.actorStateStore.store = nil
}
delete(c.states, name)
}
func (c *ComponentStore) StateStoresLen() int {
c.lock.RLock()
defer c.lock.RUnlock()
return len(c.states)
}
func (c *ComponentStore) GetStateStoreActor() (state.Store, string, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
if c.actorStateStore.store == nil {
return nil, "", false
}
return c.actorStateStore.store, c.actorStateStore.name, true
}
|
mikeee/dapr
|
pkg/runtime/compstore/statestore.go
|
GO
|
mit
| 2,055 |
/*
Copyright 2024 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"fmt"
subapi "github.com/dapr/dapr/pkg/apis/subscriptions/v2alpha1"
rtpubsub "github.com/dapr/dapr/pkg/runtime/pubsub"
"github.com/dapr/kit/ptr"
)
type DeclarativeSubscription struct {
Comp *subapi.Subscription
*NamedSubscription
}
type NamedSubscription struct {
// Name is the optional name of the subscription. If not set, the name of the
// component is used.
Name *string
rtpubsub.Subscription
}
type subscriptions struct {
programmatics []rtpubsub.Subscription
declaratives map[string]*DeclarativeSubscription
// declarativesList used to track order of declarative subscriptions for
// processing priority.
declarativesList []string
streams map[string]*DeclarativeSubscription
}
func (c *ComponentStore) SetProgramaticSubscriptions(subs ...rtpubsub.Subscription) {
c.lock.Lock()
defer c.lock.Unlock()
c.subscriptions.programmatics = subs
}
func (c *ComponentStore) AddDeclarativeSubscription(comp *subapi.Subscription, sub rtpubsub.Subscription) {
c.lock.Lock()
defer c.lock.Unlock()
for i, existing := range c.subscriptions.declarativesList {
if existing == comp.Name {
c.subscriptions.declarativesList = append(c.subscriptions.declarativesList[:i], c.subscriptions.declarativesList[i+1:]...)
break
}
}
c.subscriptions.declaratives[comp.Name] = &DeclarativeSubscription{
Comp: comp,
NamedSubscription: &NamedSubscription{
Name: ptr.Of(comp.Name),
Subscription: sub,
},
}
c.subscriptions.declarativesList = append(c.subscriptions.declarativesList, comp.Name)
}
func (c *ComponentStore) AddStreamSubscription(comp *subapi.Subscription) error {
c.lock.Lock()
defer c.lock.Unlock()
if _, ok := c.subscriptions.streams[comp.Name]; ok {
return fmt.Errorf("streamer already subscribed to pubsub %q topic %q", comp.Spec.Pubsubname, comp.Spec.Topic)
}
c.subscriptions.streams[comp.Name] = &DeclarativeSubscription{
Comp: comp,
NamedSubscription: &NamedSubscription{
Name: ptr.Of(comp.Name),
Subscription: rtpubsub.Subscription{
PubsubName: comp.Spec.Pubsubname,
Topic: comp.Spec.Topic,
DeadLetterTopic: comp.Spec.DeadLetterTopic,
Metadata: comp.Spec.Metadata,
Rules: []*rtpubsub.Rule{{Path: "/"}},
},
},
}
return nil
}
func (c *ComponentStore) DeleteStreamSubscription(names ...string) {
c.lock.Lock()
defer c.lock.Unlock()
for _, name := range names {
delete(c.subscriptions.streams, name)
}
}
func (c *ComponentStore) DeleteDeclarativeSubscription(names ...string) {
c.lock.Lock()
defer c.lock.Unlock()
for _, name := range names {
delete(c.subscriptions.declaratives, name)
for i, existing := range c.subscriptions.declarativesList {
if existing == name {
c.subscriptions.declarativesList = append(c.subscriptions.declarativesList[:i], c.subscriptions.declarativesList[i+1:]...)
break
}
}
}
}
func (c *ComponentStore) ListSubscriptions() []rtpubsub.Subscription {
c.lock.RLock()
defer c.lock.RUnlock()
var subs []rtpubsub.Subscription
taken := make(map[string]int)
for _, name := range c.subscriptions.declarativesList {
sub := c.subscriptions.declaratives[name].Subscription
key := sub.PubsubName + "||" + sub.Topic
if _, ok := taken[key]; !ok {
taken[key] = len(subs)
subs = append(subs, sub)
}
}
for i := range c.subscriptions.programmatics {
sub := c.subscriptions.programmatics[i]
key := sub.PubsubName + "||" + sub.Topic
if j, ok := taken[key]; ok {
subs[j] = sub
} else {
taken[key] = len(subs)
subs = append(subs, sub)
}
}
for i := range c.subscriptions.streams {
sub := c.subscriptions.streams[i].Subscription
key := sub.PubsubName + "||" + sub.Topic
if j, ok := taken[key]; ok {
subs[j] = sub
} else {
taken[key] = len(subs)
subs = append(subs, sub)
}
}
return subs
}
func (c *ComponentStore) ListSubscriptionsAppByPubSub(name string) []*NamedSubscription {
c.lock.RLock()
defer c.lock.RUnlock()
var subs []*NamedSubscription
taken := make(map[string]int)
for _, subName := range c.subscriptions.declarativesList {
sub := c.subscriptions.declaratives[subName]
if sub.Subscription.PubsubName != name {
continue
}
if _, ok := taken[sub.Subscription.Topic]; !ok {
taken[sub.Subscription.Topic] = len(subs)
subs = append(subs, &NamedSubscription{
Name: ptr.Of(subName),
Subscription: sub.Subscription,
})
}
}
for i := range c.subscriptions.programmatics {
sub := c.subscriptions.programmatics[i]
if sub.PubsubName != name {
continue
}
if j, ok := taken[sub.Topic]; ok {
subs[j] = &NamedSubscription{Subscription: sub}
} else {
taken[sub.Topic] = len(subs)
subs = append(subs, &NamedSubscription{Subscription: sub})
}
}
return subs
}
func (c *ComponentStore) ListSubscriptionsStreamByPubSub(name string) []*NamedSubscription {
c.lock.RLock()
defer c.lock.RUnlock()
var subs []*NamedSubscription
for _, sub := range c.subscriptions.streams {
if sub.Subscription.PubsubName == name {
subs = append(subs, sub.NamedSubscription)
}
}
return subs
}
func (c *ComponentStore) GetDeclarativeSubscription(name string) (*DeclarativeSubscription, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
for i, sub := range c.subscriptions.declaratives {
if sub.Comp.Name == name {
return c.subscriptions.declaratives[i], true
}
}
return nil, false
}
func (c *ComponentStore) GetStreamSubscription(key string) (*NamedSubscription, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
for i, sub := range c.subscriptions.streams {
if sub.Comp.Name == key {
return c.subscriptions.streams[i].NamedSubscription, true
}
}
return nil, false
}
func (c *ComponentStore) ListDeclarativeSubscriptions() []subapi.Subscription {
c.lock.RLock()
defer c.lock.RUnlock()
subs := make([]subapi.Subscription, 0, len(c.subscriptions.declaratives))
for i := range c.subscriptions.declarativesList {
subs = append(subs, *c.subscriptions.declaratives[c.subscriptions.declarativesList[i]].Comp)
}
return subs
}
func (c *ComponentStore) ListProgramaticSubscriptions() []rtpubsub.Subscription {
c.lock.RLock()
defer c.lock.RUnlock()
return c.subscriptions.programmatics
}
|
mikeee/dapr
|
pkg/runtime/compstore/subscriptions.go
|
GO
|
mit
| 6,796 |
/*
Copyright 2023 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import "github.com/dapr/components-contrib/workflows"
func (c *ComponentStore) AddWorkflow(name string, workflow workflows.Workflow) {
c.lock.Lock()
defer c.lock.Unlock()
c.workflowComponents[name] = workflow
}
func (c *ComponentStore) GetWorkflow(name string) (workflows.Workflow, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
workflow, ok := c.workflowComponents[name]
return workflow, ok
}
func (c *ComponentStore) ListWorkflows() map[string]workflows.Workflow {
c.lock.RLock()
defer c.lock.RUnlock()
return c.workflowComponents
}
func (c *ComponentStore) DeleteWorkflow(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.workflowComponents, name)
}
|
mikeee/dapr
|
pkg/runtime/compstore/workflow.go
|
GO
|
mit
| 1,259 |
/*
Copyright 2024 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compstore
import (
"github.com/microsoft/durabletask-go/backend"
)
func (c *ComponentStore) AddWorkflowBackend(name string, backend backend.Backend) {
c.lock.Lock()
defer c.lock.Unlock()
c.workflowBackends[name] = backend
}
func (c *ComponentStore) GetWorkflowBackend(name string) (backend.Backend, bool) {
c.lock.RLock()
defer c.lock.RUnlock()
backend, ok := c.workflowBackends[name]
return backend, ok
}
func (c *ComponentStore) ListWorkflowBackends() map[string]backend.Backend {
c.lock.RLock()
defer c.lock.RUnlock()
return c.workflowBackends
}
func (c *ComponentStore) DeleteWorkflowBackend(name string) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.workflowBackends, name)
}
|
mikeee/dapr
|
pkg/runtime/compstore/workflowbackend.go
|
GO
|
mit
| 1,270 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package runtime
import (
"context"
"errors"
"fmt"
"os"
"strconv"
"strings"
"time"
"github.com/dapr/dapr/pkg/acl"
"github.com/dapr/dapr/pkg/config"
env "github.com/dapr/dapr/pkg/config/env"
configmodes "github.com/dapr/dapr/pkg/config/modes"
"github.com/dapr/dapr/pkg/config/protocol"
diag "github.com/dapr/dapr/pkg/diagnostics"
"github.com/dapr/dapr/pkg/metrics"
"github.com/dapr/dapr/pkg/modes"
"github.com/dapr/dapr/pkg/operator/client"
"github.com/dapr/dapr/pkg/ports"
operatorV1 "github.com/dapr/dapr/pkg/proto/operator/v1"
resiliencyConfig "github.com/dapr/dapr/pkg/resiliency"
rterrors "github.com/dapr/dapr/pkg/runtime/errors"
"github.com/dapr/dapr/pkg/runtime/registry"
"github.com/dapr/dapr/pkg/security"
"github.com/dapr/dapr/pkg/validation"
"github.com/dapr/dapr/utils"
"github.com/dapr/kit/ptr"
)
const (
// DefaultDaprHTTPPort is the default http port for Dapr.
DefaultDaprHTTPPort = 3500
// DefaultDaprPublicPort is the default http port for Dapr.
DefaultDaprPublicPort = 3501
// DefaultDaprAPIGRPCPort is the default API gRPC port for Dapr.
DefaultDaprAPIGRPCPort = 50001
// DefaultProfilePort is the default port for profiling endpoints.
DefaultProfilePort = 7777
// DefaultMetricsPort is the default port for metrics endpoints.
DefaultMetricsPort = 9090
// DefaultMaxRequestBodySize is the default option for the maximum body size in bytes for Dapr HTTP servers.
// Equal to 4MB
DefaultMaxRequestBodySize = 4 << 20
// DefaultAPIListenAddress is which address to listen for the Dapr HTTP and GRPC APIs. Empty string is all addresses.
DefaultAPIListenAddress = ""
// DefaultReadBufferSize is the default option for the maximum header size in bytes for Dapr HTTP servers.
// Equal to 4KB
DefaultReadBufferSize = 4 << 10
// DefaultGracefulShutdownDuration is the default option for the duration of the graceful shutdown.
DefaultGracefulShutdownDuration = time.Second * 5
// DefaultAppHealthCheckPath is the default path for HTTP health checks.
DefaultAppHealthCheckPath = "/healthz"
// DefaultChannelAddress is the default local network address that user application listen on.
DefaultChannelAddress = "127.0.0.1"
)
// Config holds the Dapr Runtime configuration.
type Config struct {
AppID string
ControlPlaneAddress string
SentryAddress string
AllowedOrigins string
EnableProfiling bool
AppMaxConcurrency int
EnableMTLS bool
AppSSL bool
MaxRequestSize int // In bytes
ResourcesPath []string
ComponentsPath string
AppProtocol string
EnableAPILogging *bool
DaprHTTPPort string
DaprAPIGRPCPort string
ProfilePort string
DaprInternalGRPCPort string
DaprInternalGRPCListenAddress string
DaprPublicPort string
DaprPublicListenAddress string
ApplicationPort string
DaprGracefulShutdownSeconds int
DaprBlockShutdownDuration *time.Duration
ActorsService string
RemindersService string
DaprAPIListenAddresses string
AppHealthProbeInterval int
AppHealthProbeTimeout int
AppHealthThreshold int
EnableAppHealthCheck bool
Mode string
Config []string
UnixDomainSocket string
ReadBufferSize int // In bytes
DisableBuiltinK8sSecretStore bool
AppHealthCheckPath string
AppChannelAddress string
Metrics *metrics.Options
Registry *registry.Options
Security security.Handler
}
type internalConfig struct {
id string
httpPort int
publicPort *int
publicListenAddress string
profilePort int
enableProfiling bool
apiGRPCPort int
internalGRPCPort int
internalGRPCListenAddress string
apiListenAddresses []string
appConnectionConfig config.AppConnectionConfig
mode modes.DaprMode
actorsService string
remindersService string
allowedOrigins string
standalone configmodes.StandaloneConfig
kubernetes configmodes.KubernetesConfig
mTLSEnabled bool
sentryServiceAddress string
unixDomainSocket string
maxRequestBodySize int // In bytes
readBufferSize int // In bytes
gracefulShutdownDuration time.Duration
blockShutdownDuration *time.Duration
enableAPILogging *bool
disableBuiltinK8sSecretStore bool
config []string
registry *registry.Registry
metricsExporter metrics.Exporter
}
func (i internalConfig) ActorsEnabled() bool {
return i.actorsService != ""
}
// FromConfig creates a new Dapr Runtime from a configuration.
func FromConfig(ctx context.Context, cfg *Config) (*DaprRuntime, error) {
intc, err := cfg.toInternal()
if err != nil {
return nil, err
}
// set environment variables
// TODO - consider adding host address to runtime config and/or caching result in utils package
host, err := utils.GetHostAddress()
if err != nil {
log.Warnf("failed to get host address, env variable %s will not be set", env.HostAddress)
}
variables := map[string]string{
env.AppID: intc.id,
env.AppPort: strconv.Itoa(intc.appConnectionConfig.Port),
env.HostAddress: host,
env.DaprPort: strconv.Itoa(intc.internalGRPCPort),
env.DaprGRPCPort: strconv.Itoa(intc.apiGRPCPort),
env.DaprHTTPPort: strconv.Itoa(intc.httpPort),
env.DaprMetricsPort: intc.metricsExporter.Options().Port,
env.DaprProfilePort: strconv.Itoa(intc.profilePort),
}
if err = utils.SetEnvVariables(variables); err != nil {
return nil, err
}
// Config and resiliency need the operator client
var operatorClient operatorV1.OperatorClient
if intc.mode == modes.KubernetesMode {
log.Info("Initializing the operator client")
client, conn, clientErr := client.GetOperatorClient(ctx, cfg.ControlPlaneAddress, cfg.Security)
if clientErr != nil {
return nil, clientErr
}
defer conn.Close()
operatorClient = client
}
namespace := os.Getenv("NAMESPACE")
podName := os.Getenv("POD_NAME")
var (
globalConfig *config.Configuration
configErr error
)
if len(intc.config) > 0 {
switch intc.mode {
case modes.KubernetesMode:
if len(intc.config) > 1 {
// We are not returning an error here because in Kubernetes mode, the injector itself doesn't allow multiple configuration flags to be added, so this should never happen in normal environments
log.Warnf("Multiple configurations are not supported in Kubernetes mode; only the first one will be loaded")
}
log.Debug("Loading Kubernetes config resource: " + intc.config[0])
globalConfig, configErr = config.LoadKubernetesConfiguration(intc.config[0], namespace, podName, operatorClient)
case modes.StandaloneMode:
log.Debug("Loading config from file(s): " + strings.Join(intc.config, ", "))
globalConfig, configErr = config.LoadStandaloneConfiguration(intc.config...)
}
}
if configErr != nil {
return nil, fmt.Errorf("error loading configuration: %s", configErr)
}
if globalConfig == nil {
log.Info("loading default configuration")
globalConfig = config.LoadDefaultConfiguration()
}
config.SetTracingSpecFromEnv(globalConfig)
globalConfig.LoadFeatures()
if enabledFeatures := globalConfig.EnabledFeatures(); len(enabledFeatures) > 0 {
log.Info("Enabled features: " + strings.Join(enabledFeatures, " "))
}
// Initialize metrics only if MetricSpec is enabled.
metricsSpec := globalConfig.GetMetricsSpec()
if metricsSpec.GetEnabled() {
err = diag.InitMetrics(
intc.id,
namespace,
metricsSpec.Rules,
metricsSpec.GetHTTPPathMatching(),
metricsSpec.GetHTTPIncreasedCardinality(log),
)
if err != nil {
log.Errorf(rterrors.NewInit(rterrors.InitFailure, "metrics", err).Error())
}
}
// Load Resiliency
var resiliencyProvider *resiliencyConfig.Resiliency
switch intc.mode {
case modes.KubernetesMode:
resiliencyConfigs := resiliencyConfig.LoadKubernetesResiliency(log, intc.id, namespace, operatorClient)
log.Debugf("Found %d resiliency configurations from Kubernetes", len(resiliencyConfigs))
resiliencyProvider = resiliencyConfig.FromConfigurations(log, resiliencyConfigs...)
case modes.StandaloneMode:
if len(intc.standalone.ResourcesPath) > 0 {
resiliencyConfigs := resiliencyConfig.LoadLocalResiliency(log, intc.id, intc.standalone.ResourcesPath...)
log.Debugf("Found %d resiliency configurations in resources path", len(resiliencyConfigs))
resiliencyProvider = resiliencyConfig.FromConfigurations(log, resiliencyConfigs...)
} else {
resiliencyProvider = resiliencyConfig.FromConfigurations(log)
}
}
accessControlList, err := acl.ParseAccessControlSpec(
globalConfig.Spec.AccessControlSpec,
intc.appConnectionConfig.Protocol.IsHTTP(),
)
if err != nil {
return nil, err
}
// API logging can be enabled for this app or for every app, globally in the config
if intc.enableAPILogging == nil {
intc.enableAPILogging = ptr.Of(globalConfig.GetAPILoggingSpec().Enabled)
}
return newDaprRuntime(ctx, cfg.Security, intc, globalConfig, accessControlList, resiliencyProvider)
}
func (c *Config) toInternal() (*internalConfig, error) {
intc := &internalConfig{
id: c.AppID,
mode: modes.DaprMode(c.Mode),
config: c.Config,
sentryServiceAddress: c.SentryAddress,
allowedOrigins: c.AllowedOrigins,
kubernetes: configmodes.KubernetesConfig{
ControlPlaneAddress: c.ControlPlaneAddress,
},
standalone: configmodes.StandaloneConfig{
ResourcesPath: c.ResourcesPath,
},
enableProfiling: c.EnableProfiling,
mTLSEnabled: c.EnableMTLS,
disableBuiltinK8sSecretStore: c.DisableBuiltinK8sSecretStore,
unixDomainSocket: c.UnixDomainSocket,
maxRequestBodySize: c.MaxRequestSize,
readBufferSize: c.ReadBufferSize,
enableAPILogging: c.EnableAPILogging,
appConnectionConfig: config.AppConnectionConfig{
ChannelAddress: c.AppChannelAddress,
HealthCheckHTTPPath: c.AppHealthCheckPath,
MaxConcurrency: c.AppMaxConcurrency,
},
registry: registry.New(c.Registry),
metricsExporter: metrics.NewExporterWithOptions(log, metrics.DefaultMetricNamespace, c.Metrics),
blockShutdownDuration: c.DaprBlockShutdownDuration,
actorsService: c.ActorsService,
remindersService: c.RemindersService,
publicListenAddress: c.DaprPublicListenAddress,
internalGRPCListenAddress: c.DaprInternalGRPCListenAddress,
}
if len(intc.standalone.ResourcesPath) == 0 && c.ComponentsPath != "" {
intc.standalone.ResourcesPath = []string{c.ComponentsPath}
}
if intc.mode == modes.StandaloneMode {
if err := validation.ValidateSelfHostedAppID(intc.id); err != nil {
return nil, err
}
}
var err error
intc.httpPort, err = strconv.Atoi(c.DaprHTTPPort)
if err != nil {
return nil, fmt.Errorf("error parsing dapr-http-port flag: %w", err)
}
intc.apiGRPCPort, err = strconv.Atoi(c.DaprAPIGRPCPort)
if err != nil {
return nil, fmt.Errorf("error parsing dapr-grpc-port flag: %w", err)
}
intc.profilePort, err = strconv.Atoi(c.ProfilePort)
if err != nil {
return nil, fmt.Errorf("error parsing profile-port flag: %w", err)
}
if c.DaprInternalGRPCPort != "" && c.DaprInternalGRPCPort != "0" {
intc.internalGRPCPort, err = strconv.Atoi(c.DaprInternalGRPCPort)
if err != nil {
return nil, fmt.Errorf("error parsing dapr-internal-grpc-port: %w", err)
}
} else {
// Get a "stable random" port in the range 47300-49,347 if it can be
// acquired using a deterministic algorithm that returns the same value if
// the same app is restarted
// Otherwise, the port will be random.
intc.internalGRPCPort, err = ports.GetStablePort(47300, intc.id)
if err != nil {
return nil, fmt.Errorf("failed to get free port for internal grpc server: %w", err)
}
}
if c.DaprPublicPort != "" {
var port int
port, err = strconv.Atoi(c.DaprPublicPort)
if err != nil {
return nil, fmt.Errorf("error parsing dapr-public-port: %w", err)
}
intc.publicPort = &port
}
if c.ApplicationPort != "" {
intc.appConnectionConfig.Port, err = strconv.Atoi(c.ApplicationPort)
if err != nil {
return nil, fmt.Errorf("error parsing app-port: %w", err)
}
}
if intc.appConnectionConfig.Port == intc.httpPort {
return nil, fmt.Errorf("the 'dapr-http-port' argument value %d conflicts with 'app-port'", intc.httpPort)
}
if intc.appConnectionConfig.Port == intc.apiGRPCPort {
return nil, fmt.Errorf("the 'dapr-grpc-port' argument value %d conflicts with 'app-port'", intc.apiGRPCPort)
}
if intc.maxRequestBodySize == -1 {
intc.maxRequestBodySize = DefaultMaxRequestBodySize
}
if intc.readBufferSize == -1 {
intc.readBufferSize = DefaultReadBufferSize
}
if c.DaprGracefulShutdownSeconds < 0 {
intc.gracefulShutdownDuration = DefaultGracefulShutdownDuration
} else {
intc.gracefulShutdownDuration = time.Duration(c.DaprGracefulShutdownSeconds) * time.Second
}
if intc.appConnectionConfig.MaxConcurrency == -1 {
intc.appConnectionConfig.MaxConcurrency = 0
}
switch p := strings.ToLower(c.AppProtocol); p {
case string(protocol.GRPCSProtocol):
intc.appConnectionConfig.Protocol = protocol.GRPCSProtocol
case string(protocol.HTTPSProtocol):
intc.appConnectionConfig.Protocol = protocol.HTTPSProtocol
case string(protocol.H2CProtocol):
intc.appConnectionConfig.Protocol = protocol.H2CProtocol
case string(protocol.HTTPProtocol):
// For backwards compatibility, when protocol is HTTP and --app-ssl is set, use "https"
// TODO: Remove in a future Dapr version
if c.AppSSL {
log.Warn("The 'app-ssl' flag is deprecated; use 'app-protocol=https' instead")
intc.appConnectionConfig.Protocol = protocol.HTTPSProtocol
} else {
intc.appConnectionConfig.Protocol = protocol.HTTPProtocol
}
case string(protocol.GRPCProtocol):
// For backwards compatibility, when protocol is GRPC and --app-ssl is set, use "grpcs"
// TODO: Remove in a future Dapr version
if c.AppSSL {
log.Warn("The 'app-ssl' flag is deprecated; use 'app-protocol=grpcs' instead")
intc.appConnectionConfig.Protocol = protocol.GRPCSProtocol
} else {
intc.appConnectionConfig.Protocol = protocol.GRPCProtocol
}
case "":
intc.appConnectionConfig.Protocol = protocol.HTTPProtocol
default:
return nil, fmt.Errorf("invalid value for 'app-protocol': %v", c.AppProtocol)
}
intc.apiListenAddresses = strings.Split(c.DaprAPIListenAddresses, ",")
if len(intc.apiListenAddresses) == 0 {
intc.apiListenAddresses = []string{DefaultAPIListenAddress}
}
healthProbeInterval := time.Duration(c.AppHealthProbeInterval) * time.Second
if c.AppHealthProbeInterval <= 0 {
healthProbeInterval = config.AppHealthConfigDefaultProbeInterval
}
healthProbeTimeout := time.Duration(c.AppHealthProbeTimeout) * time.Millisecond
if c.AppHealthProbeTimeout <= 0 {
healthProbeTimeout = config.AppHealthConfigDefaultProbeTimeout
}
if healthProbeTimeout > healthProbeInterval {
return nil, errors.New("value for 'health-probe-timeout' must be smaller than 'health-probe-interval'")
}
// Also check to ensure no overflow with int32
healthThreshold := int32(c.AppHealthThreshold)
if c.AppHealthThreshold < 1 || int32(c.AppHealthThreshold+1) < 0 {
healthThreshold = config.AppHealthConfigDefaultThreshold
}
if c.EnableAppHealthCheck {
intc.appConnectionConfig.HealthCheck = &config.AppHealthConfig{
ProbeInterval: healthProbeInterval,
ProbeTimeout: healthProbeTimeout,
ProbeOnly: true,
Threshold: healthThreshold,
}
}
return intc, nil
}
|
mikeee/dapr
|
pkg/runtime/config.go
|
GO
|
mit
| 16,755 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package runtime
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/dapr/dapr/pkg/config"
"github.com/dapr/dapr/pkg/metrics"
"github.com/dapr/dapr/pkg/runtime/registry"
"github.com/dapr/kit/ptr"
)
func Test_toInternal(t *testing.T) {
cfg := defaultTestConfig()
var nilDuration *time.Duration
intc, err := cfg.toInternal()
require.NoError(t, err)
assert.Equal(t, "app1", intc.id)
assert.Equal(t, "localhost:5050", intc.actorsService)
assert.Equal(t, "localhost:5051", intc.kubernetes.ControlPlaneAddress)
assert.Equal(t, "*", intc.allowedOrigins)
_ = assert.Len(t, intc.standalone.ResourcesPath, 1) &&
assert.Equal(t, "components", intc.standalone.ResourcesPath[0])
assert.Equal(t, "http", string(intc.appConnectionConfig.Protocol))
assert.Equal(t, "kubernetes", string(intc.mode))
assert.Equal(t, 3500, intc.httpPort)
assert.Equal(t, 50002, intc.internalGRPCPort)
assert.Equal(t, 50001, intc.apiGRPCPort)
assert.Equal(t, ptr.Of(3501), intc.publicPort)
assert.Equal(t, "1.2.3.4", intc.apiListenAddresses[0])
assert.Equal(t, 8080, intc.appConnectionConfig.Port)
assert.Equal(t, 7070, intc.profilePort)
assert.True(t, intc.enableProfiling)
assert.Equal(t, 1, intc.appConnectionConfig.MaxConcurrency)
assert.True(t, intc.mTLSEnabled)
assert.Equal(t, "localhost:5052", intc.sentryServiceAddress)
assert.Equal(t, 4<<20, intc.maxRequestBodySize)
assert.Equal(t, 4<<10, intc.readBufferSize)
assert.Equal(t, "", intc.unixDomainSocket)
assert.Equal(t, time.Second, intc.gracefulShutdownDuration)
assert.Equal(t, nilDuration, intc.blockShutdownDuration)
assert.Equal(t, ptr.Of(true), intc.enableAPILogging)
assert.True(t, intc.disableBuiltinK8sSecretStore)
assert.Equal(t, "1.1.1.1", intc.appConnectionConfig.ChannelAddress)
}
func TestStandaloneWasmStrictSandbox(t *testing.T) {
global, err := config.LoadStandaloneConfiguration("../config/testdata/wasm_strict_sandbox.yaml")
require.NoError(t, err)
assert.True(t, global.Spec.WasmSpec.StrictSandbox)
}
func defaultTestConfig() Config {
return Config{
AppID: "app1",
ActorsService: "localhost:5050",
ControlPlaneAddress: "localhost:5051",
AllowedOrigins: "*",
ResourcesPath: []string{"components"},
AppProtocol: "http",
Mode: "kubernetes",
DaprHTTPPort: "3500",
DaprInternalGRPCPort: "50002",
DaprAPIGRPCPort: "50001",
DaprAPIListenAddresses: "1.2.3.4",
DaprPublicPort: "3501",
ApplicationPort: "8080",
ProfilePort: "7070",
EnableProfiling: true,
AppMaxConcurrency: 1,
EnableMTLS: true,
SentryAddress: "localhost:5052",
MaxRequestSize: 4 << 20,
ReadBufferSize: 4 << 10,
UnixDomainSocket: "",
DaprGracefulShutdownSeconds: 1,
EnableAPILogging: ptr.Of(true),
DisableBuiltinK8sSecretStore: true,
AppChannelAddress: "1.1.1.1",
Registry: registry.NewOptions(),
Metrics: &metrics.Options{MetricsEnabled: false},
}
}
|
mikeee/dapr
|
pkg/runtime/config_test.go
|
GO
|
mit
| 3,846 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package errors
import (
"fmt"
)
type InitErrorKind string
const (
InitFailure InitErrorKind = "INIT_FAILURE"
InitComponentFailure InitErrorKind = "INIT_COMPONENT_FAILURE"
CreateComponentFailure InitErrorKind = "CREATE_COMPONENT_FAILURE"
)
type InitError struct {
err error
kind InitErrorKind
entity string
}
func (e *InitError) Error() string {
if e.entity == "" {
return fmt.Sprintf("[%s]: %s", e.kind, e.err)
}
return fmt.Sprintf("[%s]: initialization error occurred for %s: %s", e.kind, e.entity, e.err)
}
func (e *InitError) Unwrap() error {
return e.err
}
// NewInit returns an InitError wrapping an existing context error.
func NewInit(kind InitErrorKind, entity string, err error) *InitError {
return &InitError{
err: err,
kind: kind,
entity: entity,
}
}
|
mikeee/dapr
|
pkg/runtime/errors/init.go
|
GO
|
mit
| 1,375 |
/*
Copyright 2021 The Dapr Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package errors
import "testing"
func TestInitError(t *testing.T) {
var _ error = new(InitError)
}
|
mikeee/dapr
|
pkg/runtime/errors/init_test.go
|
GO
|
mit
| 662 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.