diff --git a/k8s/crd/bases/event.opensergo.io_events.yaml b/k8s/crd/bases/event.opensergo.io_events.yaml index 961a7d8..3dcc58f 100644 --- a/k8s/crd/bases/event.opensergo.io_events.yaml +++ b/k8s/crd/bases/event.opensergo.io_events.yaml @@ -44,15 +44,15 @@ spec: description: EventChannel Event pipeline corresponding message queue subject properties: - id: - type: string mqTopicName: type: string + uniqueID: + type: string url: type: string required: - - id - mqTopicName + - uniqueID - url type: object type: array @@ -113,8 +113,798 @@ spec: - sources - triggers type: object + routerRules: + description: EventRouterRules event routing rules include source trigger + filter + properties: + routerRules: + items: + description: EventRouter event router + properties: + channelID: + type: string + filter: + description: EventFilter filter before trigger + properties: + cesql: + description: CloudEvents SQL Expression is based on + cloudevents sql expression + type: string + type: object + sourceID: + type: string + triggerID: + type: string + required: + - channelID + - filter + - sourceID + - triggerID + type: object + type: array + required: + - routerRules + type: object + strategies: + description: EventStrategies strategy for event + properties: + defaultDeadLetterStrategy: + description: DeadLetterStrategy dead letter message strategy for + EventTrigger + properties: + enable: + type: bool + retryTriggerThreshold: + description: Threshold value of retry triggering dead letter + format: int64 + minimum: 1 + type: integer + storeEventChannel: + description: When enable_ Effective when block=true EventChannel + indicates the channel storing dead letter production or + consumption messages Persistence indicates use local or + remote storage If StoreEventChannel and StorePersistence + both have value, StoreEventChannel has higher priority. + properties: + mqTopicName: + type: string + uniqueID: + type: string + url: + type: string + required: + - mqTopicName + - uniqueID + - url + type: object + storePersistence: + description: Persistence detail of persistence + properties: + fullStrategy: + type: int + persistenceSize: + format: int64 + type: int64 + persistenceType: + type: int + required: + - fullStrategy + - persistenceSize + - persistenceType + type: object + required: + - enable + - retryTriggerThreshold + - storeEventChannel + - storePersistence + type: object + defaultSourceRuntimeStrategy: + description: EventRuntimeStrategy runtime strategy for event source + or trigger centralized setting FaultTolerance RateLimit CircuitBreaker + properties: + circuitBreakerStrategy: + description: CircuitBreakerStrategySpec defines the spec of + CircuitBreakerStrategy. + properties: + errorConditions: + type: object + minRequestAmount: + format: int32 + minimum: 1 + type: integer + recoveryTimeout: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + slowConditions: + properties: + maxAllowedRt: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + required: + - maxAllowedRt + type: object + statDuration: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + strategy: + enum: + - SlowRequestRatio + - ErrorRequestRatio + type: string + triggerRatio: + pattern: ^([1-9]\d?|100|0)%$ + type: string + required: + - minRequestAmount + - recoveryTimeout + - statDuration + - strategy + - triggerRatio + type: object + concurrencyLimitStrategy: + description: ConcurrencyLimitStrategySpec defines the spec + of ConcurrencyLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + maxConcurrency: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - maxConcurrency + type: object + faultToleranceRule: + description: FaultToleranceRuleSpec defines the spec of FaultToleranceRule. + properties: + strategies: + items: + properties: + kind: + enum: + - RateLimitStrategy + - ConcurrencyLimitStrategy + minLength: 1 + type: string + name: + minLength: 1 + type: string + required: + - kind + - name + type: object + type: array + targets: + items: + properties: + targetResourceName: + maxLength: 1024 + minLength: 1 + type: string + required: + - targetResourceName + type: object + type: array + required: + - strategies + - targets + type: object + rateLimitStrategy: + description: RateLimitStrategySpec defines the spec of RateLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + metricType: + enum: + - RequestAmount + type: string + statDurationSeconds: + format: int32 + minimum: 1 + type: integer + threshold: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - metricType + - statDurationSeconds + - threshold + type: object + retryRule: + description: RetryRule rule of retry + properties: + backOffDelay: + description: The delay between retries uses the string + of the time period specified in the ISO-8601 rule for + example, P6S represents the duration of 6s + type: string + backOffPolicyType: + type: int + retryMax: + format: int64 + minimum: 1 + type: integer + required: + - backOffDelay + - backOffPolicyType + - retryMax + type: object + required: + - circuitBreakerStrategy + - concurrencyLimitStrategy + - faultToleranceRule + - rateLimitStrategy + - retryRule + type: object + defaultTriggerRuntimeStrategy: + description: EventRuntimeStrategy runtime strategy for event source + or trigger centralized setting FaultTolerance RateLimit CircuitBreaker + properties: + circuitBreakerStrategy: + description: CircuitBreakerStrategySpec defines the spec of + CircuitBreakerStrategy. + properties: + errorConditions: + type: object + minRequestAmount: + format: int32 + minimum: 1 + type: integer + recoveryTimeout: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + slowConditions: + properties: + maxAllowedRt: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + required: + - maxAllowedRt + type: object + statDuration: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + strategy: + enum: + - SlowRequestRatio + - ErrorRequestRatio + type: string + triggerRatio: + pattern: ^([1-9]\d?|100|0)%$ + type: string + required: + - minRequestAmount + - recoveryTimeout + - statDuration + - strategy + - triggerRatio + type: object + concurrencyLimitStrategy: + description: ConcurrencyLimitStrategySpec defines the spec + of ConcurrencyLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + maxConcurrency: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - maxConcurrency + type: object + faultToleranceRule: + description: FaultToleranceRuleSpec defines the spec of FaultToleranceRule. + properties: + strategies: + items: + properties: + kind: + enum: + - RateLimitStrategy + - ConcurrencyLimitStrategy + minLength: 1 + type: string + name: + minLength: 1 + type: string + required: + - kind + - name + type: object + type: array + targets: + items: + properties: + targetResourceName: + maxLength: 1024 + minLength: 1 + type: string + required: + - targetResourceName + type: object + type: array + required: + - strategies + - targets + type: object + rateLimitStrategy: + description: RateLimitStrategySpec defines the spec of RateLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + metricType: + enum: + - RequestAmount + type: string + statDurationSeconds: + format: int32 + minimum: 1 + type: integer + threshold: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - metricType + - statDurationSeconds + - threshold + type: object + retryRule: + description: RetryRule rule of retry + properties: + backOffDelay: + description: The delay between retries uses the string + of the time period specified in the ISO-8601 rule for + example, P6S represents the duration of 6s + type: string + backOffPolicyType: + type: int + retryMax: + format: int64 + minimum: 1 + type: integer + required: + - backOffDelay + - backOffPolicyType + - retryMax + type: object + required: + - circuitBreakerStrategy + - concurrencyLimitStrategy + - faultToleranceRule + - rateLimitStrategy + - retryRule + type: object + sourceStrategies: + items: + description: EventSourceStrategy strategy for event source producer + properties: + asyncSend: + type: bool + eventSourceID: + type: string + faultTolerantStorage: + description: Persistence detail of persistence + properties: + fullStrategy: + type: int + persistenceSize: + format: int64 + type: int64 + persistenceType: + type: int + required: + - fullStrategy + - persistenceSize + - persistenceType + type: object + runtimeStrategy: + description: EventRuntimeStrategy runtime strategy for event + source or trigger centralized setting FaultTolerance RateLimit + CircuitBreaker + properties: + circuitBreakerStrategy: + description: CircuitBreakerStrategySpec defines the + spec of CircuitBreakerStrategy. + properties: + errorConditions: + type: object + minRequestAmount: + format: int32 + minimum: 1 + type: integer + recoveryTimeout: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + slowConditions: + properties: + maxAllowedRt: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + required: + - maxAllowedRt + type: object + statDuration: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + strategy: + enum: + - SlowRequestRatio + - ErrorRequestRatio + type: string + triggerRatio: + pattern: ^([1-9]\d?|100|0)%$ + type: string + required: + - minRequestAmount + - recoveryTimeout + - statDuration + - strategy + - triggerRatio + type: object + concurrencyLimitStrategy: + description: ConcurrencyLimitStrategySpec defines the + spec of ConcurrencyLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + maxConcurrency: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - maxConcurrency + type: object + faultToleranceRule: + description: FaultToleranceRuleSpec defines the spec + of FaultToleranceRule. + properties: + strategies: + items: + properties: + kind: + enum: + - RateLimitStrategy + - ConcurrencyLimitStrategy + minLength: 1 + type: string + name: + minLength: 1 + type: string + required: + - kind + - name + type: object + type: array + targets: + items: + properties: + targetResourceName: + maxLength: 1024 + minLength: 1 + type: string + required: + - targetResourceName + type: object + type: array + required: + - strategies + - targets + type: object + rateLimitStrategy: + description: RateLimitStrategySpec defines the spec + of RateLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + metricType: + enum: + - RequestAmount + type: string + statDurationSeconds: + format: int32 + minimum: 1 + type: integer + threshold: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - metricType + - statDurationSeconds + - threshold + type: object + retryRule: + description: RetryRule rule of retry + properties: + backOffDelay: + description: The delay between retries uses the + string of the time period specified in the ISO-8601 + rule for example, P6S represents the duration + of 6s + type: string + backOffPolicyType: + type: int + retryMax: + format: int64 + minimum: 1 + type: integer + required: + - backOffDelay + - backOffPolicyType + - retryMax + type: object + required: + - circuitBreakerStrategy + - concurrencyLimitStrategy + - faultToleranceRule + - rateLimitStrategy + - retryRule + type: object + required: + - eventSourceID + - faultTolerantStorage + - runtimeStrategy + type: object + type: array + triggerStrategies: + items: + description: EventTriggerStrategy strategy for event trigger + or consumer + properties: + deadLetterStrategy: + description: DeadLetterStrategy dead letter message strategy + for EventTrigger + properties: + enable: + type: bool + retryTriggerThreshold: + description: Threshold value of retry triggering dead + letter + format: int64 + minimum: 1 + type: integer + storeEventChannel: + description: When enable_ Effective when block=true + EventChannel indicates the channel storing dead letter + production or consumption messages Persistence indicates + use local or remote storage If StoreEventChannel and + StorePersistence both have value, StoreEventChannel + has higher priority. + properties: + mqTopicName: + type: string + uniqueID: + type: string + url: + type: string + required: + - mqTopicName + - uniqueID + - url + type: object + storePersistence: + description: Persistence detail of persistence + properties: + fullStrategy: + type: int + persistenceSize: + format: int64 + type: int64 + persistenceType: + type: int + required: + - fullStrategy + - persistenceSize + - persistenceType + type: object + required: + - enable + - retryTriggerThreshold + - storeEventChannel + - storePersistence + type: object + enableIdempotence: + type: bool + eventTriggerID: + type: string + receiveBufferSize: + format: int64 + type: int64 + runtimeStrategy: + description: EventRuntimeStrategy runtime strategy for event + source or trigger centralized setting FaultTolerance RateLimit + CircuitBreaker + properties: + circuitBreakerStrategy: + description: CircuitBreakerStrategySpec defines the + spec of CircuitBreakerStrategy. + properties: + errorConditions: + type: object + minRequestAmount: + format: int32 + minimum: 1 + type: integer + recoveryTimeout: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + slowConditions: + properties: + maxAllowedRt: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + required: + - maxAllowedRt + type: object + statDuration: + pattern: ^[1-9]\d*(s|ms|m|min|minute|h|d)$ + type: string + strategy: + enum: + - SlowRequestRatio + - ErrorRequestRatio + type: string + triggerRatio: + pattern: ^([1-9]\d?|100|0)%$ + type: string + required: + - minRequestAmount + - recoveryTimeout + - statDuration + - strategy + - triggerRatio + type: object + concurrencyLimitStrategy: + description: ConcurrencyLimitStrategySpec defines the + spec of ConcurrencyLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + maxConcurrency: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - maxConcurrency + type: object + faultToleranceRule: + description: FaultToleranceRuleSpec defines the spec + of FaultToleranceRule. + properties: + strategies: + items: + properties: + kind: + enum: + - RateLimitStrategy + - ConcurrencyLimitStrategy + minLength: 1 + type: string + name: + minLength: 1 + type: string + required: + - kind + - name + type: object + type: array + targets: + items: + properties: + targetResourceName: + maxLength: 1024 + minLength: 1 + type: string + required: + - targetResourceName + type: object + type: array + required: + - strategies + - targets + type: object + rateLimitStrategy: + description: RateLimitStrategySpec defines the spec + of RateLimitStrategy. + properties: + limitMode: + enum: + - Local + - Global + type: string + metricType: + enum: + - RequestAmount + type: string + statDurationSeconds: + format: int32 + minimum: 1 + type: integer + threshold: + format: int64 + minimum: 0 + type: integer + required: + - limitMode + - metricType + - statDurationSeconds + - threshold + type: object + retryRule: + description: RetryRule rule of retry + properties: + backOffDelay: + description: The delay between retries uses the + string of the time period specified in the ISO-8601 + rule for example, P6S represents the duration + of 6s + type: string + backOffPolicyType: + type: int + retryMax: + format: int64 + minimum: 1 + type: integer + required: + - backOffDelay + - backOffPolicyType + - retryMax + type: object + required: + - circuitBreakerStrategy + - concurrencyLimitStrategy + - faultToleranceRule + - rateLimitStrategy + - retryRule + type: object + required: + - deadLetterStrategy + - eventTriggerID + - receiveBufferSize + - runtimeStrategy + type: object + type: array + required: + - defaultDeadLetterStrategy + - defaultSourceRuntimeStrategy + - defaultTriggerRuntimeStrategy + - sourceStrategies + - triggerStrategies + type: object required: - components + - routerRules + - strategies type: object status: description: EventStatus defines the observed state of Event diff --git a/pkg/api/v1alpha1/event/event.go b/pkg/api/v1alpha1/event/event.go index 89408ff..ea04617 100644 --- a/pkg/api/v1alpha1/event/event.go +++ b/pkg/api/v1alpha1/event/event.go @@ -23,7 +23,7 @@ const ( type EventChannel struct { // +kubebuilder:validation:Type=string // +kubebuilder:validation:Required - ID string `json:"id"` + UniqueID string `json:"uniqueID"` // +kubebuilder:validation:Type=string // +kubebuilder:validation:Required diff --git a/pkg/api/v1alpha1/event/event_types.go b/pkg/api/v1alpha1/event/event_types.go index be42b4b..b6b6144 100644 --- a/pkg/api/v1alpha1/event/event_types.go +++ b/pkg/api/v1alpha1/event/event_types.go @@ -29,9 +29,9 @@ type EventSpec struct { // INSERT ADDITIONAL SPEC FIELDS - desired state of cluster // Important: Run "make" to regenerate code after modifying this file - Components EventComponents `json:"components"` - // Strategies EventStrategies `json:"strategies"` - //RouterRules EventRouterRules `json:"routerRules"` + Components EventComponents `json:"components"` + Strategies EventStrategies `json:"strategies"` + RouterRules EventRouterRules `json:"routerRules"` } // EventStatus defines the observed state of Event diff --git a/pkg/api/v1alpha1/event/zz_generated.deepcopy.go b/pkg/api/v1alpha1/event/zz_generated.deepcopy.go index e09f746..b7f7219 100644 --- a/pkg/api/v1alpha1/event/zz_generated.deepcopy.go +++ b/pkg/api/v1alpha1/event/zz_generated.deepcopy.go @@ -269,6 +269,8 @@ func (in *EventSourceStrategy) DeepCopy() *EventSourceStrategy { func (in *EventSpec) DeepCopyInto(out *EventSpec) { *out = *in in.Components.DeepCopyInto(&out.Components) + in.Strategies.DeepCopyInto(&out.Strategies) + in.RouterRules.DeepCopyInto(&out.RouterRules) } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EventSpec. diff --git a/pkg/proto/event/v1/event.pb.go b/pkg/proto/event/v1/event.pb.go new file mode 100644 index 0000000..5218f7c --- /dev/null +++ b/pkg/proto/event/v1/event.pb.go @@ -0,0 +1,1794 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.29.0 +// protoc v3.21.12 +// source: event/v1/event.proto + +package v1 + +import ( + v1 "github.com/opensergo/opensergo-control-plane/pkg/proto/fault_tolerance/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) +) + +type Persistence_PersistenceType int32 + +const ( + Persistence_MEMORY Persistence_PersistenceType = 0 // 内存 + Persistence_LFS Persistence_PersistenceType = 1 // 本地文件系统 + Persistence_DFS Persistence_PersistenceType = 2 // 分布式文件系统 +) + +// Enum value maps for Persistence_PersistenceType. +var ( + Persistence_PersistenceType_name = map[int32]string{ + 0: "MEMORY", + 1: "LFS", + 2: "DFS", + } + Persistence_PersistenceType_value = map[string]int32{ + "MEMORY": 0, + "LFS": 1, + "DFS": 2, + } +) + +func (x Persistence_PersistenceType) Enum() *Persistence_PersistenceType { + p := new(Persistence_PersistenceType) + *p = x + return p +} + +func (x Persistence_PersistenceType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Persistence_PersistenceType) Descriptor() protoreflect.EnumDescriptor { + return file_event_v1_event_proto_enumTypes[0].Descriptor() +} + +func (Persistence_PersistenceType) Type() protoreflect.EnumType { + return &file_event_v1_event_proto_enumTypes[0] +} + +func (x Persistence_PersistenceType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Persistence_PersistenceType.Descriptor instead. +func (Persistence_PersistenceType) EnumDescriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{5, 0} +} + +type Persistence_FullStrategy int32 + +const ( + Persistence_BLOCK Persistence_FullStrategy = 0 // 阻塞 + Persistence_DROP Persistence_FullStrategy = 1 // 丢弃 +) + +// Enum value maps for Persistence_FullStrategy. +var ( + Persistence_FullStrategy_name = map[int32]string{ + 0: "BLOCK", + 1: "DROP", + } + Persistence_FullStrategy_value = map[string]int32{ + "BLOCK": 0, + "DROP": 1, + } +) + +func (x Persistence_FullStrategy) Enum() *Persistence_FullStrategy { + p := new(Persistence_FullStrategy) + *p = x + return p +} + +func (x Persistence_FullStrategy) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Persistence_FullStrategy) Descriptor() protoreflect.EnumDescriptor { + return file_event_v1_event_proto_enumTypes[1].Descriptor() +} + +func (Persistence_FullStrategy) Type() protoreflect.EnumType { + return &file_event_v1_event_proto_enumTypes[1] +} + +func (x Persistence_FullStrategy) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Persistence_FullStrategy.Descriptor instead. +func (Persistence_FullStrategy) EnumDescriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{5, 1} +} + +// back off 类型 +type RetryRule_BackoffPolicyType int32 + +const ( + RetryRule_BACK_OFF_POLICY_LINEAR RetryRule_BackoffPolicyType = 0 // 线性级增长策略 + RetryRule_BACK_OFF_POLICY_EXPONENTIAL RetryRule_BackoffPolicyType = 1 // 指数级增长策略 默认以2为底数 +) + +// Enum value maps for RetryRule_BackoffPolicyType. +var ( + RetryRule_BackoffPolicyType_name = map[int32]string{ + 0: "BACK_OFF_POLICY_LINEAR", + 1: "BACK_OFF_POLICY_EXPONENTIAL", + } + RetryRule_BackoffPolicyType_value = map[string]int32{ + "BACK_OFF_POLICY_LINEAR": 0, + "BACK_OFF_POLICY_EXPONENTIAL": 1, + } +) + +func (x RetryRule_BackoffPolicyType) Enum() *RetryRule_BackoffPolicyType { + p := new(RetryRule_BackoffPolicyType) + *p = x + return p +} + +func (x RetryRule_BackoffPolicyType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (RetryRule_BackoffPolicyType) Descriptor() protoreflect.EnumDescriptor { + return file_event_v1_event_proto_enumTypes[2].Descriptor() +} + +func (RetryRule_BackoffPolicyType) Type() protoreflect.EnumType { + return &file_event_v1_event_proto_enumTypes[2] +} + +func (x RetryRule_BackoffPolicyType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use RetryRule_BackoffPolicyType.Descriptor instead. +func (RetryRule_BackoffPolicyType) EnumDescriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{6, 0} +} + +// 事件管道 对应消息队列主题 +type EventChannel struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UniqueId string `protobuf:"bytes,1,opt,name=unique_id,json=uniqueId,proto3" json:"unique_id,omitempty"` // 全局唯一id + Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"` // 消息队列连接地址 + MqTopicName string `protobuf:"bytes,3,opt,name=mq_topic_name,json=mqTopicName,proto3" json:"mq_topic_name,omitempty"` // channel对应的消息队列主题 +} + +func (x *EventChannel) Reset() { + *x = EventChannel{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventChannel) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventChannel) ProtoMessage() {} + +func (x *EventChannel) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventChannel.ProtoReflect.Descriptor instead. +func (*EventChannel) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{0} +} + +func (x *EventChannel) GetUniqueId() string { + if x != nil { + return x.UniqueId + } + return "" +} + +func (x *EventChannel) GetUrl() string { + if x != nil { + return x.Url + } + return "" +} + +func (x *EventChannel) GetMqTopicName() string { + if x != nil { + return x.MqTopicName + } + return "" +} + +// 处理器对象 +type EventProcessorRef struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UniqueId string `protobuf:"bytes,1,opt,name=unique_id,json=uniqueId,proto3" json:"unique_id,omitempty"` // 全局唯一id + Kind string `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind,omitempty"` // 处理器类型 比如 Service 表示服务 + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` // 处理器名称 比如 events-demo 表示服务名叫的 events-demo 的服务 +} + +func (x *EventProcessorRef) Reset() { + *x = EventProcessorRef{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventProcessorRef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventProcessorRef) ProtoMessage() {} + +func (x *EventProcessorRef) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventProcessorRef.ProtoReflect.Descriptor instead. +func (*EventProcessorRef) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{1} +} + +func (x *EventProcessorRef) GetUniqueId() string { + if x != nil { + return x.UniqueId + } + return "" +} + +func (x *EventProcessorRef) GetKind() string { + if x != nil { + return x.Kind + } + return "" +} + +func (x *EventProcessorRef) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// 事件源 生产者 +type EventSource struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ref *EventProcessorRef `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"` +} + +func (x *EventSource) Reset() { + *x = EventSource{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventSource) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventSource) ProtoMessage() {} + +func (x *EventSource) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventSource.ProtoReflect.Descriptor instead. +func (*EventSource) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{2} +} + +func (x *EventSource) GetRef() *EventProcessorRef { + if x != nil { + return x.Ref + } + return nil +} + +// 事件触发器 消费者 +type EventTrigger struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ref *EventProcessorRef `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"` +} + +func (x *EventTrigger) Reset() { + *x = EventTrigger{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventTrigger) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventTrigger) ProtoMessage() {} + +func (x *EventTrigger) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventTrigger.ProtoReflect.Descriptor instead. +func (*EventTrigger) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{3} +} + +func (x *EventTrigger) GetRef() *EventProcessorRef { + if x != nil { + return x.Ref + } + return nil +} + +// 事件组件 +type EventComponents struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Channels []*EventChannel `protobuf:"bytes,1,rep,name=channels,proto3" json:"channels,omitempty"` + Sources []*EventSource `protobuf:"bytes,2,rep,name=sources,proto3" json:"sources,omitempty"` + Triggers []*EventTrigger `protobuf:"bytes,3,rep,name=triggers,proto3" json:"triggers,omitempty"` +} + +func (x *EventComponents) Reset() { + *x = EventComponents{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventComponents) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventComponents) ProtoMessage() {} + +func (x *EventComponents) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventComponents.ProtoReflect.Descriptor instead. +func (*EventComponents) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{4} +} + +func (x *EventComponents) GetChannels() []*EventChannel { + if x != nil { + return x.Channels + } + return nil +} + +func (x *EventComponents) GetSources() []*EventSource { + if x != nil { + return x.Sources + } + return nil +} + +func (x *EventComponents) GetTriggers() []*EventTrigger { + if x != nil { + return x.Triggers + } + return nil +} + +// 持久化 +type Persistence struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PersistenceType Persistence_PersistenceType `protobuf:"varint,1,opt,name=persistence_type,json=persistenceType,proto3,enum=io.opensergo.proto.event.v1.Persistence_PersistenceType" json:"persistence_type,omitempty"` + PersistenceSize int64 `protobuf:"varint,2,opt,name=persistence_size,json=persistenceSize,proto3" json:"persistence_size,omitempty"` // 存储大小 + FullStrategy Persistence_FullStrategy `protobuf:"varint,3,opt,name=full_strategy,json=fullStrategy,proto3,enum=io.opensergo.proto.event.v1.Persistence_FullStrategy" json:"full_strategy,omitempty"` +} + +func (x *Persistence) Reset() { + *x = Persistence{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Persistence) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Persistence) ProtoMessage() {} + +func (x *Persistence) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 Persistence.ProtoReflect.Descriptor instead. +func (*Persistence) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{5} +} + +func (x *Persistence) GetPersistenceType() Persistence_PersistenceType { + if x != nil { + return x.PersistenceType + } + return Persistence_MEMORY +} + +func (x *Persistence) GetPersistenceSize() int64 { + if x != nil { + return x.PersistenceSize + } + return 0 +} + +func (x *Persistence) GetFullStrategy() Persistence_FullStrategy { + if x != nil { + return x.FullStrategy + } + return Persistence_BLOCK +} + +// 重试规则 +type RetryRule struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RetryMax int64 `protobuf:"varint,1,opt,name=retry_max,json=retryMax,proto3" json:"retry_max,omitempty"` + // 重试之间的延时 使用 ISO-8601 规则指定时间段的字符串 比如P6S 表示持续时间6s + BackOffDelay string `protobuf:"bytes,2,opt,name=back_off_delay,json=backOffDelay,proto3" json:"back_off_delay,omitempty"` + BackOffPolicyType RetryRule_BackoffPolicyType `protobuf:"varint,3,opt,name=back_off_policy_type,json=backOffPolicyType,proto3,enum=io.opensergo.proto.event.v1.RetryRule_BackoffPolicyType" json:"back_off_policy_type,omitempty"` +} + +func (x *RetryRule) Reset() { + *x = RetryRule{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RetryRule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetryRule) ProtoMessage() {} + +func (x *RetryRule) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 RetryRule.ProtoReflect.Descriptor instead. +func (*RetryRule) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{6} +} + +func (x *RetryRule) GetRetryMax() int64 { + if x != nil { + return x.RetryMax + } + return 0 +} + +func (x *RetryRule) GetBackOffDelay() string { + if x != nil { + return x.BackOffDelay + } + return "" +} + +func (x *RetryRule) GetBackOffPolicyType() RetryRule_BackoffPolicyType { + if x != nil { + return x.BackOffPolicyType + } + return RetryRule_BACK_OFF_POLICY_LINEAR +} + +// 死信消息规则 +type DeadLetterStrategy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Enable bool `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"` // 开启死信消息 + RetryTriggerThreshold int64 `protobuf:"varint,2,opt,name=retry_trigger_threshold,json=retryTriggerThreshold,proto3" json:"retry_trigger_threshold,omitempty"` // 重试触发死信的阈值 + // Types that are assignable to Store: + // + // *DeadLetterStrategy_Channel + // *DeadLetterStrategy_Persistence + Store isDeadLetterStrategy_Store `protobuf_oneof:"store"` +} + +func (x *DeadLetterStrategy) Reset() { + *x = DeadLetterStrategy{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeadLetterStrategy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeadLetterStrategy) ProtoMessage() {} + +func (x *DeadLetterStrategy) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 DeadLetterStrategy.ProtoReflect.Descriptor instead. +func (*DeadLetterStrategy) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{7} +} + +func (x *DeadLetterStrategy) GetEnable() bool { + if x != nil { + return x.Enable + } + return false +} + +func (x *DeadLetterStrategy) GetRetryTriggerThreshold() int64 { + if x != nil { + return x.RetryTriggerThreshold + } + return 0 +} + +func (m *DeadLetterStrategy) GetStore() isDeadLetterStrategy_Store { + if m != nil { + return m.Store + } + return nil +} + +func (x *DeadLetterStrategy) GetChannel() *EventChannel { + if x, ok := x.GetStore().(*DeadLetterStrategy_Channel); ok { + return x.Channel + } + return nil +} + +func (x *DeadLetterStrategy) GetPersistence() *Persistence { + if x, ok := x.GetStore().(*DeadLetterStrategy_Persistence); ok { + return x.Persistence + } + return nil +} + +type isDeadLetterStrategy_Store interface { + isDeadLetterStrategy_Store() +} + +type DeadLetterStrategy_Channel struct { + Channel *EventChannel `protobuf:"bytes,3,opt,name=channel,proto3,oneof"` // 表示存放死信生产或者消费消息的channel +} + +type DeadLetterStrategy_Persistence struct { + Persistence *Persistence `protobuf:"bytes,4,opt,name=persistence,proto3,oneof"` // 表示使用本地或者远程存储 +} + +func (*DeadLetterStrategy_Channel) isDeadLetterStrategy_Store() {} + +func (*DeadLetterStrategy_Persistence) isDeadLetterStrategy_Store() {} + +// 事件运行时策略 +// 集中设置 封装 容错 限流 断路器 +type EventRuntimeStrategy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FaultToleranceRule *v1.FaultToleranceRule `protobuf:"bytes,1,opt,name=fault_tolerance_rule,json=faultToleranceRule,proto3" json:"fault_tolerance_rule,omitempty"` + RateLimitStrategy *v1.RateLimitStrategy `protobuf:"bytes,2,opt,name=rate_limit_strategy,json=rateLimitStrategy,proto3" json:"rate_limit_strategy,omitempty"` + CircuitBreakerStrategy *v1.CircuitBreakerStrategy `protobuf:"bytes,3,opt,name=circuit_breaker_strategy,json=circuitBreakerStrategy,proto3" json:"circuit_breaker_strategy,omitempty"` + ConcurrencyLimitStrateg *v1.ConcurrencyLimitStrategy `protobuf:"bytes,4,opt,name=concurrency_limit_strateg,json=concurrencyLimitStrateg,proto3" json:"concurrency_limit_strateg,omitempty"` + RetryRule *RetryRule `protobuf:"bytes,5,opt,name=retry_rule,json=retryRule,proto3" json:"retry_rule,omitempty"` +} + +func (x *EventRuntimeStrategy) Reset() { + *x = EventRuntimeStrategy{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventRuntimeStrategy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventRuntimeStrategy) ProtoMessage() {} + +func (x *EventRuntimeStrategy) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventRuntimeStrategy.ProtoReflect.Descriptor instead. +func (*EventRuntimeStrategy) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{8} +} + +func (x *EventRuntimeStrategy) GetFaultToleranceRule() *v1.FaultToleranceRule { + if x != nil { + return x.FaultToleranceRule + } + return nil +} + +func (x *EventRuntimeStrategy) GetRateLimitStrategy() *v1.RateLimitStrategy { + if x != nil { + return x.RateLimitStrategy + } + return nil +} + +func (x *EventRuntimeStrategy) GetCircuitBreakerStrategy() *v1.CircuitBreakerStrategy { + if x != nil { + return x.CircuitBreakerStrategy + } + return nil +} + +func (x *EventRuntimeStrategy) GetConcurrencyLimitStrateg() *v1.ConcurrencyLimitStrategy { + if x != nil { + return x.ConcurrencyLimitStrateg + } + return nil +} + +func (x *EventRuntimeStrategy) GetRetryRule() *RetryRule { + if x != nil { + return x.RetryRule + } + return nil +} + +// 事件源 生产者的策略 +type EventSourceStrategy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EventSourceId string `protobuf:"bytes,1,opt,name=event_source_id,json=eventSourceId,proto3" json:"event_source_id,omitempty"` + AsyncSend bool `protobuf:"varint,2,opt,name=async_send,json=asyncSend,proto3" json:"async_send,omitempty"` // 是否开启异步发送 + FaultTolerantStorage *Persistence `protobuf:"bytes,3,opt,name=fault_tolerant_storage,json=faultTolerantStorage,proto3" json:"fault_tolerant_storage,omitempty"` // 容错存储设置 + RuntimeStrategy *EventRuntimeStrategy `protobuf:"bytes,4,opt,name=runtime_strategy,json=runtimeStrategy,proto3" json:"runtime_strategy,omitempty"` +} + +func (x *EventSourceStrategy) Reset() { + *x = EventSourceStrategy{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventSourceStrategy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventSourceStrategy) ProtoMessage() {} + +func (x *EventSourceStrategy) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventSourceStrategy.ProtoReflect.Descriptor instead. +func (*EventSourceStrategy) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{9} +} + +func (x *EventSourceStrategy) GetEventSourceId() string { + if x != nil { + return x.EventSourceId + } + return "" +} + +func (x *EventSourceStrategy) GetAsyncSend() bool { + if x != nil { + return x.AsyncSend + } + return false +} + +func (x *EventSourceStrategy) GetFaultTolerantStorage() *Persistence { + if x != nil { + return x.FaultTolerantStorage + } + return nil +} + +func (x *EventSourceStrategy) GetRuntimeStrategy() *EventRuntimeStrategy { + if x != nil { + return x.RuntimeStrategy + } + return nil +} + +// 事件触发器 消费者的策略 +type EventTriggerStrategy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EventTriggerId string `protobuf:"bytes,1,opt,name=event_trigger_id,json=eventTriggerId,proto3" json:"event_trigger_id,omitempty"` + ReceiveBufferSize int64 `protobuf:"varint,2,opt,name=receive_buffer_size,json=receiveBufferSize,proto3" json:"receive_buffer_size,omitempty"` // 消费者缓存大小 + EnableIdempotence bool `protobuf:"varint,3,opt,name=enable_idempotence,json=enableIdempotence,proto3" json:"enable_idempotence,omitempty"` // 是否开启幂等 + RuntimeStrategy *EventRuntimeStrategy `protobuf:"bytes,4,opt,name=runtime_strategy,json=runtimeStrategy,proto3" json:"runtime_strategy,omitempty"` + DeadLetterStrategy *DeadLetterStrategy `protobuf:"bytes,5,opt,name=dead_letter_strategy,json=deadLetterStrategy,proto3" json:"dead_letter_strategy,omitempty"` +} + +func (x *EventTriggerStrategy) Reset() { + *x = EventTriggerStrategy{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventTriggerStrategy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventTriggerStrategy) ProtoMessage() {} + +func (x *EventTriggerStrategy) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventTriggerStrategy.ProtoReflect.Descriptor instead. +func (*EventTriggerStrategy) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{10} +} + +func (x *EventTriggerStrategy) GetEventTriggerId() string { + if x != nil { + return x.EventTriggerId + } + return "" +} + +func (x *EventTriggerStrategy) GetReceiveBufferSize() int64 { + if x != nil { + return x.ReceiveBufferSize + } + return 0 +} + +func (x *EventTriggerStrategy) GetEnableIdempotence() bool { + if x != nil { + return x.EnableIdempotence + } + return false +} + +func (x *EventTriggerStrategy) GetRuntimeStrategy() *EventRuntimeStrategy { + if x != nil { + return x.RuntimeStrategy + } + return nil +} + +func (x *EventTriggerStrategy) GetDeadLetterStrategy() *DeadLetterStrategy { + if x != nil { + return x.DeadLetterStrategy + } + return nil +} + +// 事件的策略 +type EventStrategies struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SourceStrategies []*EventSourceStrategy `protobuf:"bytes,1,rep,name=source_strategies,json=sourceStrategies,proto3" json:"source_strategies,omitempty"` // 生产者策略 详细如上 + TriggerStrategies []*EventTriggerStrategy `protobuf:"bytes,2,rep,name=trigger_strategies,json=triggerStrategies,proto3" json:"trigger_strategies,omitempty"` // 消费者策略 详细如上 +} + +func (x *EventStrategies) Reset() { + *x = EventStrategies{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventStrategies) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventStrategies) ProtoMessage() {} + +func (x *EventStrategies) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventStrategies.ProtoReflect.Descriptor instead. +func (*EventStrategies) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{11} +} + +func (x *EventStrategies) GetSourceStrategies() []*EventSourceStrategy { + if x != nil { + return x.SourceStrategies + } + return nil +} + +func (x *EventStrategies) GetTriggerStrategies() []*EventTriggerStrategy { + if x != nil { + return x.TriggerStrategies + } + return nil +} + +// 事件路由规则 包括 source trigger filter +type EventRouterRules struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Routers []*EventRouterRules_Router `protobuf:"bytes,1,rep,name=routers,proto3" json:"routers,omitempty"` +} + +func (x *EventRouterRules) Reset() { + *x = EventRouterRules{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventRouterRules) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventRouterRules) ProtoMessage() {} + +func (x *EventRouterRules) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventRouterRules.ProtoReflect.Descriptor instead. +func (*EventRouterRules) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{12} +} + +func (x *EventRouterRules) GetRouters() []*EventRouterRules_Router { + if x != nil { + return x.Routers + } + return nil +} + +// 事件规则 事件需遵循 CloudEvents 事件数据规范 +type Event struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Components *EventComponents `protobuf:"bytes,1,opt,name=components,proto3" json:"components,omitempty"` // 事件组件 + Strategy *EventStrategies `protobuf:"bytes,2,opt,name=strategy,proto3" json:"strategy,omitempty"` // 事件策略 + RouterRules *EventRouterRules `protobuf:"bytes,3,opt,name=router_rules,json=routerRules,proto3" json:"router_rules,omitempty"` // 事件路由规则 +} + +func (x *Event) Reset() { + *x = Event{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Event) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Event) ProtoMessage() {} + +func (x *Event) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 Event.ProtoReflect.Descriptor instead. +func (*Event) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{13} +} + +func (x *Event) GetComponents() *EventComponents { + if x != nil { + return x.Components + } + return nil +} + +func (x *Event) GetStrategy() *EventStrategies { + if x != nil { + return x.Strategy + } + return nil +} + +func (x *Event) GetRouterRules() *EventRouterRules { + if x != nil { + return x.RouterRules + } + return nil +} + +type Persistence_PersistenceAddress struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // 存储地址 根据PersistenceType确定值 + // 如 本地文件目录 /usr/local/data 远程文件系统地址 xxx.xxx.xxx.xxx + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (x *Persistence_PersistenceAddress) Reset() { + *x = Persistence_PersistenceAddress{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Persistence_PersistenceAddress) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Persistence_PersistenceAddress) ProtoMessage() {} + +func (x *Persistence_PersistenceAddress) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 Persistence_PersistenceAddress.ProtoReflect.Descriptor instead. +func (*Persistence_PersistenceAddress) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{5, 0} +} + +func (x *Persistence_PersistenceAddress) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +// 事件过滤器 +type EventRouterRules_Filter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Cesql string `protobuf:"bytes,1,opt,name=cesql,proto3" json:"cesql,omitempty"` // CloudEvents SQL Expression 基于 cloudevents sql表达式 +} + +func (x *EventRouterRules_Filter) Reset() { + *x = EventRouterRules_Filter{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventRouterRules_Filter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventRouterRules_Filter) ProtoMessage() {} + +func (x *EventRouterRules_Filter) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventRouterRules_Filter.ProtoReflect.Descriptor instead. +func (*EventRouterRules_Filter) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{12, 0} +} + +func (x *EventRouterRules_Filter) GetCesql() string { + if x != nil { + return x.Cesql + } + return "" +} + +// 事件路由 +type EventRouterRules_Router struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SourceId string `protobuf:"bytes,1,opt,name=source_id,json=sourceId,proto3" json:"source_id,omitempty"` + TriggerId string `protobuf:"bytes,2,opt,name=trigger_id,json=triggerId,proto3" json:"trigger_id,omitempty"` + ChannelId string `protobuf:"bytes,3,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` + Filter *EventRouterRules_Filter `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"` +} + +func (x *EventRouterRules_Router) Reset() { + *x = EventRouterRules_Router{} + if protoimpl.UnsafeEnabled { + mi := &file_event_v1_event_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EventRouterRules_Router) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventRouterRules_Router) ProtoMessage() {} + +func (x *EventRouterRules_Router) ProtoReflect() protoreflect.Message { + mi := &file_event_v1_event_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 EventRouterRules_Router.ProtoReflect.Descriptor instead. +func (*EventRouterRules_Router) Descriptor() ([]byte, []int) { + return file_event_v1_event_proto_rawDescGZIP(), []int{12, 1} +} + +func (x *EventRouterRules_Router) GetSourceId() string { + if x != nil { + return x.SourceId + } + return "" +} + +func (x *EventRouterRules_Router) GetTriggerId() string { + if x != nil { + return x.TriggerId + } + return "" +} + +func (x *EventRouterRules_Router) GetChannelId() string { + if x != nil { + return x.ChannelId + } + return "" +} + +func (x *EventRouterRules_Router) GetFilter() *EventRouterRules_Filter { + if x != nil { + return x.Filter + } + return nil +} + +var File_event_v1_event_proto protoreflect.FileDescriptor + +var file_event_v1_event_proto_rawDesc = []byte{ + 0x0a, 0x14, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, 0x76, 0x31, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1b, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, + 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x1a, 0x28, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, + 0x61, 0x6e, 0x63, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, + 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x61, 0x0a, + 0x0c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1b, 0x0a, + 0x09, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, + 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x22, 0x0a, 0x0d, + 0x6d, 0x71, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6d, 0x71, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x4e, 0x61, 0x6d, 0x65, + 0x22, 0x58, 0x0a, 0x11, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, + 0x6f, 0x72, 0x52, 0x65, 0x66, 0x12, 0x1b, 0x0a, 0x09, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, + 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x4f, 0x0a, 0x0b, 0x45, 0x76, + 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x40, 0x0a, 0x03, 0x72, 0x65, 0x66, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, + 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, + 0x73, 0x6f, 0x72, 0x52, 0x65, 0x66, 0x52, 0x03, 0x72, 0x65, 0x66, 0x22, 0x50, 0x0a, 0x0c, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x12, 0x40, 0x0a, 0x03, 0x72, + 0x65, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, + 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, 0x63, + 0x65, 0x73, 0x73, 0x6f, 0x72, 0x52, 0x65, 0x66, 0x52, 0x03, 0x72, 0x65, 0x66, 0x22, 0xe3, 0x01, + 0x0a, 0x0f, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, + 0x73, 0x12, 0x45, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, + 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, + 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x08, + 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x42, 0x0a, 0x07, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, + 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x52, 0x07, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x12, 0x45, 0x0a, 0x08, + 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, + 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x52, 0x08, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x73, 0x22, 0xff, 0x02, 0x0a, 0x0b, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, + 0x6e, 0x63, 0x65, 0x12, 0x63, 0x0a, 0x10, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, + 0x63, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, + 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, + 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, + 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, + 0x65, 0x6e, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x65, 0x72, 0x73, + 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0f, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x53, + 0x69, 0x7a, 0x65, 0x12, 0x5a, 0x0a, 0x0d, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x73, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x35, 0x2e, 0x69, 0x6f, 0x2e, + 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, + 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x52, 0x0c, 0x66, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x1a, + 0x2e, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, + 0x2f, 0x0a, 0x0f, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0x59, 0x10, 0x00, 0x12, 0x07, + 0x0a, 0x03, 0x4c, 0x46, 0x53, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x44, 0x46, 0x53, 0x10, 0x02, + 0x22, 0x23, 0x0a, 0x0c, 0x46, 0x75, 0x6c, 0x6c, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, + 0x12, 0x09, 0x0a, 0x05, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x44, + 0x52, 0x4f, 0x50, 0x10, 0x01, 0x22, 0x8b, 0x02, 0x0a, 0x09, 0x52, 0x65, 0x74, 0x72, 0x79, 0x52, + 0x75, 0x6c, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x6d, 0x61, 0x78, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x72, 0x65, 0x74, 0x72, 0x79, 0x4d, 0x61, 0x78, + 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x61, 0x63, 0x6b, 0x5f, 0x6f, 0x66, 0x66, 0x5f, 0x64, 0x65, 0x6c, + 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x62, 0x61, 0x63, 0x6b, 0x4f, 0x66, + 0x66, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x69, 0x0a, 0x14, 0x62, 0x61, 0x63, 0x6b, 0x5f, 0x6f, + 0x66, 0x66, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, + 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x52, 0x75, 0x6c, 0x65, 0x2e, 0x42, 0x61, 0x63, + 0x6b, 0x6f, 0x66, 0x66, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x54, 0x79, 0x70, 0x65, 0x52, 0x11, + 0x62, 0x61, 0x63, 0x6b, 0x4f, 0x66, 0x66, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x54, 0x79, 0x70, + 0x65, 0x22, 0x50, 0x0a, 0x11, 0x42, 0x61, 0x63, 0x6b, 0x6f, 0x66, 0x66, 0x50, 0x6f, 0x6c, 0x69, + 0x63, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x42, 0x41, 0x43, 0x4b, 0x5f, 0x4f, + 0x46, 0x46, 0x5f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x4c, 0x49, 0x4e, 0x45, 0x41, 0x52, + 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x1b, 0x42, 0x41, 0x43, 0x4b, 0x5f, 0x4f, 0x46, 0x46, 0x5f, 0x50, + 0x4f, 0x4c, 0x49, 0x43, 0x59, 0x5f, 0x45, 0x58, 0x50, 0x4f, 0x4e, 0x45, 0x4e, 0x54, 0x49, 0x41, + 0x4c, 0x10, 0x01, 0x22, 0x82, 0x02, 0x0a, 0x12, 0x44, 0x65, 0x61, 0x64, 0x4c, 0x65, 0x74, 0x74, + 0x65, 0x72, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, + 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x15, 0x72, 0x65, 0x74, 0x72, 0x79, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x45, 0x0a, 0x07, 0x63, 0x68, + 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x6f, + 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, + 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x48, 0x00, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, + 0x6c, 0x12, 0x4c, 0x0a, 0x0b, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, + 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, + 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, + 0x48, 0x00, 0x52, 0x0b, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x42, + 0x07, 0x0a, 0x05, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x22, 0xaa, 0x04, 0x0a, 0x14, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x12, 0x6b, 0x0a, 0x14, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, + 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x39, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, + 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x6f, 0x6c, + 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x12, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x68, + 0x0a, 0x13, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x69, 0x6f, + 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, + 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x53, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x11, 0x72, 0x61, 0x74, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x77, 0x0a, 0x18, 0x63, 0x69, 0x72, 0x63, + 0x75, 0x69, 0x74, 0x5f, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x69, 0x6f, 0x2e, + 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x2e, + 0x76, 0x31, 0x2e, 0x43, 0x69, 0x72, 0x63, 0x75, 0x69, 0x74, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x65, + 0x72, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x16, 0x63, 0x69, 0x72, 0x63, 0x75, + 0x69, 0x74, 0x42, 0x72, 0x65, 0x61, 0x6b, 0x65, 0x72, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x12, 0x7b, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, + 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, + 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, + 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, + 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x53, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x17, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x63, 0x79, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x12, 0x45, + 0x0a, 0x0a, 0x72, 0x65, 0x74, 0x72, 0x79, 0x5f, 0x72, 0x75, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, + 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x65, 0x74, 0x72, 0x79, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x09, 0x72, 0x65, 0x74, 0x72, + 0x79, 0x52, 0x75, 0x6c, 0x65, 0x22, 0x9a, 0x02, 0x0a, 0x13, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x26, 0x0a, + 0x0f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x73, + 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x73, 0x79, 0x6e, 0x63, + 0x53, 0x65, 0x6e, 0x64, 0x12, 0x5e, 0x0a, 0x16, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x74, 0x6f, + 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, + 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x52, 0x14, + 0x66, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x61, 0x6e, 0x74, 0x53, 0x74, 0x6f, + 0x72, 0x61, 0x67, 0x65, 0x12, 0x5c, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, + 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x52, 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x79, 0x22, 0xe0, 0x02, 0x0a, 0x14, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x65, + 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x13, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x5f, 0x62, 0x75, 0x66, 0x66, 0x65, 0x72, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x11, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x42, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x2d, 0x0a, 0x12, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, + 0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x11, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, + 0x65, 0x6e, 0x63, 0x65, 0x12, 0x5c, 0x0a, 0x10, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, + 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x52, 0x0f, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x79, 0x12, 0x61, 0x0a, 0x14, 0x64, 0x65, 0x61, 0x64, 0x5f, 0x6c, 0x65, 0x74, 0x74, 0x65, + 0x72, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2f, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x44, + 0x65, 0x61, 0x64, 0x4c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x79, 0x52, 0x12, 0x64, 0x65, 0x61, 0x64, 0x4c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x53, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x22, 0xd2, 0x01, 0x0a, 0x0f, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x12, 0x5d, 0x0a, 0x11, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, + 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x74, + 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x53, 0x74, + 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x12, 0x60, 0x0a, 0x12, 0x74, 0x72, 0x69, 0x67, + 0x67, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, + 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, + 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x52, 0x11, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, + 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x22, 0xb6, 0x02, 0x0a, 0x10, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, + 0x4e, 0x0a, 0x07, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x34, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x2e, + 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x52, 0x07, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x73, 0x1a, + 0x1e, 0x0a, 0x06, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x65, 0x73, + 0x71, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x65, 0x73, 0x71, 0x6c, 0x1a, + 0xb1, 0x01, 0x0a, 0x06, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x72, 0x69, 0x67, 0x67, + 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x72, 0x69, + 0x67, 0x67, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, + 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x4c, 0x0a, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, + 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, + 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x52, + 0x75, 0x6c, 0x65, 0x73, 0x2e, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x06, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x22, 0xf1, 0x01, 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x4c, 0x0a, + 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2c, 0x2e, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, + 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x52, + 0x0a, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x48, 0x0a, 0x08, 0x73, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, + 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, + 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x65, 0x73, 0x52, 0x08, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x79, 0x12, 0x50, 0x0a, 0x0c, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, + 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x69, 0x6f, + 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x52, 0x0b, 0x72, 0x6f, 0x75, 0x74, + 0x65, 0x72, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x42, 0x68, 0x0a, 0x1b, 0x69, 0x6f, 0x2e, 0x6f, 0x70, + 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x65, 0x76, + 0x65, 0x6e, 0x74, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x72, 0x67, 0x6f, 0x2f, 0x6f, 0x70, 0x65, 0x6e, 0x73, + 0x65, 0x72, 0x67, 0x6f, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x2d, 0x70, 0x6c, 0x61, + 0x6e, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x2f, 0x76, + 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_event_v1_event_proto_rawDescOnce sync.Once + file_event_v1_event_proto_rawDescData = file_event_v1_event_proto_rawDesc +) + +func file_event_v1_event_proto_rawDescGZIP() []byte { + file_event_v1_event_proto_rawDescOnce.Do(func() { + file_event_v1_event_proto_rawDescData = protoimpl.X.CompressGZIP(file_event_v1_event_proto_rawDescData) + }) + return file_event_v1_event_proto_rawDescData +} + +var file_event_v1_event_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_event_v1_event_proto_msgTypes = make([]protoimpl.MessageInfo, 17) +var file_event_v1_event_proto_goTypes = []interface{}{ + (Persistence_PersistenceType)(0), // 0: io.opensergo.proto.event.v1.Persistence.PersistenceType + (Persistence_FullStrategy)(0), // 1: io.opensergo.proto.event.v1.Persistence.FullStrategy + (RetryRule_BackoffPolicyType)(0), // 2: io.opensergo.proto.event.v1.RetryRule.BackoffPolicyType + (*EventChannel)(nil), // 3: io.opensergo.proto.event.v1.EventChannel + (*EventProcessorRef)(nil), // 4: io.opensergo.proto.event.v1.EventProcessorRef + (*EventSource)(nil), // 5: io.opensergo.proto.event.v1.EventSource + (*EventTrigger)(nil), // 6: io.opensergo.proto.event.v1.EventTrigger + (*EventComponents)(nil), // 7: io.opensergo.proto.event.v1.EventComponents + (*Persistence)(nil), // 8: io.opensergo.proto.event.v1.Persistence + (*RetryRule)(nil), // 9: io.opensergo.proto.event.v1.RetryRule + (*DeadLetterStrategy)(nil), // 10: io.opensergo.proto.event.v1.DeadLetterStrategy + (*EventRuntimeStrategy)(nil), // 11: io.opensergo.proto.event.v1.EventRuntimeStrategy + (*EventSourceStrategy)(nil), // 12: io.opensergo.proto.event.v1.EventSourceStrategy + (*EventTriggerStrategy)(nil), // 13: io.opensergo.proto.event.v1.EventTriggerStrategy + (*EventStrategies)(nil), // 14: io.opensergo.proto.event.v1.EventStrategies + (*EventRouterRules)(nil), // 15: io.opensergo.proto.event.v1.EventRouterRules + (*Event)(nil), // 16: io.opensergo.proto.event.v1.Event + (*Persistence_PersistenceAddress)(nil), // 17: io.opensergo.proto.event.v1.Persistence.PersistenceAddress + (*EventRouterRules_Filter)(nil), // 18: io.opensergo.proto.event.v1.EventRouterRules.Filter + (*EventRouterRules_Router)(nil), // 19: io.opensergo.proto.event.v1.EventRouterRules.Router + (*v1.FaultToleranceRule)(nil), // 20: io.opensergo.proto.fault_tolerance.v1.FaultToleranceRule + (*v1.RateLimitStrategy)(nil), // 21: io.opensergo.proto.fault_tolerance.v1.RateLimitStrategy + (*v1.CircuitBreakerStrategy)(nil), // 22: io.opensergo.proto.fault_tolerance.v1.CircuitBreakerStrategy + (*v1.ConcurrencyLimitStrategy)(nil), // 23: io.opensergo.proto.fault_tolerance.v1.ConcurrencyLimitStrategy +} +var file_event_v1_event_proto_depIdxs = []int32{ + 4, // 0: io.opensergo.proto.event.v1.EventSource.ref:type_name -> io.opensergo.proto.event.v1.EventProcessorRef + 4, // 1: io.opensergo.proto.event.v1.EventTrigger.ref:type_name -> io.opensergo.proto.event.v1.EventProcessorRef + 3, // 2: io.opensergo.proto.event.v1.EventComponents.channels:type_name -> io.opensergo.proto.event.v1.EventChannel + 5, // 3: io.opensergo.proto.event.v1.EventComponents.sources:type_name -> io.opensergo.proto.event.v1.EventSource + 6, // 4: io.opensergo.proto.event.v1.EventComponents.triggers:type_name -> io.opensergo.proto.event.v1.EventTrigger + 0, // 5: io.opensergo.proto.event.v1.Persistence.persistence_type:type_name -> io.opensergo.proto.event.v1.Persistence.PersistenceType + 1, // 6: io.opensergo.proto.event.v1.Persistence.full_strategy:type_name -> io.opensergo.proto.event.v1.Persistence.FullStrategy + 2, // 7: io.opensergo.proto.event.v1.RetryRule.back_off_policy_type:type_name -> io.opensergo.proto.event.v1.RetryRule.BackoffPolicyType + 3, // 8: io.opensergo.proto.event.v1.DeadLetterStrategy.channel:type_name -> io.opensergo.proto.event.v1.EventChannel + 8, // 9: io.opensergo.proto.event.v1.DeadLetterStrategy.persistence:type_name -> io.opensergo.proto.event.v1.Persistence + 20, // 10: io.opensergo.proto.event.v1.EventRuntimeStrategy.fault_tolerance_rule:type_name -> io.opensergo.proto.fault_tolerance.v1.FaultToleranceRule + 21, // 11: io.opensergo.proto.event.v1.EventRuntimeStrategy.rate_limit_strategy:type_name -> io.opensergo.proto.fault_tolerance.v1.RateLimitStrategy + 22, // 12: io.opensergo.proto.event.v1.EventRuntimeStrategy.circuit_breaker_strategy:type_name -> io.opensergo.proto.fault_tolerance.v1.CircuitBreakerStrategy + 23, // 13: io.opensergo.proto.event.v1.EventRuntimeStrategy.concurrency_limit_strateg:type_name -> io.opensergo.proto.fault_tolerance.v1.ConcurrencyLimitStrategy + 9, // 14: io.opensergo.proto.event.v1.EventRuntimeStrategy.retry_rule:type_name -> io.opensergo.proto.event.v1.RetryRule + 8, // 15: io.opensergo.proto.event.v1.EventSourceStrategy.fault_tolerant_storage:type_name -> io.opensergo.proto.event.v1.Persistence + 11, // 16: io.opensergo.proto.event.v1.EventSourceStrategy.runtime_strategy:type_name -> io.opensergo.proto.event.v1.EventRuntimeStrategy + 11, // 17: io.opensergo.proto.event.v1.EventTriggerStrategy.runtime_strategy:type_name -> io.opensergo.proto.event.v1.EventRuntimeStrategy + 10, // 18: io.opensergo.proto.event.v1.EventTriggerStrategy.dead_letter_strategy:type_name -> io.opensergo.proto.event.v1.DeadLetterStrategy + 12, // 19: io.opensergo.proto.event.v1.EventStrategies.source_strategies:type_name -> io.opensergo.proto.event.v1.EventSourceStrategy + 13, // 20: io.opensergo.proto.event.v1.EventStrategies.trigger_strategies:type_name -> io.opensergo.proto.event.v1.EventTriggerStrategy + 19, // 21: io.opensergo.proto.event.v1.EventRouterRules.routers:type_name -> io.opensergo.proto.event.v1.EventRouterRules.Router + 7, // 22: io.opensergo.proto.event.v1.Event.components:type_name -> io.opensergo.proto.event.v1.EventComponents + 14, // 23: io.opensergo.proto.event.v1.Event.strategy:type_name -> io.opensergo.proto.event.v1.EventStrategies + 15, // 24: io.opensergo.proto.event.v1.Event.router_rules:type_name -> io.opensergo.proto.event.v1.EventRouterRules + 18, // 25: io.opensergo.proto.event.v1.EventRouterRules.Router.filter:type_name -> io.opensergo.proto.event.v1.EventRouterRules.Filter + 26, // [26:26] is the sub-list for method output_type + 26, // [26:26] is the sub-list for method input_type + 26, // [26:26] is the sub-list for extension type_name + 26, // [26:26] is the sub-list for extension extendee + 0, // [0:26] is the sub-list for field type_name +} + +func init() { file_event_v1_event_proto_init() } +func file_event_v1_event_proto_init() { + if File_event_v1_event_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_event_v1_event_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventChannel); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventProcessorRef); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventSource); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventTrigger); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventComponents); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Persistence); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetryRule); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeadLetterStrategy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventRuntimeStrategy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventSourceStrategy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventTriggerStrategy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventStrategies); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventRouterRules); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Event); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Persistence_PersistenceAddress); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventRouterRules_Filter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_event_v1_event_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EventRouterRules_Router); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_event_v1_event_proto_msgTypes[7].OneofWrappers = []interface{}{ + (*DeadLetterStrategy_Channel)(nil), + (*DeadLetterStrategy_Persistence)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_event_v1_event_proto_rawDesc, + NumEnums: 3, + NumMessages: 17, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_event_v1_event_proto_goTypes, + DependencyIndexes: file_event_v1_event_proto_depIdxs, + EnumInfos: file_event_v1_event_proto_enumTypes, + MessageInfos: file_event_v1_event_proto_msgTypes, + }.Build() + File_event_v1_event_proto = out.File + file_event_v1_event_proto_rawDesc = nil + file_event_v1_event_proto_goTypes = nil + file_event_v1_event_proto_depIdxs = nil +} diff --git a/pkg/proto/event/event.proto b/pkg/proto/event/v1/event.proto similarity index 92% rename from pkg/proto/event/event.proto rename to pkg/proto/event/v1/event.proto index 0bf8eca..145fc98 100644 --- a/pkg/proto/event/event.proto +++ b/pkg/proto/event/v1/event.proto @@ -11,15 +11,16 @@ import "fault_tolerance/v1/fault_tolerance.proto"; // 事件管道 对应消息队列主题 message EventChannel { - string id = 1; // 全局唯一id + string unique_id = 1; // 全局唯一id string url = 2; // 消息队列连接地址 string mq_topic_name = 3; // channel对应的消息队列主题 } // 处理器对象 message EventProcessorRef { - string kind = 1; // 处理器类型 比如 Service 表示服务 - string name = 2; // 处理器名称 比如 events-demo 表示服务名叫的 events-demo 的服务 + string unique_id = 1; // 全局唯一id + string kind = 2; // 处理器类型 比如 Service 表示服务 + string name = 3; // 处理器名称 比如 events-demo 表示服务名叫的 events-demo 的服务 } // 事件源 生产者 @@ -94,7 +95,7 @@ message EventRuntimeStrategy { io.opensergo.proto.fault_tolerance.v1.FaultToleranceRule fault_tolerance_rule = 1; io.opensergo.proto.fault_tolerance.v1.RateLimitStrategy rate_limit_strategy = 2; io.opensergo.proto.fault_tolerance.v1.CircuitBreakerStrategy circuit_breaker_strategy = 3; - io.opensergo.proto.fault_tolerance.v1.ConcurrencyLimitStrateg concurrency_limit_strateg = 4; + io.opensergo.proto.fault_tolerance.v1.ConcurrencyLimitStrategy concurrency_limit_strateg = 4; RetryRule retry_rule = 5; }