public/PandaX
1
0
Fork 0
mirror of https://gitee.com/XM-GO/PandaX.git synced 2026-05-13 07:02:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

【feat】添加http设备接入，优化iothub结构

Browse Source
This commit is contained in:
XM-GO
2023-09-25 18:14:42 +08:00
parent cdbbe85a70
commit 4c7bacad97
18 changed files with 462 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3455
iothub/server/emqxserver/protobuf/exhook.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

499
iothub/server/emqxserver/protobuf/exhook.proto Normal file
View File

@@ -0,0 +1,499 @@
//------------------------------------------------------------------------------
// Copyright (c) 2020-2022 EMQ Technologies Co., Ltd. All Rights Reserved.
//
// 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.
//------------------------------------------------------------------------------
syntax = "proto3";
option csharp_namespace = "Emqx.Exhook.V2";
option go_package = "emqx.io/grpc/exhook";
option java_multiple_files = true;
option java_package = "io.emqx.exhook";
option java_outer_classname = "EmqxExHookProto";
// The exhook proto version should be fixed as `v2` in EMQX v5.x
// to make sure the exhook proto version is compatible
package emqx.exhook.v2;
service HookProvider {
rpc OnProviderLoaded(ProviderLoadedRequest) returns (LoadedResponse) {};
rpc OnProviderUnloaded(ProviderUnloadedRequest) returns (EmptySuccess) {};
rpc OnClientConnect(ClientConnectRequest) returns (EmptySuccess) {};
rpc OnClientConnack(ClientConnackRequest) returns (EmptySuccess) {};
rpc OnClientConnected(ClientConnectedRequest) returns (EmptySuccess) {};
rpc OnClientDisconnected(ClientDisconnectedRequest) returns (EmptySuccess) {};
rpc OnClientAuthenticate(ClientAuthenticateRequest) returns (ValuedResponse) {};
rpc OnClientAuthorize(ClientAuthorizeRequest) returns (ValuedResponse) {};
rpc OnClientSubscribe(ClientSubscribeRequest) returns (EmptySuccess) {};
rpc OnClientUnsubscribe(ClientUnsubscribeRequest) returns (EmptySuccess) {};
rpc OnSessionCreated(SessionCreatedRequest) returns (EmptySuccess) {};
rpc OnSessionSubscribed(SessionSubscribedRequest) returns (EmptySuccess) {};
rpc OnSessionUnsubscribed(SessionUnsubscribedRequest) returns (EmptySuccess) {};
rpc OnSessionResumed(SessionResumedRequest) returns (EmptySuccess) {};
rpc OnSessionDiscarded(SessionDiscardedRequest) returns (EmptySuccess) {};
rpc OnSessionTakenover(SessionTakenoverRequest) returns (EmptySuccess) {};
rpc OnSessionTerminated(SessionTerminatedRequest) returns (EmptySuccess) {};
rpc OnMessagePublish(MessagePublishRequest) returns (ValuedResponse) {};
rpc OnMessageDelivered(MessageDeliveredRequest) returns (EmptySuccess) {};
rpc OnMessageDropped(MessageDroppedRequest) returns (EmptySuccess) {};
rpc OnMessageAcked(MessageAckedRequest) returns (EmptySuccess) {};
}
//------------------------------------------------------------------------------
// Request
//------------------------------------------------------------------------------
message ProviderLoadedRequest {
BrokerInfo broker = 1;
RequestMeta meta = 2;
}
message ProviderUnloadedRequest {
RequestMeta meta = 1;
}
message ClientConnectRequest {
ConnInfo conninfo = 1;
// MQTT CONNECT packet's properties (MQTT v5.0)
//
// It should be empty on MQTT v3.1.1/v3.1 or others protocol
repeated Property props = 2;
RequestMeta meta = 3;
}
message ClientConnackRequest {
ConnInfo conninfo = 1;
string result_code = 2;
repeated Property props = 3;
RequestMeta meta = 4;
}
message ClientConnectedRequest {
ClientInfo clientinfo = 1;
RequestMeta meta = 2;
}
message ClientDisconnectedRequest {
ClientInfo clientinfo = 1;
string reason = 2;
RequestMeta meta = 3;
}
message ClientAuthenticateRequest {
ClientInfo clientinfo = 1;
bool result = 2;
RequestMeta meta = 3;
}
message ClientAuthorizeRequest {
ClientInfo clientinfo = 1;
enum AuthorizeReqType {
PUBLISH = 0;
SUBSCRIBE = 1;
}
AuthorizeReqType type = 2;
string topic = 3;
bool result = 4;
RequestMeta meta = 5;
}
message ClientSubscribeRequest {
ClientInfo clientinfo = 1;
repeated Property props = 2;
repeated TopicFilter topic_filters = 3;
RequestMeta meta = 4;
}
message ClientUnsubscribeRequest {
ClientInfo clientinfo = 1;
repeated Property props = 2;
repeated TopicFilter topic_filters = 3;
RequestMeta meta = 4;
}
message SessionCreatedRequest {
ClientInfo clientinfo = 1;
RequestMeta meta = 2;
}
message SessionSubscribedRequest {
ClientInfo clientinfo = 1;
string topic = 2;
SubOpts subopts = 3;
RequestMeta meta = 4;
}
message SessionUnsubscribedRequest {
ClientInfo clientinfo = 1;
string topic = 2;
RequestMeta meta = 3;
}
message SessionResumedRequest {
ClientInfo clientinfo = 1;
RequestMeta meta = 2;
}
message SessionDiscardedRequest {
ClientInfo clientinfo = 1;
RequestMeta meta = 2;
}
message SessionTakenoverRequest {
ClientInfo clientinfo = 1;
RequestMeta meta = 2;
}
message SessionTerminatedRequest {
ClientInfo clientinfo = 1;
string reason = 2;
RequestMeta meta = 3;
}
message MessagePublishRequest {
Message message = 1;
RequestMeta meta = 2;
}
message MessageDeliveredRequest {
ClientInfo clientinfo = 1;
Message message = 2;
RequestMeta meta = 3;
}
message MessageDroppedRequest {
Message message = 1;
string reason = 2;
RequestMeta meta = 3;
}
message MessageAckedRequest {
ClientInfo clientinfo = 1;
Message message = 2;
RequestMeta meta = 3;
}
//------------------------------------------------------------------------------
// Response
//------------------------------------------------------------------------------
// Responsed by `ProviderLoadedRequest`
message LoadedResponse {
repeated HookSpec hooks = 1;
}
// Responsed by `ClientAuthenticateRequest` `ClientAuthorizeRequest` `MessagePublishRequest`
message ValuedResponse {
// The responded value type
// - contiune: Use the responded value and execute the next hook
// - ignore: Ignore the responded value
// - stop_and_return: Use the responded value and stop the chain executing
enum ResponsedType {
CONTINUE = 0;
IGNORE = 1;
STOP_AND_RETURN = 2;
}
ResponsedType type = 1;
oneof value {
// Boolean result, used on the 'client.authenticate', 'client.authorize' hooks
bool bool_result = 3;
// Message result, used on the 'message.*' hooks
Message message = 4;
}
}
// no Response by other Requests
message EmptySuccess { }
//------------------------------------------------------------------------------
// Basic data types
//------------------------------------------------------------------------------
message BrokerInfo {
string version = 1;
string sysdescr = 2;
int64 uptime = 3;
string datetime = 4;
}
message HookSpec {
// The registered hooks name
//
// Available value:
// "client.connect", "client.connack"
// "client.connected", "client.disconnected"
// "client.authenticate", "client.authorize"
// "client.subscribe", "client.unsubscribe"
//
// "session.created", "session.subscribed"
// "session.unsubscribed", "session.resumed"
// "session.discarded", "session.takenover"
// "session.terminated"
//
// "message.publish", "message.delivered"
// "message.acked", "message.dropped"
string name = 1;
// The topic filters for message hooks
repeated string topics = 2;
}
message ConnInfo {
string node = 1;
string clientid = 2;
string username = 3;
string peerhost = 4;
uint32 sockport = 5;
string proto_name = 6;
string proto_ver = 7;
uint32 keepalive = 8;
}
message ClientInfo {
string node = 1;
string clientid = 2;
string username = 3;
string password = 4;
string peerhost = 5;
uint32 sockport = 6;
string protocol = 7;
string mountpoint = 8;
bool is_superuser = 9;
bool anonymous = 10;
// common name of client TLS cert
string cn = 11;
// subject of client TLS cert
string dn = 12;
}
message Message {
string node = 1;
string id = 2;
uint32 qos = 3;
string from = 4;
string topic = 5;
bytes payload = 6;
uint64 timestamp = 7;
// The key of header can be:
// - username:
// * Readonly
// * The username of sender client
// * Value type: utf8 string
// - protocol:
// * Readonly
// * The protocol name of sender client
// * Value type: string enum with "mqtt", "mqtt-sn", ...
// - peerhost:
// * Readonly
// * The peerhost of sender client
// * Value type: ip address string
// - allow_publish:
// * Writable
// * Whether to allow the message to be published by emqx
// * Value type: string enum with "true", "false", default is "true"
//
// Notes: All header may be missing, which means that the message does not
// carry these headers. We can guarantee that clients coming from MQTT,
// MQTT-SN, CoAP, LwM2M and other natively supported protocol clients will
// carry these headers, but there is no guarantee that messages published
// by other means will do, e.g. messages published by HTTP-API
map<string, string> headers = 8;
}
message Property {
string name = 1;
string value = 2;
}
message TopicFilter {
string name = 1;
uint32 qos = 2;
}
message SubOpts {
// The QoS level
uint32 qos = 1;
// The group name for shared subscription
string share = 2;
// The Retain Handling option (MQTT v5.0)
//
// 0 = Send retained messages at the time of the subscribe
// 1 = Send retained messages at subscribe only if the subscription does
// not currently exist
// 2 = Do not send retained messages at the time of the subscribe
uint32 rh = 3;
// The Retain as Published option (MQTT v5.0)
//
// If 1, Application Messages forwarded using this subscription keep the
// RETAIN flag they were published with.
// If 0, Application Messages forwarded using this subscription have the
// RETAIN flag set to 0.
// Retained messages sent when the subscription is established have the RETAIN flag set to 1.
uint32 rap = 4;
// The No Local option (MQTT v5.0)
//
// If the value is 1, Application Messages MUST NOT be forwarded to a
// connection with a ClientID equal to the ClientID of the publishing
uint32 nl = 5;
}
message RequestMeta {
string node = 1;
string version = 2;
string sysdescr = 3;
string cluster_name = 4;
}

825
iothub/server/emqxserver/protobuf/exhook_grpc.pb.go Normal file
View File

@@ -0,0 +1,825 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc v3.18.1
// source: protobuf/exhook.proto
package exhook
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
// HookProviderClient is the client API for HookProvider 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 HookProviderClient interface {
OnProviderLoaded(ctx context.Context, in *ProviderLoadedRequest, opts ...grpc.CallOption) (*LoadedResponse, error)
OnProviderUnloaded(ctx context.Context, in *ProviderUnloadedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnClientConnect(ctx context.Context, in *ClientConnectRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnClientConnack(ctx context.Context, in *ClientConnackRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnClientConnected(ctx context.Context, in *ClientConnectedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnClientDisconnected(ctx context.Context, in *ClientDisconnectedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnClientAuthenticate(ctx context.Context, in *ClientAuthenticateRequest, opts ...grpc.CallOption) (*ValuedResponse, error)
OnClientAuthorize(ctx context.Context, in *ClientAuthorizeRequest, opts ...grpc.CallOption) (*ValuedResponse, error)
OnClientSubscribe(ctx context.Context, in *ClientSubscribeRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnClientUnsubscribe(ctx context.Context, in *ClientUnsubscribeRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionCreated(ctx context.Context, in *SessionCreatedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionSubscribed(ctx context.Context, in *SessionSubscribedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionUnsubscribed(ctx context.Context, in *SessionUnsubscribedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionResumed(ctx context.Context, in *SessionResumedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionDiscarded(ctx context.Context, in *SessionDiscardedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionTakenover(ctx context.Context, in *SessionTakenoverRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnSessionTerminated(ctx context.Context, in *SessionTerminatedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnMessagePublish(ctx context.Context, in *MessagePublishRequest, opts ...grpc.CallOption) (*ValuedResponse, error)
OnMessageDelivered(ctx context.Context, in *MessageDeliveredRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnMessageDropped(ctx context.Context, in *MessageDroppedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
OnMessageAcked(ctx context.Context, in *MessageAckedRequest, opts ...grpc.CallOption) (*EmptySuccess, error)
}
type hookProviderClient struct {
cc grpc.ClientConnInterface
}
func NewHookProviderClient(cc grpc.ClientConnInterface) HookProviderClient {
return &hookProviderClient{cc}
}
func (c *hookProviderClient) OnProviderLoaded(ctx context.Context, in *ProviderLoadedRequest, opts ...grpc.CallOption) (*LoadedResponse, error) {
out := new(LoadedResponse)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnProviderLoaded", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnProviderUnloaded(ctx context.Context, in *ProviderUnloadedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnProviderUnloaded", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientConnect(ctx context.Context, in *ClientConnectRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientConnect", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientConnack(ctx context.Context, in *ClientConnackRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientConnack", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientConnected(ctx context.Context, in *ClientConnectedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientConnected", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientDisconnected(ctx context.Context, in *ClientDisconnectedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientDisconnected", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientAuthenticate(ctx context.Context, in *ClientAuthenticateRequest, opts ...grpc.CallOption) (*ValuedResponse, error) {
out := new(ValuedResponse)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientAuthenticate", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientAuthorize(ctx context.Context, in *ClientAuthorizeRequest, opts ...grpc.CallOption) (*ValuedResponse, error) {
out := new(ValuedResponse)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientAuthorize", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientSubscribe(ctx context.Context, in *ClientSubscribeRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientSubscribe", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnClientUnsubscribe(ctx context.Context, in *ClientUnsubscribeRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnClientUnsubscribe", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionCreated(ctx context.Context, in *SessionCreatedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionCreated", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionSubscribed(ctx context.Context, in *SessionSubscribedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionSubscribed", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionUnsubscribed(ctx context.Context, in *SessionUnsubscribedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionUnsubscribed", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionResumed(ctx context.Context, in *SessionResumedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionResumed", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionDiscarded(ctx context.Context, in *SessionDiscardedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionDiscarded", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionTakenover(ctx context.Context, in *SessionTakenoverRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionTakenover", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnSessionTerminated(ctx context.Context, in *SessionTerminatedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnSessionTerminated", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnMessagePublish(ctx context.Context, in *MessagePublishRequest, opts ...grpc.CallOption) (*ValuedResponse, error) {
out := new(ValuedResponse)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnMessagePublish", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnMessageDelivered(ctx context.Context, in *MessageDeliveredRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnMessageDelivered", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnMessageDropped(ctx context.Context, in *MessageDroppedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnMessageDropped", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *hookProviderClient) OnMessageAcked(ctx context.Context, in *MessageAckedRequest, opts ...grpc.CallOption) (*EmptySuccess, error) {
out := new(EmptySuccess)
err := c.cc.Invoke(ctx, "/emqx.exhook.v2.HookProvider/OnMessageAcked", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// HookProviderServer is the server API for HookProvider service.
// All implementations must embed UnimplementedHookProviderServer
// for forward compatibility
type HookProviderServer interface {
OnProviderLoaded(context.Context, *ProviderLoadedRequest) (*LoadedResponse, error)
OnProviderUnloaded(context.Context, *ProviderUnloadedRequest) (*EmptySuccess, error)
OnClientConnect(context.Context, *ClientConnectRequest) (*EmptySuccess, error)
OnClientConnack(context.Context, *ClientConnackRequest) (*EmptySuccess, error)
OnClientConnected(context.Context, *ClientConnectedRequest) (*EmptySuccess, error)
OnClientDisconnected(context.Context, *ClientDisconnectedRequest) (*EmptySuccess, error)
OnClientAuthenticate(context.Context, *ClientAuthenticateRequest) (*ValuedResponse, error)
OnClientAuthorize(context.Context, *ClientAuthorizeRequest) (*ValuedResponse, error)
OnClientSubscribe(context.Context, *ClientSubscribeRequest) (*EmptySuccess, error)
OnClientUnsubscribe(context.Context, *ClientUnsubscribeRequest) (*EmptySuccess, error)
OnSessionCreated(context.Context, *SessionCreatedRequest) (*EmptySuccess, error)
OnSessionSubscribed(context.Context, *SessionSubscribedRequest) (*EmptySuccess, error)
OnSessionUnsubscribed(context.Context, *SessionUnsubscribedRequest) (*EmptySuccess, error)
OnSessionResumed(context.Context, *SessionResumedRequest) (*EmptySuccess, error)
OnSessionDiscarded(context.Context, *SessionDiscardedRequest) (*EmptySuccess, error)
OnSessionTakenover(context.Context, *SessionTakenoverRequest) (*EmptySuccess, error)
OnSessionTerminated(context.Context, *SessionTerminatedRequest) (*EmptySuccess, error)
OnMessagePublish(context.Context, *MessagePublishRequest) (*ValuedResponse, error)
OnMessageDelivered(context.Context, *MessageDeliveredRequest) (*EmptySuccess, error)
OnMessageDropped(context.Context, *MessageDroppedRequest) (*EmptySuccess, error)
OnMessageAcked(context.Context, *MessageAckedRequest) (*EmptySuccess, error)
mustEmbedUnimplementedHookProviderServer()
}
// UnimplementedHookProviderServer must be embedded to have forward compatible implementations.
type UnimplementedHookProviderServer struct {
}
func (UnimplementedHookProviderServer) OnProviderLoaded(context.Context, *ProviderLoadedRequest) (*LoadedResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnProviderLoaded not implemented")
}
func (UnimplementedHookProviderServer) OnProviderUnloaded(context.Context, *ProviderUnloadedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnProviderUnloaded not implemented")
}
func (UnimplementedHookProviderServer) OnClientConnect(context.Context, *ClientConnectRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientConnect not implemented")
}
func (UnimplementedHookProviderServer) OnClientConnack(context.Context, *ClientConnackRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientConnack not implemented")
}
func (UnimplementedHookProviderServer) OnClientConnected(context.Context, *ClientConnectedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientConnected not implemented")
}
func (UnimplementedHookProviderServer) OnClientDisconnected(context.Context, *ClientDisconnectedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientDisconnected not implemented")
}
func (UnimplementedHookProviderServer) OnClientAuthenticate(context.Context, *ClientAuthenticateRequest) (*ValuedResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientAuthenticate not implemented")
}
func (UnimplementedHookProviderServer) OnClientAuthorize(context.Context, *ClientAuthorizeRequest) (*ValuedResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientAuthorize not implemented")
}
func (UnimplementedHookProviderServer) OnClientSubscribe(context.Context, *ClientSubscribeRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientSubscribe not implemented")
}
func (UnimplementedHookProviderServer) OnClientUnsubscribe(context.Context, *ClientUnsubscribeRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnClientUnsubscribe not implemented")
}
func (UnimplementedHookProviderServer) OnSessionCreated(context.Context, *SessionCreatedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionCreated not implemented")
}
func (UnimplementedHookProviderServer) OnSessionSubscribed(context.Context, *SessionSubscribedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionSubscribed not implemented")
}
func (UnimplementedHookProviderServer) OnSessionUnsubscribed(context.Context, *SessionUnsubscribedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionUnsubscribed not implemented")
}
func (UnimplementedHookProviderServer) OnSessionResumed(context.Context, *SessionResumedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionResumed not implemented")
}
func (UnimplementedHookProviderServer) OnSessionDiscarded(context.Context, *SessionDiscardedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionDiscarded not implemented")
}
func (UnimplementedHookProviderServer) OnSessionTakenover(context.Context, *SessionTakenoverRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionTakenover not implemented")
}
func (UnimplementedHookProviderServer) OnSessionTerminated(context.Context, *SessionTerminatedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnSessionTerminated not implemented")
}
func (UnimplementedHookProviderServer) OnMessagePublish(context.Context, *MessagePublishRequest) (*ValuedResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnMessagePublish not implemented")
}
func (UnimplementedHookProviderServer) OnMessageDelivered(context.Context, *MessageDeliveredRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnMessageDelivered not implemented")
}
func (UnimplementedHookProviderServer) OnMessageDropped(context.Context, *MessageDroppedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnMessageDropped not implemented")
}
func (UnimplementedHookProviderServer) OnMessageAcked(context.Context, *MessageAckedRequest) (*EmptySuccess, error) {
return nil, status.Errorf(codes.Unimplemented, "method OnMessageAcked not implemented")
}
func (UnimplementedHookProviderServer) mustEmbedUnimplementedHookProviderServer() {}
// UnsafeHookProviderServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to HookProviderServer will
// result in compilation errors.
type UnsafeHookProviderServer interface {
mustEmbedUnimplementedHookProviderServer()
}
func RegisterHookProviderServer(s grpc.ServiceRegistrar, srv HookProviderServer) {
s.RegisterService(&HookProvider_ServiceDesc, srv)
}
func _HookProvider_OnProviderLoaded_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ProviderLoadedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnProviderLoaded(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnProviderLoaded",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnProviderLoaded(ctx, req.(*ProviderLoadedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnProviderUnloaded_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ProviderUnloadedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnProviderUnloaded(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnProviderUnloaded",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnProviderUnloaded(ctx, req.(*ProviderUnloadedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientConnect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientConnectRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientConnect(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientConnect",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientConnect(ctx, req.(*ClientConnectRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientConnack_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientConnackRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientConnack(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientConnack",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientConnack(ctx, req.(*ClientConnackRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientConnected_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientConnectedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientConnected(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientConnected",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientConnected(ctx, req.(*ClientConnectedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientDisconnected_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientDisconnectedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientDisconnected(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientDisconnected",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientDisconnected(ctx, req.(*ClientDisconnectedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientAuthenticate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientAuthenticateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientAuthenticate(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientAuthenticate",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientAuthenticate(ctx, req.(*ClientAuthenticateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientAuthorize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientAuthorizeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientAuthorize(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientAuthorize",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientAuthorize(ctx, req.(*ClientAuthorizeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientSubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientSubscribeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientSubscribe(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientSubscribe",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientSubscribe(ctx, req.(*ClientSubscribeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnClientUnsubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ClientUnsubscribeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnClientUnsubscribe(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnClientUnsubscribe",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnClientUnsubscribe(ctx, req.(*ClientUnsubscribeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionCreated_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionCreatedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionCreated(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionCreated",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionCreated(ctx, req.(*SessionCreatedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionSubscribed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionSubscribedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionSubscribed(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionSubscribed",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionSubscribed(ctx, req.(*SessionSubscribedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionUnsubscribed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionUnsubscribedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionUnsubscribed(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionUnsubscribed",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionUnsubscribed(ctx, req.(*SessionUnsubscribedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionResumed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionResumedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionResumed(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionResumed",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionResumed(ctx, req.(*SessionResumedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionDiscarded_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionDiscardedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionDiscarded(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionDiscarded",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionDiscarded(ctx, req.(*SessionDiscardedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionTakenover_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionTakenoverRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionTakenover(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionTakenover",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionTakenover(ctx, req.(*SessionTakenoverRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnSessionTerminated_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SessionTerminatedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnSessionTerminated(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnSessionTerminated",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnSessionTerminated(ctx, req.(*SessionTerminatedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnMessagePublish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MessagePublishRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnMessagePublish(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnMessagePublish",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnMessagePublish(ctx, req.(*MessagePublishRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnMessageDelivered_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MessageDeliveredRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnMessageDelivered(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnMessageDelivered",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnMessageDelivered(ctx, req.(*MessageDeliveredRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnMessageDropped_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MessageDroppedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnMessageDropped(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnMessageDropped",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnMessageDropped(ctx, req.(*MessageDroppedRequest))
}
return interceptor(ctx, in, info, handler)
}
func _HookProvider_OnMessageAcked_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MessageAckedRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HookProviderServer).OnMessageAcked(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/emqx.exhook.v2.HookProvider/OnMessageAcked",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HookProviderServer).OnMessageAcked(ctx, req.(*MessageAckedRequest))
}
return interceptor(ctx, in, info, handler)
}
// HookProvider_ServiceDesc is the grpc.ServiceDesc for HookProvider service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var HookProvider_ServiceDesc = grpc.ServiceDesc{
ServiceName: "emqx.exhook.v2.HookProvider",
HandlerType: (*HookProviderServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "OnProviderLoaded",
Handler: _HookProvider_OnProviderLoaded_Handler,
},
{
MethodName: "OnProviderUnloaded",
Handler: _HookProvider_OnProviderUnloaded_Handler,
},
{
MethodName: "OnClientConnect",
Handler: _HookProvider_OnClientConnect_Handler,
},
{
MethodName: "OnClientConnack",
Handler: _HookProvider_OnClientConnack_Handler,
},
{
MethodName: "OnClientConnected",
Handler: _HookProvider_OnClientConnected_Handler,
},
{
MethodName: "OnClientDisconnected",
Handler: _HookProvider_OnClientDisconnected_Handler,
},
{
MethodName: "OnClientAuthenticate",
Handler: _HookProvider_OnClientAuthenticate_Handler,
},
{
MethodName: "OnClientAuthorize",
Handler: _HookProvider_OnClientAuthorize_Handler,
},
{
MethodName: "OnClientSubscribe",
Handler: _HookProvider_OnClientSubscribe_Handler,
},
{
MethodName: "OnClientUnsubscribe",
Handler: _HookProvider_OnClientUnsubscribe_Handler,
},
{
MethodName: "OnSessionCreated",
Handler: _HookProvider_OnSessionCreated_Handler,
},
{
MethodName: "OnSessionSubscribed",
Handler: _HookProvider_OnSessionSubscribed_Handler,
},
{
MethodName: "OnSessionUnsubscribed",
Handler: _HookProvider_OnSessionUnsubscribed_Handler,
},
{
MethodName: "OnSessionResumed",
Handler: _HookProvider_OnSessionResumed_Handler,
},
{
MethodName: "OnSessionDiscarded",
Handler: _HookProvider_OnSessionDiscarded_Handler,
},
{
MethodName: "OnSessionTakenover",
Handler: _HookProvider_OnSessionTakenover_Handler,
},
{
MethodName: "OnSessionTerminated",
Handler: _HookProvider_OnSessionTerminated_Handler,
},
{
MethodName: "OnMessagePublish",
Handler: _HookProvider_OnMessagePublish_Handler,
},
{
MethodName: "OnMessageDelivered",
Handler: _HookProvider_OnMessageDelivered_Handler,
},
{
MethodName: "OnMessageDropped",
Handler: _HookProvider_OnMessageDropped_Handler,
},
{
MethodName: "OnMessageAcked",
Handler: _HookProvider_OnMessageAcked_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "protobuf/exhook.proto",
}