remove AtomicQueue, not used.

lichao

2021-06-01 72851db66655912cb9c92300a80985fb9797d168

 proto/source/bhome_msg/bhome_msg.pb.go

@@ -25,10 +25,12 @@
type MsgType int32

const (
   MsgType_kMsgTypeInvalid     MsgType = 0
   MsgType_kMsgTypeRawData     MsgType = 1
   MsgType_kMsgTypeCommonReply MsgType = 2
   MsgType_kMsgTypeRegister    MsgType = 10
   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
   // kMsgTypeHeartbeatReply = 13;
@@ -42,12 +44,19 @@
   MsgType_kMsgTypeSubscribe MsgType = 22
   // kMsgTypeSubscribeReply = 23;
   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",
@@ -58,12 +67,17 @@
   20: "kMsgTypePublish",
   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,
@@ -74,6 +88,9 @@
   "kMsgTypePublish":           20,
   "kMsgTypeSubscribe":         22,
   "kMsgTypeUnsubscribe":       24,
   "kMsgTypeUnregister":        26,
   "kMsgTypeQueryProc":         28,
   "kMsgTypeQueryProcReply":    29,
}

func (x MsgType) String() string {
@@ -89,8 +106,10 @@
   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"`
   Dest      *BHAddress   `protobuf:"bytes,8,opt,name=dest,proto3" json:"dest,omitempty"`
}

func (m *BHMsgHead) Reset()         { *m = BHMsgHead{} }
@@ -154,6 +173,13 @@
   return 0
}

func (m *BHMsgHead) GetSsnId() uint64 {
   if m != nil {
      return m.SsnId
   }
   return 0
}

func (m *BHMsgHead) GetProcId() []byte {
   if m != nil {
      return m.ProcId
@@ -164,6 +190,13 @@
func (m *BHMsgHead) GetTopic() []byte {
   if m != nil {
      return m.Topic
   }
   return nil
}

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

func (m *BHMsgHead) Marshal() (dAtA []byte, err error) {
@@ -779,17 +928,32 @@
      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)
   }
   if m.Dest != nil {
      dAtA[i] = 0x42
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Dest.Size()))
      n1, err1 := m.Dest.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i += n1
   }
   return i, nil
}
@@ -813,11 +977,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Topics.Size()))
      n1, err1 := m.Topics.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      n2, err2 := m.Topics.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      }
      i += n1
      i += n2
   }
   return i, nil
}
@@ -841,11 +1005,11 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Topics.Size()))
      n2, err2 := m.Topics.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      n3, err3 := m.Topics.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      }
      i += n2
      i += n3
   }
   return i, nil
}
@@ -869,11 +1033,79 @@
      dAtA[i] = 0xa
      i++
      i = encodeVarintBhomeMsg(dAtA, i, uint64(m.Topics.Size()))
      n3, err3 := m.Topics.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      n4, err4 := m.Topics.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n3
      i += n4
   }
   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()))
      n5, err5 := m.Errmsg.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n5
   }
   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
}
@@ -894,11 +1126,11 @@
   var l int
   _ = l
   if m.Request != nil {
      nn4, err4 := m.Request.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      nn6, err6 := m.Request.MarshalTo(dAtA[i:])
      if err6 != nil {
         return 0, err6
      }
      i += nn4
      i += nn6
   }
   return i, nil
}
@@ -909,11 +1141,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
      n7, err7 := m.Register.MarshalTo(dAtA[i:])
      if err7 != nil {
         return 0, err7
      }
      i += n5
      i += n7
   }
   return i, nil
}
@@ -923,11 +1155,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
      n8, err8 := m.TopicRequest.MarshalTo(dAtA[i:])
      if err8 != nil {
         return 0, err8
      }
      i += n6
      i += n8
   }
   return i, nil
}
@@ -937,11 +1169,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
      n9, err9 := m.TopicQuery.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      }
      i += n7
      i += n9
   }
   return i, nil
}
@@ -964,11 +1196,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
      n10, err10 := m.ErrMsg.MarshalTo(dAtA[i:])
      if err10 != nil {
         return 0, err10
      }
      i += n8
      i += n10
   }
   return i, nil
}
@@ -989,11 +1221,11 @@
   var l int
   _ = l
   if m.Reqrep != nil {
      nn9, err9 := m.Reqrep.MarshalTo(dAtA[i:])
      if err9 != nil {
         return 0, err9
      nn11, err11 := m.Reqrep.MarshalTo(dAtA[i:])
      if err11 != nil {
         return 0, err11
      }
      i += nn9
      i += nn11
   }
   return i, nil
}
@@ -1004,11 +1236,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
      n12, err12 := m.Request.MarshalTo(dAtA[i:])
      if err12 != nil {
         return 0, err12
      }
      i += n10
      i += n12
   }
   return i, nil
}
@@ -1018,11 +1250,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
      n13, err13 := m.Reply.MarshalTo(dAtA[i:])
      if err13 != nil {
         return 0, err13
      }
      i += n11
      i += n13
   }
   return i, nil
}
@@ -1057,12 +1289,19 @@
   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 {
      n += 1 + l + sovBhomeMsg(uint64(l))
   }
   l = len(m.Topic)
   if l > 0 {
      n += 1 + l + sovBhomeMsg(uint64(l))
   }
   if m.Dest != nil {
      l = m.Dest.Size()
      n += 1 + l + sovBhomeMsg(uint64(l))
   }
   return n
@@ -1103,6 +1342,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
}
@@ -1347,6 +1620,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)
         }
@@ -1380,7 +1672,7 @@
            m.ProcId = []byte{}
         }
         iNdEx = postIndex
      case 6:
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Topic", wireType)
         }
@@ -1412,6 +1704,42 @@
         m.Topic = append(m.Topic[:0], dAtA[iNdEx:postIndex]...)
         if m.Topic == nil {
            m.Topic = []byte{}
         }
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Dest", 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.Dest == nil {
            m.Dest = &BHAddress{}
         }
         if err := m.Dest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
@@ -1705,6 +2033,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