refactor, clean up useless code.

lichao

2021-06-01 365c864a587365fe443b11cc0cd7cfc8f8f8eb81

 proto/source/bhome_msg/bhome_msg_api.pb.go

@@ -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,47 +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{
   // 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,
   // 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) {
@@ -1297,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()))
@@ -1308,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
}
@@ -1558,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
}
@@ -3199,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
@@ -3226,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