重新生成pb.go

liuxiaolong

2021-04-25 238b3cab1bc1c6b2f1b2f03df3a78c8d1db6c685

重新生成pb.go

 proto/source/bhome_msg/bhome_msg.pb.go

@@ -42,6 +42,8 @@
    MsgType_kMsgTypeSubscribe MsgType = 22
    // kMsgTypeSubscribeReply = 23;
    MsgType_kMsgTypeUnsubscribe MsgType = 24
    // kMsgTypeUnsubscribeReply = 25;
    MsgType_kMsgTypeUnregister MsgType = 26
)

var MsgType_name = map[int32]string{
@@ -58,6 +60,7 @@
    20: "kMsgTypePublish",
    22: "kMsgTypeSubscribe",
    24: "kMsgTypeUnsubscribe",
    26: "kMsgTypeUnregister",
}

var MsgType_value = map[string]int32{
@@ -74,6 +77,7 @@
    "kMsgTypePublish":           20,
    "kMsgTypeSubscribe":         22,
    "kMsgTypeUnsubscribe":       24,
    "kMsgTypeUnregister":        26,
}

func (x MsgType) String() string {
@@ -693,47 +697,48 @@
func init() { proto.RegisterFile("bhome_msg.proto", fileDescriptor_88ce6d52215a3d3f) }

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

func (m *BHMsgHead) Marshal() (dAtA []byte, err error) {

 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