重新生成proto

liuxiaolong

2021-05-19 d31fa2331c113a333f81347157ae4c5e64664393

 proto/source/bhome_msg/bhome_msg.pb.go

@@ -25,10 +25,12 @@
type MsgType int32

const (
   MsgType_kMsgTypeInvalid     MsgType = 0
   MsgType_kMsgTypeRawData     MsgType = 1
   MsgType_kMsgTypeCommonReply MsgType = 2
   MsgType_kMsgTypeRegister    MsgType = 10
   MsgType_kMsgTypeInvalid       MsgType = 0
   MsgType_kMsgTypeRawData       MsgType = 1
   MsgType_kMsgTypeCommonReply   MsgType = 2
   MsgType_kMsgTypeProcInit      MsgType = 8
   MsgType_kMsgTypeProcInitReply MsgType = 9
   MsgType_kMsgTypeRegister      MsgType = 10
   // kMsgTypeRegisterReply= 11;
   MsgType_kMsgTypeHeartbeat MsgType = 12
   // kMsgTypeHeartbeatReply = 13;
@@ -44,12 +46,17 @@
   MsgType_kMsgTypeUnsubscribe MsgType = 24
   // kMsgTypeUnsubscribeReply = 25;
   MsgType_kMsgTypeUnregister MsgType = 26
   // kMsgTypeUnregisterReply = 27;
   MsgType_kMsgTypeQueryProc      MsgType = 28
   MsgType_kMsgTypeQueryProcReply MsgType = 29
)

var MsgType_name = map[int32]string{
   0:  "kMsgTypeInvalid",
   1:  "kMsgTypeRawData",
   2:  "kMsgTypeCommonReply",
   8:  "kMsgTypeProcInit",
   9:  "kMsgTypeProcInitReply",
   10: "kMsgTypeRegister",
   12: "kMsgTypeHeartbeat",
   14: "kMsgTypeQueryTopic",
@@ -61,12 +68,16 @@
   22: "kMsgTypeSubscribe",
   24: "kMsgTypeUnsubscribe",
   26: "kMsgTypeUnregister",
   28: "kMsgTypeQueryProc",
   29: "kMsgTypeQueryProcReply",
}

var MsgType_value = map[string]int32{
   "kMsgTypeInvalid":           0,
   "kMsgTypeRawData":           1,
   "kMsgTypeCommonReply":       2,
   "kMsgTypeProcInit":          8,
   "kMsgTypeProcInitReply":     9,
   "kMsgTypeRegister":          10,
   "kMsgTypeHeartbeat":         12,
   "kMsgTypeQueryTopic":        14,
@@ -78,6 +89,8 @@
   "kMsgTypeSubscribe":         22,
   "kMsgTypeUnsubscribe":       24,
   "kMsgTypeUnregister":        26,
   "kMsgTypeQueryProc":         28,
   "kMsgTypeQueryProcReply":    29,
}

func (x MsgType) String() string {
@@ -93,8 +106,9 @@
   Route     []*BHAddress `protobuf:"bytes,2,rep,name=route,proto3" json:"route,omitempty"`
   Timestamp int64        `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
   Type      int32        `protobuf:"varint,4,opt,name=type,proto3" json:"type,omitempty"`
   ProcId    []byte       `protobuf:"bytes,5,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
   Topic     []byte       `protobuf:"bytes,6,opt,name=topic,proto3" json:"topic,omitempty"`
   SsnId     uint64       `protobuf:"varint,5,opt,name=ssn_id,json=ssnId,proto3" json:"ssn_id,omitempty"`
   ProcId    []byte       `protobuf:"bytes,6,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
   Topic     []byte       `protobuf:"bytes,7,opt,name=topic,proto3" json:"topic,omitempty"`
}

func (m *BHMsgHead) Reset()         { *m = BHMsgHead{} }
@@ -154,6 +168,13 @@
func (m *BHMsgHead) GetType() int32 {
   if m != nil {
      return m.Type
   }
   return 0
}

func (m *BHMsgHead) GetSsnId() uint64 {
   if m != nil {
      return m.SsnId
   }
   return 0
}
@@ -304,6 +325,110 @@
   return nil
}

type MsgProcInit struct {
   ExtraMqNum int32 `protobuf:"varint,1,opt,name=extra_mq_num,json=extraMqNum,proto3" json:"extra_mq_num,omitempty"`
}

func (m *MsgProcInit) Reset()         { *m = MsgProcInit{} }
func (m *MsgProcInit) String() string { return proto.CompactTextString(m) }
func (*MsgProcInit) ProtoMessage()    {}
func (*MsgProcInit) Descriptor() ([]byte, []int) {
   return fileDescriptor_88ce6d52215a3d3f, []int{4}
}
func (m *MsgProcInit) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *MsgProcInit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_MsgProcInit.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *MsgProcInit) XXX_Merge(src proto.Message) {
   xxx_messageInfo_MsgProcInit.Merge(m, src)
}
func (m *MsgProcInit) XXX_Size() int {
   return m.Size()
}
func (m *MsgProcInit) XXX_DiscardUnknown() {
   xxx_messageInfo_MsgProcInit.DiscardUnknown(m)
}

var xxx_messageInfo_MsgProcInit proto.InternalMessageInfo

func (m *MsgProcInit) GetExtraMqNum() int32 {
   if m != nil {
      return m.ExtraMqNum
   }
   return 0
}

type MsgProcInitReply struct {
   Errmsg    *ErrorMsg    `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
   ProcIndex int32        `protobuf:"varint,2,opt,name=proc_index,json=procIndex,proto3" json:"proc_index,omitempty"`
   ExtraMqs  []*BHAddress `protobuf:"bytes,3,rep,name=extra_mqs,json=extraMqs,proto3" json:"extra_mqs,omitempty"`
}

func (m *MsgProcInitReply) Reset()         { *m = MsgProcInitReply{} }
func (m *MsgProcInitReply) String() string { return proto.CompactTextString(m) }
func (*MsgProcInitReply) ProtoMessage()    {}
func (*MsgProcInitReply) Descriptor() ([]byte, []int) {
   return fileDescriptor_88ce6d52215a3d3f, []int{5}
}
func (m *MsgProcInitReply) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *MsgProcInitReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_MsgProcInitReply.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *MsgProcInitReply) XXX_Merge(src proto.Message) {
   xxx_messageInfo_MsgProcInitReply.Merge(m, src)
}
func (m *MsgProcInitReply) XXX_Size() int {
   return m.Size()
}
func (m *MsgProcInitReply) XXX_DiscardUnknown() {
   xxx_messageInfo_MsgProcInitReply.DiscardUnknown(m)
}

var xxx_messageInfo_MsgProcInitReply proto.InternalMessageInfo

func (m *MsgProcInitReply) GetErrmsg() *ErrorMsg {
   if m != nil {
      return m.Errmsg
   }
   return nil
}

func (m *MsgProcInitReply) GetProcIndex() int32 {
   if m != nil {
      return m.ProcIndex
   }
   return 0
}

func (m *MsgProcInitReply) GetExtraMqs() []*BHAddress {
   if m != nil {
      return m.ExtraMqs
   }
   return nil
}

type MsgRequest struct {
   // oneof body;
   //
@@ -318,7 +443,7 @@
func (m *MsgRequest) String() string { return proto.CompactTextString(m) }
func (*MsgRequest) ProtoMessage()    {}
func (*MsgRequest) Descriptor() ([]byte, []int) {
   return fileDescriptor_88ce6d52215a3d3f, []int{4}
   return fileDescriptor_88ce6d52215a3d3f, []int{6}
}
func (m *MsgRequest) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -496,7 +621,7 @@
func (m *MsgReply) String() string { return proto.CompactTextString(m) }
func (*MsgReply) ProtoMessage()    {}
func (*MsgReply) Descriptor() ([]byte, []int) {
   return fileDescriptor_88ce6d52215a3d3f, []int{5}
   return fileDescriptor_88ce6d52215a3d3f, []int{7}
}
func (m *MsgReply) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -543,7 +668,7 @@
func (m *BHMsgBody) String() string { return proto.CompactTextString(m) }
func (*BHMsgBody) ProtoMessage()    {}
func (*BHMsgBody) Descriptor() ([]byte, []int) {
   return fileDescriptor_88ce6d52215a3d3f, []int{6}
   return fileDescriptor_88ce6d52215a3d3f, []int{8}
}
func (m *BHMsgBody) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -689,6 +814,8 @@
   proto.RegisterType((*MsgSubscribe)(nil), "bhome_msg.MsgSubscribe")
   proto.RegisterType((*MsgUnsubscribe)(nil), "bhome_msg.MsgUnsubscribe")
   proto.RegisterType((*MsgRegisterRPC)(nil), "bhome_msg.MsgRegisterRPC")
   proto.RegisterType((*MsgProcInit)(nil), "bhome_msg.MsgProcInit")
   proto.RegisterType((*MsgProcInitReply)(nil), "bhome_msg.MsgProcInitReply")
   proto.RegisterType((*MsgRequest)(nil), "bhome_msg.MsgRequest")
   proto.RegisterType((*MsgReply)(nil), "bhome_msg.MsgReply")
   proto.RegisterType((*BHMsgBody)(nil), "bhome_msg.BHMsgBody")
@@ -697,48 +824,56 @@
func init() { proto.RegisterFile("bhome_msg.proto", fileDescriptor_88ce6d52215a3d3f) }

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

func (m *BHMsgHead) Marshal() (dAtA []byte, err error) {
@@ -784,14 +919,19 @@
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Type))
   }
   if m.SsnId != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.SsnId))
   }
   if len(m.ProcId) > 0 {
      dAtA[i] = 0x2a
      dAtA[i] = 0x32
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(len(m.ProcId)))
      i += copy(dAtA[i:], m.ProcId)
   }
   if len(m.Topic) > 0 {
      dAtA[i] = 0x32
      dAtA[i] = 0x3a
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(len(m.Topic)))
      i += copy(dAtA[i:], m.Topic)
@@ -883,6 +1023,74 @@
   return i, nil
}

func (m *MsgProcInit) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *MsgProcInit) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.ExtraMqNum != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.ExtraMqNum))
   }
   return i, nil
}

func (m *MsgProcInitReply) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *MsgProcInitReply) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Errmsg != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Errmsg.Size()))
      n4, err4 := m.Errmsg.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n4
   }
   if m.ProcIndex != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.ProcIndex))
   }
   if len(m.ExtraMqs) > 0 {
      for _, msg := range m.ExtraMqs {
         dAtA[i] = 0x1a
         i++
         i = encodeVarintBhomeMsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *MsgRequest) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -899,11 +1107,11 @@
   var l int
   _ = l
   if m.Request != nil {
      nn4, err4 := m.Request.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      nn5, err5 := m.Request.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += nn4
      i += nn5
   }
   return i, nil
}
@@ -914,11 +1122,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Register.Size()))
      n5, err5 := m.Register.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      n6, err6 := m.Register.MarshalTo(dAtA[i:])
      if err6 != nil {
         return 0, err6
      }
      i += n5
      i += n6
   }
   return i, nil
}
@@ -928,11 +1136,11 @@
      dAtA[i] = 0x12
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.TopicRequest.Size()))
      n6, err6 := m.TopicRequest.MarshalTo(dAtA[i:])
      if err6 != nil {
         return 0, err6
      n7, err7 := m.TopicRequest.MarshalTo(dAtA[i:])
      if err7 != nil {
         return 0, err7
      }
      i += n6
      i += n7
   }
   return i, nil
}
@@ -942,11 +1150,11 @@
      dAtA[i] = 0x1a
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.TopicQuery.Size()))
      n7, err7 := m.TopicQuery.MarshalTo(dAtA[i:])
      if err7 != nil {
         return 0, err7
      n8, err8 := m.TopicQuery.MarshalTo(dAtA[i:])
      if err8 != nil {
         return 0, err8
      }
      i += n7
      i += n8
   }
   return i, nil
}
@@ -969,11 +1177,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.ErrMsg.Size()))
      n8, err8 := m.ErrMsg.MarshalTo(dAtA[i:])
      if err8 != nil {
         return 0, err8
      n9, err9 := m.ErrMsg.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n8
      i += n9
   }
   return i, nil
}
@@ -994,11 +1202,11 @@
   var l int
   _ = l
   if m.Reqrep != nil {
      nn9, err9 := m.Reqrep.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      nn10, err10 := m.Reqrep.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      }
      i += nn9
      i += nn10
   }
   return i, nil
}
@@ -1009,11 +1217,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Request.Size()))
      n10, err10 := m.Request.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      n11, err11 := m.Request.MarshalTo(dAtA[i:])
      if err11 != nil {
         return 0, err11
      }
      i += n10
      i += n11
   }
   return i, nil
}
@@ -1023,11 +1231,11 @@
      dAtA[i] = 0x12
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Reply.Size()))
      n11, err11 := m.Reply.MarshalTo(dAtA[i:])
      if err11 != nil {
         return 0, err11
      n12, err12 := m.Reply.MarshalTo(dAtA[i:])
      if err12 != nil {
         return 0, err12
      }
      i += n11
      i += n12
   }
   return i, nil
}
@@ -1061,6 +1269,9 @@
   }
   if m.Type != 0 {
      n += 1 + sovBhomeMsg(uint64(m.Type))
   }
   if m.SsnId != 0 {
      n += 1 + sovBhomeMsg(uint64(m.SsnId))
   }
   l = len(m.ProcId)
   if l > 0 {
@@ -1108,6 +1319,40 @@
   if m.Topics != nil {
      l = m.Topics.Size()
      n += 1 + l + sovBhomeMsg(uint64(l))
   }
   return n
}

func (m *MsgProcInit) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.ExtraMqNum != 0 {
      n += 1 + sovBhomeMsg(uint64(m.ExtraMqNum))
   }
   return n
}

func (m *MsgProcInitReply) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Errmsg != nil {
      l = m.Errmsg.Size()
      n += 1 + l + sovBhomeMsg(uint64(l))
   }
   if m.ProcIndex != 0 {
      n += 1 + sovBhomeMsg(uint64(m.ProcIndex))
   }
   if len(m.ExtraMqs) > 0 {
      for _, e := range m.ExtraMqs {
         l = e.Size()
         n += 1 + l + sovBhomeMsg(uint64(l))
      }
   }
   return n
}
@@ -1352,6 +1597,25 @@
            }
         }
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field SsnId", wireType)
         }
         m.SsnId = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.SsnId |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ProcId", wireType)
         }
@@ -1385,7 +1649,7 @@
            m.ProcId = []byte{}
         }
         iNdEx = postIndex
      case 6:
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
         }
@@ -1710,6 +1974,220 @@
   }
   return nil
}
func (m *MsgProcInit) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowBhomeMsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: MsgProcInit: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: MsgProcInit: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ExtraMqNum", wireType)
         }
         m.ExtraMqNum = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ExtraMqNum |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *MsgProcInitReply) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowBhomeMsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: MsgProcInitReply: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: MsgProcInitReply: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Errmsg", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Errmsg == nil {
            m.Errmsg = &ErrorMsg{}
         }
         if err := m.Errmsg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ProcIndex", wireType)
         }
         m.ProcIndex = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ProcIndex |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ExtraMqs", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ExtraMqs = append(m.ExtraMqs, &BHAddress{})
         if err := m.ExtraMqs[len(m.ExtraMqs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthBhomeMsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *MsgRequest) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0