merge

panlei

2019-08-21 4d63ce5655e697a679ebcc30216f69ff869c075f

 sysset.pb.go

@@ -464,1593 +464,3 @@
   0xd7, 0xaa, 0xc4, 0x65, 0x9f, 0x96, 0xfd, 0xf2, 0x27, 0x00, 0x00, 0xff, 0xff, 0x1c, 0xcb, 0xf3,
   0x28, 0x7e, 0x04, 0x00, 0x00,
}

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) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
   }
   return n
}
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")
)