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,7 +20,7 @@
// 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"`
@@ -37,9 +39,8 @@
    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:"-"`
    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) {
    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:"-"`
}

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) {
    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)
@@ -248,9 +276,6 @@
    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:"-"`
}

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) {
    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)
@@ -321,9 +354,6 @@
    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:"-"`
}

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