update proto.

lichao

2021-05-19 ef289dc295e5597bbe39bcfdee06971726be7d7c

 proto/source/bhome_msg/bhome_msg_api.pb.go

@@ -23,7 +23,10 @@
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"`
   AbsAddr int64  `protobuf:"varint,2,opt,name=abs_addr,json=absAddr,proto3" json:"abs_addr,omitempty"`
   Ip      []byte `protobuf:"bytes,3,opt,name=ip,proto3" json:"ip,omitempty"`
   Port    int32  `protobuf:"varint,4,opt,name=port,proto3" json:"port,omitempty"`
}

func (m *BHAddress) Reset()         { *m = BHAddress{} }
@@ -59,11 +62,32 @@

var xxx_messageInfo_BHAddress proto.InternalMessageInfo

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

func (m *BHAddress) GetAbsAddr() int64 {
   if m != nil {
      return m.AbsAddr
   }
   return 0
}

func (m *BHAddress) GetIp() []byte {
   if m != nil {
      return m.Ip
   }
   return nil
}

func (m *BHAddress) GetPort() int32 {
   if m != nil {
      return m.Port
   }
   return 0
}

type ProcInfo struct {
@@ -379,8 +403,7 @@
}

type MsgRegister struct {
   Proc  *ProcInfo    `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
   Addrs []*BHAddress `protobuf:"bytes,2,rep,name=addrs,proto3" json:"addrs,omitempty"`
   Proc *ProcInfo `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
}

func (m *MsgRegister) Reset()         { *m = MsgRegister{} }
@@ -423,9 +446,46 @@
   return nil
}

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

func (m *BHAddress) Marshal() (dAtA []byte, err error) {
@@ -633,11 +852,26 @@
   _ = 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 m.AbsAddr != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.AbsAddr))
   }
   if len(m.Ip) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Ip)))
      i += copy(dAtA[i:], m.Ip)
   }
   if m.Port != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Port))
   }
   return i, nil
}
@@ -857,17 +1091,33 @@
      }
      i += n3
   }
   if len(m.Addrs) > 0 {
      for _, msg := range m.Addrs {
         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 *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
}
@@ -891,11 +1141,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
}
@@ -943,21 +1193,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
}
@@ -977,9 +1327,18 @@
   }
   var l int
   _ = l
   l = len(m.MqId)
   if m.MqId != 0 {
      n += 1 + sovBhomeMsgApi(uint64(m.MqId))
   }
   if m.AbsAddr != 0 {
      n += 1 + sovBhomeMsgApi(uint64(m.AbsAddr))
   }
   l = len(m.Ip)
   if l > 0 {
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   if m.Port != 0 {
      n += 1 + sovBhomeMsgApi(uint64(m.Port))
   }
   return n
}
@@ -1098,11 +1457,18 @@
      l = m.Proc.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   if len(m.Addrs) > 0 {
      for _, e := range m.Addrs {
         l = e.Size()
         n += 1 + l + sovBhomeMsgApi(uint64(l))
      }
   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
}
@@ -1143,9 +1509,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
}
@@ -1186,8 +1603,46 @@
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field MqId", wireType)
         }
         m.MqId = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.MqId |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field AbsAddr", wireType)
         }
         m.AbsAddr = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.AbsAddr |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
@@ -1214,11 +1669,30 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.MqId = append(m.MqId[:0], dAtA[iNdEx:postIndex]...)
         if m.MqId == nil {
            m.MqId = []byte{}
         m.Ip = append(m.Ip[:0], dAtA[iNdEx:postIndex]...)
         if m.Ip == nil {
            m.Ip = []byte{}
         }
         iNdEx = postIndex
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
         }
         m.Port = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Port |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
@@ -2036,9 +2510,62 @@
            return err
         }
         iNdEx = postIndex
      case 2:
      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 *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 Addrs", wireType)
            return fmt.Errorf("proto: wrong wireType = %d for field Proc", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
@@ -2065,8 +2592,10 @@
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Addrs = append(m.Addrs, &BHAddress{})
         if err := m.Addrs[len(m.Addrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
         if m.Proc == nil {
            m.Proc = &ProcInfo{}
         }
         if err := m.Proc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
@@ -2337,7 +2866,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 {
@@ -2364,10 +2893,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