重新生成proto

liuxiaolong

2021-05-19 d31fa2331c113a333f81347157ae4c5e64664393

重新生成proto

 proto/source/bhome_msg/bhome_msg.pb.go

@@ -28,6 +28,8 @@
    MsgType_kMsgTypeInvalid     MsgType = 0
    MsgType_kMsgTypeRawData     MsgType = 1
    MsgType_kMsgTypeCommonReply MsgType = 2
    MsgType_kMsgTypeProcInit      MsgType = 8
    MsgType_kMsgTypeProcInitReply MsgType = 9
    MsgType_kMsgTypeRegister    MsgType = 10
    // kMsgTypeRegisterReply= 11;
    MsgType_kMsgTypeHeartbeat MsgType = 12
@@ -44,12 +46,17 @@
    MsgType_kMsgTypeUnsubscribe MsgType = 24
    // kMsgTypeUnsubscribeReply = 25;
    MsgType_kMsgTypeUnregister MsgType = 26
    // kMsgTypeUnregisterReply = 27;
    MsgType_kMsgTypeQueryProc      MsgType = 28
    MsgType_kMsgTypeQueryProcReply MsgType = 29
)

var MsgType_name = map[int32]string{
    0:  "kMsgTypeInvalid",
    1:  "kMsgTypeRawData",
    2:  "kMsgTypeCommonReply",
    8:  "kMsgTypeProcInit",
    9:  "kMsgTypeProcInitReply",
    10: "kMsgTypeRegister",
    12: "kMsgTypeHeartbeat",
    14: "kMsgTypeQueryTopic",
@@ -61,12 +68,16 @@
    22: "kMsgTypeSubscribe",
    24: "kMsgTypeUnsubscribe",
    26: "kMsgTypeUnregister",
    28: "kMsgTypeQueryProc",
    29: "kMsgTypeQueryProcReply",
}

var MsgType_value = map[string]int32{
    "kMsgTypeInvalid":           0,
    "kMsgTypeRawData":           1,
    "kMsgTypeCommonReply":       2,
    "kMsgTypeProcInit":          8,
    "kMsgTypeProcInitReply":     9,
    "kMsgTypeRegister":          10,
    "kMsgTypeHeartbeat":         12,
    "kMsgTypeQueryTopic":        14,
@@ -78,6 +89,8 @@
    "kMsgTypeSubscribe":         22,
    "kMsgTypeUnsubscribe":       24,
    "kMsgTypeUnregister":        26,
    "kMsgTypeQueryProc":         28,
    "kMsgTypeQueryProcReply":    29,
}

func (x MsgType) String() string {
@@ -93,8 +106,9 @@
    Route     []*BHAddress `protobuf:"bytes,2,rep,name=route,proto3" json:"route,omitempty"`
    Timestamp int64        `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
    Type      int32        `protobuf:"varint,4,opt,name=type,proto3" json:"type,omitempty"`
    ProcId    []byte       `protobuf:"bytes,5,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
    Topic     []byte       `protobuf:"bytes,6,opt,name=topic,proto3" json:"topic,omitempty"`
    SsnId     uint64       `protobuf:"varint,5,opt,name=ssn_id,json=ssnId,proto3" json:"ssn_id,omitempty"`
    ProcId    []byte       `protobuf:"bytes,6,opt,name=proc_id,json=procId,proto3" json:"proc_id,omitempty"`
    Topic     []byte       `protobuf:"bytes,7,opt,name=topic,proto3" json:"topic,omitempty"`
}

func (m *BHMsgHead) Reset()         { *m = BHMsgHead{} }
@@ -154,6 +168,13 @@
func (m *BHMsgHead) GetType() int32 {
    if m != nil {
        return m.Type
    }
    return 0
}

func (m *BHMsgHead) GetSsnId() uint64 {
    if m != nil {
        return m.SsnId
    }
    return 0
}
@@ -304,6 +325,110 @@
    return nil
}

type MsgProcInit struct {
    ExtraMqNum int32 `protobuf:"varint,1,opt,name=extra_mq_num,json=extraMqNum,proto3" json:"extra_mq_num,omitempty"`
}

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

var xxx_messageInfo_MsgProcInit proto.InternalMessageInfo

func (m *MsgProcInit) GetExtraMqNum() int32 {
    if m != nil {
        return m.ExtraMqNum
    }
    return 0
}

type MsgProcInitReply struct {
    Errmsg    *ErrorMsg    `protobuf:"bytes,1,opt,name=errmsg,proto3" json:"errmsg,omitempty"`
    ProcIndex int32        `protobuf:"varint,2,opt,name=proc_index,json=procIndex,proto3" json:"proc_index,omitempty"`
    ExtraMqs  []*BHAddress `protobuf:"bytes,3,rep,name=extra_mqs,json=extraMqs,proto3" json:"extra_mqs,omitempty"`
}

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

var xxx_messageInfo_MsgProcInitReply proto.InternalMessageInfo

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

func (m *MsgProcInitReply) GetProcIndex() int32 {
    if m != nil {
        return m.ProcIndex
    }
    return 0
}

func (m *MsgProcInitReply) GetExtraMqs() []*BHAddress {
    if m != nil {
        return m.ExtraMqs
    }
    return nil
}

type MsgRequest struct {
    // oneof body;
    //
@@ -318,7 +443,7 @@
func (m *MsgRequest) String() string { return proto.CompactTextString(m) }
func (*MsgRequest) ProtoMessage()    {}
func (*MsgRequest) Descriptor() ([]byte, []int) {
    return fileDescriptor_88ce6d52215a3d3f, []int{4}
    return fileDescriptor_88ce6d52215a3d3f, []int{6}
}
func (m *MsgRequest) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -496,7 +621,7 @@
func (m *MsgReply) String() string { return proto.CompactTextString(m) }
func (*MsgReply) ProtoMessage()    {}
func (*MsgReply) Descriptor() ([]byte, []int) {
    return fileDescriptor_88ce6d52215a3d3f, []int{5}
    return fileDescriptor_88ce6d52215a3d3f, []int{7}
}
func (m *MsgReply) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -543,7 +668,7 @@
func (m *BHMsgBody) String() string { return proto.CompactTextString(m) }
func (*BHMsgBody) ProtoMessage()    {}
func (*BHMsgBody) Descriptor() ([]byte, []int) {
    return fileDescriptor_88ce6d52215a3d3f, []int{6}
    return fileDescriptor_88ce6d52215a3d3f, []int{8}
}
func (m *BHMsgBody) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -689,6 +814,8 @@
    proto.RegisterType((*MsgSubscribe)(nil), "bhome_msg.MsgSubscribe")
    proto.RegisterType((*MsgUnsubscribe)(nil), "bhome_msg.MsgUnsubscribe")
    proto.RegisterType((*MsgRegisterRPC)(nil), "bhome_msg.MsgRegisterRPC")
    proto.RegisterType((*MsgProcInit)(nil), "bhome_msg.MsgProcInit")
    proto.RegisterType((*MsgProcInitReply)(nil), "bhome_msg.MsgProcInitReply")
    proto.RegisterType((*MsgRequest)(nil), "bhome_msg.MsgRequest")
    proto.RegisterType((*MsgReply)(nil), "bhome_msg.MsgReply")
    proto.RegisterType((*BHMsgBody)(nil), "bhome_msg.BHMsgBody")
@@ -697,48 +824,56 @@
func init() { proto.RegisterFile("bhome_msg.proto", fileDescriptor_88ce6d52215a3d3f) }

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

func (m *BHMsgHead) Marshal() (dAtA []byte, err error) {
@@ -784,14 +919,19 @@
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Type))
    }
    if m.SsnId != 0 {
        dAtA[i] = 0x28
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.SsnId))
    }
    if len(m.ProcId) > 0 {
        dAtA[i] = 0x2a
        dAtA[i] = 0x32
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(len(m.ProcId)))
        i += copy(dAtA[i:], m.ProcId)
    }
    if len(m.Topic) > 0 {
        dAtA[i] = 0x32
        dAtA[i] = 0x3a
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(len(m.Topic)))
        i += copy(dAtA[i:], m.Topic)
@@ -883,6 +1023,74 @@
    return i, nil
}

func (m *MsgProcInit) 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 *MsgProcInit) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.ExtraMqNum != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.ExtraMqNum))
    }
    return i, nil
}

func (m *MsgProcInitReply) 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 *MsgProcInitReply) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Errmsg != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Errmsg.Size()))
        n4, err4 := m.Errmsg.MarshalTo(dAtA[i:])
        if err4 != nil {
            return 0, err4
        }
        i += n4
    }
    if m.ProcIndex != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.ProcIndex))
    }
    if len(m.ExtraMqs) > 0 {
        for _, msg := range m.ExtraMqs {
            dAtA[i] = 0x1a
            i++
            i = encodeVarintBhomeMsg(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    return i, nil
}

func (m *MsgRequest) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
@@ -899,11 +1107,11 @@
    var l int
    _ = l
    if m.Request != nil {
        nn4, err4 := m.Request.MarshalTo(dAtA[i:])
        if err4 != nil {
            return 0, err4
        nn5, err5 := m.Request.MarshalTo(dAtA[i:])
        if err5 != nil {
            return 0, err5
        }
        i += nn4
        i += nn5
    }
    return i, nil
}
@@ -914,11 +1122,11 @@
        dAtA[i] = 0xa
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Register.Size()))
        n5, err5 := m.Register.MarshalTo(dAtA[i:])
        if err5 != nil {
            return 0, err5
        n6, err6 := m.Register.MarshalTo(dAtA[i:])
        if err6 != nil {
            return 0, err6
        }
        i += n5
        i += n6
    }
    return i, nil
}
@@ -928,11 +1136,11 @@
        dAtA[i] = 0x12
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.TopicRequest.Size()))
        n6, err6 := m.TopicRequest.MarshalTo(dAtA[i:])
        if err6 != nil {
            return 0, err6
        n7, err7 := m.TopicRequest.MarshalTo(dAtA[i:])
        if err7 != nil {
            return 0, err7
        }
        i += n6
        i += n7
    }
    return i, nil
}
@@ -942,11 +1150,11 @@
        dAtA[i] = 0x1a
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.TopicQuery.Size()))
        n7, err7 := m.TopicQuery.MarshalTo(dAtA[i:])
        if err7 != nil {
            return 0, err7
        n8, err8 := m.TopicQuery.MarshalTo(dAtA[i:])
        if err8 != nil {
            return 0, err8
        }
        i += n7
        i += n8
    }
    return i, nil
}
@@ -969,11 +1177,11 @@
        dAtA[i] = 0xa
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.ErrMsg.Size()))
        n8, err8 := m.ErrMsg.MarshalTo(dAtA[i:])
        if err8 != nil {
            return 0, err8
        n9, err9 := m.ErrMsg.MarshalTo(dAtA[i:])
        if err9 != nil {
            return 0, err9
        }
        i += n8
        i += n9
    }
    return i, nil
}
@@ -994,11 +1202,11 @@
    var l int
    _ = l
    if m.Reqrep != nil {
        nn9, err9 := m.Reqrep.MarshalTo(dAtA[i:])
        if err9 != nil {
            return 0, err9
        nn10, err10 := m.Reqrep.MarshalTo(dAtA[i:])
        if err10 != nil {
            return 0, err10
        }
        i += nn9
        i += nn10
    }
    return i, nil
}
@@ -1009,11 +1217,11 @@
        dAtA[i] = 0xa
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Request.Size()))
        n10, err10 := m.Request.MarshalTo(dAtA[i:])
        if err10 != nil {
            return 0, err10
        n11, err11 := m.Request.MarshalTo(dAtA[i:])
        if err11 != nil {
            return 0, err11
        }
        i += n10
        i += n11
    }
    return i, nil
}
@@ -1023,11 +1231,11 @@
        dAtA[i] = 0x12
        i++
        i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Reply.Size()))
        n11, err11 := m.Reply.MarshalTo(dAtA[i:])
        if err11 != nil {
            return 0, err11
        n12, err12 := m.Reply.MarshalTo(dAtA[i:])
        if err12 != nil {
            return 0, err12
        }
        i += n11
        i += n12
    }
    return i, nil
}
@@ -1061,6 +1269,9 @@
    }
    if m.Type != 0 {
        n += 1 + sovBhomeMsg(uint64(m.Type))
    }
    if m.SsnId != 0 {
        n += 1 + sovBhomeMsg(uint64(m.SsnId))
    }
    l = len(m.ProcId)
    if l > 0 {
@@ -1108,6 +1319,40 @@
    if m.Topics != nil {
        l = m.Topics.Size()
        n += 1 + l + sovBhomeMsg(uint64(l))
    }
    return n
}

func (m *MsgProcInit) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.ExtraMqNum != 0 {
        n += 1 + sovBhomeMsg(uint64(m.ExtraMqNum))
    }
    return n
}

func (m *MsgProcInitReply) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Errmsg != nil {
        l = m.Errmsg.Size()
        n += 1 + l + sovBhomeMsg(uint64(l))
    }
    if m.ProcIndex != 0 {
        n += 1 + sovBhomeMsg(uint64(m.ProcIndex))
    }
    if len(m.ExtraMqs) > 0 {
        for _, e := range m.ExtraMqs {
            l = e.Size()
            n += 1 + l + sovBhomeMsg(uint64(l))
        }
    }
    return n
}
@@ -1352,6 +1597,25 @@
                }
            }
        case 5:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field SsnId", wireType)
            }
            m.SsnId = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowBhomeMsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.SsnId |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field ProcId", wireType)
            }
@@ -1385,7 +1649,7 @@
                m.ProcId = []byte{}
            }
            iNdEx = postIndex
        case 6:
        case 7:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
            }
@@ -1710,6 +1974,220 @@
    }
    return nil
}
func (m *MsgProcInit) 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 ErrIntOverflowBhomeMsg
            }
            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: MsgProcInit: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: MsgProcInit: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field ExtraMqNum", wireType)
            }
            m.ExtraMqNum = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowBhomeMsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.ExtraMqNum |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipBhomeMsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *MsgProcInitReply) 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 ErrIntOverflowBhomeMsg
            }
            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: MsgProcInitReply: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: MsgProcInitReply: 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 ErrIntOverflowBhomeMsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            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 != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field ProcIndex", wireType)
            }
            m.ProcIndex = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowBhomeMsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.ProcIndex |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field ExtraMqs", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowBhomeMsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.ExtraMqs = append(m.ExtraMqs, &BHAddress{})
            if err := m.ExtraMqs[len(m.ExtraMqs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipBhomeMsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthBhomeMsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *MsgRequest) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0

 proto/source/bhome_msg/bhome_msg_api.pb.go

@@ -24,8 +24,9 @@

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"`
    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
}
@@ -396,7 +404,6 @@

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"`
}

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
}
@@ -799,41 +799,42 @@
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,
    // 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) {
@@ -856,14 +857,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))
    }
@@ -1084,18 +1090,6 @@
            return 0, err3
        }
        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
}
@@ -1336,6 +1330,9 @@
    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))
@@ -1459,12 +1456,6 @@
    if m.Proc != nil {
        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
}
@@ -1631,6 +1622,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 +1674,7 @@
                m.Ip = []byte{}
            }
            iNdEx = postIndex
        case 3:
        case 4:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
            }
@@ -2497,40 +2507,6 @@
                m.Proc = &ProcInfo{}
            }
            if err := m.Proc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                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