add alarm_thread_ to LocalConfig

liuxiaolong

2019-07-22 47bff08141f1607823d8cc596875eabf71b961c9

add alarm_thread_ to LocalConfig

 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")
)

 sysset.proto

@@ -20,6 +20,8 @@
    string gate_way = 14;
    string net_mask = 15;
    int32 real_max = 16;//实时处理的最大路数
    int32 alarm_threshold_type = 17;//报警阈值设置(1:按最高分，2：按阈值以上)
    int32 alarm_threshold = 18;
}

message PollConfig {