更新dataprocess.pb

zhangzengfei

2024-05-08 80ae7958a17a492098f18f31fa21804f37b6cbaa

 sysset.pb.go

@@ -203,10 +203,11 @@
}

type PollConfig struct {
   ServerId   string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   PollPeriod int32  `protobuf:"varint,2,opt,name=poll_period,json=pollPeriod,proto3" json:"poll_period,omitempty"`
   Delay      int32  `protobuf:"varint,3,opt,name=delay,proto3" json:"delay,omitempty"`
   Enable     bool   `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
   ServerId         string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   PollPeriod       int32  `protobuf:"varint,2,opt,name=poll_period,json=pollPeriod,proto3" json:"poll_period,omitempty"`
   Delay            int32  `protobuf:"varint,3,opt,name=delay,proto3" json:"delay,omitempty"`
   Enable           bool   `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
   PollChannelCount int32  `protobuf:"varint,5,opt,name=pollChannelCount,proto3" json:"pollChannelCount,omitempty"`
}

func (m *PollConfig) Reset()         { *m = PollConfig{} }
@@ -268,6 +269,13 @@
      return m.Enable
   }
   return false
}

func (m *PollConfig) GetPollChannelCount() int32 {
   if m != nil {
      return m.PollChannelCount
   }
   return 0
}

type Cluster struct {
@@ -438,55 +446,236 @@
   return ""
}

type ResourceConfig struct {
   IpType    int32  `protobuf:"varint,1,opt,name=ipType,proto3" json:"ipType,omitempty"`
   ServiceIp string `protobuf:"bytes,2,opt,name=serviceIp,proto3" json:"serviceIp,omitempty"`
   Domain    string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"`
   FilePort  int32  `protobuf:"varint,4,opt,name=filePort,proto3" json:"filePort,omitempty"`
}

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

var xxx_messageInfo_ResourceConfig proto.InternalMessageInfo

func (m *ResourceConfig) GetIpType() int32 {
   if m != nil {
      return m.IpType
   }
   return 0
}

func (m *ResourceConfig) GetServiceIp() string {
   if m != nil {
      return m.ServiceIp
   }
   return ""
}

func (m *ResourceConfig) GetDomain() string {
   if m != nil {
      return m.Domain
   }
   return ""
}

func (m *ResourceConfig) GetFilePort() int32 {
   if m != nil {
      return m.FilePort
   }
   return 0
}

type Gb28181Config struct {
   Id           string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
   ServerIp     string `protobuf:"bytes,2,opt,name=ServerIp,proto3" json:"ServerIp,omitempty"`
   ServerPort   string `protobuf:"bytes,3,opt,name=ServerPort,proto3" json:"ServerPort,omitempty"`
   PublicId     string `protobuf:"bytes,4,opt,name=PublicId,proto3" json:"PublicId,omitempty"`
   GbServerPort string `protobuf:"bytes,5,opt,name=GbServerPort,proto3" json:"GbServerPort,omitempty"`
   IsAuth       bool   `protobuf:"varint,6,opt,name=IsAuth,proto3" json:"IsAuth,omitempty"`
   Password     string `protobuf:"bytes,7,opt,name=Password,proto3" json:"Password,omitempty"`
   UpdateTime   string `protobuf:"bytes,8,opt,name=UpdateTime,proto3" json:"UpdateTime,omitempty"`
}

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

var xxx_messageInfo_Gb28181Config proto.InternalMessageInfo

func (m *Gb28181Config) GetId() string {
   if m != nil {
      return m.Id
   }
   return ""
}

func (m *Gb28181Config) GetServerIp() string {
   if m != nil {
      return m.ServerIp
   }
   return ""
}

func (m *Gb28181Config) GetServerPort() string {
   if m != nil {
      return m.ServerPort
   }
   return ""
}

func (m *Gb28181Config) GetPublicId() string {
   if m != nil {
      return m.PublicId
   }
   return ""
}

func (m *Gb28181Config) GetGbServerPort() string {
   if m != nil {
      return m.GbServerPort
   }
   return ""
}

func (m *Gb28181Config) GetIsAuth() bool {
   if m != nil {
      return m.IsAuth
   }
   return false
}

func (m *Gb28181Config) GetPassword() string {
   if m != nil {
      return m.Password
   }
   return ""
}

func (m *Gb28181Config) GetUpdateTime() string {
   if m != nil {
      return m.UpdateTime
   }
   return ""
}

func init() {
   proto.RegisterType((*LocalConfig)(nil), "protomsg.LocalConfig")
   proto.RegisterType((*PollConfig)(nil), "protomsg.PollConfig")
   proto.RegisterType((*Cluster)(nil), "protomsg.Cluster")
   proto.RegisterType((*ClusterNode)(nil), "protomsg.ClusterNode")
   proto.RegisterType((*ResourceConfig)(nil), "protomsg.ResourceConfig")
   proto.RegisterType((*Gb28181Config)(nil), "protomsg.Gb28181Config")
}

func init() { proto.RegisterFile("sysset.proto", fileDescriptor_5be590c6b2a0d755) }

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

func (m *LocalConfig) Marshal() (dAtA []byte, err error) {
@@ -653,6 +842,11 @@
      }
      i++
   }
   if m.PollChannelCount != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.PollChannelCount))
   }
   return i, nil
}

@@ -770,6 +964,116 @@
   return i, nil
}

func (m *ResourceConfig) 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 *ResourceConfig) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.IpType != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.IpType))
   }
   if len(m.ServiceIp) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServiceIp)))
      i += copy(dAtA[i:], m.ServiceIp)
   }
   if len(m.Domain) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Domain)))
      i += copy(dAtA[i:], m.Domain)
   }
   if m.FilePort != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.FilePort))
   }
   return i, nil
}

func (m *Gb28181Config) 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 *Gb28181Config) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.ServerIp) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
      i += copy(dAtA[i:], m.ServerIp)
   }
   if len(m.ServerPort) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerPort)))
      i += copy(dAtA[i:], m.ServerPort)
   }
   if len(m.PublicId) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.PublicId)))
      i += copy(dAtA[i:], m.PublicId)
   }
   if len(m.GbServerPort) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.GbServerPort)))
      i += copy(dAtA[i:], m.GbServerPort)
   }
   if m.IsAuth {
      dAtA[i] = 0x30
      i++
      if m.IsAuth {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.Password) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
      i += copy(dAtA[i:], m.Password)
   }
   if len(m.UpdateTime) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.UpdateTime)))
      i += copy(dAtA[i:], m.UpdateTime)
   }
   return i, nil
}

func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -870,6 +1174,9 @@
   if m.Enable {
      n += 2
   }
   if m.PollChannelCount != 0 {
      n += 1 + sovSysset(uint64(m.PollChannelCount))
   }
   return n
}

@@ -935,6 +1242,69 @@
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.CreateTime)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   return n
}

func (m *ResourceConfig) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.IpType != 0 {
      n += 1 + sovSysset(uint64(m.IpType))
   }
   l = len(m.ServiceIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.Domain)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.FilePort != 0 {
      n += 1 + sovSysset(uint64(m.FilePort))
   }
   return n
}

func (m *Gb28181Config) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerPort)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.PublicId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.GbServerPort)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.IsAuth {
      n += 2
   }
   l = len(m.Password)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.UpdateTime)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
@@ -1578,6 +1948,25 @@
            }
         }
         m.Enable = bool(v != 0)
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field PollChannelCount", wireType)
         }
         m.PollChannelCount = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.PollChannelCount |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSysset(dAtA[iNdEx:])
@@ -2094,6 +2483,458 @@
   }
   return nil
}
func (m *ResourceConfig) 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 ErrIntOverflowSysset
         }
         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: ResourceConfig: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ResourceConfig: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IpType", wireType)
         }
         m.IpType = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.IpType |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServiceIp", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ServiceIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Domain = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field FilePort", wireType)
         }
         m.FilePort = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.FilePort |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSysset(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSysset
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSysset
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *Gb28181Config) 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 ErrIntOverflowSysset
         }
         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: Gb28181Config: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Gb28181Config: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerIp", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ServerIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerPort", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ServerPort = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PublicId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.PublicId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field GbServerPort", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.GbServerPort = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IsAuth", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.IsAuth = bool(v != 0)
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Password = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.UpdateTime = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipSysset(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSysset
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSysset
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func skipSysset(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0