重新生成pb.go

liuxiaolong

2021-04-25 238b3cab1bc1c6b2f1b2f03df3a78c8d1db6c685

 proto/source/bhome_msg/bhome_msg_api.pb.go

@@ -23,7 +23,7 @@
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type BHAddress struct {
   MqId []byte `protobuf:"bytes,1,opt,name=mq_id,json=mqId,proto3" json:"mq_id,omitempty"`
   MqId uint64 `protobuf:"varint,1,opt,name=mq_id,json=mqId,proto3" json:"mq_id,omitempty"`
   Ip   []byte `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
   Port int32  `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
}
@@ -61,11 +61,11 @@

var xxx_messageInfo_BHAddress proto.InternalMessageInfo

func (m *BHAddress) GetMqId() []byte {
func (m *BHAddress) GetMqId() uint64 {
   if m != nil {
      return m.MqId
   }
   return nil
   return 0
}

func (m *BHAddress) GetIp() []byte {
@@ -446,6 +446,50 @@
   return nil
}

type MsgUnregister struct {
   Proc *ProcInfo `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
}

func (m *MsgUnregister) Reset()         { *m = MsgUnregister{} }
func (m *MsgUnregister) String() string { return proto.CompactTextString(m) }
func (*MsgUnregister) ProtoMessage()    {}
func (*MsgUnregister) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{8}
}
func (m *MsgUnregister) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *MsgUnregister) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_MsgUnregister.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 *MsgUnregister) XXX_Merge(src proto.Message) {
   xxx_messageInfo_MsgUnregister.Merge(m, src)
}
func (m *MsgUnregister) XXX_Size() int {
   return m.Size()
}
func (m *MsgUnregister) XXX_DiscardUnknown() {
   xxx_messageInfo_MsgUnregister.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUnregister proto.InternalMessageInfo

func (m *MsgUnregister) GetProc() *ProcInfo {
   if m != nil {
      return m.Proc
   }
   return nil
}

type MsgHeartbeat struct {
   Proc *ProcInfo `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
}
@@ -454,7 +498,7 @@
func (m *MsgHeartbeat) String() string { return proto.CompactTextString(m) }
func (*MsgHeartbeat) ProtoMessage()    {}
func (*MsgHeartbeat) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{8}
   return fileDescriptor_a49c9c1f511a168c, []int{9}
}
func (m *MsgHeartbeat) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -498,7 +542,7 @@
func (m *MsgQueryTopic) String() string { return proto.CompactTextString(m) }
func (*MsgQueryTopic) ProtoMessage()    {}
func (*MsgQueryTopic) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{9}
   return fileDescriptor_a49c9c1f511a168c, []int{10}
}
func (m *MsgQueryTopic) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -535,15 +579,15 @@
}

type MsgQueryTopicReply struct {
   Errmsg  *ErrorMsg  `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
   Address *BHAddress `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
   Errmsg      *ErrorMsg                           `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
   NodeAddress []*MsgQueryTopicReply_BHNodeAddress `protobuf:"bytes,2,rep,name=node_address,json=nodeAddress,proto3" json:"node_address,omitempty"`
}

func (m *MsgQueryTopicReply) Reset()         { *m = MsgQueryTopicReply{} }
func (m *MsgQueryTopicReply) String() string { return proto.CompactTextString(m) }
func (*MsgQueryTopicReply) ProtoMessage()    {}
func (*MsgQueryTopicReply) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{10}
   return fileDescriptor_a49c9c1f511a168c, []int{11}
}
func (m *MsgQueryTopicReply) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -579,9 +623,157 @@
   return nil
}

func (m *MsgQueryTopicReply) GetAddress() *BHAddress {
func (m *MsgQueryTopicReply) GetNodeAddress() []*MsgQueryTopicReply_BHNodeAddress {
   if m != nil {
      return m.Address
      return m.NodeAddress
   }
   return nil
}

type MsgQueryTopicReply_BHNodeAddress struct {
   ProcId []byte     `protobuf:"bytes,1,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
   Addr   *BHAddress `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
}

func (m *MsgQueryTopicReply_BHNodeAddress) Reset()         { *m = MsgQueryTopicReply_BHNodeAddress{} }
func (m *MsgQueryTopicReply_BHNodeAddress) String() string { return proto.CompactTextString(m) }
func (*MsgQueryTopicReply_BHNodeAddress) ProtoMessage()    {}
func (*MsgQueryTopicReply_BHNodeAddress) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{11, 0}
}
func (m *MsgQueryTopicReply_BHNodeAddress) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *MsgQueryTopicReply_BHNodeAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_MsgQueryTopicReply_BHNodeAddress.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 *MsgQueryTopicReply_BHNodeAddress) XXX_Merge(src proto.Message) {
   xxx_messageInfo_MsgQueryTopicReply_BHNodeAddress.Merge(m, src)
}
func (m *MsgQueryTopicReply_BHNodeAddress) XXX_Size() int {
   return m.Size()
}
func (m *MsgQueryTopicReply_BHNodeAddress) XXX_DiscardUnknown() {
   xxx_messageInfo_MsgQueryTopicReply_BHNodeAddress.DiscardUnknown(m)
}

var xxx_messageInfo_MsgQueryTopicReply_BHNodeAddress proto.InternalMessageInfo

func (m *MsgQueryTopicReply_BHNodeAddress) GetProcId() []byte {
   if m != nil {
      return m.ProcId
   }
   return nil
}

func (m *MsgQueryTopicReply_BHNodeAddress) GetAddr() *BHAddress {
   if m != nil {
      return m.Addr
   }
   return nil
}

type MsgQueryProc struct {
   ProcId []byte `protobuf:"bytes,1,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
}

func (m *MsgQueryProc) Reset()         { *m = MsgQueryProc{} }
func (m *MsgQueryProc) String() string { return proto.CompactTextString(m) }
func (*MsgQueryProc) ProtoMessage()    {}
func (*MsgQueryProc) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{12}
}
func (m *MsgQueryProc) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *MsgQueryProc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_MsgQueryProc.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 *MsgQueryProc) XXX_Merge(src proto.Message) {
   xxx_messageInfo_MsgQueryProc.Merge(m, src)
}
func (m *MsgQueryProc) XXX_Size() int {
   return m.Size()
}
func (m *MsgQueryProc) XXX_DiscardUnknown() {
   xxx_messageInfo_MsgQueryProc.DiscardUnknown(m)
}

var xxx_messageInfo_MsgQueryProc proto.InternalMessageInfo

func (m *MsgQueryProc) GetProcId() []byte {
   if m != nil {
      return m.ProcId
   }
   return nil
}

type MsgQueryProcReply struct {
   Errmsg *ErrorMsg   `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
   Proc   []*ProcInfo `protobuf:"bytes,2,rep,name=proc,proto3" json:"proc,omitempty"`
}

func (m *MsgQueryProcReply) Reset()         { *m = MsgQueryProcReply{} }
func (m *MsgQueryProcReply) String() string { return proto.CompactTextString(m) }
func (*MsgQueryProcReply) ProtoMessage()    {}
func (*MsgQueryProcReply) Descriptor() ([]byte, []int) {
   return fileDescriptor_a49c9c1f511a168c, []int{13}
}
func (m *MsgQueryProcReply) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *MsgQueryProcReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_MsgQueryProcReply.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 *MsgQueryProcReply) XXX_Merge(src proto.Message) {
   xxx_messageInfo_MsgQueryProcReply.Merge(m, src)
}
func (m *MsgQueryProcReply) XXX_Size() int {
   return m.Size()
}
func (m *MsgQueryProcReply) XXX_DiscardUnknown() {
   xxx_messageInfo_MsgQueryProcReply.DiscardUnknown(m)
}

var xxx_messageInfo_MsgQueryProcReply proto.InternalMessageInfo

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

func (m *MsgQueryProcReply) GetProc() []*ProcInfo {
   if m != nil {
      return m.Proc
   }
   return nil
}
@@ -595,45 +787,53 @@
   proto.RegisterType((*MsgRequestTopic)(nil), "bhome_msg.MsgRequestTopic")
   proto.RegisterType((*MsgRequestTopicReply)(nil), "bhome_msg.MsgRequestTopicReply")
   proto.RegisterType((*MsgRegister)(nil), "bhome_msg.MsgRegister")
   proto.RegisterType((*MsgUnregister)(nil), "bhome_msg.MsgUnregister")
   proto.RegisterType((*MsgHeartbeat)(nil), "bhome_msg.MsgHeartbeat")
   proto.RegisterType((*MsgQueryTopic)(nil), "bhome_msg.MsgQueryTopic")
   proto.RegisterType((*MsgQueryTopicReply)(nil), "bhome_msg.MsgQueryTopicReply")
   proto.RegisterType((*MsgQueryTopicReply_BHNodeAddress)(nil), "bhome_msg.MsgQueryTopicReply.BHNodeAddress")
   proto.RegisterType((*MsgQueryProc)(nil), "bhome_msg.MsgQueryProc")
   proto.RegisterType((*MsgQueryProcReply)(nil), "bhome_msg.MsgQueryProcReply")
}

func init() { proto.RegisterFile("bhome_msg_api.proto", fileDescriptor_a49c9c1f511a168c) }

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

func (m *BHAddress) Marshal() (dAtA []byte, err error) {
@@ -651,11 +851,10 @@
   _ = i
   var l int
   _ = l
   if len(m.MqId) > 0 {
      dAtA[i] = 0xa
   if m.MqId != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.MqId)))
      i += copy(dAtA[i:], m.MqId)
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.MqId))
   }
   if len(m.Ip) > 0 {
      dAtA[i] = 0x12
@@ -901,6 +1100,34 @@
   return i, nil
}

func (m *MsgUnregister) 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 *MsgUnregister) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Proc != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Proc.Size()))
      n4, err4 := m.Proc.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n4
   }
   return i, nil
}

func (m *MsgHeartbeat) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -920,11 +1147,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Proc.Size()))
      n4, err4 := m.Proc.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      n5, err5 := m.Proc.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n4
      i += n5
   }
   return i, nil
}
@@ -972,21 +1199,121 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Errmsg.Size()))
      n5, err5 := m.Errmsg.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n5
   }
   if m.Address != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Address.Size()))
      n6, err6 := m.Address.MarshalTo(dAtA[i:])
      n6, err6 := m.Errmsg.MarshalTo(dAtA[i:])
      if err6 != nil {
         return 0, err6
      }
      i += n6
   }
   if len(m.NodeAddress) > 0 {
      for _, msg := range m.NodeAddress {
         dAtA[i] = 0x12
         i++
         i = encodeVarintBhomeMsgApi(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *MsgQueryTopicReply_BHNodeAddress) 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 *MsgQueryTopicReply_BHNodeAddress) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ProcId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.ProcId)))
      i += copy(dAtA[i:], m.ProcId)
   }
   if m.Addr != nil {
      dAtA[i] = 0x12
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Addr.Size()))
      n7, err7 := m.Addr.MarshalTo(dAtA[i:])
      if err7 != nil {
         return 0, err7
      }
      i += n7
   }
   return i, nil
}

func (m *MsgQueryProc) 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 *MsgQueryProc) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ProcId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.ProcId)))
      i += copy(dAtA[i:], m.ProcId)
   }
   return i, nil
}

func (m *MsgQueryProcReply) 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 *MsgQueryProcReply) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.Errmsg != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Errmsg.Size()))
      n8, err8 := m.Errmsg.MarshalTo(dAtA[i:])
      if err8 != nil {
         return 0, err8
      }
      i += n8
   }
   if len(m.Proc) > 0 {
      for _, msg := range m.Proc {
         dAtA[i] = 0x12
         i++
         i = encodeVarintBhomeMsgApi(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}
@@ -1006,9 +1333,8 @@
   }
   var l int
   _ = l
   l = len(m.MqId)
   if l > 0 {
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   if m.MqId != 0 {
      n += 1 + sovBhomeMsgApi(uint64(m.MqId))
   }
   l = len(m.Ip)
   if l > 0 {
@@ -1143,6 +1469,19 @@
   return n
}

func (m *MsgUnregister) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Proc != nil {
      l = m.Proc.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   return n
}

func (m *MsgHeartbeat) Size() (n int) {
   if m == nil {
      return 0
@@ -1179,9 +1518,60 @@
      l = m.Errmsg.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   if m.Address != nil {
      l = m.Address.Size()
   if len(m.NodeAddress) > 0 {
      for _, e := range m.NodeAddress {
         l = e.Size()
         n += 1 + l + sovBhomeMsgApi(uint64(l))
      }
   }
   return n
}

func (m *MsgQueryTopicReply_BHNodeAddress) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ProcId)
   if l > 0 {
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   if m.Addr != nil {
      l = m.Addr.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   return n
}

func (m *MsgQueryProc) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ProcId)
   if l > 0 {
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   return n
}

func (m *MsgQueryProcReply) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.Errmsg != nil {
      l = m.Errmsg.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   if len(m.Proc) > 0 {
      for _, e := range m.Proc {
         l = e.Size()
         n += 1 + l + sovBhomeMsgApi(uint64(l))
      }
   }
   return n
}
@@ -1222,10 +1612,10 @@
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field MqId", wireType)
         }
         var byteLen int
         m.MqId = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
@@ -1235,26 +1625,11 @@
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            m.MqId |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.MqId = append(m.MqId[:0], dAtA[iNdEx:postIndex]...)
         if m.MqId == nil {
            m.MqId = []byte{}
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
@@ -2183,6 +2558,95 @@
   }
   return nil
}
func (m *MsgUnregister) 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 ErrIntOverflowBhomeMsgApi
         }
         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: MsgUnregister: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: MsgUnregister: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Proc", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Proc == nil {
            m.Proc = &ProcInfo{}
         }
         if err := m.Proc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *MsgHeartbeat) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
@@ -2426,7 +2890,7 @@
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
            return fmt.Errorf("proto: wrong wireType = %d for field NodeAddress", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
@@ -2453,10 +2917,341 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Address == nil {
            m.Address = &BHAddress{}
         m.NodeAddress = append(m.NodeAddress, &MsgQueryTopicReply_BHNodeAddress{})
         if err := m.NodeAddress[len(m.NodeAddress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *MsgQueryTopicReply_BHNodeAddress) 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 ErrIntOverflowBhomeMsgApi
         }
         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: BHNodeAddress: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: BHNodeAddress: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ProcId", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ProcId = append(m.ProcId[:0], dAtA[iNdEx:postIndex]...)
         if m.ProcId == nil {
            m.ProcId = []byte{}
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Addr == nil {
            m.Addr = &BHAddress{}
         }
         if err := m.Addr.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *MsgQueryProc) 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 ErrIntOverflowBhomeMsgApi
         }
         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: MsgQueryProc: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: MsgQueryProc: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ProcId", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ProcId = append(m.ProcId[:0], dAtA[iNdEx:postIndex]...)
         if m.ProcId == nil {
            m.ProcId = []byte{}
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *MsgQueryProcReply) 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 ErrIntOverflowBhomeMsgApi
         }
         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: MsgQueryProcReply: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: MsgQueryProcReply: 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 ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         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 != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Proc", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthBhomeMsgApi
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Proc = append(m.Proc, &ProcInfo{})
         if err := m.Proc[len(m.Proc)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex