refactor, log dir.

lichao

2021-05-26 a011a040996dd4cdb0152aae2206aebc7f4f7034

 proto/source/bhome_msg/bhome_msg_api.pb.go

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

type BHAddress struct {
   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"`
   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{} }
@@ -64,6 +65,13 @@
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
}
@@ -395,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{} }
@@ -435,13 +442,6 @@
func (m *MsgRegister) GetProc() *ProcInfo {
   if m != nil {
      return m.Proc
   }
   return nil
}

func (m *MsgRegister) GetAddrs() []*BHAddress {
   if m != nil {
      return m.Addrs
   }
   return nil
}
@@ -727,8 +727,8 @@
}

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"`
   Errmsg   *ErrorMsg                 `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
   ProcList []*MsgQueryProcReply_Info `protobuf:"bytes,2,rep,name=proc_list,json=procList,proto3" json:"proc_list,omitempty"`
}

func (m *MsgQueryProcReply) Reset()         { *m = MsgQueryProcReply{} }
@@ -771,9 +771,69 @@
   return nil
}

func (m *MsgQueryProcReply) GetProc() []*ProcInfo {
func (m *MsgQueryProcReply) GetProcList() []*MsgQueryProcReply_Info {
   if m != nil {
      return m.ProcList
   }
   return nil
}

type MsgQueryProcReply_Info struct {
   Proc   *ProcInfo     `protobuf:"bytes,1,opt,name=proc,proto3" json:"proc,omitempty"`
   Online bool          `protobuf:"varint,2,opt,name=online,proto3" json:"online,omitempty"`
   Topics *MsgTopicList `protobuf:"bytes,3,opt,name=topics,proto3" json:"topics,omitempty"`
}

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

var xxx_messageInfo_MsgQueryProcReply_Info proto.InternalMessageInfo

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

func (m *MsgQueryProcReply_Info) GetOnline() bool {
   if m != nil {
      return m.Online
   }
   return false
}

func (m *MsgQueryProcReply_Info) GetTopics() *MsgTopicList {
   if m != nil {
      return m.Topics
   }
   return nil
}
@@ -794,46 +854,51 @@
   proto.RegisterType((*MsgQueryTopicReply_BHNodeAddress)(nil), "bhome_msg.MsgQueryTopicReply.BHNodeAddress")
   proto.RegisterType((*MsgQueryProc)(nil), "bhome_msg.MsgQueryProc")
   proto.RegisterType((*MsgQueryProcReply)(nil), "bhome_msg.MsgQueryProcReply")
   proto.RegisterType((*MsgQueryProcReply_Info)(nil), "bhome_msg.MsgQueryProcReply.Info")
}

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

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

func (m *BHAddress) Marshal() (dAtA []byte, err error) {
@@ -856,14 +921,19 @@
      i++
      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] = 0x12
      dAtA[i] = 0x1a
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(len(m.Ip)))
      i += copy(dAtA[i:], m.Ip)
   }
   if m.Port != 0 {
      dAtA[i] = 0x18
      dAtA[i] = 0x20
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Port))
   }
@@ -1085,18 +1155,6 @@
      }
      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
}

@@ -1303,8 +1361,8 @@
      }
      i += n8
   }
   if len(m.Proc) > 0 {
      for _, msg := range m.Proc {
   if len(m.ProcList) > 0 {
      for _, msg := range m.ProcList {
         dAtA[i] = 0x12
         i++
         i = encodeVarintBhomeMsgApi(dAtA, i, uint64(msg.Size()))
@@ -1314,6 +1372,54 @@
         }
         i += n
      }
   }
   return i, nil
}

func (m *MsgQueryProcReply_Info) 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_Info) 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()))
      n9, err9 := m.Proc.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n9
   }
   if m.Online {
      dAtA[i] = 0x10
      i++
      if m.Online {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if m.Topics != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintBhomeMsgApi(dAtA, i, uint64(m.Topics.Size()))
      n10, err10 := m.Topics.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      }
      i += n10
   }
   return i, nil
}
@@ -1335,6 +1441,9 @@
   _ = l
   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 {
@@ -1460,12 +1569,6 @@
      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
}

@@ -1567,11 +1670,31 @@
      l = m.Errmsg.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   if len(m.Proc) > 0 {
      for _, e := range m.Proc {
   if len(m.ProcList) > 0 {
      for _, e := range m.ProcList {
         l = e.Size()
         n += 1 + l + sovBhomeMsgApi(uint64(l))
      }
   }
   return n
}

func (m *MsgQueryProcReply_Info) 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))
   }
   if m.Online {
      n += 2
   }
   if m.Topics != nil {
      l = m.Topics.Size()
      n += 1 + l + sovBhomeMsgApi(uint64(l))
   }
   return n
}
@@ -1631,6 +1754,25 @@
            }
         }
      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)
         }
@@ -1664,7 +1806,7 @@
            m.Ip = []byte{}
         }
         iNdEx = postIndex
      case 3:
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
         }
@@ -2500,40 +2642,6 @@
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Addrs", 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.Addrs = append(m.Addrs, &BHAddress{})
         if err := m.Addrs[len(m.Addrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipBhomeMsgApi(dAtA[iNdEx:])
@@ -3223,6 +3331,93 @@
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ProcList", 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.ProcList = append(m.ProcList, &MsgQueryProcReply_Info{})
         if err := m.ProcList[len(m.ProcList)-1].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 *MsgQueryProcReply_Info) 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: Info: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Info: 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
@@ -3250,8 +3445,66 @@
         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 {
         if m.Proc == nil {
            m.Proc = &ProcInfo{}
         }
         if err := m.Proc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Online", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowBhomeMsgApi
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.Online = bool(v != 0)
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Topics", 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.Topics == nil {
            m.Topics = &MsgTopicList{}
         }
         if err := m.Topics.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex