mbroker.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: mbroker.proto

package mbroker

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// Notification messages
type NotifyChannelOpened struct {
	// channel id set by client (or client broker when routing)
	Channel              int64    `protobuf:"varint,1,opt,name=channel,proto3" json:"channel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NotifyChannelOpened) Reset()         { *m = NotifyChannelOpened{} }
func (m *NotifyChannelOpened) String() string { return proto.CompactTextString(m) }
func (*NotifyChannelOpened) ProtoMessage()    {}
func (*NotifyChannelOpened) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{0}
}

func (m *NotifyChannelOpened) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NotifyChannelOpened.Unmarshal(m, b)
}
func (m *NotifyChannelOpened) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NotifyChannelOpened.Marshal(b, m, deterministic)
}
func (m *NotifyChannelOpened) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NotifyChannelOpened.Merge(m, src)
}
func (m *NotifyChannelOpened) XXX_Size() int {
	return xxx_messageInfo_NotifyChannelOpened.Size(m)
}
func (m *NotifyChannelOpened) XXX_DiscardUnknown() {
	xxx_messageInfo_NotifyChannelOpened.DiscardUnknown(m)
}

var xxx_messageInfo_NotifyChannelOpened proto.InternalMessageInfo

func (m *NotifyChannelOpened) GetChannel() int64 {
	if m != nil {
		return m.Channel
	}
	return 0
}

type NotifyChannelClosed struct {
	// channel id
	Channel              int64    `protobuf:"varint,1,opt,name=channel,proto3" json:"channel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NotifyChannelClosed) Reset()         { *m = NotifyChannelClosed{} }
func (m *NotifyChannelClosed) String() string { return proto.CompactTextString(m) }
func (*NotifyChannelClosed) ProtoMessage()    {}
func (*NotifyChannelClosed) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{1}
}

func (m *NotifyChannelClosed) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NotifyChannelClosed.Unmarshal(m, b)
}
func (m *NotifyChannelClosed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NotifyChannelClosed.Marshal(b, m, deterministic)
}
func (m *NotifyChannelClosed) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NotifyChannelClosed.Merge(m, src)
}
func (m *NotifyChannelClosed) XXX_Size() int {
	return xxx_messageInfo_NotifyChannelClosed.Size(m)
}
func (m *NotifyChannelClosed) XXX_DiscardUnknown() {
	xxx_messageInfo_NotifyChannelClosed.DiscardUnknown(m)
}

var xxx_messageInfo_NotifyChannelClosed proto.InternalMessageInfo

func (m *NotifyChannelClosed) GetChannel() int64 {
	if m != nil {
		return m.Channel
	}
	return 0
}

// Open designated channel to the service
type OpenChannel struct {
	// Service to consume
	Service string `protobuf:"bytes,1,opt,name=service,proto3" json:"service,omitempty"`
	// channel id set by client (or client broker when routing)
	Channel              int64    `protobuf:"varint,2,opt,name=channel,proto3" json:"channel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OpenChannel) Reset()         { *m = OpenChannel{} }
func (m *OpenChannel) String() string { return proto.CompactTextString(m) }
func (*OpenChannel) ProtoMessage()    {}
func (*OpenChannel) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{2}
}

func (m *OpenChannel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_OpenChannel.Unmarshal(m, b)
}
func (m *OpenChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_OpenChannel.Marshal(b, m, deterministic)
}
func (m *OpenChannel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OpenChannel.Merge(m, src)
}
func (m *OpenChannel) XXX_Size() int {
	return xxx_messageInfo_OpenChannel.Size(m)
}
func (m *OpenChannel) XXX_DiscardUnknown() {
	xxx_messageInfo_OpenChannel.DiscardUnknown(m)
}

var xxx_messageInfo_OpenChannel proto.InternalMessageInfo

func (m *OpenChannel) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

func (m *OpenChannel) GetChannel() int64 {
	if m != nil {
		return m.Channel
	}
	return 0
}

// Close specified channel
type CloseChannel struct {
	// channel id
	Channel              int64    `protobuf:"varint,1,opt,name=channel,proto3" json:"channel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CloseChannel) Reset()         { *m = CloseChannel{} }
func (m *CloseChannel) String() string { return proto.CompactTextString(m) }
func (*CloseChannel) ProtoMessage()    {}
func (*CloseChannel) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{3}
}

func (m *CloseChannel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CloseChannel.Unmarshal(m, b)
}
func (m *CloseChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CloseChannel.Marshal(b, m, deterministic)
}
func (m *CloseChannel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseChannel.Merge(m, src)
}
func (m *CloseChannel) XXX_Size() int {
	return xxx_messageInfo_CloseChannel.Size(m)
}
func (m *CloseChannel) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseChannel.DiscardUnknown(m)
}

var xxx_messageInfo_CloseChannel proto.InternalMessageInfo

func (m *CloseChannel) GetChannel() int64 {
	if m != nil {
		return m.Channel
	}
	return 0
}

// The message with raw data
type Data struct {
	// channel id identifying channel between client server (uniquely assigned within client runtime context)
	Channel int64 `protobuf:"varint,1,opt,name=channel,proto3" json:"channel,omitempty"`
	// raw data
	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Data) Reset()         { *m = Data{} }
func (m *Data) String() string { return proto.CompactTextString(m) }
func (*Data) ProtoMessage()    {}
func (*Data) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{4}
}

func (m *Data) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Data.Unmarshal(m, b)
}
func (m *Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Data.Marshal(b, m, deterministic)
}
func (m *Data) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Data.Merge(m, src)
}
func (m *Data) XXX_Size() int {
	return xxx_messageInfo_Data.Size(m)
}
func (m *Data) XXX_DiscardUnknown() {
	xxx_messageInfo_Data.DiscardUnknown(m)
}

var xxx_messageInfo_Data proto.InternalMessageInfo

func (m *Data) GetChannel() int64 {
	if m != nil {
		return m.Channel
	}
	return 0
}

func (m *Data) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

// The message from Service to the broker
// - will register or will send data
type ServiceRequest struct {
	// Types that are valid to be assigned to Msg:
	//	*ServiceRequest_RegisterProvider_
	//	*ServiceRequest_SendData
	Msg                  isServiceRequest_Msg `protobuf_oneof:"msg"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ServiceRequest) Reset()         { *m = ServiceRequest{} }
func (m *ServiceRequest) String() string { return proto.CompactTextString(m) }
func (*ServiceRequest) ProtoMessage()    {}
func (*ServiceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{5}
}

func (m *ServiceRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceRequest.Unmarshal(m, b)
}
func (m *ServiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceRequest.Marshal(b, m, deterministic)
}
func (m *ServiceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceRequest.Merge(m, src)
}
func (m *ServiceRequest) XXX_Size() int {
	return xxx_messageInfo_ServiceRequest.Size(m)
}
func (m *ServiceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceRequest proto.InternalMessageInfo

type isServiceRequest_Msg interface {
	isServiceRequest_Msg()
}

type ServiceRequest_RegisterProvider_ struct {
	RegisterProvider *ServiceRequest_RegisterProvider `protobuf:"bytes,1,opt,name=register_provider,json=registerProvider,proto3,oneof"`
}

type ServiceRequest_SendData struct {
	SendData *Data `protobuf:"bytes,3,opt,name=send_data,json=sendData,proto3,oneof"`
}

func (*ServiceRequest_RegisterProvider_) isServiceRequest_Msg() {}

func (*ServiceRequest_SendData) isServiceRequest_Msg() {}

func (m *ServiceRequest) GetMsg() isServiceRequest_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ServiceRequest) GetRegisterProvider() *ServiceRequest_RegisterProvider {
	if x, ok := m.GetMsg().(*ServiceRequest_RegisterProvider_); ok {
		return x.RegisterProvider
	}
	return nil
}

func (m *ServiceRequest) GetSendData() *Data {
	if x, ok := m.GetMsg().(*ServiceRequest_SendData); ok {
		return x.SendData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServiceRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServiceRequest_RegisterProvider_)(nil),
		(*ServiceRequest_SendData)(nil),
	}
}

type ServiceRequest_RegisterProvider struct {
	// device name, e.g. projects/xyz/devices/abcd (may integrate this way with goten: auth, etc)
	Device string `protobuf:"bytes,1,opt,name=device,proto3" json:"device,omitempty"`
	// service name, e.g. ssh
	Service              string   `protobuf:"bytes,2,opt,name=service,proto3" json:"service,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ServiceRequest_RegisterProvider) Reset()         { *m = ServiceRequest_RegisterProvider{} }
func (m *ServiceRequest_RegisterProvider) String() string { return proto.CompactTextString(m) }
func (*ServiceRequest_RegisterProvider) ProtoMessage()    {}
func (*ServiceRequest_RegisterProvider) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{5, 0}
}

func (m *ServiceRequest_RegisterProvider) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceRequest_RegisterProvider.Unmarshal(m, b)
}
func (m *ServiceRequest_RegisterProvider) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceRequest_RegisterProvider.Marshal(b, m, deterministic)
}
func (m *ServiceRequest_RegisterProvider) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceRequest_RegisterProvider.Merge(m, src)
}
func (m *ServiceRequest_RegisterProvider) XXX_Size() int {
	return xxx_messageInfo_ServiceRequest_RegisterProvider.Size(m)
}
func (m *ServiceRequest_RegisterProvider) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceRequest_RegisterProvider.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceRequest_RegisterProvider proto.InternalMessageInfo

func (m *ServiceRequest_RegisterProvider) GetDevice() string {
	if m != nil {
		return m.Device
	}
	return ""
}

func (m *ServiceRequest_RegisterProvider) GetService() string {
	if m != nil {
		return m.Service
	}
	return ""
}

type ServiceResponse struct {
	// Types that are valid to be assigned to Msg:
	//	*ServiceResponse_ChannelOpened
	//	*ServiceResponse_ChannelClosed
	//	*ServiceResponse_RecvData
	Msg                  isServiceResponse_Msg `protobuf_oneof:"msg"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ServiceResponse) Reset()         { *m = ServiceResponse{} }
func (m *ServiceResponse) String() string { return proto.CompactTextString(m) }
func (*ServiceResponse) ProtoMessage()    {}
func (*ServiceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{6}
}

func (m *ServiceResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ServiceResponse.Unmarshal(m, b)
}
func (m *ServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ServiceResponse.Marshal(b, m, deterministic)
}
func (m *ServiceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ServiceResponse.Merge(m, src)
}
func (m *ServiceResponse) XXX_Size() int {
	return xxx_messageInfo_ServiceResponse.Size(m)
}
func (m *ServiceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ServiceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ServiceResponse proto.InternalMessageInfo

type isServiceResponse_Msg interface {
	isServiceResponse_Msg()
}

type ServiceResponse_ChannelOpened struct {
	ChannelOpened *NotifyChannelOpened `protobuf:"bytes,1,opt,name=channel_opened,json=channelOpened,proto3,oneof"`
}

type ServiceResponse_ChannelClosed struct {
	ChannelClosed *NotifyChannelClosed `protobuf:"bytes,2,opt,name=channel_closed,json=channelClosed,proto3,oneof"`
}

type ServiceResponse_RecvData struct {
	RecvData *Data `protobuf:"bytes,3,opt,name=recv_data,json=recvData,proto3,oneof"`
}

func (*ServiceResponse_ChannelOpened) isServiceResponse_Msg() {}

func (*ServiceResponse_ChannelClosed) isServiceResponse_Msg() {}

func (*ServiceResponse_RecvData) isServiceResponse_Msg() {}

func (m *ServiceResponse) GetMsg() isServiceResponse_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ServiceResponse) GetChannelOpened() *NotifyChannelOpened {
	if x, ok := m.GetMsg().(*ServiceResponse_ChannelOpened); ok {
		return x.ChannelOpened
	}
	return nil
}

func (m *ServiceResponse) GetChannelClosed() *NotifyChannelClosed {
	if x, ok := m.GetMsg().(*ServiceResponse_ChannelClosed); ok {
		return x.ChannelClosed
	}
	return nil
}

func (m *ServiceResponse) GetRecvData() *Data {
	if x, ok := m.GetMsg().(*ServiceResponse_RecvData); ok {
		return x.RecvData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ServiceResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ServiceResponse_ChannelOpened)(nil),
		(*ServiceResponse_ChannelClosed)(nil),
		(*ServiceResponse_RecvData)(nil),
	}
}

// The message from Consumer to the broker
// - will register or will send data
type ConsumeRequest struct {
	// Types that are valid to be assigned to Msg:
	//	*ConsumeRequest_OpenChannel
	//	*ConsumeRequest_SendData
	Msg                  isConsumeRequest_Msg `protobuf_oneof:"msg"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ConsumeRequest) Reset()         { *m = ConsumeRequest{} }
func (m *ConsumeRequest) String() string { return proto.CompactTextString(m) }
func (*ConsumeRequest) ProtoMessage()    {}
func (*ConsumeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{7}
}

func (m *ConsumeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConsumeRequest.Unmarshal(m, b)
}
func (m *ConsumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConsumeRequest.Marshal(b, m, deterministic)
}
func (m *ConsumeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConsumeRequest.Merge(m, src)
}
func (m *ConsumeRequest) XXX_Size() int {
	return xxx_messageInfo_ConsumeRequest.Size(m)
}
func (m *ConsumeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ConsumeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ConsumeRequest proto.InternalMessageInfo

type isConsumeRequest_Msg interface {
	isConsumeRequest_Msg()
}

type ConsumeRequest_OpenChannel struct {
	OpenChannel *OpenChannel `protobuf:"bytes,1,opt,name=open_channel,json=openChannel,proto3,oneof"`
}

type ConsumeRequest_SendData struct {
	SendData *Data `protobuf:"bytes,2,opt,name=send_data,json=sendData,proto3,oneof"`
}

func (*ConsumeRequest_OpenChannel) isConsumeRequest_Msg() {}

func (*ConsumeRequest_SendData) isConsumeRequest_Msg() {}

func (m *ConsumeRequest) GetMsg() isConsumeRequest_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ConsumeRequest) GetOpenChannel() *OpenChannel {
	if x, ok := m.GetMsg().(*ConsumeRequest_OpenChannel); ok {
		return x.OpenChannel
	}
	return nil
}

func (m *ConsumeRequest) GetSendData() *Data {
	if x, ok := m.GetMsg().(*ConsumeRequest_SendData); ok {
		return x.SendData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ConsumeRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ConsumeRequest_OpenChannel)(nil),
		(*ConsumeRequest_SendData)(nil),
	}
}

type ConsumeResponse struct {
	// Types that are valid to be assigned to Msg:
	//	*ConsumeResponse_ChannelOpened
	//	*ConsumeResponse_ChannelClosed
	//	*ConsumeResponse_RecvData
	Msg                  isConsumeResponse_Msg `protobuf_oneof:"msg"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ConsumeResponse) Reset()         { *m = ConsumeResponse{} }
func (m *ConsumeResponse) String() string { return proto.CompactTextString(m) }
func (*ConsumeResponse) ProtoMessage()    {}
func (*ConsumeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_4c4736d7ab2a0daa, []int{8}
}

func (m *ConsumeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConsumeResponse.Unmarshal(m, b)
}
func (m *ConsumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConsumeResponse.Marshal(b, m, deterministic)
}
func (m *ConsumeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConsumeResponse.Merge(m, src)
}
func (m *ConsumeResponse) XXX_Size() int {
	return xxx_messageInfo_ConsumeResponse.Size(m)
}
func (m *ConsumeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ConsumeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ConsumeResponse proto.InternalMessageInfo

type isConsumeResponse_Msg interface {
	isConsumeResponse_Msg()
}

type ConsumeResponse_ChannelOpened struct {
	ChannelOpened *NotifyChannelOpened `protobuf:"bytes,1,opt,name=channel_opened,json=channelOpened,proto3,oneof"`
}

type ConsumeResponse_ChannelClosed struct {
	ChannelClosed *NotifyChannelClosed `protobuf:"bytes,2,opt,name=channel_closed,json=channelClosed,proto3,oneof"`
}

type ConsumeResponse_RecvData struct {
	RecvData *Data `protobuf:"bytes,3,opt,name=recv_data,json=recvData,proto3,oneof"`
}

func (*ConsumeResponse_ChannelOpened) isConsumeResponse_Msg() {}

func (*ConsumeResponse_ChannelClosed) isConsumeResponse_Msg() {}

func (*ConsumeResponse_RecvData) isConsumeResponse_Msg() {}

func (m *ConsumeResponse) GetMsg() isConsumeResponse_Msg {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *ConsumeResponse) GetChannelOpened() *NotifyChannelOpened {
	if x, ok := m.GetMsg().(*ConsumeResponse_ChannelOpened); ok {
		return x.ChannelOpened
	}
	return nil
}

func (m *ConsumeResponse) GetChannelClosed() *NotifyChannelClosed {
	if x, ok := m.GetMsg().(*ConsumeResponse_ChannelClosed); ok {
		return x.ChannelClosed
	}
	return nil
}

func (m *ConsumeResponse) GetRecvData() *Data {
	if x, ok := m.GetMsg().(*ConsumeResponse_RecvData); ok {
		return x.RecvData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ConsumeResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ConsumeResponse_ChannelOpened)(nil),
		(*ConsumeResponse_ChannelClosed)(nil),
		(*ConsumeResponse_RecvData)(nil),
	}
}

func init() {
	proto.RegisterType((*NotifyChannelOpened)(nil), "mbroker.NotifyChannelOpened")
	proto.RegisterType((*NotifyChannelClosed)(nil), "mbroker.NotifyChannelClosed")
	proto.RegisterType((*OpenChannel)(nil), "mbroker.OpenChannel")
	proto.RegisterType((*CloseChannel)(nil), "mbroker.CloseChannel")
	proto.RegisterType((*Data)(nil), "mbroker.Data")
	proto.RegisterType((*ServiceRequest)(nil), "mbroker.ServiceRequest")
	proto.RegisterType((*ServiceRequest_RegisterProvider)(nil), "mbroker.ServiceRequest.RegisterProvider")
	proto.RegisterType((*ServiceResponse)(nil), "mbroker.ServiceResponse")
	proto.RegisterType((*ConsumeRequest)(nil), "mbroker.ConsumeRequest")
	proto.RegisterType((*ConsumeResponse)(nil), "mbroker.ConsumeResponse")
}

func init() { proto.RegisterFile("mbroker.proto", fileDescriptor_4c4736d7ab2a0daa) }

var fileDescriptor_4c4736d7ab2a0daa = []byte{
	// 460 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x54, 0x4d, 0x8f, 0xd3, 0x30,
	0x10, 0x8d, 0xdb, 0xa5, 0x4b, 0xa7, 0x1f, 0x2c, 0x06, 0x41, 0xb5, 0xe2, 0x80, 0x72, 0x8a, 0xd0,
	0x2a, 0xa0, 0xc2, 0x85, 0x23, 0xe9, 0x22, 0x85, 0x03, 0x50, 0x19, 0x24, 0x8e, 0x51, 0x36, 0x19,
	0x4a, 0x44, 0x13, 0x07, 0x3b, 0xad, 0xe0, 0xc6, 0x1f, 0xe1, 0x5f, 0xf1, 0x13, 0xf8, 0x21, 0xc8,
	0x8e, 0x13, 0x39, 0x2d, 0x59, 0xee, 0x7b, 0xf3, 0x38, 0x6f, 0x9e, 0x9f, 0xdf, 0xbc, 0x18, 0x66,
	0xf9, 0x95, 0xe0, 0x5f, 0x51, 0xf8, 0xa5, 0xe0, 0x15, 0xa7, 0xa7, 0xa6, 0x74, 0x9f, 0xc2, 0xbd,
	0x77, 0xbc, 0xca, 0x3e, 0xff, 0x58, 0x7d, 0x89, 0x8b, 0x02, 0xb7, 0xef, 0x4b, 0x2c, 0x30, 0xa5,
	0x0b, 0x38, 0x4d, 0xea, 0x8d, 0x05, 0x79, 0x4c, 0xbc, 0x21, 0x6b, 0xca, 0xa3, 0x86, 0xd5, 0x96,
	0xcb, 0x6b, 0x1b, 0x5e, 0xc1, 0x44, 0x91, 0x1a, 0xb8, 0x02, 0x4a, 0x14, 0xfb, 0x2c, 0x41, 0x0d,
	0x1c, 0xb3, 0xa6, 0xb4, 0x29, 0x06, 0x5d, 0x0a, 0x0f, 0xa6, 0xfa, 0x18, 0x8b, 0xa3, 0xe7, 0xb0,
	0x17, 0x70, 0x72, 0x19, 0x57, 0x71, 0x3f, 0x82, 0x52, 0x38, 0x49, 0xe3, 0x2a, 0xd6, 0x47, 0x4c,
	0x99, 0x5e, 0xbb, 0x7f, 0x08, 0xcc, 0x3f, 0xd4, 0x2a, 0x18, 0x7e, 0xdb, 0xa1, 0xac, 0xe8, 0x27,
	0xb8, 0x2b, 0x70, 0x93, 0xc9, 0x0a, 0x45, 0x54, 0x0a, 0xbe, 0xcf, 0x52, 0x14, 0x9a, 0x6a, 0xb2,
	0xf4, 0xfc, 0xc6, 0xcb, 0x6e, 0x8f, 0xcf, 0x4c, 0xc3, 0xda, 0xe0, 0x43, 0x87, 0x9d, 0x89, 0x83,
	0x3d, 0x7a, 0x01, 0x63, 0x89, 0x45, 0x1a, 0x69, 0x11, 0x43, 0x4d, 0x38, 0x6b, 0x09, 0x95, 0xf6,
	0xd0, 0x61, 0xb7, 0x15, 0x42, 0xad, 0xcf, 0x2f, 0xe1, 0xec, 0x90, 0x95, 0x3e, 0x80, 0x51, 0x8a,
	0x96, 0x81, 0xa6, 0xb2, 0x9d, 0x1d, 0x74, 0x9c, 0x0d, 0x6e, 0xc1, 0x30, 0x97, 0x1b, 0xf7, 0x37,
	0x81, 0x3b, 0xad, 0x64, 0x59, 0xf2, 0x42, 0x22, 0x7d, 0x0d, 0x73, 0xe3, 0x4c, 0xc4, 0xf5, 0xe8,
	0xcd, 0x25, 0x1f, 0xb5, 0x9a, 0xfe, 0x11, 0x8f, 0xd0, 0x61, 0xb3, 0xa4, 0x93, 0x17, 0x8b, 0x26,
	0xd1, 0x81, 0xd0, 0x12, 0x7a, 0x69, 0xea, 0xd0, 0x58, 0x34, 0x26, 0x45, 0x17, 0x30, 0x16, 0x98,
	0xec, 0xaf, 0x37, 0x47, 0x21, 0xd4, 0xba, 0xb9, 0xd6, 0x4f, 0x02, 0xf3, 0x15, 0x2f, 0xe4, 0x2e,
	0x6f, 0xa7, 0xf7, 0x12, 0xa6, 0xea, 0x36, 0x91, 0x9d, 0x81, 0xc9, 0xf2, 0x7e, 0x4b, 0x65, 0x05,
	0x32, 0x74, 0xd8, 0x84, 0x5b, 0xf9, 0xec, 0xcc, 0x67, 0xf0, 0x9f, 0xf9, 0xd8, 0xce, 0xb6, 0x12,
	0x6e, 0x8c, 0xb3, 0xcb, 0x5f, 0x04, 0x46, 0x81, 0x86, 0xd0, 0x10, 0x66, 0x26, 0x3a, 0x1f, 0x77,
	0xda, 0xa7, 0x87, 0x3d, 0x7f, 0xc1, 0xf9, 0xe2, 0xf8, 0x43, 0xed, 0x88, 0xeb, 0x78, 0xe4, 0x19,
	0xa1, 0x6f, 0xda, 0x69, 0x89, 0x23, 0xaa, 0xee, 0x18, 0x2d, 0xaa, 0x03, 0x73, 0x6b, 0xaa, 0xe0,
	0x09, 0x2c, 0x32, 0xee, 0x6f, 0x44, 0x99, 0xf8, 0xf8, 0x3d, 0xce, 0xcb, 0x2d, 0xca, 0xa6, 0x23,
	0x98, 0xbe, 0xad, 0x95, 0xaf, 0xd5, 0x7b, 0xb7, 0x26, 0x57, 0x23, 0xfd, 0xf0, 0x3d, 0xff, 0x1b,
	0x00, 0x00, 0xff, 0xff, 0xda, 0xbd, 0x8c, 0x9b, 0x09, 0x05, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// BrokerClient is the client API for Broker service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BrokerClient interface {
	ServiceTunnel(ctx context.Context, opts ...grpc.CallOption) (Broker_ServiceTunnelClient, error)
	ConsumerTunnel(ctx context.Context, opts ...grpc.CallOption) (Broker_ConsumerTunnelClient, error)
}

type brokerClient struct {
	cc *grpc.ClientConn
}

func NewBrokerClient(cc *grpc.ClientConn) BrokerClient {
	return &brokerClient{cc}
}

func (c *brokerClient) ServiceTunnel(ctx context.Context, opts ...grpc.CallOption) (Broker_ServiceTunnelClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Broker_serviceDesc.Streams[0], "/mbroker.Broker/ServiceTunnel", opts...)
	if err != nil {
		return nil, err
	}
	x := &brokerServiceTunnelClient{stream}
	return x, nil
}

type Broker_ServiceTunnelClient interface {
	Send(*ServiceRequest) error
	Recv() (*ServiceResponse, error)
	grpc.ClientStream
}

type brokerServiceTunnelClient struct {
	grpc.ClientStream
}

func (x *brokerServiceTunnelClient) Send(m *ServiceRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *brokerServiceTunnelClient) Recv() (*ServiceResponse, error) {
	m := new(ServiceResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *brokerClient) ConsumerTunnel(ctx context.Context, opts ...grpc.CallOption) (Broker_ConsumerTunnelClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Broker_serviceDesc.Streams[1], "/mbroker.Broker/ConsumerTunnel", opts...)
	if err != nil {
		return nil, err
	}
	x := &brokerConsumerTunnelClient{stream}
	return x, nil
}

type Broker_ConsumerTunnelClient interface {
	Send(*ConsumeRequest) error
	Recv() (*ConsumeResponse, error)
	grpc.ClientStream
}

type brokerConsumerTunnelClient struct {
	grpc.ClientStream
}

func (x *brokerConsumerTunnelClient) Send(m *ConsumeRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *brokerConsumerTunnelClient) Recv() (*ConsumeResponse, error) {
	m := new(ConsumeResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// BrokerServer is the server API for Broker service.
type BrokerServer interface {
	ServiceTunnel(Broker_ServiceTunnelServer) error
	ConsumerTunnel(Broker_ConsumerTunnelServer) error
}

// UnimplementedBrokerServer can be embedded to have forward compatible implementations.
type UnimplementedBrokerServer struct {
}

func (*UnimplementedBrokerServer) ServiceTunnel(srv Broker_ServiceTunnelServer) error {
	return status.Errorf(codes.Unimplemented, "method ServiceTunnel not implemented")
}
func (*UnimplementedBrokerServer) ConsumerTunnel(srv Broker_ConsumerTunnelServer) error {
	return status.Errorf(codes.Unimplemented, "method ConsumerTunnel not implemented")
}

func RegisterBrokerServer(s *grpc.Server, srv BrokerServer) {
	s.RegisterService(&_Broker_serviceDesc, srv)
}

func _Broker_ServiceTunnel_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(BrokerServer).ServiceTunnel(&brokerServiceTunnelServer{stream})
}

type Broker_ServiceTunnelServer interface {
	Send(*ServiceResponse) error
	Recv() (*ServiceRequest, error)
	grpc.ServerStream
}

type brokerServiceTunnelServer struct {
	grpc.ServerStream
}

func (x *brokerServiceTunnelServer) Send(m *ServiceResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *brokerServiceTunnelServer) Recv() (*ServiceRequest, error) {
	m := new(ServiceRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Broker_ConsumerTunnel_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(BrokerServer).ConsumerTunnel(&brokerConsumerTunnelServer{stream})
}

type Broker_ConsumerTunnelServer interface {
	Send(*ConsumeResponse) error
	Recv() (*ConsumeRequest, error)
	grpc.ServerStream
}

type brokerConsumerTunnelServer struct {
	grpc.ServerStream
}

func (x *brokerConsumerTunnelServer) Send(m *ConsumeResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *brokerConsumerTunnelServer) Recv() (*ConsumeRequest, error) {
	m := new(ConsumeRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Broker_serviceDesc = grpc.ServiceDesc{
	ServiceName: "mbroker.Broker",
	HandlerType: (*BrokerServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ServiceTunnel",
			Handler:       _Broker_ServiceTunnel_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "ConsumerTunnel",
			Handler:       _Broker_ConsumerTunnel_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "mbroker.proto",
}