更新dataprocess.pb

zhangzengfei

2024-05-08 80ae7958a17a492098f18f31fa21804f37b6cbaa

 sysset.pb.go

@@ -8,6 +8,7 @@
   proto "github.com/gogo/protobuf/proto"
   io "io"
   math "math"
   math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -22,22 +23,24 @@
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type LocalConfig struct {
   ServerId       string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   ServerName     string `protobuf:"bytes,2,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
   ServerType     int32  `protobuf:"varint,3,opt,name=server_type,json=serverType,proto3" json:"server_type,omitempty"`
   ServerIp       string `protobuf:"bytes,4,opt,name=server_ip,json=serverIp,proto3" json:"server_ip,omitempty"`
   AlarmIp        string `protobuf:"bytes,5,opt,name=alarm_ip,json=alarmIp,proto3" json:"alarm_ip,omitempty"`
   AlarmPort      int32  `protobuf:"varint,6,opt,name=alarm_port,json=alarmPort,proto3" json:"alarm_port,omitempty"`
   WebPicIp       string `protobuf:"bytes,7,opt,name=web_pic_ip,json=webPicIp,proto3" json:"web_pic_ip,omitempty"`
   WebPicPort     int32  `protobuf:"varint,8,opt,name=web_pic_port,json=webPicPort,proto3" json:"web_pic_port,omitempty"`
   EsPicIp        string `protobuf:"bytes,9,opt,name=es_pic_ip,json=esPicIp,proto3" json:"es_pic_ip,omitempty"`
   EsPicPort      int32  `protobuf:"varint,10,opt,name=es_pic_port,json=esPicPort,proto3" json:"es_pic_port,omitempty"`
   CutMaxDuration int32  `protobuf:"varint,11,opt,name=cut_max_duration,json=cutMaxDuration,proto3" json:"cut_max_duration,omitempty"`
   CutMinDuration int32  `protobuf:"varint,12,opt,name=cut_min_duration,json=cutMinDuration,proto3" json:"cut_min_duration,omitempty"`
   Reserved       string `protobuf:"bytes,13,opt,name=reserved,proto3" json:"reserved,omitempty"`
   GateWay        string `protobuf:"bytes,14,opt,name=gate_way,json=gateWay,proto3" json:"gate_way,omitempty"`
   NetMask        string `protobuf:"bytes,15,opt,name=net_mask,json=netMask,proto3" json:"net_mask,omitempty"`
   RealMax        int32  `protobuf:"varint,16,opt,name=real_max,json=realMax,proto3" json:"real_max,omitempty"`
   ServerId           string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   ServerName         string `protobuf:"bytes,2,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
   ServerType         int32  `protobuf:"varint,3,opt,name=server_type,json=serverType,proto3" json:"server_type,omitempty"`
   ServerIp           string `protobuf:"bytes,4,opt,name=server_ip,json=serverIp,proto3" json:"server_ip,omitempty"`
   AlarmIp            string `protobuf:"bytes,5,opt,name=alarm_ip,json=alarmIp,proto3" json:"alarm_ip,omitempty"`
   AlarmPort          int32  `protobuf:"varint,6,opt,name=alarm_port,json=alarmPort,proto3" json:"alarm_port,omitempty"`
   WebPicIp           string `protobuf:"bytes,7,opt,name=web_pic_ip,json=webPicIp,proto3" json:"web_pic_ip,omitempty"`
   WebPicPort         int32  `protobuf:"varint,8,opt,name=web_pic_port,json=webPicPort,proto3" json:"web_pic_port,omitempty"`
   EsPicIp            string `protobuf:"bytes,9,opt,name=es_pic_ip,json=esPicIp,proto3" json:"es_pic_ip,omitempty"`
   EsPicPort          int32  `protobuf:"varint,10,opt,name=es_pic_port,json=esPicPort,proto3" json:"es_pic_port,omitempty"`
   CutMaxDuration     int32  `protobuf:"varint,11,opt,name=cut_max_duration,json=cutMaxDuration,proto3" json:"cut_max_duration,omitempty"`
   CutMinDuration     int32  `protobuf:"varint,12,opt,name=cut_min_duration,json=cutMinDuration,proto3" json:"cut_min_duration,omitempty"`
   Reserved           string `protobuf:"bytes,13,opt,name=reserved,proto3" json:"reserved,omitempty"`
   GateWay            string `protobuf:"bytes,14,opt,name=gate_way,json=gateWay,proto3" json:"gate_way,omitempty"`
   NetMask            string `protobuf:"bytes,15,opt,name=net_mask,json=netMask,proto3" json:"net_mask,omitempty"`
   RealMax            int32  `protobuf:"varint,16,opt,name=real_max,json=realMax,proto3" json:"real_max,omitempty"`
   AlarmThresholdType int32  `protobuf:"varint,17,opt,name=alarm_threshold_type,json=alarmThresholdType,proto3" json:"alarm_threshold_type,omitempty"`
   AlarmThreshold     int32  `protobuf:"varint,18,opt,name=alarm_threshold,json=alarmThreshold,proto3" json:"alarm_threshold,omitempty"`
}

func (m *LocalConfig) Reset()         { *m = LocalConfig{} }
@@ -185,11 +188,26 @@
   return 0
}

func (m *LocalConfig) GetAlarmThresholdType() int32 {
   if m != nil {
      return m.AlarmThresholdType
   }
   return 0
}

func (m *LocalConfig) GetAlarmThreshold() int32 {
   if m != nil {
      return m.AlarmThreshold
   }
   return 0
}

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{} }
@@ -251,6 +269,13 @@
      return m.Enable
   }
   return false
}

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

type Cluster struct {
@@ -421,53 +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{
   // 568 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcd, 0x6e, 0x13, 0x3f,
   0x10, 0xef, 0xa6, 0x4d, 0xb2, 0x3b, 0x9b, 0x7f, 0xff, 0x95, 0xc5, 0x87, 0x29, 0xb0, 0x84, 0x9c,
   0x22, 0x21, 0xf5, 0x00, 0x6f, 0x40, 0xb9, 0x44, 0xa2, 0x55, 0x14, 0x55, 0xe2, 0x18, 0x39, 0xeb,
   0xa1, 0xb2, 0xba, 0xbb, 0xb6, 0x6c, 0xa7, 0xc9, 0xde, 0x78, 0x04, 0xde, 0x85, 0x97, 0xe0, 0x82,
   0xd4, 0x23, 0x47, 0xd4, 0xbe, 0x08, 0xb2, 0xbd, 0x9b, 0xa4, 0x45, 0x42, 0x9c, 0x76, 0xe7, 0xf7,
   0x31, 0x33, 0xb6, 0x67, 0x60, 0x60, 0x6a, 0x63, 0xd0, 0x9e, 0x28, 0x2d, 0xad, 0x24, 0xb1, 0xff,
   0x94, 0xe6, 0x72, 0xf4, 0xe5, 0x00, 0xd2, 0x8f, 0x32, 0x67, 0xc5, 0xa9, 0xac, 0x3e, 0x8b, 0x4b,
   0xf2, 0x1c, 0x12, 0x83, 0xfa, 0x1a, 0xf5, 0x5c, 0x70, 0x1a, 0x0d, 0xa3, 0x71, 0x32, 0x8b, 0x03,
   0x30, 0xe1, 0xe4, 0x15, 0xa4, 0x0d, 0x59, 0xb1, 0x12, 0x69, 0xc7, 0xd3, 0x10, 0xa0, 0x73, 0x56,
   0xe2, 0x8e, 0xc0, 0xd6, 0x0a, 0xe9, 0xfe, 0x30, 0x1a, 0x77, 0x5b, 0xc1, 0x45, 0xad, 0x70, 0x37,
   0xbd, 0xa2, 0x07, 0xf7, 0xd2, 0x2b, 0xf2, 0x0c, 0x62, 0x56, 0x30, 0x5d, 0x3a, 0xae, 0xeb, 0xb9,
   0xbe, 0x8f, 0x27, 0x8a, 0xbc, 0x04, 0x08, 0x94, 0x92, 0xda, 0xd2, 0x9e, 0xcf, 0x9b, 0x78, 0x64,
   0x2a, 0xb5, 0x25, 0x2f, 0x00, 0x56, 0xb8, 0x98, 0x2b, 0x91, 0x3b, 0x6f, 0x3f, 0xe4, 0x5d, 0xe1,
   0x62, 0x2a, 0xf2, 0x89, 0x22, 0x43, 0x18, 0xb4, 0xac, 0xb7, 0xc7, 0xa1, 0xad, 0xc0, 0x7b, 0xff,
   0x31, 0x24, 0x68, 0x5a, 0x7b, 0x12, 0x4a, 0xa3, 0x09, 0xee, 0x0c, 0xd2, 0x86, 0xf3, 0x66, 0x08,
   0xb5, 0x3d, 0xeb, 0xbd, 0x63, 0x38, 0xca, 0x97, 0x76, 0x5e, 0xb2, 0xf5, 0x9c, 0x2f, 0x35, 0xb3,
   0x42, 0x56, 0x34, 0xf5, 0xa2, 0xc3, 0x7c, 0x69, 0xcf, 0xd8, 0xfa, 0x43, 0x83, 0x6e, 0x94, 0xa2,
   0xda, 0x2a, 0x07, 0x5b, 0xa5, 0xa8, 0x36, 0xca, 0x63, 0x88, 0x35, 0xfa, 0x7b, 0xe1, 0xf4, 0xbf,
   0x70, 0x9a, 0x36, 0x76, 0xb7, 0x74, 0xc9, 0x2c, 0xce, 0x57, 0xac, 0xa6, 0x87, 0xa1, 0x55, 0x17,
   0x7f, 0x62, 0xb5, 0xa3, 0x2a, 0x74, 0xad, 0x98, 0x2b, 0xfa, 0x7f, 0xa0, 0x2a, 0xb4, 0x67, 0xcc,
   0x5c, 0x39, 0x4a, 0x23, 0x2b, 0x5c, 0x9b, 0xf4, 0xc8, 0xd7, 0xec, 0xbb, 0xf8, 0x8c, 0xad, 0x47,
   0x6b, 0x80, 0xa9, 0x2c, 0xfe, 0x75, 0x00, 0x94, 0x2c, 0x8a, 0xb9, 0x42, 0x2d, 0x24, 0xf7, 0x03,
   0xd0, 0x9d, 0x81, 0x83, 0xa6, 0x1e, 0x21, 0x8f, 0xa0, 0xcb, 0xb1, 0x60, 0x75, 0xf3, 0xf4, 0x21,
   0x20, 0x4f, 0xa0, 0x87, 0x15, 0x5b, 0x14, 0xe8, 0x9f, 0x3c, 0x9e, 0x35, 0xd1, 0xe8, 0x5b, 0x04,
   0xfd, 0xd3, 0x62, 0x69, 0x2c, 0x6a, 0xf7, 0xc2, 0x79, 0xf8, 0xdd, 0x16, 0x4e, 0x1a, 0x64, 0xc2,
   0xc9, 0x6b, 0x18, 0xb4, 0xf4, 0xce, 0xec, 0xa5, 0x0d, 0xe6, 0x87, 0xef, 0x18, 0x62, 0xc5, 0x8c,
   0x59, 0x49, 0xcd, 0x7d, 0xf9, 0x64, 0xb6, 0x89, 0x5d, 0xf6, 0x6b, 0xa1, 0xed, 0x92, 0x15, 0xdb,
   0xc1, 0x4b, 0x1a, 0x64, 0xa2, 0xc8, 0x1b, 0xe8, 0x56, 0x92, 0xa3, 0xa1, 0xdd, 0xe1, 0xfe, 0x38,
   0x7d, 0xfb, 0xf8, 0xa4, 0xdd, 0x8f, 0x93, 0xa6, 0xbd, 0x73, 0xc9, 0x71, 0x16, 0x34, 0xa3, 0x1f,
   0x11, 0xa4, 0x3b, 0x30, 0x39, 0x84, 0xce, 0xa6, 0xe3, 0x8e, 0xe0, 0x0f, 0x4e, 0xd2, 0x79, 0x78,
   0x92, 0x7b, 0x17, 0xbc, 0xff, 0xf7, 0x0d, 0x3b, 0xf8, 0x63, 0xc3, 0x9e, 0x42, 0xdf, 0x75, 0xe1,
   0xbc, 0x61, 0x45, 0x7a, 0x2e, 0x9c, 0xf0, 0x2d, 0xa1, 0xfc, 0x7a, 0xb4, 0x84, 0x72, 0x29, 0x73,
   0x8d, 0x6e, 0x62, 0xac, 0x28, 0xb1, 0x59, 0x0e, 0x08, 0xd0, 0x85, 0x28, 0xf1, 0x3d, 0xfd, 0x7e,
   0x9b, 0x45, 0x37, 0xb7, 0x59, 0xf4, 0xeb, 0x36, 0x8b, 0xbe, 0xde, 0x65, 0x7b, 0x37, 0x77, 0xd9,
   0xde, 0xcf, 0xbb, 0x6c, 0x6f, 0xd1, 0xf3, 0xd7, 0xf0, 0xee, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff,
   0x77, 0xe6, 0x9a, 0x28, 0x3d, 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) {
@@ -576,6 +784,20 @@
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.RealMax))
   }
   if m.AlarmThresholdType != 0 {
      dAtA[i] = 0x88
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThresholdType))
   }
   if m.AlarmThreshold != 0 {
      dAtA[i] = 0x90
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThreshold))
   }
   return i, nil
}

@@ -619,6 +841,11 @@
         dAtA[i] = 0
      }
      i++
   }
   if m.PollChannelCount != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.PollChannelCount))
   }
   return i, nil
}
@@ -737,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)
@@ -809,6 +1146,12 @@
   if m.RealMax != 0 {
      n += 2 + sovSysset(uint64(m.RealMax))
   }
   if m.AlarmThresholdType != 0 {
      n += 2 + sovSysset(uint64(m.AlarmThresholdType))
   }
   if m.AlarmThreshold != 0 {
      n += 2 + sovSysset(uint64(m.AlarmThreshold))
   }
   return n
}

@@ -830,6 +1173,9 @@
   }
   if m.Enable {
      n += 2
   }
   if m.PollChannelCount != 0 {
      n += 1 + sovSysset(uint64(m.PollChannelCount))
   }
   return n
}
@@ -902,15 +1248,71 @@
   return n
}

func sovSysset(x uint64) (n int) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
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))
   }
   return n
}

func sovSysset(x uint64) (n int) {
   return (math_bits.Len64(x|1) + 6) / 7
}
func sozSysset(x uint64) (n int) {
   return sovSysset(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -1365,6 +1767,44 @@
               break
            }
         }
      case 17:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field AlarmThresholdType", wireType)
         }
         m.AlarmThresholdType = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.AlarmThresholdType |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 18:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field AlarmThreshold", wireType)
         }
         m.AlarmThreshold = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.AlarmThreshold |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipSysset(dAtA[iNdEx:])
@@ -1508,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:])
@@ -2024,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