更新dataprocess.pb

zhangzengfei

2024-05-08 80ae7958a17a492098f18f31fa21804f37b6cbaa

 sysset.pb.go

@@ -5,9 +5,10 @@

import (
   fmt "fmt"
   proto "github.com/golang/protobuf/proto"
   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.
@@ -19,28 +20,27 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
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"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   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{} }
@@ -188,14 +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"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   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{} }
@@ -259,15 +271,19 @@
   return false
}

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

type Cluster struct {
   ClusterId            string         `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
   ClusterName          string         `protobuf:"bytes,2,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
   Password             string         `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
   VirtualIp            string         `protobuf:"bytes,4,opt,name=virtual_ip,json=virtualIp,proto3" json:"virtual_ip,omitempty"`
   Nodes                []*ClusterNode `protobuf:"bytes,5,rep,name=nodes,proto3" json:"nodes,omitempty"`
   XXX_NoUnkeyedLiteral struct{}       `json:"-"`
   XXX_unrecognized     []byte         `json:"-"`
   XXX_sizecache        int32          `json:"-"`
   ClusterId   string         `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
   ClusterName string         `protobuf:"bytes,2,opt,name=cluster_name,json=clusterName,proto3" json:"cluster_name,omitempty"`
   Password    string         `protobuf:"bytes,3,opt,name=password,proto3" json:"password,omitempty"`
   VirtualIp   string         `protobuf:"bytes,4,opt,name=virtual_ip,json=virtualIp,proto3" json:"virtual_ip,omitempty"`
   Nodes       []*ClusterNode `protobuf:"bytes,5,rep,name=nodes,proto3" json:"nodes,omitempty"`
}

func (m *Cluster) Reset()         { *m = Cluster{} }
@@ -339,16 +355,13 @@
}

type ClusterNode struct {
   Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   ClusterId            string   `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
   ServerId             string   `protobuf:"bytes,3,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   ServerName           string   `protobuf:"bytes,4,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
   NodeId               string   `protobuf:"bytes,5,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
   NodeIp               string   `protobuf:"bytes,6,opt,name=node_ip,json=nodeIp,proto3" json:"node_ip,omitempty"`
   CreateTime           string   `protobuf:"bytes,7,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   Id         string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   ClusterId  string `protobuf:"bytes,2,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
   ServerId   string `protobuf:"bytes,3,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
   ServerName string `protobuf:"bytes,4,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
   NodeId     string `protobuf:"bytes,5,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
   NodeIp     string `protobuf:"bytes,6,opt,name=node_ip,json=nodeIp,proto3" json:"node_ip,omitempty"`
   CreateTime string `protobuf:"bytes,7,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
}

func (m *ClusterNode) Reset()         { *m = ClusterNode{} }
@@ -433,52 +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{
   // 559 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcd, 0x8e, 0xd3, 0x3e,
   0x10, 0xff, 0xa7, 0xbb, 0x69, 0x93, 0x49, 0xff, 0xcb, 0xca, 0xe2, 0x23, 0x2c, 0x50, 0x4a, 0x4f,
   0x95, 0x90, 0xf6, 0x00, 0x6f, 0xc0, 0x72, 0x89, 0xc4, 0xae, 0xaa, 0x6a, 0x25, 0x8e, 0x91, 0x1b,
   0x0f, 0x95, 0xb5, 0x49, 0x6c, 0xd9, 0xee, 0xb6, 0xb9, 0xf1, 0x18, 0xbc, 0x07, 0x2f, 0xc1, 0x05,
   0x89, 0x47, 0x40, 0xe5, 0x45, 0x90, 0xed, 0xa4, 0xed, 0x2e, 0x12, 0xe2, 0x94, 0xcc, 0xef, 0x63,
   0x66, 0x6c, 0xcf, 0xc0, 0x50, 0x37, 0x5a, 0xa3, 0x39, 0x97, 0x4a, 0x18, 0x41, 0x22, 0xf7, 0xa9,
   0xf4, 0x72, 0xf2, 0xf9, 0x18, 0x92, 0x0f, 0xa2, 0xa0, 0xe5, 0x85, 0xa8, 0x3f, 0xf1, 0x25, 0x79,
   0x06, 0xb1, 0x46, 0x75, 0x8b, 0x2a, 0xe7, 0x2c, 0x0d, 0xc6, 0xc1, 0x34, 0x9e, 0x47, 0x1e, 0xc8,
   0x18, 0x79, 0x09, 0x49, 0x4b, 0xd6, 0xb4, 0xc2, 0xb4, 0xe7, 0x68, 0xf0, 0xd0, 0x15, 0xad, 0xf0,
   0x40, 0x60, 0x1a, 0x89, 0xe9, 0xd1, 0x38, 0x98, 0x86, 0x9d, 0xe0, 0xba, 0x91, 0x78, 0x98, 0x5e,
   0xa6, 0xc7, 0x77, 0xd2, 0x4b, 0xf2, 0x14, 0x22, 0x5a, 0x52, 0x55, 0x59, 0x2e, 0x74, 0xdc, 0xc0,
   0xc5, 0x99, 0x24, 0x2f, 0x00, 0x3c, 0x25, 0x85, 0x32, 0x69, 0xdf, 0xe5, 0x8d, 0x1d, 0x32, 0x13,
   0xca, 0x90, 0xe7, 0x00, 0x6b, 0x5c, 0xe4, 0x92, 0x17, 0xd6, 0x3b, 0xf0, 0x79, 0xd7, 0xb8, 0x98,
   0xf1, 0x22, 0x93, 0x64, 0x0c, 0xc3, 0x8e, 0x75, 0xf6, 0xc8, 0xb7, 0xe5, 0x79, 0xe7, 0x3f, 0x83,
   0x18, 0x75, 0x67, 0x8f, 0x7d, 0x69, 0xd4, 0xde, 0x3d, 0x82, 0xa4, 0xe5, 0x9c, 0x19, 0x7c, 0x6d,
   0xc7, 0x3a, 0xef, 0x14, 0x4e, 0x8b, 0x95, 0xc9, 0x2b, 0xba, 0xc9, 0xd9, 0x4a, 0x51, 0xc3, 0x45,
   0x9d, 0x26, 0x4e, 0x74, 0x52, 0xac, 0xcc, 0x25, 0xdd, 0xbc, 0x6f, 0xd1, 0x9d, 0x92, 0xd7, 0x7b,
   0xe5, 0x70, 0xaf, 0xe4, 0xf5, 0x4e, 0x79, 0x06, 0x91, 0x42, 0x77, 0x2f, 0x2c, 0xfd, 0xdf, 0x9f,
   0xa6, 0x8b, 0xed, 0x2d, 0x2d, 0xa9, 0xc1, 0x7c, 0x4d, 0x9b, 0xf4, 0xc4, 0xb7, 0x6a, 0xe3, 0x8f,
   0xb4, 0xb1, 0x54, 0x8d, 0xb6, 0x15, 0x7d, 0x93, 0x3e, 0xf0, 0x54, 0x8d, 0xe6, 0x92, 0xea, 0x1b,
   0x4b, 0x29, 0xa4, 0xa5, 0x6d, 0x33, 0x3d, 0x75, 0x35, 0x07, 0x36, 0xbe, 0xa4, 0x9b, 0xc9, 0x06,
   0x60, 0x26, 0xca, 0x7f, 0x1d, 0x00, 0x29, 0xca, 0x32, 0x97, 0xa8, 0xb8, 0x60, 0x6e, 0x00, 0xc2,
   0x39, 0x58, 0x68, 0xe6, 0x10, 0xf2, 0x10, 0x42, 0x86, 0x25, 0x6d, 0xda, 0xa7, 0xf7, 0x01, 0x79,
   0x0c, 0x7d, 0xac, 0xe9, 0xa2, 0x44, 0xf7, 0xe4, 0xd1, 0xbc, 0x8d, 0x26, 0x5f, 0x03, 0x18, 0x5c,
   0x94, 0x2b, 0x6d, 0x50, 0xd9, 0x17, 0x2e, 0xfc, 0xef, 0xbe, 0x70, 0xdc, 0x22, 0x19, 0x23, 0xaf,
   0x60, 0xd8, 0xd1, 0x07, 0xb3, 0x97, 0xb4, 0x98, 0x1b, 0xbe, 0x33, 0x88, 0x24, 0xd5, 0x7a, 0x2d,
   0x14, 0x73, 0xe5, 0xe3, 0xf9, 0x2e, 0xb6, 0xd9, 0x6f, 0xb9, 0x32, 0x2b, 0x5a, 0xee, 0x07, 0x2f,
   0x6e, 0x91, 0x4c, 0x92, 0xd7, 0x10, 0xd6, 0x82, 0xa1, 0x4e, 0xc3, 0xf1, 0xd1, 0x34, 0x79, 0xf3,
   0xe8, 0xbc, 0xdb, 0x8f, 0xf3, 0xb6, 0xbd, 0x2b, 0xc1, 0x70, 0xee, 0x35, 0x93, 0xef, 0x01, 0x24,
   0x07, 0x30, 0x39, 0x81, 0xde, 0xae, 0xe3, 0x1e, 0x67, 0xf7, 0x4e, 0xd2, 0xbb, 0x7f, 0x92, 0x3b,
   0x17, 0x7c, 0xf4, 0xf7, 0x0d, 0x3b, 0xfe, 0x63, 0xc3, 0x9e, 0xc0, 0xc0, 0x76, 0x61, 0xbd, 0x7e,
   0x45, 0xfa, 0x36, 0xcc, 0xd8, 0x9e, 0x90, 0x6e, 0x3d, 0x3a, 0x42, 0xda, 0x94, 0x85, 0x42, 0x3b,
   0x31, 0x86, 0x57, 0xd8, 0x2e, 0x07, 0x78, 0xe8, 0x9a, 0x57, 0xf8, 0xee, 0xf4, 0xdb, 0x76, 0x14,
   0xfc, 0xd8, 0x8e, 0x82, 0x9f, 0xdb, 0x51, 0xf0, 0xe5, 0xd7, 0xe8, 0xbf, 0x45, 0xdf, 0x1d, 0xff,
   0xed, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x6d, 0x48, 0x9b, 0x35, 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) {
@@ -587,8 +784,19 @@
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.RealMax))
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
   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
}
@@ -634,8 +842,10 @@
      }
      i++
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
   if m.PollChannelCount != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.PollChannelCount))
   }
   return i, nil
}
@@ -690,9 +900,6 @@
         }
         i += n
      }
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
   }
   return i, nil
}
@@ -754,8 +961,115 @@
      i = encodeVarintSysset(dAtA, i, uint64(len(m.CreateTime)))
      i += copy(dAtA[i:], m.CreateTime)
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
   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
}
@@ -832,8 +1146,11 @@
   if m.RealMax != 0 {
      n += 2 + sovSysset(uint64(m.RealMax))
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   if m.AlarmThresholdType != 0 {
      n += 2 + sovSysset(uint64(m.AlarmThresholdType))
   }
   if m.AlarmThreshold != 0 {
      n += 2 + sovSysset(uint64(m.AlarmThreshold))
   }
   return n
}
@@ -857,8 +1174,8 @@
   if m.Enable {
      n += 2
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   if m.PollChannelCount != 0 {
      n += 1 + sovSysset(uint64(m.PollChannelCount))
   }
   return n
}
@@ -890,9 +1207,6 @@
         l = e.Size()
         n += 1 + l + sovSysset(uint64(l))
      }
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   }
   return n
}
@@ -931,21 +1245,74 @@
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   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))
   }
   return n
}

func sovSysset(x uint64) (n int) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
   }
   return n
   return (math_bits.Len64(x|1) + 6) / 7
}
func sozSysset(x uint64) (n int) {
   return sovSysset(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -1400,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:])
@@ -1415,7 +1820,6 @@
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }
@@ -1544,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:])
@@ -1559,7 +1982,6 @@
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }
@@ -1775,7 +2197,6 @@
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }
@@ -2053,7 +2474,458 @@
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   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
      }
   }