add alarm_thread_ to LocalConfig

liuxiaolong

2019-07-22 47bff08141f1607823d8cc596875eabf71b961c9

 sysset.pb.go

@@ -1,12 +1,14 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: sysset.proto

package protomsg

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.
@@ -18,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.ProtoPackageIsVersion3 // 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{} }
@@ -48,18 +49,26 @@
func (*LocalConfig) Descriptor() ([]byte, []int) {
   return fileDescriptor_5be590c6b2a0d755, []int{0}
}

func (m *LocalConfig) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_LocalConfig.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *LocalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_LocalConfig.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_LocalConfig.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 *LocalConfig) XXX_Merge(src proto.Message) {
   xxx_messageInfo_LocalConfig.Merge(m, src)
}
func (m *LocalConfig) XXX_Size() int {
   return xxx_messageInfo_LocalConfig.Size(m)
   return m.Size()
}
func (m *LocalConfig) XXX_DiscardUnknown() {
   xxx_messageInfo_LocalConfig.DiscardUnknown(m)
@@ -179,14 +188,25 @@
   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"`
}

func (m *PollConfig) Reset()         { *m = PollConfig{} }
@@ -195,18 +215,26 @@
func (*PollConfig) Descriptor() ([]byte, []int) {
   return fileDescriptor_5be590c6b2a0d755, []int{1}
}

func (m *PollConfig) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_PollConfig.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *PollConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_PollConfig.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_PollConfig.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 *PollConfig) XXX_Merge(src proto.Message) {
   xxx_messageInfo_PollConfig.Merge(m, src)
}
func (m *PollConfig) XXX_Size() int {
   return xxx_messageInfo_PollConfig.Size(m)
   return m.Size()
}
func (m *PollConfig) XXX_DiscardUnknown() {
   xxx_messageInfo_PollConfig.DiscardUnknown(m)
@@ -243,14 +271,11 @@
}

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{} }
@@ -259,18 +284,26 @@
func (*Cluster) Descriptor() ([]byte, []int) {
   return fileDescriptor_5be590c6b2a0d755, []int{2}
}

func (m *Cluster) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_Cluster.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_Cluster.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 *Cluster) XXX_Merge(src proto.Message) {
   xxx_messageInfo_Cluster.Merge(m, src)
}
func (m *Cluster) XXX_Size() int {
   return xxx_messageInfo_Cluster.Size(m)
   return m.Size()
}
func (m *Cluster) XXX_DiscardUnknown() {
   xxx_messageInfo_Cluster.DiscardUnknown(m)
@@ -314,16 +347,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{} }
@@ -332,18 +362,26 @@
func (*ClusterNode) Descriptor() ([]byte, []int) {
   return fileDescriptor_5be590c6b2a0d755, []int{3}
}

func (m *ClusterNode) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_ClusterNode.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *ClusterNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_ClusterNode.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_ClusterNode.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 *ClusterNode) XXX_Merge(src proto.Message) {
   xxx_messageInfo_ClusterNode.Merge(m, src)
}
func (m *ClusterNode) XXX_Size() int {
   return xxx_messageInfo_ClusterNode.Size(m)
   return m.Size()
}
func (m *ClusterNode) XXX_DiscardUnknown() {
   xxx_messageInfo_ClusterNode.DiscardUnknown(m)
@@ -410,39 +448,1759 @@
func init() { proto.RegisterFile("sysset.proto", fileDescriptor_5be590c6b2a0d755) }

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

func (m *LocalConfig) 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 *LocalConfig) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ServerId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   if len(m.ServerName) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
      i += copy(dAtA[i:], m.ServerName)
   }
   if m.ServerType != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.ServerType))
   }
   if len(m.ServerIp) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
      i += copy(dAtA[i:], m.ServerIp)
   }
   if len(m.AlarmIp) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.AlarmIp)))
      i += copy(dAtA[i:], m.AlarmIp)
   }
   if m.AlarmPort != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmPort))
   }
   if len(m.WebPicIp) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.WebPicIp)))
      i += copy(dAtA[i:], m.WebPicIp)
   }
   if m.WebPicPort != 0 {
      dAtA[i] = 0x40
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.WebPicPort))
   }
   if len(m.EsPicIp) > 0 {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.EsPicIp)))
      i += copy(dAtA[i:], m.EsPicIp)
   }
   if m.EsPicPort != 0 {
      dAtA[i] = 0x50
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.EsPicPort))
   }
   if m.CutMaxDuration != 0 {
      dAtA[i] = 0x58
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.CutMaxDuration))
   }
   if m.CutMinDuration != 0 {
      dAtA[i] = 0x60
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.CutMinDuration))
   }
   if len(m.Reserved) > 0 {
      dAtA[i] = 0x6a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Reserved)))
      i += copy(dAtA[i:], m.Reserved)
   }
   if len(m.GateWay) > 0 {
      dAtA[i] = 0x72
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.GateWay)))
      i += copy(dAtA[i:], m.GateWay)
   }
   if len(m.NetMask) > 0 {
      dAtA[i] = 0x7a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NetMask)))
      i += copy(dAtA[i:], m.NetMask)
   }
   if m.RealMax != 0 {
      dAtA[i] = 0x80
      i++
      dAtA[i] = 0x1
      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
}

func (m *PollConfig) 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 *PollConfig) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ServerId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   if m.PollPeriod != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.PollPeriod))
   }
   if m.Delay != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.Delay))
   }
   if m.Enable {
      dAtA[i] = 0x20
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   return i, nil
}

func (m *Cluster) 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 *Cluster) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.ClusterId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
      i += copy(dAtA[i:], m.ClusterId)
   }
   if len(m.ClusterName) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterName)))
      i += copy(dAtA[i:], m.ClusterName)
   }
   if len(m.Password) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
      i += copy(dAtA[i:], m.Password)
   }
   if len(m.VirtualIp) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.VirtualIp)))
      i += copy(dAtA[i:], m.VirtualIp)
   }
   if len(m.Nodes) > 0 {
      for _, msg := range m.Nodes {
         dAtA[i] = 0x2a
         i++
         i = encodeVarintSysset(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *ClusterNode) 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 *ClusterNode) 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.ClusterId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
      i += copy(dAtA[i:], m.ClusterId)
   }
   if len(m.ServerId) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   if len(m.ServerName) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
      i += copy(dAtA[i:], m.ServerName)
   }
   if len(m.NodeId) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeId)))
      i += copy(dAtA[i:], m.NodeId)
   }
   if len(m.NodeIp) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeIp)))
      i += copy(dAtA[i:], m.NodeIp)
   }
   if len(m.CreateTime) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.CreateTime)))
      i += copy(dAtA[i:], m.CreateTime)
   }
   return i, nil
}

func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return offset + 1
}
func (m *LocalConfig) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ServerId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerName)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.ServerType != 0 {
      n += 1 + sovSysset(uint64(m.ServerType))
   }
   l = len(m.ServerIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.AlarmIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.AlarmPort != 0 {
      n += 1 + sovSysset(uint64(m.AlarmPort))
   }
   l = len(m.WebPicIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.WebPicPort != 0 {
      n += 1 + sovSysset(uint64(m.WebPicPort))
   }
   l = len(m.EsPicIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.EsPicPort != 0 {
      n += 1 + sovSysset(uint64(m.EsPicPort))
   }
   if m.CutMaxDuration != 0 {
      n += 1 + sovSysset(uint64(m.CutMaxDuration))
   }
   if m.CutMinDuration != 0 {
      n += 1 + sovSysset(uint64(m.CutMinDuration))
   }
   l = len(m.Reserved)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.GateWay)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.NetMask)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   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
}

func (m *PollConfig) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ServerId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.PollPeriod != 0 {
      n += 1 + sovSysset(uint64(m.PollPeriod))
   }
   if m.Delay != 0 {
      n += 1 + sovSysset(uint64(m.Delay))
   }
   if m.Enable {
      n += 2
   }
   return n
}

func (m *Cluster) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ClusterId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ClusterName)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.Password)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.VirtualIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if len(m.Nodes) > 0 {
      for _, e := range m.Nodes {
         l = e.Size()
         n += 1 + l + sovSysset(uint64(l))
      }
   }
   return n
}

func (m *ClusterNode) 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.ClusterId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerName)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.NodeId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.NodeIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.CreateTime)
   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))))
}
func (m *LocalConfig) 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: LocalConfig: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: LocalConfig: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerId", 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.ServerId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerName", 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.ServerName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerType", wireType)
         }
         m.ServerType = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ServerType |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         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 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AlarmIp", 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.AlarmIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field AlarmPort", wireType)
         }
         m.AlarmPort = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.AlarmPort |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field WebPicIp", 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.WebPicIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field WebPicPort", wireType)
         }
         m.WebPicPort = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.WebPicPort |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 9:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field EsPicIp", 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.EsPicIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 10:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field EsPicPort", wireType)
         }
         m.EsPicPort = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.EsPicPort |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 11:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field CutMaxDuration", wireType)
         }
         m.CutMaxDuration = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.CutMaxDuration |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 12:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field CutMinDuration", wireType)
         }
         m.CutMinDuration = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.CutMinDuration |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 13:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Reserved", 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.Reserved = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 14:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field GateWay", 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.GateWay = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 15:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NetMask", 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.NetMask = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 16:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field RealMax", wireType)
         }
         m.RealMax = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.RealMax |= int32(b&0x7F) << shift
            if b < 0x80 {
               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:])
         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 *PollConfig) 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: PollConfig: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: PollConfig: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerId", 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.ServerId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field PollPeriod", wireType)
         }
         m.PollPeriod = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.PollPeriod |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 3:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Delay", wireType)
         }
         m.Delay = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Delay |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", 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.Enable = bool(v != 0)
      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 *Cluster) 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: Cluster: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Cluster: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", 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.ClusterId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", 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.ClusterName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         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 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field VirtualIp", 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.VirtualIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthSysset
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Nodes = append(m.Nodes, &ClusterNode{})
         if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         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 (m *ClusterNode) 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: ClusterNode: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: ClusterNode: 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 ClusterId", 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.ClusterId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerId", 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.ServerId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerName", 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.ServerName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NodeId", 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.NodeId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field NodeIp", 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.NodeIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", 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.CreateTime = 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
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 0, ErrIntOverflowSysset
         }
         if iNdEx >= l {
            return 0, io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= (uint64(b) & 0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      wireType := int(wire & 0x7)
      switch wireType {
      case 0:
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            iNdEx++
            if dAtA[iNdEx-1] < 0x80 {
               break
            }
         }
         return iNdEx, nil
      case 1:
         iNdEx += 8
         return iNdEx, nil
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            length |= (int(b) & 0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if length < 0 {
            return 0, ErrInvalidLengthSysset
         }
         iNdEx += length
         if iNdEx < 0 {
            return 0, ErrInvalidLengthSysset
         }
         return iNdEx, nil
      case 3:
         for {
            var innerWire uint64
            var start int = iNdEx
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return 0, ErrIntOverflowSysset
               }
               if iNdEx >= l {
                  return 0, io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               innerWire |= (uint64(b) & 0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            innerWireType := int(innerWire & 0x7)
            if innerWireType == 4 {
               break
            }
            next, err := skipSysset(dAtA[start:])
            if err != nil {
               return 0, err
            }
            iNdEx = start + next
            if iNdEx < 0 {
               return 0, ErrInvalidLengthSysset
            }
         }
         return iNdEx, nil
      case 4:
         return iNdEx, nil
      case 5:
         iNdEx += 4
         return iNdEx, nil
      default:
         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
   }
   panic("unreachable")
}

var (
   ErrInvalidLengthSysset = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowSysset   = fmt.Errorf("proto: integer overflow")
)