add soInfo

panlei

2019-08-21 70eebbdd95fda629fa7f3efa670cd58d099e0f1a

add soInfo

 .idea/workspace.xml

@@ -1,7 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ChangeListManager">
    <list default="true" id="becdd117-1021-4e06-af58-0f70d982f4ee" name="Default Changelist" comment="" />
    <list default="true" id="becdd117-1021-4e06-af58-0f70d982f4ee" name="Default Changelist" comment="">
      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/sdk.pb.go" beforeDir="false" afterPath="$PROJECT_DIR$/sdk.pb.go" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/sdk.proto" beforeDir="false" afterPath="$PROJECT_DIR$/sdk.proto" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/sysset.pb.go" beforeDir="false" afterPath="$PROJECT_DIR$/sysset.pb.go" afterDir="false" />
    </list>
    <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -10,20 +15,25 @@
  </component>
  <component name="FileEditorManager">
    <leaf SIDE_TABS_SIZE_LIMIT_KEY="375">
      <file pinned="false" current-in-tab="false">
      <file pinned="false" current-in-tab="true">
        <entry file="file://$PROJECT_DIR$/sdk.proto">
          <provider selected="true" editor-type-id="text-editor">
            <state relative-caret-position="420">
              <caret line="69" column="25" selection-start-line="69" selection-start-column="25" selection-end-line="69" selection-end-column="25" />
            <state relative-caret-position="258">
              <caret line="75" column="42" lean-forward="true" selection-start-line="75" selection-start-column="42" selection-end-line="75" selection-end-column="42" />
            </state>
          </provider>
        </entry>
      </file>
      <file pinned="false" current-in-tab="true">
      <file pinned="false" current-in-tab="false">
        <entry file="file://$PROJECT_DIR$/sdk.pb.go">
          <provider selected="true" editor-type-id="text-editor" />
        </entry>
      </file>
      <file pinned="false" current-in-tab="false">
        <entry file="file://$PROJECT_DIR$/protomsg.proto">
          <provider selected="true" editor-type-id="text-editor">
            <state relative-caret-position="301">
              <caret line="213" column="20" lean-forward="true" selection-start-line="213" selection-start-column="20" selection-end-line="213" selection-end-column="20" />
            <state relative-caret-position="343">
              <caret line="180" column="30" selection-start-line="180" selection-start-column="30" selection-end-line="180" selection-end-column="30" />
            </state>
          </provider>
        </entry>
@@ -38,16 +48,7 @@
    <option name="CHANGED_PATHS">
      <list>
        <option value="$PROJECT_DIR$/protomsg.proto" />
      </list>
    </option>
  </component>
  <component name="ProjectConfigurationFiles">
    <option name="files">
      <list>
        <option value="$PROJECT_DIR$/.idea/protomsg.iml" />
        <option value="$PROJECT_DIR$/.idea/vcs.xml" />
        <option value="$PROJECT_DIR$/.idea/misc.xml" />
        <option value="$PROJECT_DIR$/.idea/modules.xml" />
        <option value="$PROJECT_DIR$/sdk.proto" />
      </list>
    </option>
  </component>
@@ -62,7 +63,17 @@
      <foldersAlwaysOnTop value="true" />
    </navigator>
    <panes>
      <pane id="ProjectPane" />
      <pane id="ProjectPane">
        <subPane>
          <expand>
            <path>
              <item name="protomsg" type="b2602c69:ProjectViewProjectNode" />
              <item name="protomsg" type="462c0819:PsiDirectoryNode" />
            </path>
          </expand>
          <select />
        </subPane>
      </pane>
      <pane id="Scope" />
    </panes>
  </component>
@@ -75,6 +86,7 @@
    <property name="last_opened_file_path" value="$PROJECT_DIR$" />
    <property name="nodejs_interpreter_path.stuck_in_default_project" value="undefined stuck path" />
    <property name="nodejs_npm_path_reset_for_default_project" value="true" />
    <property name="settings.editor.selected.configurable" value="go.vgo" />
  </component>
  <component name="RunDashboard">
    <option name="ruleStates">
@@ -92,7 +104,7 @@
    <frame x="-8" y="-8" width="1936" height="1176" extended-state="6" />
    <editor active="true" />
    <layout>
      <window_info content_ui="combo" id="Project" order="0" visible="true" weight="0.19796138" />
      <window_info content_ui="combo" id="Project" order="0" visible="true" weight="0.20064378" />
      <window_info id="Structure" order="1" side_tool="true" weight="0.25" />
      <window_info id="Favorites" order="2" side_tool="true" />
      <window_info anchor="bottom" id="Message" order="0" />
@@ -116,18 +128,24 @@
  <component name="TypeScriptGeneratedFilesManager">
    <option name="version" value="1" />
  </component>
  <component name="VgoProject">
    <integration-enabled>true</integration-enabled>
  </component>
  <component name="editorHistoryManager">
    <entry file="file://$PROJECT_DIR$/sdk.proto">
    <entry file="file://$PROJECT_DIR$/protomsg.proto">
      <provider selected="true" editor-type-id="text-editor">
        <state relative-caret-position="420">
          <caret line="69" column="25" selection-start-line="69" selection-start-column="25" selection-end-line="69" selection-end-column="25" />
        <state relative-caret-position="343">
          <caret line="180" column="30" selection-start-line="180" selection-start-column="30" selection-end-line="180" selection-end-column="30" />
        </state>
      </provider>
    </entry>
    <entry file="file://$PROJECT_DIR$/protomsg.proto">
    <entry file="file://$PROJECT_DIR$/sdk.pb.go">
      <provider selected="true" editor-type-id="text-editor" />
    </entry>
    <entry file="file://$PROJECT_DIR$/sdk.proto">
      <provider selected="true" editor-type-id="text-editor">
        <state relative-caret-position="301">
          <caret line="213" column="20" lean-forward="true" selection-start-line="213" selection-start-column="20" selection-end-line="213" selection-end-column="20" />
        <state relative-caret-position="258">
          <caret line="75" column="42" lean-forward="true" selection-start-line="75" selection-start-column="42" selection-end-line="75" selection-end-column="42" />
        </state>
      </provider>
    </entry>

 sdk.pb.go

@@ -732,6 +732,61 @@
    return nil
}

type SoInfo struct {
    Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
    SdkId                string   `protobuf:"bytes,2,opt,name=sdkId,proto3" json:"sdkId,omitempty"`
    SoName               string   `protobuf:"bytes,3,opt,name=soName,proto3" json:"soName,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *SoInfo) Reset()         { *m = SoInfo{} }
func (m *SoInfo) String() string { return proto.CompactTextString(m) }
func (*SoInfo) ProtoMessage()    {}
func (*SoInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_70decb0fb6f436df, []int{11}
}

func (m *SoInfo) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_SoInfo.Unmarshal(m, b)
}
func (m *SoInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_SoInfo.Marshal(b, m, deterministic)
}
func (m *SoInfo) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SoInfo.Merge(m, src)
}
func (m *SoInfo) XXX_Size() int {
    return xxx_messageInfo_SoInfo.Size(m)
}
func (m *SoInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_SoInfo.DiscardUnknown(m)
}

var xxx_messageInfo_SoInfo proto.InternalMessageInfo

func (m *SoInfo) GetId() int32 {
    if m != nil {
        return m.Id
    }
    return 0
}

func (m *SoInfo) GetSdkId() string {
    if m != nil {
        return m.SdkId
    }
    return ""
}

func (m *SoInfo) GetSoName() string {
    if m != nil {
        return m.SoName
    }
    return ""
}

func init() {
    proto.RegisterType((*Image)(nil), "protomsg.Image")
    proto.RegisterType((*FaceAngle)(nil), "protomsg.FaceAngle")
@@ -744,52 +799,55 @@
    proto.RegisterType((*ResultFaceExtCom)(nil), "protomsg.ResultFaceExtCom")
    proto.RegisterType((*ParamFaceFeature)(nil), "protomsg.ParamFaceFeature")
    proto.RegisterType((*ParamYoloObj)(nil), "protomsg.ParamYoloObj")
    proto.RegisterType((*SoInfo)(nil), "protomsg.SoInfo")
}

func init() { proto.RegisterFile("sdk.proto", fileDescriptor_70decb0fb6f436df) }

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

 sdk.proto

@@ -4,79 +4,85 @@
package protomsg;

// Image ipc struct
message Image{
message Image {
    int32 width = 1;
    int32 height = 2;
    bytes data = 3;
	
    string timestamp = 4;
    int64 id = 5;
    string cid = 6;
    bytes data = 3;

    string timestamp = 4;
    int64 id = 5;
    string cid = 6;
}

message FaceAngle{
    int32 yaw = 1;
    int32 pitch =2;
    int32 roll = 3;
    float confidence =4;
message FaceAngle {
    int32 yaw = 1;
    int32 pitch = 2;
    int32 roll = 3;
    float confidence = 4;
}
message ThftResult{
    int32 gender = 1;
    int32 age = 2;
    int32 race = 3;
    int32 beauty = 4;
    int32 smile = 5;
message ThftResult {
    int32 gender = 1;
    int32 age = 2;
    int32 race = 3;
    int32 beauty = 4;
    int32 smile = 5;
}
message FacePos{
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
message FacePos {
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;

    uint64 faceID = 9;
    uint64 faceID = 9;
}
message FaceInfo{
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
    int64 faceID = 9;
message FaceInfo {
    Rect rcFace = 1;
    Point ptLeftEye = 2;
    Point ptRightEye = 3;
    Point ptMouth = 4;
    Point ptNose = 5;
    FaceAngle fAngle = 6;
    int32 quality = 7;
    bytes facialData = 8;
    int64 faceID = 9;
}
message ObjInfo{
    Rect rcObj = 1;
    int32 typ = 2;
    float prob = 3;
    uint64 objID = 4;
message ObjInfo {
    Rect rcObj = 1;
    int32 typ = 2;
    float prob = 3;
    uint64 objID = 4;
}

// sdk face property
message ResultFaceDetect{
message ResultFaceDetect {
    FacePos pos = 1;
    ThftResult result = 2;
    bytes feats = 3;
    ThftResult result = 2;
    bytes feats = 3;
}
message ParamFacePos{
    repeated ResultFaceDetect faces = 1;
message ParamFacePos {
    repeated ResultFaceDetect faces = 1;
}

message ResultFaceExtCom{
    bytes feats = 1;
    bytes comp = 2;
    ResultFaceDetect pos = 3;
message ResultFaceExtCom {
    bytes feats = 1;
    bytes comp = 2;
    ResultFaceDetect pos = 3;
}
message ParamFaceFeature{
    repeated ResultFaceExtCom extComp = 2;
message ParamFaceFeature {
    repeated ResultFaceExtCom extComp = 2;
}

// sdk yolo detect
message ParamYoloObj{
message ParamYoloObj {
    repeated ObjInfo infos = 1;
}

message SoInfo {
    int32 id = 1;
    string sdkId = 2;
    string soName = 3;
}

 sysset.pb.go

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

package protomsg

import (
    fmt "fmt"
    proto "github.com/gogo/protobuf/proto"
    io "io"
    proto "github.com/golang/protobuf/proto"
    math "math"
    math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -20,27 +18,30 @@
// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type LocalConfig struct {
    ServerId           string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
    ServerName         string `protobuf:"bytes,2,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
    ServerType         int32  `protobuf:"varint,3,opt,name=server_type,json=serverType,proto3" json:"server_type,omitempty"`
    ServerIp           string `protobuf:"bytes,4,opt,name=server_ip,json=serverIp,proto3" json:"server_ip,omitempty"`
    AlarmIp            string `protobuf:"bytes,5,opt,name=alarm_ip,json=alarmIp,proto3" json:"alarm_ip,omitempty"`
    AlarmPort          int32  `protobuf:"varint,6,opt,name=alarm_port,json=alarmPort,proto3" json:"alarm_port,omitempty"`
    WebPicIp           string `protobuf:"bytes,7,opt,name=web_pic_ip,json=webPicIp,proto3" json:"web_pic_ip,omitempty"`
    WebPicPort         int32  `protobuf:"varint,8,opt,name=web_pic_port,json=webPicPort,proto3" json:"web_pic_port,omitempty"`
    EsPicIp            string `protobuf:"bytes,9,opt,name=es_pic_ip,json=esPicIp,proto3" json:"es_pic_ip,omitempty"`
    EsPicPort          int32  `protobuf:"varint,10,opt,name=es_pic_port,json=esPicPort,proto3" json:"es_pic_port,omitempty"`
    CutMaxDuration     int32  `protobuf:"varint,11,opt,name=cut_max_duration,json=cutMaxDuration,proto3" json:"cut_max_duration,omitempty"`
    CutMinDuration     int32  `protobuf:"varint,12,opt,name=cut_min_duration,json=cutMinDuration,proto3" json:"cut_min_duration,omitempty"`
    Reserved           string `protobuf:"bytes,13,opt,name=reserved,proto3" json:"reserved,omitempty"`
    GateWay            string `protobuf:"bytes,14,opt,name=gate_way,json=gateWay,proto3" json:"gate_way,omitempty"`
    NetMask            string `protobuf:"bytes,15,opt,name=net_mask,json=netMask,proto3" json:"net_mask,omitempty"`
    RealMax            int32  `protobuf:"varint,16,opt,name=real_max,json=realMax,proto3" json:"real_max,omitempty"`
    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"`
    ServerId             string   `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
    ServerName           string   `protobuf:"bytes,2,opt,name=server_name,json=serverName,proto3" json:"server_name,omitempty"`
    ServerType           int32    `protobuf:"varint,3,opt,name=server_type,json=serverType,proto3" json:"server_type,omitempty"`
    ServerIp             string   `protobuf:"bytes,4,opt,name=server_ip,json=serverIp,proto3" json:"server_ip,omitempty"`
    AlarmIp              string   `protobuf:"bytes,5,opt,name=alarm_ip,json=alarmIp,proto3" json:"alarm_ip,omitempty"`
    AlarmPort            int32    `protobuf:"varint,6,opt,name=alarm_port,json=alarmPort,proto3" json:"alarm_port,omitempty"`
    WebPicIp             string   `protobuf:"bytes,7,opt,name=web_pic_ip,json=webPicIp,proto3" json:"web_pic_ip,omitempty"`
    WebPicPort           int32    `protobuf:"varint,8,opt,name=web_pic_port,json=webPicPort,proto3" json:"web_pic_port,omitempty"`
    EsPicIp              string   `protobuf:"bytes,9,opt,name=es_pic_ip,json=esPicIp,proto3" json:"es_pic_ip,omitempty"`
    EsPicPort            int32    `protobuf:"varint,10,opt,name=es_pic_port,json=esPicPort,proto3" json:"es_pic_port,omitempty"`
    CutMaxDuration       int32    `protobuf:"varint,11,opt,name=cut_max_duration,json=cutMaxDuration,proto3" json:"cut_max_duration,omitempty"`
    CutMinDuration       int32    `protobuf:"varint,12,opt,name=cut_min_duration,json=cutMinDuration,proto3" json:"cut_min_duration,omitempty"`
    Reserved             string   `protobuf:"bytes,13,opt,name=reserved,proto3" json:"reserved,omitempty"`
    GateWay              string   `protobuf:"bytes,14,opt,name=gate_way,json=gateWay,proto3" json:"gate_way,omitempty"`
    NetMask              string   `protobuf:"bytes,15,opt,name=net_mask,json=netMask,proto3" json:"net_mask,omitempty"`
    RealMax              int32    `protobuf:"varint,16,opt,name=real_max,json=realMax,proto3" json:"real_max,omitempty"`
    AlarmThresholdType   int32    `protobuf:"varint,17,opt,name=alarm_threshold_type,json=alarmThresholdType,proto3" json:"alarm_threshold_type,omitempty"`
    AlarmThreshold       int32    `protobuf:"varint,18,opt,name=alarm_threshold,json=alarmThreshold,proto3" json:"alarm_threshold,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *LocalConfig) Reset()         { *m = LocalConfig{} }
@@ -49,26 +50,18 @@
func (*LocalConfig) Descriptor() ([]byte, []int) {
    return fileDescriptor_5be590c6b2a0d755, []int{0}
}

func (m *LocalConfig) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_LocalConfig.Unmarshal(m, 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
    }
    return xxx_messageInfo_LocalConfig.Marshal(b, m, deterministic)
}
func (m *LocalConfig) XXX_Merge(src proto.Message) {
    xxx_messageInfo_LocalConfig.Merge(m, src)
}
func (m *LocalConfig) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_LocalConfig.Size(m)
}
func (m *LocalConfig) XXX_DiscardUnknown() {
    xxx_messageInfo_LocalConfig.DiscardUnknown(m)
@@ -203,10 +196,13 @@
}

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"`
    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{} }
@@ -215,26 +211,18 @@
func (*PollConfig) Descriptor() ([]byte, []int) {
    return fileDescriptor_5be590c6b2a0d755, []int{1}
}

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

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

func (m *Cluster) Reset()         { *m = Cluster{} }
@@ -284,26 +275,18 @@
func (*Cluster) Descriptor() ([]byte, []int) {
    return fileDescriptor_5be590c6b2a0d755, []int{2}
}

func (m *Cluster) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_Cluster.Unmarshal(m, 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
    }
    return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
}
func (m *Cluster) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Cluster.Merge(m, src)
}
func (m *Cluster) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_Cluster.Size(m)
}
func (m *Cluster) XXX_DiscardUnknown() {
    xxx_messageInfo_Cluster.DiscardUnknown(m)
@@ -347,13 +330,16 @@
}

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

func (m *ClusterNode) Reset()         { *m = ClusterNode{} }
@@ -362,26 +348,18 @@
func (*ClusterNode) Descriptor() ([]byte, []int) {
    return fileDescriptor_5be590c6b2a0d755, []int{3}
}

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

var fileDescriptor_5be590c6b2a0d755 = []byte{
    // 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,
    // 565 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xdb, 0x6e, 0x13, 0x31,
    0x10, 0x55, 0xd2, 0x26, 0xd9, 0x9d, 0x0d, 0x6d, 0xb1, 0x0a, 0x98, 0x72, 0x0b, 0x79, 0x21, 0x12,
    0x52, 0x85, 0xe0, 0x13, 0xca, 0x4b, 0x24, 0x5a, 0x45, 0x51, 0x25, 0x1e, 0x23, 0x67, 0x3d, 0xb4,
    0x56, 0x77, 0xd7, 0x96, 0xed, 0x34, 0xd9, 0xef, 0xe2, 0x3b, 0xf8, 0x02, 0x7e, 0x06, 0x79, 0xbc,
    0x9b, 0xa4, 0x45, 0x42, 0x3c, 0x25, 0x73, 0xce, 0x99, 0x9b, 0xf7, 0x0c, 0x0c, 0x5d, 0xed, 0x1c,
    0xfa, 0x73, 0x63, 0xb5, 0xd7, 0x2c, 0xa1, 0x9f, 0xd2, 0xdd, 0x8c, 0x7f, 0x1f, 0x42, 0xf6, 0x4d,
    0xe7, 0xa2, 0xb8, 0xd0, 0xd5, 0x0f, 0x75, 0xc3, 0x5e, 0x41, 0xea, 0xd0, 0xde, 0xa3, 0x5d, 0x28,
    0xc9, 0x3b, 0xa3, 0xce, 0x24, 0x9d, 0x27, 0x11, 0x98, 0x4a, 0xf6, 0x0e, 0xb2, 0x86, 0xac, 0x44,
    0x89, 0xbc, 0x4b, 0x34, 0x44, 0xe8, 0x4a, 0x94, 0xb8, 0x27, 0xf0, 0xb5, 0x41, 0x7e, 0x30, 0xea,
    0x4c, 0x7a, 0xad, 0xe0, 0xba, 0x36, 0xb8, 0x5f, 0xde, 0xf0, 0xc3, 0x07, 0xe5, 0x0d, 0x7b, 0x09,
    0x89, 0x28, 0x84, 0x2d, 0x03, 0xd7, 0x23, 0x6e, 0x40, 0xf1, 0xd4, 0xb0, 0x37, 0x00, 0x91, 0x32,
    0xda, 0x7a, 0xde, 0xa7, 0xba, 0x29, 0x21, 0x33, 0x6d, 0x3d, 0x7b, 0x0d, 0xb0, 0xc6, 0xe5, 0xc2,
    0xa8, 0x3c, 0xe4, 0x0e, 0x62, 0xdd, 0x35, 0x2e, 0x67, 0x2a, 0x9f, 0x1a, 0x36, 0x82, 0x61, 0xcb,
    0x52, 0x7a, 0x12, 0xc7, 0x8a, 0x3c, 0xe5, 0x9f, 0x41, 0x8a, 0xae, 0x4d, 0x4f, 0x63, 0x6b, 0x74,
    0x31, 0xfb, 0x2d, 0x64, 0x0d, 0x47, 0xc9, 0x10, 0x7b, 0x13, 0x4b, 0xb9, 0x13, 0x38, 0xc9, 0x57,
    0x7e, 0x51, 0x8a, 0xcd, 0x42, 0xae, 0xac, 0xf0, 0x4a, 0x57, 0x3c, 0x23, 0xd1, 0x51, 0xbe, 0xf2,
    0x97, 0x62, 0xf3, 0xb5, 0x41, 0xb7, 0x4a, 0x55, 0xed, 0x94, 0xc3, 0x9d, 0x52, 0x55, 0x5b, 0xe5,
    0x19, 0x24, 0x16, 0xe9, 0x5d, 0x24, 0x7f, 0x12, 0xb7, 0x69, 0xe3, 0xf0, 0x4a, 0x37, 0xc2, 0xe3,
    0x62, 0x2d, 0x6a, 0x7e, 0x14, 0x47, 0x0d, 0xf1, 0x77, 0x51, 0x07, 0xaa, 0xc2, 0x30, 0x8a, 0xbb,
    0xe3, 0xc7, 0x91, 0xaa, 0xd0, 0x5f, 0x0a, 0x77, 0x17, 0x28, 0x8b, 0xa2, 0x08, 0x63, 0xf2, 0x13,
    0xea, 0x39, 0x08, 0xf1, 0xa5, 0xd8, 0xb0, 0x4f, 0x70, 0x1a, 0xdf, 0xd6, 0xdf, 0x5a, 0x74, 0xb7,
    0xba, 0x90, 0xf1, 0xeb, 0x3d, 0x25, 0x19, 0x23, 0xee, 0xba, 0xa5, 0xe8, 0x2b, 0x7e, 0x80, 0xe3,
    0x47, 0x19, 0x9c, 0xc5, 0x3d, 0x1e, 0x8a, 0xc7, 0x1b, 0x80, 0x99, 0x2e, 0xfe, 0xd7, 0x5b, 0x46,
    0x17, 0xc5, 0xc2, 0xa0, 0x55, 0x5a, 0x92, 0xb7, 0x7a, 0x73, 0x08, 0xd0, 0x8c, 0x10, 0x76, 0x0a,
    0x3d, 0x89, 0x85, 0xa8, 0x1b, 0x57, 0xc5, 0x80, 0x3d, 0x87, 0x3e, 0x56, 0x62, 0x59, 0x20, 0xb9,
    0x29, 0x99, 0x37, 0xd1, 0xf8, 0x67, 0x07, 0x06, 0x17, 0xc5, 0xca, 0x79, 0xb4, 0xc1, 0x3c, 0x79,
    0xfc, 0xbb, 0x6b, 0x9c, 0x36, 0xc8, 0x54, 0xb2, 0xf7, 0x30, 0x6c, 0xe9, 0x3d, 0x5b, 0x67, 0x0d,
    0x46, 0xbe, 0x3e, 0x83, 0xc4, 0x08, 0xe7, 0xd6, 0xda, 0x4a, 0x6a, 0x9f, 0xce, 0xb7, 0x71, 0xa8,
    0x7e, 0xaf, 0xac, 0x5f, 0x89, 0x62, 0xe7, 0xe9, 0xb4, 0x41, 0xa6, 0x86, 0x7d, 0x84, 0x5e, 0xa5,
    0x25, 0x3a, 0xde, 0x1b, 0x1d, 0x4c, 0xb2, 0xcf, 0xcf, 0xce, 0xdb, 0xd3, 0x3b, 0x6f, 0xc6, 0xbb,
    0xd2, 0x12, 0xe7, 0x51, 0x33, 0xfe, 0xd5, 0x81, 0x6c, 0x0f, 0x66, 0x47, 0xd0, 0xdd, 0x4e, 0xdc,
    0x55, 0xf2, 0xd1, 0x26, 0xdd, 0xc7, 0x9b, 0x3c, 0x78, 0xe0, 0x83, 0x7f, 0x1f, 0xef, 0xe1, 0x5f,
    0xc7, 0xfb, 0x02, 0x06, 0x61, 0x8a, 0x90, 0x1b, 0xaf, 0xaf, 0x1f, 0xc2, 0xa9, 0xdc, 0x11, 0x86,
    0x2e, 0xaf, 0x25, 0x4c, 0x28, 0x99, 0x5b, 0x0c, 0x66, 0xf4, 0xaa, 0xc4, 0xe6, 0xee, 0x20, 0x42,
    0xd7, 0xaa, 0xc4, 0x65, 0x9f, 0x96, 0xfd, 0xf2, 0x27, 0x00, 0x00, 0xff, 0xff, 0x1c, 0xcb, 0xf3,
    0x28, 0x7e, 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")
)