Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "SandboxContainerWalker", "(", "out", "*", "Sandbox", ",", "containerID", "string", ")", "SandboxWalker", "{", "return", "func", "(", "sb", "Sandbox", ")", "bool", "{", "if", "sb", ".", "ContainerID", "(", ")", "==", "containerID", "{", "*", "out", "=", "sb", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "SandboxContainerWalker", "returns", "a", "Sandbox", "Walker", "function", "which", "looks", "for", "an", "existing", "Sandbox", "with", "the", "passed", "containerID" ]

[ "func", "SandboxKeyWalker", "(", "out", "*", "Sandbox", ",", "key", "string", ")", "SandboxWalker", "{", "return", "func", "(", "sb", "Sandbox", ")", "bool", "{", "if", "sb", ".", "Key", "(", ")", "==", "key", "{", "*", "out", "=", "sb", "\n", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "SandboxKeyWalker", "returns", "a", "Sandbox", "Walker", "function", "which", "looks", "for", "an", "existing", "Sandbox", "with", "the", "passed", "key" ]

[ "func", "(", "c", "*", "controller", ")", "StartDiagnostic", "(", "port", "int", ")", "{", "c", ".", "Lock", "(", ")", "\n", "if", "!", "c", ".", "DiagnosticServer", ".", "IsDiagnosticEnabled", "(", ")", "{", "c", ".", "DiagnosticServer", ".", "EnableDiagnostic", "(", "\"", "\"", ",", "port", ")", "\n", "}", "\n", "c", ".", "Unlock", "(", ")", "\n", "}" ]

[ "StartDiagnostic", "start", "the", "network", "dias", "mode" ]

[ "func", "(", "c", "*", "controller", ")", "StopDiagnostic", "(", ")", "{", "c", ".", "Lock", "(", ")", "\n", "if", "c", ".", "DiagnosticServer", ".", "IsDiagnosticEnabled", "(", ")", "{", "c", ".", "DiagnosticServer", ".", "DisableDiagnostic", "(", ")", "\n", "}", "\n", "c", ".", "Unlock", "(", ")", "\n", "}" ]

[ "StopDiagnostic", "start", "the", "network", "dias", "mode" ]

[ "func", "(", "c", "*", "controller", ")", "IsDiagnosticEnabled", "(", ")", "bool", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "return", "c", ".", "DiagnosticServer", ".", "IsDiagnosticEnabled", "(", ")", "\n", "}" ]

[ "IsDiagnosticEnabled", "returns", "true", "if", "the", "dias", "is", "enabled" ]

[ "func", "(", "n", "*", "network", ")", "destroySandbox", "(", ")", "{", "if", "n", ".", "sbox", "!=", "nil", "{", "for", "_", ",", "iface", ":=", "range", "n", ".", "sbox", ".", "Info", "(", ")", ".", "Interfaces", "(", ")", "{", "if", "err", ":=", "iface", ".", "Remove", "(", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "iface", ".", "SrcName", "(", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "s", ":=", "range", "n", ".", "subnets", "{", "if", "hostMode", "{", "if", "err", ":=", "removeFilters", "(", "n", ".", "id", "[", ":", "12", "]", ",", "s", ".", "brName", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "s", ".", "vxlanName", "!=", "\"", "\"", "{", "err", ":=", "deleteInterface", "(", "s", ".", "vxlanName", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "hostMode", "{", "if", "err", ":=", "removeNetworkChain", "(", "n", ".", "id", "[", ":", "12", "]", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// Close the netlink socket, this will also release the watchMiss goroutine that is using it", "if", "n", ".", "nlSocket", "!=", "nil", "{", "n", ".", "nlSocket", ".", "Close", "(", ")", "\n", "n", ".", "nlSocket", "=", "nil", "\n", "}", "\n\n", "n", ".", "sbox", ".", "Destroy", "(", ")", "\n", "n", ".", "sbox", "=", "nil", "\n", "}", "\n", "}" ]

[ "to", "be", "called", "while", "holding", "network", "lock" ]

[ "func", "(", "n", "*", "network", ")", "initSubnetSandbox", "(", "s", "*", "subnet", ",", "restore", "bool", ")", "error", "{", "brName", ":=", "n", ".", "generateBridgeName", "(", "s", ")", "\n", "vxlanName", ":=", "n", ".", "generateVxlanName", "(", "s", ")", "\n\n", "if", "restore", "{", "if", "err", ":=", "n", ".", "restoreSubnetSandbox", "(", "s", ",", "brName", ",", "vxlanName", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "if", "err", ":=", "n", ".", "setupSubnetSandbox", "(", "s", ",", "brName", ",", "vxlanName", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "s", ".", "vxlanName", "=", "vxlanName", "\n", "s", ".", "brName", "=", "brName", "\n\n", "return", "nil", "\n", "}" ]

[ "Must", "be", "called", "with", "the", "network", "lock" ]

[ "func", "(", "d", "*", "driver", ")", "restoreNetworkFromStore", "(", "nid", "string", ")", "*", "network", "{", "n", ":=", "d", ".", "getNetworkFromStore", "(", "nid", ")", "\n", "if", "n", "!=", "nil", "{", "n", ".", "driver", "=", "d", "\n", "n", ".", "endpoints", "=", "endpointTable", "{", "}", "\n", "d", ".", "networks", "[", "nid", "]", "=", "n", "\n", "}", "\n", "return", "n", "\n", "}" ]

[ "Restore", "a", "network", "from", "the", "store", "to", "the", "driver", "if", "it", "is", "present", ".", "Must", "be", "called", "with", "the", "driver", "locked!" ]

[ "func", "(", "d", "*", "driver", ")", "createNetwork", "(", "config", "*", "configuration", ")", "error", "{", "networkList", ":=", "d", ".", "getNetworks", "(", ")", "\n", "for", "_", ",", "nw", ":=", "range", "networkList", "{", "if", "config", ".", "Parent", "==", "nw", ".", "config", ".", "Parent", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "getDummyName", "(", "stringid", ".", "TruncateID", "(", "nw", ".", "config", ".", "ID", ")", ")", ",", "config", ".", "Parent", ")", "\n", "}", "\n", "}", "\n", "if", "!", "parentExists", "(", "config", ".", "Parent", ")", "{", "// if the --internal flag is set, create a dummy link", "if", "config", ".", "Internal", "{", "err", ":=", "createDummyLink", "(", "config", ".", "Parent", ",", "getDummyName", "(", "stringid", ".", "TruncateID", "(", "config", ".", "ID", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "config", ".", "CreatedSlaveLink", "=", "true", "\n", "// notify the user in logs they have limited communications", "if", "config", ".", "Parent", "==", "getDummyName", "(", "stringid", ".", "TruncateID", "(", "config", ".", "ID", ")", ")", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "config", ".", "Parent", ")", "\n", "}", "\n", "}", "else", "{", "// if the subinterface parent_iface.vlan_id checks do not pass, return err.", "// a valid example is 'eth0.10' for a parent iface 'eth0' with a vlan id '10'", "err", ":=", "createVlanLink", "(", "config", ".", "Parent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// if driver created the networks slave link, record it for future deletion", "config", ".", "CreatedSlaveLink", "=", "true", "\n", "}", "\n", "}", "\n", "n", ":=", "&", "network", "{", "id", ":", "config", ".", "ID", ",", "driver", ":", "d", ",", "endpoints", ":", "endpointTable", "{", "}", ",", "config", ":", "config", ",", "}", "\n", "// add the *network", "d", ".", "addNetwork", "(", "n", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "createNetwork", "is", "used", "by", "new", "network", "callbacks", "and", "persistent", "network", "cache" ]

[ "func", "(", "d", "*", "driver", ")", "DeleteNetwork", "(", "nid", "string", ")", "error", "{", "defer", "osl", ".", "InitOSContext", "(", ")", "(", ")", "\n", "n", ":=", "d", ".", "network", "(", "nid", ")", "\n", "if", "n", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "nid", ")", "\n", "}", "\n", "// if the driver created the slave interface, delete it, otherwise leave it", "if", "ok", ":=", "n", ".", "config", ".", "CreatedSlaveLink", ";", "ok", "{", "// if the interface exists, only delete if it matches iface.vlan or dummy.net_id naming", "if", "ok", ":=", "parentExists", "(", "n", ".", "config", ".", "Parent", ")", ";", "ok", "{", "// only delete the link if it is named the net_id", "if", "n", ".", "config", ".", "Parent", "==", "getDummyName", "(", "stringid", ".", "TruncateID", "(", "nid", ")", ")", "{", "err", ":=", "delDummyLink", "(", "n", ".", "config", ".", "Parent", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "n", ".", "config", ".", "Parent", ",", "err", ")", "\n", "}", "\n", "}", "else", "{", "// only delete the link if it matches iface.vlan naming", "err", ":=", "delVlanLink", "(", "n", ".", "config", ".", "Parent", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "n", ".", "config", ".", "Parent", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "for", "_", ",", "ep", ":=", "range", "n", ".", "endpoints", "{", "if", "link", ",", "err", ":=", "ns", ".", "NlHandle", "(", ")", ".", "LinkByName", "(", "ep", ".", "srcName", ")", ";", "err", "==", "nil", "{", "if", "err", ":=", "ns", ".", "NlHandle", "(", ")", ".", "LinkDel", "(", "link", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "WithError", "(", "err", ")", ".", "Warnf", "(", "\"", "\"", ",", "ep", ".", "srcName", ",", "ep", ".", "id", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "d", ".", "storeDelete", "(", "ep", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "ep", ".", "id", ",", "err", ")", "\n", "}", "\n", "}", "\n", "// delete the *network", "d", ".", "deleteNetwork", "(", "nid", ")", "\n", "// delete the network record from persistent cache", "err", ":=", "d", ".", "storeDelete", "(", "n", ".", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "nid", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "DeleteNetwork", "the", "network", "for", "the", "specified", "driver", "type" ]

[ "func", "parseNetworkOptions", "(", "id", "string", ",", "option", "options", ".", "Generic", ")", "(", "*", "configuration", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "config", "=", "&", "configuration", "{", "}", "\n", ")", "\n", "// parse generic labels first", "if", "genData", ",", "ok", ":=", "option", "[", "netlabel", ".", "GenericData", "]", ";", "ok", "&&", "genData", "!=", "nil", "{", "if", "config", ",", "err", "=", "parseNetworkGenericOptions", "(", "genData", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "// setting the parent to \"\" will trigger an isolated network dummy parent link", "if", "_", ",", "ok", ":=", "option", "[", "netlabel", ".", "Internal", "]", ";", "ok", "{", "config", ".", "Internal", "=", "true", "\n", "// empty --parent= and --internal are handled the same.", "config", ".", "Parent", "=", "\"", "\"", "\n", "}", "\n", "return", "config", ",", "nil", "\n", "}" ]

[ "parseNetworkOptions", "parse", "docker", "network", "options" ]

[ "func", "parseNetworkGenericOptions", "(", "data", "interface", "{", "}", ")", "(", "*", "configuration", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "config", "*", "configuration", "\n", ")", "\n", "switch", "opt", ":=", "data", ".", "(", "type", ")", "{", "case", "*", "configuration", ":", "config", "=", "opt", "\n", "case", "map", "[", "string", "]", "string", ":", "config", "=", "&", "configuration", "{", "}", "\n", "err", "=", "config", ".", "fromOptions", "(", "opt", ")", "\n", "case", "options", ".", "Generic", ":", "var", "opaqueConfig", "interface", "{", "}", "\n", "if", "opaqueConfig", ",", "err", "=", "options", ".", "GenerateFromModel", "(", "opt", ",", "config", ")", ";", "err", "==", "nil", "{", "config", "=", "opaqueConfig", ".", "(", "*", "configuration", ")", "\n", "}", "\n", "default", ":", "err", "=", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "opt", ")", "\n", "}", "\n", "return", "config", ",", "err", "\n", "}" ]

[ "parseNetworkGenericOptions", "parse", "generic", "driver", "docker", "network", "options" ]

[ "func", "(", "config", "*", "configuration", ")", "fromOptions", "(", "labels", "map", "[", "string", "]", "string", ")", "error", "{", "for", "label", ",", "value", ":=", "range", "labels", "{", "switch", "label", "{", "case", "parentOpt", ":", "// parse driver option '-o parent'", "config", ".", "Parent", "=", "value", "\n", "case", "driverModeOpt", ":", "// parse driver option '-o ipvlan_mode'", "config", ".", "IpvlanMode", "=", "value", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "fromOptions", "binds", "the", "generic", "options", "to", "networkConfiguration", "to", "cache" ]

[ "func", "(", "config", "*", "configuration", ")", "processIPAM", "(", "id", "string", ",", "ipamV4Data", ",", "ipamV6Data", "[", "]", "driverapi", ".", "IPAMData", ")", "error", "{", "if", "len", "(", "ipamV4Data", ")", ">", "0", "{", "for", "_", ",", "ipd", ":=", "range", "ipamV4Data", "{", "s", ":=", "&", "ipv4Subnet", "{", "SubnetIP", ":", "ipd", ".", "Pool", ".", "String", "(", ")", ",", "GwIP", ":", "ipd", ".", "Gateway", ".", "String", "(", ")", ",", "}", "\n", "config", ".", "Ipv4Subnets", "=", "append", "(", "config", ".", "Ipv4Subnets", ",", "s", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "ipamV6Data", ")", ">", "0", "{", "for", "_", ",", "ipd", ":=", "range", "ipamV6Data", "{", "s", ":=", "&", "ipv6Subnet", "{", "SubnetIP", ":", "ipd", ".", "Pool", ".", "String", "(", ")", ",", "GwIP", ":", "ipd", ".", "Gateway", ".", "String", "(", ")", ",", "}", "\n", "config", ".", "Ipv6Subnets", "=", "append", "(", "config", ".", "Ipv6Subnets", ",", "s", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processIPAM", "parses", "v4", "and", "v6", "IP", "information", "and", "binds", "it", "to", "the", "network", "configuration" ]

[ "func", "NewHostDiscovery", "(", "watcher", "discovery", ".", "Watcher", ")", "HostDiscovery", "{", "return", "&", "hostDiscovery", "{", "watcher", ":", "watcher", ",", "nodes", ":", "mapset", ".", "NewSet", "(", ")", ",", "stopChan", ":", "make", "(", "chan", "struct", "{", "}", ")", "}", "\n", "}" ]

[ "NewHostDiscovery", "function", "creates", "a", "host", "discovery", "object" ]

[ "func", "(", "i", "*", "IPAMData", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "m", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "m", "[", "\"", "\"", "]", "=", "i", ".", "AddressSpace", "\n", "if", "i", ".", "Pool", "!=", "nil", "{", "m", "[", "\"", "\"", "]", "=", "i", ".", "Pool", ".", "String", "(", ")", "\n", "}", "\n", "if", "i", ".", "Gateway", "!=", "nil", "{", "m", "[", "\"", "\"", "]", "=", "i", ".", "Gateway", ".", "String", "(", ")", "\n", "}", "\n", "if", "i", ".", "AuxAddresses", "!=", "nil", "{", "am", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "i", ".", "AuxAddresses", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "i", ".", "AuxAddresses", "{", "am", "[", "k", "]", "=", "v", ".", "String", "(", ")", "\n", "}", "\n", "m", "[", "\"", "\"", "]", "=", "am", "\n", "}", "\n", "return", "json", ".", "Marshal", "(", "m", ")", "\n", "}" ]

[ "MarshalJSON", "encodes", "IPAMData", "into", "json", "message" ]

[ "func", "(", "i", "*", "IPAMData", ")", "UnmarshalJSON", "(", "data", "[", "]", "byte", ")", "error", "{", "var", "(", "m", "map", "[", "string", "]", "interface", "{", "}", "\n", "err", "error", "\n", ")", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "i", ".", "AddressSpace", "=", "m", "[", "\"", "\"", "]", ".", "(", "string", ")", "\n", "if", "v", ",", "ok", ":=", "m", "[", "\"", "\"", "]", ";", "ok", "{", "if", "i", ".", "Pool", ",", "err", "=", "types", ".", "ParseCIDR", "(", "v", ".", "(", "string", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "v", ",", "ok", ":=", "m", "[", "\"", "\"", "]", ";", "ok", "{", "if", "i", ".", "Gateway", ",", "err", "=", "types", ".", "ParseCIDR", "(", "v", ".", "(", "string", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "if", "v", ",", "ok", ":=", "m", "[", "\"", "\"", "]", ";", "ok", "{", "b", ",", "_", ":=", "json", ".", "Marshal", "(", "v", ")", "\n", "var", "am", "map", "[", "string", "]", "string", "\n", "if", "err", "=", "json", ".", "Unmarshal", "(", "b", ",", "&", "am", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "i", ".", "AuxAddresses", "=", "make", "(", "map", "[", "string", "]", "*", "net", ".", "IPNet", ",", "len", "(", "am", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "am", "{", "if", "i", ".", "AuxAddresses", "[", "k", "]", ",", "err", "=", "types", ".", "ParseCIDR", "(", "v", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UnmarshalJSON", "decodes", "a", "json", "message", "into", "IPAMData" ]

[ "func", "(", "i", "*", "IPAMData", ")", "Validate", "(", ")", "error", "{", "var", "isV6", "bool", "\n", "if", "i", ".", "Pool", "==", "nil", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "i", ".", "Gateway", "==", "nil", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ")", "\n", "}", "\n", "isV6", "=", "i", ".", "IsV6", "(", ")", "\n", "if", "isV6", "&&", "i", ".", "Gateway", ".", "IP", ".", "To4", "(", ")", "!=", "nil", "||", "!", "isV6", "&&", "i", ".", "Gateway", ".", "IP", ".", "To4", "(", ")", "==", "nil", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ")", "\n", "}", "\n", "for", "k", ",", "sip", ":=", "range", "i", ".", "AuxAddresses", "{", "if", "isV6", "&&", "sip", ".", "IP", ".", "To4", "(", ")", "!=", "nil", "||", "!", "isV6", "&&", "sip", ".", "IP", ".", "To4", "(", ")", "==", "nil", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "}", "\n", "if", "!", "i", ".", "Pool", ".", "Contains", "(", "i", ".", "Gateway", ".", "IP", ")", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "i", ".", "Gateway", ",", "i", ".", "Pool", ")", "\n", "}", "\n", "for", "k", ",", "sip", ":=", "range", "i", ".", "AuxAddresses", "{", "if", "!", "i", ".", "Pool", ".", "Contains", "(", "sip", ".", "IP", ")", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "k", ",", "i", ".", "Gateway", ",", "i", ".", "Pool", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "checks", "whether", "the", "IPAMData", "structure", "contains", "congruent", "data" ]

[ "func", "(", "sb", "*", "sandbox", ")", "clearDefaultGW", "(", ")", "error", "{", "var", "ep", "*", "endpoint", "\n\n", "if", "ep", "=", "sb", ".", "getEndpointInGWNetwork", "(", ")", ";", "ep", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "err", ":=", "ep", ".", "sbLeave", "(", "sb", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "containerID", ",", "err", ")", "\n", "}", "\n", "if", "err", ":=", "ep", ".", "Delete", "(", "false", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sb", ".", "containerID", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "If", "present", "detach", "and", "remove", "the", "endpoint", "connecting", "the", "sandbox", "to", "the", "default", "gw", "network", "." ]

[ "func", "(", "sb", "*", "sandbox", ")", "needDefaultGW", "(", ")", "bool", "{", "var", "needGW", "bool", "\n\n", "for", "_", ",", "ep", ":=", "range", "sb", ".", "getConnectedEndpoints", "(", ")", "{", "if", "ep", ".", "endpointInGWNetwork", "(", ")", "{", "continue", "\n", "}", "\n", "if", "ep", ".", "getNetwork", "(", ")", ".", "Type", "(", ")", "==", "\"", "\"", "||", "ep", ".", "getNetwork", "(", ")", ".", "Type", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "ep", ".", "getNetwork", "(", ")", ".", "Internal", "(", ")", "{", "continue", "\n", "}", "\n", "// During stale sandbox cleanup, joinInfo may be nil", "if", "ep", ".", "joinInfo", "!=", "nil", "&&", "ep", ".", "joinInfo", ".", "disableGatewayService", "{", "continue", "\n", "}", "\n", "// TODO v6 needs to be handled.", "if", "len", "(", "ep", ".", "Gateway", "(", ")", ")", ">", "0", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "r", ":=", "range", "ep", ".", "StaticRoutes", "(", ")", "{", "if", "r", ".", "Destination", "!=", "nil", "&&", "r", ".", "Destination", ".", "String", "(", ")", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "}", "\n", "needGW", "=", "true", "\n", "}", "\n\n", "return", "needGW", "\n", "}" ]

[ "Evaluate", "whether", "the", "sandbox", "requires", "a", "default", "gateway", "based", "on", "the", "endpoints", "to", "which", "it", "is", "connected", ".", "It", "does", "not", "account", "for", "the", "default", "gateway", "network", "endpoint", "." ]

[ "func", "(", "c", "*", "controller", ")", "defaultGwNetwork", "(", ")", "(", "Network", ",", "error", ")", "{", "procGwNetwork", "<-", "true", "\n", "defer", "func", "(", ")", "{", "<-", "procGwNetwork", "}", "(", ")", "\n\n", "n", ",", "err", ":=", "c", ".", "NetworkByName", "(", "libnGWNetwork", ")", "\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "types", ".", "NotFoundError", ")", ";", "ok", "{", "n", ",", "err", "=", "c", ".", "createGWNetwork", "(", ")", "\n", "}", "\n", "return", "n", ",", "err", "\n", "}" ]

[ "Looks", "for", "the", "default", "gw", "network", "and", "creates", "it", "if", "not", "there", ".", "Parallel", "executions", "are", "serialized", "." ]

[ "func", "(", "sb", "*", "sandbox", ")", "getGatewayEndpoint", "(", ")", "*", "endpoint", "{", "for", "_", ",", "ep", ":=", "range", "sb", ".", "getConnectedEndpoints", "(", ")", "{", "if", "ep", ".", "getNetwork", "(", ")", ".", "Type", "(", ")", "==", "\"", "\"", "||", "ep", ".", "getNetwork", "(", ")", ".", "Type", "(", ")", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "if", "len", "(", "ep", ".", "Gateway", "(", ")", ")", "!=", "0", "{", "return", "ep", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Returns", "the", "endpoint", "which", "is", "providing", "external", "connectivity", "to", "the", "sandbox" ]

[ "func", "CheckNameserverOverlaps", "(", "nameservers", "[", "]", "string", ",", "toCheck", "*", "net", ".", "IPNet", ")", "error", "{", "if", "len", "(", "nameservers", ")", ">", "0", "{", "for", "_", ",", "ns", ":=", "range", "nameservers", "{", "_", ",", "nsNetwork", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "ns", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "NetworkOverlaps", "(", "toCheck", ",", "nsNetwork", ")", "{", "return", "ErrNetworkOverlapsWithNameservers", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckNameserverOverlaps", "checks", "whether", "the", "passed", "network", "overlaps", "with", "any", "of", "the", "nameservers" ]

[ "func", "NetworkOverlaps", "(", "netX", "*", "net", ".", "IPNet", ",", "netY", "*", "net", ".", "IPNet", ")", "bool", "{", "return", "netX", ".", "Contains", "(", "netY", ".", "IP", ")", "||", "netY", ".", "Contains", "(", "netX", ".", "IP", ")", "\n", "}" ]

[ "NetworkOverlaps", "detects", "overlap", "between", "one", "IPNet", "and", "another" ]

[ "func", "NetworkRange", "(", "network", "*", "net", ".", "IPNet", ")", "(", "net", ".", "IP", ",", "net", ".", "IP", ")", "{", "if", "network", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "firstIP", ":=", "network", ".", "IP", ".", "Mask", "(", "network", ".", "Mask", ")", "\n", "lastIP", ":=", "types", ".", "GetIPCopy", "(", "firstIP", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "firstIP", ")", ";", "i", "++", "{", "lastIP", "[", "i", "]", "=", "firstIP", "[", "i", "]", "|", "^", "network", ".", "Mask", "[", "i", "]", "\n", "}", "\n\n", "if", "network", ".", "IP", ".", "To4", "(", ")", "!=", "nil", "{", "firstIP", "=", "firstIP", ".", "To4", "(", ")", "\n", "lastIP", "=", "lastIP", ".", "To4", "(", ")", "\n", "}", "\n\n", "return", "firstIP", ",", "lastIP", "\n", "}" ]

[ "NetworkRange", "calculates", "the", "first", "and", "last", "IP", "addresses", "in", "an", "IPNet" ]

[ "func", "GetIfaceAddr", "(", "name", "string", ")", "(", "net", ".", "Addr", ",", "[", "]", "net", ".", "Addr", ",", "error", ")", "{", "iface", ",", "err", ":=", "net", ".", "InterfaceByName", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "addrs", ",", "err", ":=", "iface", ".", "Addrs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "var", "addrs4", "[", "]", "net", ".", "Addr", "\n", "var", "addrs6", "[", "]", "net", ".", "Addr", "\n", "for", "_", ",", "addr", ":=", "range", "addrs", "{", "ip", ":=", "(", "addr", ".", "(", "*", "net", ".", "IPNet", ")", ")", ".", "IP", "\n", "if", "ip4", ":=", "ip", ".", "To4", "(", ")", ";", "ip4", "!=", "nil", "{", "addrs4", "=", "append", "(", "addrs4", ",", "addr", ")", "\n", "}", "else", "if", "ip6", ":=", "ip", ".", "To16", "(", ")", ";", "len", "(", "ip6", ")", "==", "net", ".", "IPv6len", "{", "addrs6", "=", "append", "(", "addrs6", ",", "addr", ")", "\n", "}", "\n", "}", "\n", "switch", "{", "case", "len", "(", "addrs4", ")", "==", "0", ":", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "case", "len", "(", "addrs4", ")", ">", "1", ":", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "name", ",", "(", "addrs4", "[", "0", "]", ".", "(", "*", "net", ".", "IPNet", ")", ")", ".", "IP", ")", "\n", "}", "\n", "return", "addrs4", "[", "0", "]", ",", "addrs6", ",", "nil", "\n", "}" ]

[ "GetIfaceAddr", "returns", "the", "first", "IPv4", "address", "and", "slice", "of", "IPv6", "addresses", "for", "the", "specified", "network", "interface" ]

[ "func", "GenerateRandomName", "(", "prefix", "string", ",", "size", "int", ")", "(", "string", ",", "error", ")", "{", "id", ":=", "make", "(", "[", "]", "byte", ",", "32", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "rand", ".", "Reader", ",", "id", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "prefix", "+", "hex", ".", "EncodeToString", "(", "id", ")", "[", ":", "size", "]", ",", "nil", "\n", "}" ]

[ "GenerateRandomName", "returns", "a", "new", "name", "joined", "with", "a", "prefix", ".", "This", "size", "specified", "is", "used", "to", "truncate", "the", "randomly", "generated", "value" ]

[ "func", "ReverseIP", "(", "IP", "string", ")", "string", "{", "var", "reverseIP", "[", "]", "string", "\n\n", "if", "net", ".", "ParseIP", "(", "IP", ")", ".", "To4", "(", ")", "!=", "nil", "{", "reverseIP", "=", "strings", ".", "Split", "(", "IP", ",", "\"", "\"", ")", "\n", "l", ":=", "len", "(", "reverseIP", ")", "\n", "for", "i", ",", "j", ":=", "0", ",", "l", "-", "1", ";", "i", "<", "l", "/", "2", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "-", "1", "{", "reverseIP", "[", "i", "]", ",", "reverseIP", "[", "j", "]", "=", "reverseIP", "[", "j", "]", ",", "reverseIP", "[", "i", "]", "\n", "}", "\n", "}", "else", "{", "reverseIP", "=", "strings", ".", "Split", "(", "IP", ",", "\"", "\"", ")", "\n\n", "// Reversed IPv6 is represented in dotted decimal instead of the typical", "// colon hex notation", "for", "key", ":=", "range", "reverseIP", "{", "if", "len", "(", "reverseIP", "[", "key", "]", ")", "==", "0", "{", "// expand the compressed 0s", "reverseIP", "[", "key", "]", "=", "strings", ".", "Repeat", "(", "\"", "\"", ",", "8", "-", "strings", ".", "Count", "(", "IP", ",", "\"", "\"", ")", ")", "\n", "}", "else", "if", "len", "(", "reverseIP", "[", "key", "]", ")", "<", "4", "{", "// 0-padding needed", "reverseIP", "[", "key", "]", "=", "strings", ".", "Repeat", "(", "\"", "\"", ",", "4", "-", "len", "(", "reverseIP", "[", "key", "]", ")", ")", "+", "reverseIP", "[", "key", "]", "\n", "}", "\n", "}", "\n\n", "reverseIP", "=", "strings", ".", "Split", "(", "strings", ".", "Join", "(", "reverseIP", ",", "\"", "\"", ")", ",", "\"", "\"", ")", "\n\n", "l", ":=", "len", "(", "reverseIP", ")", "\n", "for", "i", ",", "j", ":=", "0", ",", "l", "-", "1", ";", "i", "<", "l", "/", "2", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "-", "1", "{", "reverseIP", "[", "i", "]", ",", "reverseIP", "[", "j", "]", "=", "reverseIP", "[", "j", "]", ",", "reverseIP", "[", "i", "]", "\n", "}", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "reverseIP", ",", "\"", "\"", ")", "\n", "}" ]

[ "ReverseIP", "accepts", "a", "V4", "or", "V6", "IP", "string", "in", "the", "canonical", "form", "and", "returns", "a", "reversed", "IP", "in", "the", "dotted", "decimal", "form", ".", "This", "is", "used", "to", "setup", "the", "IP", "to", "service", "name", "mapping", "in", "the", "optimal", "way", "for", "the", "DNS", "PTR", "queries", "." ]

[ "func", "assembleService", "(", "attrs", "[", "]", "syscall", ".", "NetlinkRouteAttr", ")", "(", "*", "Service", ",", "error", ")", "{", "var", "s", "Service", "\n\n", "for", "_", ",", "attr", ":=", "range", "attrs", "{", "attrType", ":=", "int", "(", "attr", ".", "Attr", ".", "Type", ")", "\n\n", "switch", "attrType", "{", "case", "ipvsSvcAttrAddressFamily", ":", "s", ".", "AddressFamily", "=", "native", ".", "Uint16", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrProtocol", ":", "s", ".", "Protocol", "=", "native", ".", "Uint16", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrAddress", ":", "ip", ",", "err", ":=", "parseIP", "(", "attr", ".", "Value", ",", "s", ".", "AddressFamily", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "s", ".", "Address", "=", "ip", "\n", "case", "ipvsSvcAttrPort", ":", "s", ".", "Port", "=", "binary", ".", "BigEndian", ".", "Uint16", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrFWMark", ":", "s", ".", "FWMark", "=", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrSchedName", ":", "s", ".", "SchedName", "=", "nl", ".", "BytesToString", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrFlags", ":", "s", ".", "Flags", "=", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrTimeout", ":", "s", ".", "Timeout", "=", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrNetmask", ":", "s", ".", "Netmask", "=", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", "\n", "case", "ipvsSvcAttrStats", ":", "stats", ",", "err", ":=", "assembleStats", "(", "attr", ".", "Value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "s", ".", "Stats", "=", "stats", "\n", "}", "\n\n", "}", "\n", "return", "&", "s", ",", "nil", "\n", "}" ]

[ "assembleService", "assembles", "a", "services", "back", "from", "a", "hain", "of", "netlink", "attributes" ]

[ "func", "(", "i", "*", "Handle", ")", "parseService", "(", "msg", "[", "]", "byte", ")", "(", "*", "Service", ",", "error", ")", "{", "var", "s", "*", "Service", "\n\n", "//Remove General header for this message and parse the NetLink message", "hdr", ":=", "deserializeGenlMsg", "(", "msg", ")", "\n", "NetLinkAttrs", ",", "err", ":=", "nl", ".", "ParseRouteAttr", "(", "msg", "[", "hdr", ".", "Len", "(", ")", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "NetLinkAttrs", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "//Now Parse and get IPVS related attributes messages packed in this message.", "ipvsAttrs", ",", "err", ":=", "nl", ".", "ParseRouteAttr", "(", "NetLinkAttrs", "[", "0", "]", ".", "Value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "//Assemble all the IPVS related attribute messages and create a service record", "s", ",", "err", "=", "assembleService", "(", "ipvsAttrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "parseService", "given", "a", "ipvs", "netlink", "response", "this", "function", "will", "respond", "with", "a", "valid", "service", "entry", "an", "error", "otherwise" ]

[ "func", "(", "i", "*", "Handle", ")", "doCmdWithoutAttr", "(", "cmd", "uint8", ")", "(", "[", "]", "[", "]", "byte", ",", "error", ")", "{", "req", ":=", "newIPVSRequest", "(", "cmd", ")", "\n", "req", ".", "Seq", "=", "atomic", ".", "AddUint32", "(", "&", "i", ".", "seq", ",", "1", ")", "\n", "return", "execute", "(", "i", ".", "sock", ",", "req", ",", "0", ")", "\n", "}" ]

[ "doCmdWithoutAttr", "a", "simple", "wrapper", "of", "netlink", "socket", "execute", "command" ]

[ "func", "(", "i", "*", "Handle", ")", "parseDestination", "(", "msg", "[", "]", "byte", ")", "(", "*", "Destination", ",", "error", ")", "{", "var", "dst", "*", "Destination", "\n\n", "//Remove General header for this message", "hdr", ":=", "deserializeGenlMsg", "(", "msg", ")", "\n", "NetLinkAttrs", ",", "err", ":=", "nl", ".", "ParseRouteAttr", "(", "msg", "[", "hdr", ".", "Len", "(", ")", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "NetLinkAttrs", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "//Now Parse and get IPVS related attributes messages packed in this message.", "ipvsAttrs", ",", "err", ":=", "nl", ".", "ParseRouteAttr", "(", "NetLinkAttrs", "[", "0", "]", ".", "Value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "//Assemble netlink attributes and create a Destination record", "dst", ",", "err", "=", "assembleDestination", "(", "ipvsAttrs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "dst", ",", "nil", "\n", "}" ]

[ "parseDestination", "given", "a", "ipvs", "netlink", "response", "this", "function", "will", "respond", "with", "a", "valid", "destination", "entry", "an", "error", "otherwise" ]

[ "func", "(", "i", "*", "Handle", ")", "parseConfig", "(", "msg", "[", "]", "byte", ")", "(", "*", "Config", ",", "error", ")", "{", "var", "c", "Config", "\n\n", "//Remove General header for this message", "hdr", ":=", "deserializeGenlMsg", "(", "msg", ")", "\n", "attrs", ",", "err", ":=", "nl", ".", "ParseRouteAttr", "(", "msg", "[", "hdr", ".", "Len", "(", ")", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "attr", ":=", "range", "attrs", "{", "attrType", ":=", "int", "(", "attr", ".", "Attr", ".", "Type", ")", "\n", "switch", "attrType", "{", "case", "ipvsCmdAttrTimeoutTCP", ":", "c", ".", "TimeoutTCP", "=", "time", ".", "Duration", "(", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", ")", "*", "time", ".", "Second", "\n", "case", "ipvsCmdAttrTimeoutTCPFin", ":", "c", ".", "TimeoutTCPFin", "=", "time", ".", "Duration", "(", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", ")", "*", "time", ".", "Second", "\n", "case", "ipvsCmdAttrTimeoutUDP", ":", "c", ".", "TimeoutUDP", "=", "time", ".", "Duration", "(", "native", ".", "Uint32", "(", "attr", ".", "Value", ")", ")", "*", "time", ".", "Second", "\n", "}", "\n", "}", "\n\n", "return", "&", "c", ",", "nil", "\n", "}" ]

[ "parseConfig", "given", "a", "ipvs", "netlink", "response", "this", "function", "will", "respond", "with", "a", "valid", "config", "entry", "an", "error", "otherwise" ]

[ "func", "(", "i", "*", "Handle", ")", "doGetConfigCmd", "(", ")", "(", "*", "Config", ",", "error", ")", "{", "msg", ",", "err", ":=", "i", ".", "doCmdWithoutAttr", "(", "ipvsCmdGetConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", ",", "err", ":=", "i", ".", "parseConfig", "(", "msg", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "res", ",", "err", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "doGetConfigCmd", "a", "wrapper", "function", "to", "be", "used", "by", "GetConfig" ]

[ "func", "(", "i", "*", "Handle", ")", "doSetConfigCmd", "(", "c", "*", "Config", ")", "error", "{", "req", ":=", "newIPVSRequest", "(", "ipvsCmdSetConfig", ")", "\n", "req", ".", "Seq", "=", "atomic", ".", "AddUint32", "(", "&", "i", ".", "seq", ",", "1", ")", "\n\n", "req", ".", "AddData", "(", "nl", ".", "NewRtAttr", "(", "ipvsCmdAttrTimeoutTCP", ",", "nl", ".", "Uint32Attr", "(", "uint32", "(", "c", ".", "TimeoutTCP", ".", "Seconds", "(", ")", ")", ")", ")", ")", "\n", "req", ".", "AddData", "(", "nl", ".", "NewRtAttr", "(", "ipvsCmdAttrTimeoutTCPFin", ",", "nl", ".", "Uint32Attr", "(", "uint32", "(", "c", ".", "TimeoutTCPFin", ".", "Seconds", "(", ")", ")", ")", ")", ")", "\n", "req", ".", "AddData", "(", "nl", ".", "NewRtAttr", "(", "ipvsCmdAttrTimeoutUDP", ",", "nl", ".", "Uint32Attr", "(", "uint32", "(", "c", ".", "TimeoutUDP", ".", "Seconds", "(", ")", ")", ")", ")", ")", "\n\n", "_", ",", "err", ":=", "execute", "(", "i", ".", "sock", ",", "req", ",", "0", ")", "\n\n", "return", "err", "\n", "}" ]

[ "doSetConfigCmd", "a", "wrapper", "function", "to", "be", "used", "by", "SetConfig" ]

[ "func", "setupDeviceUp", "(", "config", "*", "networkConfiguration", ",", "i", "*", "bridgeInterface", ")", "error", "{", "err", ":=", "i", ".", "nlh", ".", "LinkSetUp", "(", "i", ".", "Link", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "config", ".", "BridgeName", ",", "err", ")", "\n", "}", "\n\n", "// Attempt to update the bridge interface to refresh the flags status,", "// ignoring any failure to do so.", "if", "lnk", ",", "err", ":=", "i", ".", "nlh", ".", "LinkByName", "(", "config", ".", "BridgeName", ")", ";", "err", "==", "nil", "{", "i", ".", "Link", "=", "lnk", "\n", "}", "else", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "config", ".", "BridgeName", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetupDeviceUp", "ups", "the", "given", "bridge", "interface", "." ]

[ "func", "(", "e", "ErrPortAlreadyAllocated", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "ip", ",", "e", ".", "port", ")", "\n", "}" ]

[ "Error", "is", "the", "implementation", "of", "error", ".", "Error", "interface" ]

[ "func", "(", "p", "*", "PortAllocator", ")", "RequestPort", "(", "ip", "net", ".", "IP", ",", "proto", "string", ",", "port", "int", ")", "(", "int", ",", "error", ")", "{", "return", "p", ".", "RequestPortInRange", "(", "ip", ",", "proto", ",", "port", ",", "port", ")", "\n", "}" ]

[ "RequestPort", "requests", "new", "port", "from", "global", "ports", "pool", "for", "specified", "ip", "and", "proto", ".", "If", "port", "is", "0", "it", "returns", "first", "free", "port", ".", "Otherwise", "it", "checks", "port", "availability", "in", "proto", "s", "pool", "and", "returns", "that", "port", "or", "error", "if", "port", "is", "already", "busy", "." ]

[ "func", "(", "p", "*", "PortAllocator", ")", "ReleasePort", "(", "ip", "net", ".", "IP", ",", "proto", "string", ",", "port", "int", ")", "error", "{", "p", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "ip", "==", "nil", "{", "ip", "=", "defaultIP", "\n", "}", "\n", "protomap", ",", "ok", ":=", "p", ".", "ipMap", "[", "ip", ".", "String", "(", ")", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n", "delete", "(", "protomap", "[", "proto", "]", ".", "p", ",", "port", ")", "\n", "return", "nil", "\n", "}" ]

[ "ReleasePort", "releases", "port", "from", "global", "ports", "pool", "for", "specified", "ip", "and", "proto", "." ]

[ "func", "(", "p", "*", "PortAllocator", ")", "ReleaseAll", "(", ")", "error", "{", "p", ".", "mutex", ".", "Lock", "(", ")", "\n", "p", ".", "ipMap", "=", "ipMapping", "{", "}", "\n", "p", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "ReleaseAll", "releases", "all", "ports", "for", "all", "ips", "." ]

[ "func", "createMacVlan", "(", "containerIfName", ",", "parent", ",", "macvlanMode", "string", ")", "(", "string", ",", "error", ")", "{", "// Set the macvlan mode. Default is bridge mode", "mode", ",", "err", ":=", "setMacVlanMode", "(", "macvlanMode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "macvlanMode", ",", "err", ")", "\n", "}", "\n", "// verify the Docker host interface acting as the macvlan parent iface exists", "if", "!", "parentExists", "(", "parent", ")", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "parent", ")", "\n", "}", "\n", "// Get the link for the master index (Example: the docker host eth iface)", "parentLink", ",", "err", ":=", "ns", ".", "NlHandle", "(", ")", ".", "LinkByName", "(", "parent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "macvlanType", ",", "parent", ",", "err", ")", "\n", "}", "\n", "// Create a macvlan link", "macvlan", ":=", "&", "netlink", ".", "Macvlan", "{", "LinkAttrs", ":", "netlink", ".", "LinkAttrs", "{", "Name", ":", "containerIfName", ",", "ParentIndex", ":", "parentLink", ".", "Attrs", "(", ")", ".", "Index", ",", "}", ",", "Mode", ":", "mode", ",", "}", "\n", "if", "err", ":=", "ns", ".", "NlHandle", "(", ")", ".", "LinkAdd", "(", "macvlan", ")", ";", "err", "!=", "nil", "{", "// If a user creates a macvlan and ipvlan on same parent, only one slave iface can be active at a time.", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "macvlanType", ",", "err", ")", "\n", "}", "\n\n", "return", "macvlan", ".", "Attrs", "(", ")", ".", "Name", ",", "nil", "\n", "}" ]

[ "Create", "the", "macvlan", "slave", "specifying", "the", "source", "name" ]

[ "func", "setMacVlanMode", "(", "mode", "string", ")", "(", "netlink", ".", "MacvlanMode", ",", "error", ")", "{", "switch", "mode", "{", "case", "modePrivate", ":", "return", "netlink", ".", "MACVLAN_MODE_PRIVATE", ",", "nil", "\n", "case", "modeVepa", ":", "return", "netlink", ".", "MACVLAN_MODE_VEPA", ",", "nil", "\n", "case", "modeBridge", ":", "return", "netlink", ".", "MACVLAN_MODE_BRIDGE", ",", "nil", "\n", "case", "modePassthru", ":", "return", "netlink", ".", "MACVLAN_MODE_PASSTHRU", ",", "nil", "\n", "default", ":", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "mode", ")", "\n", "}", "\n", "}" ]

[ "setMacVlanMode", "setter", "for", "one", "of", "the", "four", "macvlan", "port", "types" ]

[ "func", "delVlanLink", "(", "linkName", "string", ")", "error", "{", "if", "strings", ".", "Contains", "(", "linkName", ",", "\"", "\"", ")", "{", "_", ",", "_", ",", "err", ":=", "parseVlan", "(", "linkName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// delete the vlan subinterface", "vlanLink", ",", "err", ":=", "ns", ".", "NlHandle", "(", ")", ".", "LinkByName", "(", "linkName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "linkName", ",", "err", ")", "\n", "}", "\n", "// verify a parent interface isn't being deleted", "if", "vlanLink", ".", "Attrs", "(", ")", ".", "ParentIndex", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "linkName", ",", "err", ")", "\n", "}", "\n", "// delete the macvlan slave device", "if", "err", ":=", "ns", ".", "NlHandle", "(", ")", ".", "LinkDel", "(", "vlanLink", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "linkName", ",", "err", ")", "\n", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "linkName", ")", "\n", "}", "\n", "// if the subinterface doesn't parse to iface.vlan_id leave the interface in", "// place since it could be a user specified name not created by the driver.", "return", "nil", "\n", "}" ]

[ "delVlanLink", "verifies", "only", "sub", "-", "interfaces", "with", "a", "vlan", "id", "get", "deleted" ]

[ "func", "GetSpecific", "(", "path", "string", ")", "(", "*", "File", ",", "error", ")", "{", "resolv", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "hash", ",", "err", ":=", "ioutils", ".", "HashData", "(", "bytes", ".", "NewReader", "(", "resolv", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "File", "{", "Content", ":", "resolv", ",", "Hash", ":", "hash", "}", ",", "nil", "\n", "}" ]

[ "GetSpecific", "returns", "the", "contents", "of", "the", "user", "specified", "resolv", ".", "conf", "file", "and", "its", "hash" ]

[ "func", "GetLastModified", "(", ")", "*", "File", "{", "lastModified", ".", "Lock", "(", ")", "\n", "defer", "lastModified", ".", "Unlock", "(", ")", "\n\n", "return", "&", "File", "{", "Content", ":", "lastModified", ".", "contents", ",", "Hash", ":", "lastModified", ".", "sha256", "}", "\n", "}" ]

[ "GetLastModified", "retrieves", "the", "last", "used", "contents", "and", "hash", "of", "the", "host", "resolv", ".", "conf", ".", "Used", "by", "containers", "updating", "on", "restart" ]

[ "func", "getLines", "(", "input", "[", "]", "byte", ",", "commentMarker", "[", "]", "byte", ")", "[", "]", "[", "]", "byte", "{", "lines", ":=", "bytes", ".", "Split", "(", "input", ",", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ")", "\n", "var", "output", "[", "]", "[", "]", "byte", "\n", "for", "_", ",", "currentLine", ":=", "range", "lines", "{", "var", "commentIndex", "=", "bytes", ".", "Index", "(", "currentLine", ",", "commentMarker", ")", "\n", "if", "commentIndex", "==", "-", "1", "{", "output", "=", "append", "(", "output", ",", "currentLine", ")", "\n", "}", "else", "{", "output", "=", "append", "(", "output", ",", "currentLine", "[", ":", "commentIndex", "]", ")", "\n", "}", "\n", "}", "\n", "return", "output", "\n", "}" ]

[ "getLines", "parses", "input", "into", "lines", "and", "strips", "away", "comments", "." ]

[ "func", "Build", "(", "path", "string", ",", "dns", ",", "dnsSearch", ",", "dnsOptions", "[", "]", "string", ")", "(", "*", "File", ",", "error", ")", "{", "content", ":=", "bytes", ".", "NewBuffer", "(", "nil", ")", "\n", "if", "len", "(", "dnsSearch", ")", ">", "0", "{", "if", "searchString", ":=", "strings", ".", "Join", "(", "dnsSearch", ",", "\"", "\"", ")", ";", "strings", ".", "Trim", "(", "searchString", ",", "\"", "\"", ")", "!=", "\"", "\"", "{", "if", "_", ",", "err", ":=", "content", ".", "WriteString", "(", "\"", "\"", "+", "searchString", "+", "\"", "\\n", "\"", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "for", "_", ",", "dns", ":=", "range", "dns", "{", "if", "_", ",", "err", ":=", "content", ".", "WriteString", "(", "\"", "\"", "+", "dns", "+", "\"", "\\n", "\"", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "len", "(", "dnsOptions", ")", ">", "0", "{", "if", "optsString", ":=", "strings", ".", "Join", "(", "dnsOptions", ",", "\"", "\"", ")", ";", "strings", ".", "Trim", "(", "optsString", ",", "\"", "\"", ")", "!=", "\"", "\"", "{", "if", "_", ",", "err", ":=", "content", ".", "WriteString", "(", "\"", "\"", "+", "optsString", "+", "\"", "\\n", "\"", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "hash", ",", "err", ":=", "ioutils", ".", "HashData", "(", "bytes", ".", "NewReader", "(", "content", ".", "Bytes", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "File", "{", "Content", ":", "content", ".", "Bytes", "(", ")", ",", "Hash", ":", "hash", "}", ",", "ioutil", ".", "WriteFile", "(", "path", ",", "content", ".", "Bytes", "(", ")", ",", "0644", ")", "\n", "}" ]

[ "Build", "writes", "a", "configuration", "file", "to", "path", "containing", "a", "nameserver", "entry", "for", "every", "element", "in", "dns", "a", "search", "entry", "for", "every", "element", "in", "dnsSearch", "and", "an", "options", "entry", "for", "every", "element", "in", "dnsOptions", "." ]

[ "func", "NewAllocator", "(", "lcDs", ",", "glDs", "datastore", ".", "DataStore", ")", "(", "*", "Allocator", ",", "error", ")", "{", "a", ":=", "&", "Allocator", "{", "}", "\n\n", "// Load predefined subnet pools", "a", ".", "predefined", "=", "map", "[", "string", "]", "[", "]", "*", "net", ".", "IPNet", "{", "localAddressSpace", ":", "ipamutils", ".", "GetLocalScopeDefaultNetworks", "(", ")", ",", "globalAddressSpace", ":", "ipamutils", ".", "GetGlobalScopeDefaultNetworks", "(", ")", ",", "}", "\n\n", "// Initialize asIndices map", "a", ".", "predefinedStartIndices", "=", "make", "(", "map", "[", "string", "]", "int", ")", "\n\n", "// Initialize bitseq map", "a", ".", "addresses", "=", "make", "(", "map", "[", "SubnetKey", "]", "*", "bitseq", ".", "Handle", ")", "\n\n", "// Initialize address spaces", "a", ".", "addrSpaces", "=", "make", "(", "map", "[", "string", "]", "*", "addrSpace", ")", "\n", "for", "_", ",", "aspc", ":=", "range", "[", "]", "struct", "{", "as", "string", "\n", "ds", "datastore", ".", "DataStore", "\n", "}", "{", "{", "localAddressSpace", ",", "lcDs", "}", ",", "{", "globalAddressSpace", ",", "glDs", "}", ",", "}", "{", "a", ".", "initializeAddressSpace", "(", "aspc", ".", "as", ",", "aspc", ".", "ds", ")", "\n", "}", "\n\n", "return", "a", ",", "nil", "\n", "}" ]

[ "NewAllocator", "returns", "an", "instance", "of", "libnetwork", "ipam" ]

[ "func", "(", "a", "*", "Allocator", ")", "checkConsistency", "(", "as", "string", ")", "{", "var", "sKeyList", "[", "]", "SubnetKey", "\n\n", "// Retrieve this address space's configuration and bitmasks from the datastore", "a", ".", "refresh", "(", "as", ")", "\n", "a", ".", "Lock", "(", ")", "\n", "aSpace", ",", "ok", ":=", "a", ".", "addrSpaces", "[", "as", "]", "\n", "a", ".", "Unlock", "(", ")", "\n", "if", "!", "ok", "{", "return", "\n", "}", "\n", "a", ".", "updateBitMasks", "(", "aSpace", ")", "\n\n", "aSpace", ".", "Lock", "(", ")", "\n", "for", "sk", ",", "pd", ":=", "range", "aSpace", ".", "subnets", "{", "if", "pd", ".", "Range", "!=", "nil", "{", "continue", "\n", "}", "\n", "sKeyList", "=", "append", "(", "sKeyList", ",", "sk", ")", "\n", "}", "\n", "aSpace", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "sk", ":=", "range", "sKeyList", "{", "a", ".", "Lock", "(", ")", "\n", "bm", ":=", "a", ".", "addresses", "[", "sk", "]", "\n", "a", ".", "Unlock", "(", ")", "\n", "if", "err", ":=", "bm", ".", "CheckConsistency", "(", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "sk", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Checks", "for", "and", "fixes", "damaged", "bitmask", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "DiscoverNew", "(", "dType", "discoverapi", ".", "DiscoveryType", ",", "data", "interface", "{", "}", ")", "error", "{", "if", "dType", "!=", "discoverapi", ".", "DatastoreConfig", "{", "return", "nil", "\n", "}", "\n\n", "dsc", ",", "ok", ":=", "data", ".", "(", "discoverapi", ".", "DatastoreConfigData", ")", "\n", "if", "!", "ok", "{", "return", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "data", ")", "\n", "}", "\n\n", "ds", ",", "err", ":=", "datastore", ".", "NewDataStoreFromConfig", "(", "dsc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "a", ".", "initializeAddressSpace", "(", "globalAddressSpace", ",", "ds", ")", "\n", "}" ]

[ "DiscoverNew", "informs", "the", "allocator", "about", "a", "new", "global", "scope", "datastore" ]

[ "func", "(", "a", "*", "Allocator", ")", "RequestPool", "(", "addressSpace", ",", "pool", ",", "subPool", "string", ",", "options", "map", "[", "string", "]", "string", ",", "v6", "bool", ")", "(", "string", ",", "*", "net", ".", "IPNet", ",", "map", "[", "string", "]", "string", ",", "error", ")", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "addressSpace", ",", "pool", ",", "subPool", ",", "options", ",", "v6", ")", "\n\n", "k", ",", "nw", ",", "ipr", ",", "err", ":=", "a", ".", "parsePoolRequest", "(", "addressSpace", ",", "pool", ",", "subPool", ",", "v6", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "addressSpace", ",", "pool", ",", "subPool", ",", "err", ")", "\n", "}", "\n\n", "pdf", ":=", "k", "==", "nil", "\n\n", "retry", ":", "if", "pdf", "{", "if", "nw", ",", "err", "=", "a", ".", "getPredefinedPool", "(", "addressSpace", ",", "v6", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "k", "=", "&", "SubnetKey", "{", "AddressSpace", ":", "addressSpace", ",", "Subnet", ":", "nw", ".", "String", "(", ")", "}", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "refresh", "(", "addressSpace", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "aSpace", ",", "err", ":=", "a", ".", "getAddrSpace", "(", "addressSpace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "insert", ",", "err", ":=", "aSpace", ".", "updatePoolDBOnAdd", "(", "*", "k", ",", "nw", ",", "ipr", ",", "pdf", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "types", ".", "MaskableError", ")", ";", "ok", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "goto", "retry", "\n", "}", "\n", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "writeToStore", "(", "aSpace", ")", ";", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "types", ".", "RetryError", ")", ";", "!", "ok", "{", "return", "\"", "\"", ",", "nil", ",", "nil", ",", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "goto", "retry", "\n", "}", "\n\n", "return", "k", ".", "String", "(", ")", ",", "nw", ",", "nil", ",", "insert", "(", ")", "\n", "}" ]

[ "RequestPool", "returns", "an", "address", "pool", "along", "with", "its", "unique", "id", ".", "addressSpace", "must", "be", "a", "valid", "address", "space", "name", "and", "must", "not", "be", "the", "empty", "string", ".", "If", "pool", "is", "the", "empty", "string", "then", "the", "default", "predefined", "pool", "for", "addressSpace", "will", "be", "used", "otherwise", "pool", "must", "be", "a", "valid", "IP", "address", "and", "length", "in", "CIDR", "notation", ".", "If", "subPool", "is", "not", "empty", "it", "must", "be", "a", "valid", "IP", "address", "and", "length", "in", "CIDR", "notation", "which", "is", "a", "sub", "-", "range", "of", "pool", ".", "subPool", "must", "be", "empty", "if", "pool", "is", "empty", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "ReleasePool", "(", "poolID", "string", ")", "error", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "poolID", ")", "\n", "k", ":=", "SubnetKey", "{", "}", "\n", "if", "err", ":=", "k", ".", "FromString", "(", "poolID", ")", ";", "err", "!=", "nil", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "poolID", ")", "\n", "}", "\n\n", "retry", ":", "if", "err", ":=", "a", ".", "refresh", "(", "k", ".", "AddressSpace", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "aSpace", ",", "err", ":=", "a", ".", "getAddrSpace", "(", "k", ".", "AddressSpace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "remove", ",", "err", ":=", "aSpace", ".", "updatePoolDBOnRemoval", "(", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", "=", "a", ".", "writeToStore", "(", "aSpace", ")", ";", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "types", ".", "RetryError", ")", ";", "!", "ok", "{", "return", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "poolID", ",", "err", ")", "\n", "}", "\n", "goto", "retry", "\n", "}", "\n\n", "return", "remove", "(", ")", "\n", "}" ]

[ "ReleasePool", "releases", "the", "address", "pool", "identified", "by", "the", "passed", "id" ]

[ "func", "(", "a", "*", "Allocator", ")", "getAddrSpace", "(", "as", "string", ")", "(", "*", "addrSpace", ",", "error", ")", "{", "a", ".", "Lock", "(", ")", "\n", "defer", "a", ".", "Unlock", "(", ")", "\n", "aSpace", ",", "ok", ":=", "a", ".", "addrSpaces", "[", "as", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "as", ")", "\n", "}", "\n", "return", "aSpace", ",", "nil", "\n", "}" ]

[ "Given", "the", "address", "space", "returns", "the", "local", "or", "global", "PoolConfig", "based", "on", "whether", "the", "address", "space", "is", "local", "or", "global", ".", "AddressSpace", "locality", "is", "registered", "with", "IPAM", "out", "of", "band", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "parsePoolRequest", "(", "addressSpace", ",", "pool", ",", "subPool", "string", ",", "v6", "bool", ")", "(", "*", "SubnetKey", ",", "*", "net", ".", "IPNet", ",", "*", "AddressRange", ",", "error", ")", "{", "var", "(", "nw", "*", "net", ".", "IPNet", "\n", "ipr", "*", "AddressRange", "\n", "err", "error", "\n", ")", "\n\n", "if", "addressSpace", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "nil", ",", "ipamapi", ".", "ErrInvalidAddressSpace", "\n", "}", "\n\n", "if", "pool", "==", "\"", "\"", "&&", "subPool", "!=", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "nil", ",", "ipamapi", ".", "ErrInvalidSubPool", "\n", "}", "\n\n", "if", "pool", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "nil", ",", "nil", "\n", "}", "\n\n", "if", "_", ",", "nw", ",", "err", "=", "net", ".", "ParseCIDR", "(", "pool", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "ipamapi", ".", "ErrInvalidPool", "\n", "}", "\n\n", "if", "subPool", "!=", "\"", "\"", "{", "if", "ipr", ",", "err", "=", "getAddressRange", "(", "subPool", ",", "nw", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "&", "SubnetKey", "{", "AddressSpace", ":", "addressSpace", ",", "Subnet", ":", "nw", ".", "String", "(", ")", ",", "ChildSubnet", ":", "subPool", "}", ",", "nw", ",", "ipr", ",", "nil", "\n", "}" ]

[ "parsePoolRequest", "parses", "and", "validates", "a", "request", "to", "create", "a", "new", "pool", "under", "addressSpace", "and", "returns", "a", "SubnetKey", "network", "and", "range", "describing", "the", "request", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "RequestAddress", "(", "poolID", "string", ",", "prefAddress", "net", ".", "IP", ",", "opts", "map", "[", "string", "]", "string", ")", "(", "*", "net", ".", "IPNet", ",", "map", "[", "string", "]", "string", ",", "error", ")", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "poolID", ",", "prefAddress", ",", "opts", ")", "\n", "k", ":=", "SubnetKey", "{", "}", "\n", "if", "err", ":=", "k", ".", "FromString", "(", "poolID", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "poolID", ")", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "refresh", "(", "k", ".", "AddressSpace", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "aSpace", ",", "err", ":=", "a", ".", "getAddrSpace", "(", "k", ".", "AddressSpace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "aSpace", ".", "Lock", "(", ")", "\n", "p", ",", "ok", ":=", "aSpace", ".", "subnets", "[", "k", "]", "\n", "if", "!", "ok", "{", "aSpace", ".", "Unlock", "(", ")", "\n", "return", "nil", ",", "nil", ",", "types", ".", "NotFoundErrorf", "(", "\"", "\"", ",", "poolID", ")", "\n", "}", "\n\n", "if", "prefAddress", "!=", "nil", "&&", "!", "p", ".", "Pool", ".", "Contains", "(", "prefAddress", ")", "{", "aSpace", ".", "Unlock", "(", ")", "\n", "return", "nil", ",", "nil", ",", "ipamapi", ".", "ErrIPOutOfRange", "\n", "}", "\n\n", "c", ":=", "p", "\n", "for", "c", ".", "Range", "!=", "nil", "{", "k", "=", "c", ".", "ParentKey", "\n", "c", "=", "aSpace", ".", "subnets", "[", "k", "]", "\n", "}", "\n", "aSpace", ".", "Unlock", "(", ")", "\n\n", "bm", ",", "err", ":=", "a", ".", "retrieveBitmask", "(", "k", ",", "c", ".", "Pool", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "k", ".", "String", "(", ")", ",", "prefAddress", ",", "poolID", ",", "err", ")", "\n", "}", "\n", "// In order to request for a serial ip address allocation, callers can pass in the option to request", "// IP allocation serially or first available IP in the subnet", "var", "serial", "bool", "\n", "if", "opts", "!=", "nil", "{", "if", "val", ",", "ok", ":=", "opts", "[", "ipamapi", ".", "AllocSerialPrefix", "]", ";", "ok", "{", "serial", "=", "(", "val", "==", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "ip", ",", "err", ":=", "a", ".", "getAddress", "(", "p", ".", "Pool", ",", "bm", ",", "prefAddress", ",", "p", ".", "Range", ",", "serial", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "net", ".", "IPNet", "{", "IP", ":", "ip", ",", "Mask", ":", "p", ".", "Pool", ".", "Mask", "}", ",", "nil", ",", "nil", "\n", "}" ]

[ "RequestAddress", "returns", "an", "address", "from", "the", "specified", "pool", "ID" ]

[ "func", "(", "a", "*", "Allocator", ")", "ReleaseAddress", "(", "poolID", "string", ",", "address", "net", ".", "IP", ")", "error", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "poolID", ",", "address", ")", "\n", "k", ":=", "SubnetKey", "{", "}", "\n", "if", "err", ":=", "k", ".", "FromString", "(", "poolID", ")", ";", "err", "!=", "nil", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "poolID", ")", "\n", "}", "\n\n", "if", "err", ":=", "a", ".", "refresh", "(", "k", ".", "AddressSpace", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "aSpace", ",", "err", ":=", "a", ".", "getAddrSpace", "(", "k", ".", "AddressSpace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "aSpace", ".", "Lock", "(", ")", "\n", "p", ",", "ok", ":=", "aSpace", ".", "subnets", "[", "k", "]", "\n", "if", "!", "ok", "{", "aSpace", ".", "Unlock", "(", ")", "\n", "return", "types", ".", "NotFoundErrorf", "(", "\"", "\"", ",", "poolID", ")", "\n", "}", "\n\n", "if", "address", "==", "nil", "{", "aSpace", ".", "Unlock", "(", ")", "\n", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "!", "p", ".", "Pool", ".", "Contains", "(", "address", ")", "{", "aSpace", ".", "Unlock", "(", ")", "\n", "return", "ipamapi", ".", "ErrIPOutOfRange", "\n", "}", "\n\n", "c", ":=", "p", "\n", "for", "c", ".", "Range", "!=", "nil", "{", "k", "=", "c", ".", "ParentKey", "\n", "c", "=", "aSpace", ".", "subnets", "[", "k", "]", "\n", "}", "\n", "aSpace", ".", "Unlock", "(", ")", "\n\n", "mask", ":=", "p", ".", "Pool", ".", "Mask", "\n\n", "h", ",", "err", ":=", "types", ".", "GetHostPartIP", "(", "address", ",", "mask", ")", "\n", "if", "err", "!=", "nil", "{", "return", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "address", ".", "String", "(", ")", ",", "err", ")", "\n", "}", "\n\n", "bm", ",", "err", ":=", "a", ".", "retrieveBitmask", "(", "k", ",", "c", ".", "Pool", ")", "\n", "if", "err", "!=", "nil", "{", "return", "types", ".", "InternalErrorf", "(", "\"", "\"", ",", "k", ".", "String", "(", ")", ",", "address", ",", "poolID", ",", "err", ")", "\n", "}", "\n", "defer", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "poolID", ",", "address", ",", "bm", ".", "String", "(", ")", ")", "\n\n", "return", "bm", ".", "Unset", "(", "ipToUint64", "(", "h", ")", ")", "\n", "}" ]

[ "ReleaseAddress", "releases", "the", "address", "from", "the", "specified", "pool", "ID" ]

[ "func", "(", "a", "*", "Allocator", ")", "DumpDatabase", "(", ")", "string", "{", "a", ".", "Lock", "(", ")", "\n", "aspaces", ":=", "make", "(", "map", "[", "string", "]", "*", "addrSpace", ",", "len", "(", "a", ".", "addrSpaces", ")", ")", "\n", "orderedAS", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "a", ".", "addrSpaces", ")", ")", "\n", "for", "as", ",", "aSpace", ":=", "range", "a", ".", "addrSpaces", "{", "orderedAS", "=", "append", "(", "orderedAS", ",", "as", ")", "\n", "aspaces", "[", "as", "]", "=", "aSpace", "\n", "}", "\n", "a", ".", "Unlock", "(", ")", "\n\n", "sort", ".", "Strings", "(", "orderedAS", ")", "\n\n", "var", "s", "string", "\n", "for", "_", ",", "as", ":=", "range", "orderedAS", "{", "aSpace", ":=", "aspaces", "[", "as", "]", "\n", "s", "=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\"", ",", "as", ")", "\n", "aSpace", ".", "Lock", "(", ")", "\n", "for", "k", ",", "config", ":=", "range", "aSpace", ".", "subnets", "{", "s", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "k", ",", "config", ")", "\n", "if", "config", ".", "Range", "==", "nil", "{", "a", ".", "retrieveBitmask", "(", "k", ",", "config", ".", "Pool", ")", "\n", "}", "\n", "}", "\n", "aSpace", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "s", "=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\"", ",", "s", ")", "\n", "for", "k", ",", "bm", ":=", "range", "a", ".", "addresses", "{", "s", "+=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "k", ",", "bm", ")", "\n", "}", "\n\n", "return", "s", "\n", "}" ]

[ "DumpDatabase", "dumps", "the", "internal", "info" ]

[ "func", "(", "sb", "*", "sandbox", ")", "populateLoadBalancers", "(", "ep", "*", "endpoint", ")", "{", "// This is an interface less endpoint. Nothing to do.", "if", "ep", ".", "Iface", "(", ")", "==", "nil", "{", "return", "\n", "}", "\n\n", "n", ":=", "ep", ".", "getNetwork", "(", ")", "\n", "eIP", ":=", "ep", ".", "Iface", "(", ")", ".", "Address", "(", ")", "\n\n", "if", "n", ".", "ingress", "{", "if", "err", ":=", "addRedirectRules", "(", "sb", ".", "Key", "(", ")", ",", "eIP", ",", "ep", ".", "ingressPorts", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\"", ",", "ep", ".", "Name", "(", ")", ",", "ep", ".", "ID", "(", ")", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Populate", "all", "loadbalancers", "on", "the", "network", "that", "the", "passed", "endpoint", "belongs", "to", "into", "this", "sandbox", "." ]

[ "func", "invokeFWMarker", "(", "path", "string", ",", "vip", "net", ".", "IP", ",", "fwMark", "uint32", ",", "ingressPorts", "[", "]", "*", "PortConfig", ",", "eIP", "*", "net", ".", "IPNet", ",", "isDelete", "bool", ",", "lbMode", "string", ")", "error", "{", "var", "ingressPortsFile", "string", "\n\n", "if", "len", "(", "ingressPorts", ")", "!=", "0", "{", "var", "err", "error", "\n", "ingressPortsFile", ",", "err", "=", "writePortsToFile", "(", "ingressPorts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "defer", "os", ".", "Remove", "(", "ingressPortsFile", ")", "\n", "}", "\n\n", "addDelOpt", ":=", "\"", "\"", "\n", "if", "isDelete", "{", "addDelOpt", "=", "\"", "\"", "\n", "}", "\n\n", "cmd", ":=", "&", "exec", ".", "Cmd", "{", "Path", ":", "reexec", ".", "Self", "(", ")", ",", "Args", ":", "append", "(", "[", "]", "string", "{", "\"", "\"", "}", ",", "path", ",", "vip", ".", "String", "(", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "fwMark", ")", ",", "addDelOpt", ",", "ingressPortsFile", ",", "eIP", ".", "String", "(", ")", ",", "lbMode", ")", ",", "Stdout", ":", "os", ".", "Stdout", ",", "Stderr", ":", "os", ".", "Stderr", ",", "}", "\n\n", "if", "err", ":=", "cmd", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Invoke", "fwmarker", "reexec", "routine", "to", "mark", "vip", "destined", "packets", "with", "the", "passed", "firewall", "mark", "." ]

[ "func", "IsBuiltinLocalDriver", "(", "networkType", "string", ")", "bool", "{", "if", "\"", "\"", "==", "networkType", "||", "\"", "\"", "==", "networkType", "||", "\"", "\"", "==", "networkType", "||", "\"", "\"", "==", "networkType", "||", "\"", "\"", "==", "networkType", "{", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "IsBuiltinLocalDriver", "validates", "if", "network", "-", "type", "is", "a", "builtin", "local", "-", "scoped", "driver" ]

[ "func", "newDriver", "(", "networkType", "string", ")", "*", "driver", "{", "return", "&", "driver", "{", "name", ":", "networkType", ",", "networks", ":", "map", "[", "string", "]", "*", "hnsNetwork", "{", "}", "}", "\n", "}" ]

[ "New", "constructs", "a", "new", "bridge", "driver" ]

[ "func", "GetInit", "(", "networkType", "string", ")", "func", "(", "dc", "driverapi", ".", "DriverCallback", ",", "config", "map", "[", "string", "]", "interface", "{", "}", ")", "error", "{", "return", "func", "(", "dc", "driverapi", ".", "DriverCallback", ",", "config", "map", "[", "string", "]", "interface", "{", "}", ")", "error", "{", "if", "!", "IsBuiltinLocalDriver", "(", "networkType", ")", "{", "return", "types", ".", "BadRequestErrorf", "(", "\"", "\"", ",", "networkType", ")", "\n", "}", "\n\n", "d", ":=", "newDriver", "(", "networkType", ")", "\n\n", "err", ":=", "d", ".", "initStore", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "dc", ".", "RegisterDriver", "(", "networkType", ",", "d", ",", "driverapi", ".", "Capability", "{", "DataScope", ":", "datastore", ".", "LocalScope", ",", "ConnectivityScope", ":", "datastore", ".", "LocalScope", ",", "}", ")", "\n", "}", "\n", "}" ]

[ "GetInit", "returns", "an", "initializer", "for", "the", "given", "network", "type" ]

[ "func", "ConvertPortBindings", "(", "portBindings", "[", "]", "types", ".", "PortBinding", ")", "(", "[", "]", "json", ".", "RawMessage", ",", "error", ")", "{", "var", "pbs", "[", "]", "json", ".", "RawMessage", "\n\n", "// Enumerate through the port bindings specified by the user and convert", "// them into the internal structure matching the JSON blob that can be", "// understood by the HCS.", "for", "_", ",", "elem", ":=", "range", "portBindings", "{", "proto", ":=", "strings", ".", "ToUpper", "(", "elem", ".", "Proto", ".", "String", "(", ")", ")", "\n", "if", "proto", "!=", "\"", "\"", "&&", "proto", "!=", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "elem", ".", "Proto", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "if", "elem", ".", "HostPort", "!=", "elem", ".", "HostPortEnd", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "elem", ".", "HostIP", ")", "!=", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "encodedPolicy", ",", "err", ":=", "json", ".", "Marshal", "(", "hcsshim", ".", "NatPolicy", "{", "Type", ":", "\"", "\"", ",", "ExternalPort", ":", "elem", ".", "HostPort", ",", "InternalPort", ":", "elem", ".", "Port", ",", "Protocol", ":", "elem", ".", "Proto", ".", "String", "(", ")", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "pbs", "=", "append", "(", "pbs", ",", "encodedPolicy", ")", "\n", "}", "\n", "return", "pbs", ",", "nil", "\n", "}" ]

[ "ConvertPortBindings", "converts", "PortBindings", "to", "JSON", "for", "HNS", "request" ]

[ "func", "ParsePortBindingPolicies", "(", "policies", "[", "]", "json", ".", "RawMessage", ")", "(", "[", "]", "types", ".", "PortBinding", ",", "error", ")", "{", "var", "bindings", "[", "]", "types", ".", "PortBinding", "\n", "hcsPolicy", ":=", "&", "hcsshim", ".", "NatPolicy", "{", "}", "\n\n", "for", "_", ",", "elem", ":=", "range", "policies", "{", "if", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "elem", ")", ",", "&", "hcsPolicy", ")", ";", "err", "!=", "nil", "||", "hcsPolicy", ".", "Type", "!=", "\"", "\"", "{", "continue", "\n", "}", "\n\n", "binding", ":=", "types", ".", "PortBinding", "{", "HostPort", ":", "hcsPolicy", ".", "ExternalPort", ",", "HostPortEnd", ":", "hcsPolicy", ".", "ExternalPort", ",", "Port", ":", "hcsPolicy", ".", "InternalPort", ",", "Proto", ":", "types", ".", "ParseProtocol", "(", "hcsPolicy", ".", "Protocol", ")", ",", "HostIP", ":", "net", ".", "IPv4", "(", "0", ",", "0", ",", "0", ",", "0", ")", ",", "}", "\n\n", "bindings", "=", "append", "(", "bindings", ",", "binding", ")", "\n", "}", "\n\n", "return", "bindings", ",", "nil", "\n", "}" ]

[ "ParsePortBindingPolicies", "parses", "HNS", "endpoint", "response", "message", "to", "PortBindings" ]

[ "func", "ParseEndpointConnectivity", "(", "epOptions", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "*", "EndpointConnectivity", ",", "error", ")", "{", "if", "epOptions", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "ec", ":=", "&", "EndpointConnectivity", "{", "}", "\n\n", "if", "opt", ",", "ok", ":=", "epOptions", "[", "netlabel", ".", "PortMap", "]", ";", "ok", "{", "if", "bs", ",", "ok", ":=", "opt", ".", "(", "[", "]", "types", ".", "PortBinding", ")", ";", "ok", "{", "ec", ".", "PortBindings", "=", "bs", "\n", "}", "else", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "opt", ",", "ok", ":=", "epOptions", "[", "netlabel", ".", "ExposedPorts", "]", ";", "ok", "{", "if", "ports", ",", "ok", ":=", "opt", ".", "(", "[", "]", "types", ".", "TransportPort", ")", ";", "ok", "{", "ec", ".", "ExposedPorts", "=", "ports", "\n", "}", "else", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "ec", ",", "nil", "\n", "}" ]

[ "ParseEndpointConnectivity", "parses", "options", "passed", "to", "CreateEndpoint", "specifically", "port", "bindings", "and", "store", "in", "a", "endpointConnectivity", "object", "." ]

[ "func", "(", "c", "*", "controller", ")", "cleanupServiceDiscovery", "(", "cleanupNID", "string", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "if", "cleanupNID", "==", "\"", "\"", "{", "logrus", ".", "Debugf", "(", "\"", "\"", ")", "\n", "c", ".", "svcRecords", "=", "make", "(", "map", "[", "string", "]", "svcInfo", ")", "\n", "return", "\n", "}", "\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "cleanupNID", ")", "\n", "delete", "(", "c", ".", "svcRecords", ",", "cleanupNID", ")", "\n", "}" ]

[ "cleanupServiceDiscovery", "when", "the", "network", "is", "being", "deleted", "erase", "all", "the", "associated", "service", "discovery", "records" ]

[ "func", "getKernelBoolParam", "(", "path", "string", ")", "(", "bool", ",", "error", ")", "{", "enabled", ":=", "false", "\n", "line", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "len", "(", "line", ")", ">", "0", "{", "enabled", "=", "line", "[", "0", "]", "==", "'1'", "\n", "}", "\n", "return", "enabled", ",", "err", "\n", "}" ]

[ "Gets", "the", "value", "of", "the", "kernel", "parameters", "located", "at", "the", "given", "path" ]

[ "func", "setKernelBoolParam", "(", "path", "string", ",", "on", "bool", ")", "error", "{", "value", ":=", "byte", "(", "'0'", ")", "\n", "if", "on", "{", "value", "=", "byte", "(", "'1'", ")", "\n", "}", "\n", "return", "ioutil", ".", "WriteFile", "(", "path", ",", "[", "]", "byte", "{", "value", ",", "'\\n'", "}", ",", "0644", ")", "\n", "}" ]

[ "Sets", "the", "value", "of", "the", "kernel", "parameter", "located", "at", "the", "given", "path" ]

[ "func", "isPacketForwardingEnabled", "(", "ipVer", "ipVersion", ",", "iface", "string", ")", "(", "bool", ",", "error", ")", "{", "switch", "ipVer", "{", "case", "ipv4", ",", "ipv6", ":", "return", "getKernelBoolParam", "(", "getForwardingKernelParam", "(", "ipVer", ",", "iface", ")", ")", "\n", "case", "ipvboth", ":", "enabled", ",", "err", ":=", "getKernelBoolParam", "(", "getForwardingKernelParam", "(", "ipv4", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "||", "!", "enabled", "{", "return", "enabled", ",", "err", "\n", "}", "\n", "return", "getKernelBoolParam", "(", "getForwardingKernelParam", "(", "ipv6", ",", "iface", ")", ")", "\n", "default", ":", "return", "true", ",", "nil", "\n", "}", "\n", "}" ]

[ "Checks", "to", "see", "if", "packet", "forwarding", "is", "enabled" ]

[ "func", "(", "ep", "*", "endpoint", ")", "isServiceEnabled", "(", ")", "bool", "{", "ep", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "Unlock", "(", ")", "\n", "return", "ep", ".", "serviceEnabled", "\n", "}" ]

[ "isServiceEnabled", "check", "if", "service", "is", "enabled", "on", "the", "endpoint" ]

[ "func", "(", "ep", "*", "endpoint", ")", "enableService", "(", ")", "{", "ep", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "Unlock", "(", ")", "\n", "ep", ".", "serviceEnabled", "=", "true", "\n", "}" ]

[ "enableService", "sets", "service", "enabled", "on", "the", "endpoint" ]

[ "func", "(", "ep", "*", "endpoint", ")", "disableService", "(", ")", "{", "ep", ".", "Lock", "(", ")", "\n", "defer", "ep", ".", "Unlock", "(", ")", "\n", "ep", ".", "serviceEnabled", "=", "false", "\n", "}" ]

[ "disableService", "disables", "service", "on", "the", "endpoint" ]

[ "func", "EndpointOptionGeneric", "(", "generic", "map", "[", "string", "]", "interface", "{", "}", ")", "EndpointOption", "{", "return", "func", "(", "ep", "*", "endpoint", ")", "{", "for", "k", ",", "v", ":=", "range", "generic", "{", "ep", ".", "generic", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n", "}" ]

[ "EndpointOptionGeneric", "function", "returns", "an", "option", "setter", "for", "a", "Generic", "option", "defined", "in", "a", "Dictionary", "of", "Key", "-", "Value", "pair" ]

[ "func", "CreateOptionIpam", "(", "ipV4", ",", "ipV6", "net", ".", "IP", ",", "llIPs", "[", "]", "net", ".", "IP", ",", "ipamOptions", "map", "[", "string", "]", "string", ")", "EndpointOption", "{", "return", "func", "(", "ep", "*", "endpoint", ")", "{", "ep", ".", "prefAddress", "=", "ipV4", "\n", "ep", ".", "prefAddressV6", "=", "ipV6", "\n", "if", "len", "(", "llIPs", ")", "!=", "0", "{", "for", "_", ",", "ip", ":=", "range", "llIPs", "{", "nw", ":=", "&", "net", ".", "IPNet", "{", "IP", ":", "ip", ",", "Mask", ":", "linkLocalMask", "}", "\n", "if", "ip", ".", "To4", "(", ")", "==", "nil", "{", "nw", ".", "Mask", "=", "linkLocalMaskIPv6", "\n", "}", "\n", "ep", ".", "iface", ".", "llAddrs", "=", "append", "(", "ep", ".", "iface", ".", "llAddrs", ",", "nw", ")", "\n", "}", "\n", "}", "\n", "ep", ".", "ipamOptions", "=", "ipamOptions", "\n", "}", "\n", "}" ]

[ "CreateOptionIpam", "function", "returns", "an", "option", "setter", "for", "the", "ipam", "configuration", "for", "this", "endpoint" ]

[ "func", "CreateOptionDNS", "(", "dns", "[", "]", "string", ")", "EndpointOption", "{", "return", "func", "(", "ep", "*", "endpoint", ")", "{", "ep", ".", "generic", "[", "netlabel", ".", "DNSServers", "]", "=", "dns", "\n", "}", "\n", "}" ]

[ "CreateOptionDNS", "function", "returns", "an", "option", "setter", "for", "dns", "entry", "option", "to", "be", "passed", "to", "container", "Create", "method", "." ]

[ "func", "CreateOptionAlias", "(", "name", "string", ",", "alias", "string", ")", "EndpointOption", "{", "return", "func", "(", "ep", "*", "endpoint", ")", "{", "if", "ep", ".", "aliases", "==", "nil", "{", "ep", ".", "aliases", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "ep", ".", "aliases", "[", "alias", "]", "=", "name", "\n", "}", "\n", "}" ]

[ "CreateOptionAlias", "function", "returns", "an", "option", "setter", "for", "setting", "endpoint", "alias" ]

[ "func", "CreateOptionService", "(", "name", ",", "id", "string", ",", "vip", "net", ".", "IP", ",", "ingressPorts", "[", "]", "*", "PortConfig", ",", "aliases", "[", "]", "string", ")", "EndpointOption", "{", "return", "func", "(", "ep", "*", "endpoint", ")", "{", "ep", ".", "svcName", "=", "name", "\n", "ep", ".", "svcID", "=", "id", "\n", "ep", ".", "virtualIP", "=", "vip", "\n", "ep", ".", "ingressPorts", "=", "ingressPorts", "\n", "ep", ".", "svcAliases", "=", "aliases", "\n", "}", "\n", "}" ]

[ "CreateOptionService", "function", "returns", "an", "option", "setter", "for", "setting", "service", "binding", "configuration" ]

[ "func", "CreateOptionMyAlias", "(", "alias", "string", ")", "EndpointOption", "{", "return", "func", "(", "ep", "*", "endpoint", ")", "{", "ep", ".", "myAliases", "=", "append", "(", "ep", ".", "myAliases", ",", "alias", ")", "\n", "}", "\n", "}" ]

[ "CreateOptionMyAlias", "function", "returns", "an", "option", "setter", "for", "setting", "endpoint", "s", "self", "alias" ]

[ "func", "DeleteConntrackEntries", "(", "nlh", "*", "netlink", ".", "Handle", ",", "ipv4List", "[", "]", "net", ".", "IP", ",", "ipv6List", "[", "]", "net", ".", "IP", ")", "(", "uint", ",", "uint", ",", "error", ")", "{", "if", "!", "IsConntrackProgrammable", "(", "nlh", ")", "{", "return", "0", ",", "0", ",", "ErrConntrackNotConfigurable", "\n", "}", "\n\n", "var", "totalIPv4FlowPurged", "uint", "\n", "for", "_", ",", "ipAddress", ":=", "range", "ipv4List", "{", "flowPurged", ",", "err", ":=", "purgeConntrackState", "(", "nlh", ",", "syscall", ".", "AF_INET", ",", "ipAddress", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "ipAddress", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "totalIPv4FlowPurged", "+=", "flowPurged", "\n", "}", "\n\n", "var", "totalIPv6FlowPurged", "uint", "\n", "for", "_", ",", "ipAddress", ":=", "range", "ipv6List", "{", "flowPurged", ",", "err", ":=", "purgeConntrackState", "(", "nlh", ",", "syscall", ".", "AF_INET6", ",", "ipAddress", ")", "\n", "if", "err", "!=", "nil", "{", "logrus", ".", "Warnf", "(", "\"", "\"", ",", "ipAddress", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "totalIPv6FlowPurged", "+=", "flowPurged", "\n", "}", "\n\n", "logrus", ".", "Debugf", "(", "\"", "\"", ",", "totalIPv4FlowPurged", ",", "totalIPv6FlowPurged", ")", "\n", "return", "totalIPv4FlowPurged", ",", "totalIPv6FlowPurged", ",", "nil", "\n", "}" ]

[ "DeleteConntrackEntries", "deletes", "all", "the", "conntrack", "connections", "on", "the", "host", "for", "the", "specified", "IP", "Returns", "the", "number", "of", "flows", "deleted", "for", "IPv4", "IPv6", "else", "error" ]

[ "func", "(", "cli", "*", "NetworkCli", ")", "CmdServicePublish", "(", "chain", "string", ",", "args", "...", "string", ")", "error", "{", "cmd", ":=", "cli", ".", "Subcmd", "(", "chain", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ")", "\n", "flAlias", ":=", "opts", ".", "NewListOpts", "(", "netutils", ".", "ValidateAlias", ")", "\n", "cmd", ".", "Var", "(", "&", "flAlias", ",", "[", "]", "string", "{", "\"", "\"", "}", ",", "\"", "\"", ")", "\n", "cmd", ".", "Require", "(", "flag", ".", "Exact", ",", "1", ")", "\n", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sn", ",", "nn", ":=", "parseServiceName", "(", "cmd", ".", "Arg", "(", "0", ")", ")", "\n", "sc", ":=", "serviceCreate", "{", "Name", ":", "sn", ",", "Network", ":", "nn", ",", "MyAliases", ":", "flAlias", ".", "GetAll", "(", ")", "}", "\n", "obj", ",", "_", ",", "err", ":=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", ",", "sc", ",", "nil", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "replyID", "string", "\n", "err", "=", "json", ".", "Unmarshal", "(", "obj", ",", "&", "replyID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "cli", ".", "out", ",", "\"", "\\n", "\"", ",", "replyID", ")", "\n", "return", "nil", "\n", "}" ]

[ "CmdServicePublish", "handles", "service", "create", "UI" ]

[ "func", "(", "cli", "*", "NetworkCli", ")", "CmdServiceUnpublish", "(", "chain", "string", ",", "args", "...", "string", ")", "error", "{", "cmd", ":=", "cli", ".", "Subcmd", "(", "chain", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ")", "\n", "force", ":=", "cmd", ".", "Bool", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "false", ",", "\"", "\"", ")", "\n", "cmd", ".", "Require", "(", "flag", ".", "Exact", ",", "1", ")", "\n", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sn", ",", "nn", ":=", "parseServiceName", "(", "cmd", ".", "Arg", "(", "0", ")", ")", "\n", "serviceID", ",", "err", ":=", "lookupServiceID", "(", "cli", ",", "nn", ",", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sd", ":=", "serviceDelete", "{", "Name", ":", "sn", ",", "Force", ":", "*", "force", "}", "\n", "_", ",", "_", ",", "err", "=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", "+", "serviceID", ",", "sd", ",", "nil", ")", ")", "\n\n", "return", "err", "\n", "}" ]

[ "CmdServiceUnpublish", "handles", "service", "delete", "UI" ]

[ "func", "(", "cli", "*", "NetworkCli", ")", "CmdServiceLs", "(", "chain", "string", ",", "args", "...", "string", ")", "error", "{", "cmd", ":=", "cli", ".", "Subcmd", "(", "chain", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ")", "\n", "flNetwork", ":=", "cmd", ".", "String", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "quiet", ":=", "cmd", ".", "Bool", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "false", ",", "\"", "\"", ")", "\n", "noTrunc", ":=", "cmd", ".", "Bool", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", ",", "false", ",", "\"", "\"", ")", "\n\n", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "obj", "[", "]", "byte", "\n", "if", "*", "flNetwork", "==", "\"", "\"", "{", "obj", ",", "_", ",", "err", "=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", ",", "nil", ",", "nil", ")", ")", "\n", "}", "else", "{", "obj", ",", "_", ",", "err", "=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", "+", "*", "flNetwork", ",", "nil", ",", "nil", ")", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "serviceResources", "[", "]", "serviceResource", "\n", "err", "=", "json", ".", "Unmarshal", "(", "obj", ",", "&", "serviceResources", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "wr", ":=", "tabwriter", ".", "NewWriter", "(", "cli", ".", "out", ",", "20", ",", "1", ",", "3", ",", "' '", ",", "0", ")", "\n", "// unless quiet (-q) is specified, print field titles", "if", "!", "*", "quiet", "{", "fmt", ".", "Fprintln", "(", "wr", ",", "\"", "\\t", "\\t", "\\t", "\\t", "\"", ")", "\n", "}", "\n\n", "for", "_", ",", "sr", ":=", "range", "serviceResources", "{", "ID", ":=", "sr", ".", "ID", "\n", "bkID", ",", "sbID", ",", "err", ":=", "getBackendID", "(", "cli", ",", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "*", "noTrunc", "{", "ID", "=", "stringid", ".", "TruncateID", "(", "ID", ")", "\n", "bkID", "=", "stringid", ".", "TruncateID", "(", "bkID", ")", "\n", "sbID", "=", "stringid", ".", "TruncateID", "(", "sbID", ")", "\n", "}", "\n", "if", "!", "*", "quiet", "{", "fmt", ".", "Fprintf", "(", "wr", ",", "\"", "\\t", "\\t", "\\t", "\\t", "\\n", "\"", ",", "ID", ",", "sr", ".", "Name", ",", "sr", ".", "Network", ",", "bkID", ",", "sbID", ")", "\n", "}", "else", "{", "fmt", ".", "Fprintln", "(", "wr", ",", "ID", ")", "\n", "}", "\n", "}", "\n", "wr", ".", "Flush", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "CmdServiceLs", "handles", "service", "list", "UI" ]

[ "func", "(", "cli", "*", "NetworkCli", ")", "CmdServiceInfo", "(", "chain", "string", ",", "args", "...", "string", ")", "error", "{", "cmd", ":=", "cli", ".", "Subcmd", "(", "chain", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ")", "\n", "cmd", ".", "Require", "(", "flag", ".", "Min", ",", "1", ")", "\n\n", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sn", ",", "nn", ":=", "parseServiceName", "(", "cmd", ".", "Arg", "(", "0", ")", ")", "\n", "serviceID", ",", "err", ":=", "lookupServiceID", "(", "cli", ",", "nn", ",", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "obj", ",", "_", ",", "err", ":=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", "+", "serviceID", ",", "nil", ",", "nil", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sr", ":=", "&", "serviceResource", "{", "}", "\n", "if", "err", ":=", "json", ".", "NewDecoder", "(", "bytes", ".", "NewReader", "(", "obj", ")", ")", ".", "Decode", "(", "sr", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "fmt", ".", "Fprintf", "(", "cli", ".", "out", ",", "\"", "\\n", "\"", ",", "sr", ".", "ID", ")", "\n", "fmt", ".", "Fprintf", "(", "cli", ".", "out", ",", "\"", "\\t", "\\n", "\"", ",", "sr", ".", "Name", ")", "\n", "fmt", ".", "Fprintf", "(", "cli", ".", "out", ",", "\"", "\\t", "\\n", "\"", ",", "sr", ".", "Network", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "CmdServiceInfo", "handles", "service", "info", "UI" ]

[ "func", "(", "cli", "*", "NetworkCli", ")", "CmdServiceAttach", "(", "chain", "string", ",", "args", "...", "string", ")", "error", "{", "cmd", ":=", "cli", ".", "Subcmd", "(", "chain", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ")", "\n", "flAlias", ":=", "opts", ".", "NewListOpts", "(", "netutils", ".", "ValidateAlias", ")", "\n", "cmd", ".", "Var", "(", "&", "flAlias", ",", "[", "]", "string", "{", "\"", "\"", "}", ",", "\"", "\"", ")", "\n", "cmd", ".", "Require", "(", "flag", ".", "Min", ",", "2", ")", "\n", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "containerID", ",", "err", ":=", "lookupContainerID", "(", "cli", ",", "cmd", ".", "Arg", "(", "0", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sandboxID", ",", "err", ":=", "lookupSandboxID", "(", "cli", ",", "containerID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sn", ",", "nn", ":=", "parseServiceName", "(", "cmd", ".", "Arg", "(", "1", ")", ")", "\n", "serviceID", ",", "err", ":=", "lookupServiceID", "(", "cli", ",", "nn", ",", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "nc", ":=", "serviceAttach", "{", "SandboxID", ":", "sandboxID", ",", "Aliases", ":", "flAlias", ".", "GetAll", "(", ")", "}", "\n\n", "_", ",", "_", ",", "err", "=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", "+", "serviceID", "+", "\"", "\"", ",", "nc", ",", "nil", ")", ")", "\n\n", "return", "err", "\n", "}" ]

[ "CmdServiceAttach", "handles", "service", "attach", "UI" ]

[ "func", "(", "cli", "*", "NetworkCli", ")", "CmdServiceDetach", "(", "chain", "string", ",", "args", "...", "string", ")", "error", "{", "cmd", ":=", "cli", ".", "Subcmd", "(", "chain", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "false", ")", "\n", "cmd", ".", "Require", "(", "flag", ".", "Min", ",", "2", ")", "\n", "err", ":=", "cmd", ".", "ParseFlags", "(", "args", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sn", ",", "nn", ":=", "parseServiceName", "(", "cmd", ".", "Arg", "(", "1", ")", ")", "\n", "containerID", ",", "err", ":=", "lookupContainerID", "(", "cli", ",", "cmd", ".", "Arg", "(", "0", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "sandboxID", ",", "err", ":=", "lookupSandboxID", "(", "cli", ",", "containerID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "serviceID", ",", "err", ":=", "lookupServiceID", "(", "cli", ",", "nn", ",", "sn", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "_", ",", "err", "=", "readBody", "(", "cli", ".", "call", "(", "\"", "\"", ",", "\"", "\"", "+", "serviceID", "+", "\"", "\"", "+", "sandboxID", ",", "nil", ",", "nil", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CmdServiceDetach", "handles", "service", "detach", "UI" ]

[ "func", "(", "aSpace", "*", "addrSpace", ")", "SetValue", "(", "value", "[", "]", "byte", ")", "error", "{", "rc", ":=", "&", "addrSpace", "{", "subnets", ":", "make", "(", "map", "[", "SubnetKey", "]", "*", "PoolData", ")", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "value", ",", "rc", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "aSpace", ".", "subnets", "=", "rc", ".", "subnets", "\n", "return", "nil", "\n", "}" ]

[ "SetValue", "unmarshalls", "the", "data", "from", "the", "KV", "store", "." ]

[ "func", "New", "(", "path", "string", ")", "(", "*", "Handle", ",", "error", ")", "{", "setup", "(", ")", "\n\n", "n", ":=", "netns", ".", "None", "(", ")", "\n", "if", "path", "!=", "\"", "\"", "{", "var", "err", "error", "\n", "n", ",", "err", "=", "netns", ".", "GetFromPath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "defer", "n", ".", "Close", "(", ")", "\n\n", "sock", ",", "err", ":=", "nl", ".", "GetNetlinkSocketAt", "(", "n", ",", "netns", ".", "None", "(", ")", ",", "syscall", ".", "NETLINK_GENERIC", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Add operation timeout to avoid deadlocks", "tv", ":=", "syscall", ".", "NsecToTimeval", "(", "netlinkSendSocketTimeout", ".", "Nanoseconds", "(", ")", ")", "\n", "if", "err", ":=", "sock", ".", "SetSendTimeout", "(", "&", "tv", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tv", "=", "syscall", ".", "NsecToTimeval", "(", "netlinkRecvSocketsTimeout", ".", "Nanoseconds", "(", ")", ")", "\n", "if", "err", ":=", "sock", ".", "SetReceiveTimeout", "(", "&", "tv", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "Handle", "{", "sock", ":", "sock", "}", ",", "nil", "\n", "}" ]

[ "New", "provides", "a", "new", "ipvs", "handle", "in", "the", "namespace", "pointed", "to", "by", "the", "passed", "path", ".", "It", "will", "return", "a", "valid", "handle", "or", "an", "error", "in", "case", "an", "error", "occurred", "while", "creating", "the", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "NewService", "(", "s", "*", "Service", ")", "error", "{", "return", "i", ".", "doCmd", "(", "s", ",", "nil", ",", "ipvsCmdNewService", ")", "\n", "}" ]

[ "NewService", "creates", "a", "new", "ipvs", "service", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "IsServicePresent", "(", "s", "*", "Service", ")", "bool", "{", "return", "nil", "==", "i", ".", "doCmd", "(", "s", ",", "nil", ",", "ipvsCmdGetService", ")", "\n", "}" ]

[ "IsServicePresent", "queries", "for", "the", "ipvs", "service", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "UpdateService", "(", "s", "*", "Service", ")", "error", "{", "return", "i", ".", "doCmd", "(", "s", ",", "nil", ",", "ipvsCmdSetService", ")", "\n", "}" ]

[ "UpdateService", "updates", "an", "already", "existing", "service", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "DelService", "(", "s", "*", "Service", ")", "error", "{", "return", "i", ".", "doCmd", "(", "s", ",", "nil", ",", "ipvsCmdDelService", ")", "\n", "}" ]

[ "DelService", "deletes", "an", "already", "existing", "service", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "Flush", "(", ")", "error", "{", "_", ",", "err", ":=", "i", ".", "doCmdWithoutAttr", "(", "ipvsCmdFlush", ")", "\n", "return", "err", "\n", "}" ]

[ "Flush", "deletes", "all", "existing", "services", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "NewDestination", "(", "s", "*", "Service", ",", "d", "*", "Destination", ")", "error", "{", "return", "i", ".", "doCmd", "(", "s", ",", "d", ",", "ipvsCmdNewDest", ")", "\n", "}" ]

[ "NewDestination", "creates", "a", "new", "real", "server", "in", "the", "passed", "ipvs", "service", "which", "should", "already", "be", "existing", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "UpdateDestination", "(", "s", "*", "Service", ",", "d", "*", "Destination", ")", "error", "{", "return", "i", ".", "doCmd", "(", "s", ",", "d", ",", "ipvsCmdSetDest", ")", "\n", "}" ]

[ "UpdateDestination", "updates", "an", "already", "existing", "real", "server", "in", "the", "passed", "ipvs", "service", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "DelDestination", "(", "s", "*", "Service", ",", "d", "*", "Destination", ")", "error", "{", "return", "i", ".", "doCmd", "(", "s", ",", "d", ",", "ipvsCmdDelDest", ")", "\n", "}" ]

[ "DelDestination", "deletes", "an", "already", "existing", "real", "server", "in", "the", "passed", "ipvs", "service", "in", "the", "passed", "handle", "." ]

[ "func", "(", "i", "*", "Handle", ")", "GetDestinations", "(", "s", "*", "Service", ")", "(", "[", "]", "*", "Destination", ",", "error", ")", "{", "return", "i", ".", "doGetDestinationsCmd", "(", "s", ",", "nil", ")", "\n", "}" ]

[ "GetDestinations", "returns", "an", "array", "of", "Destinations", "configured", "for", "this", "Service" ]

[ "func", "(", "i", "*", "Handle", ")", "GetService", "(", "s", "*", "Service", ")", "(", "*", "Service", ",", "error", ")", "{", "res", ",", "err", ":=", "i", ".", "doGetServicesCmd", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// We are looking for exactly one service otherwise error out", "if", "len", "(", "res", ")", "!=", "1", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "res", ")", ")", "\n", "}", "\n\n", "return", "res", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "GetService", "gets", "details", "of", "a", "specific", "IPVS", "services", "useful", "in", "updating", "statisics", "etc", "." ]

[ "func", "NewWithPortAllocator", "(", "allocator", "*", "portallocator", ".", "PortAllocator", ",", "proxyPath", "string", ")", "*", "PortMapper", "{", "return", "&", "PortMapper", "{", "currentMappings", ":", "make", "(", "map", "[", "string", "]", "*", "mapping", ")", ",", "Allocator", ":", "allocator", ",", "proxyPath", ":", "proxyPath", ",", "}", "\n", "}" ]

[ "NewWithPortAllocator", "returns", "a", "new", "instance", "of", "PortMapper", "which", "will", "use", "the", "specified", "PortAllocator" ]

[ "func", "(", "pm", "*", "PortMapper", ")", "Map", "(", "container", "net", ".", "Addr", ",", "hostIP", "net", ".", "IP", ",", "hostPort", "int", ",", "useProxy", "bool", ")", "(", "host", "net", ".", "Addr", ",", "err", "error", ")", "{", "return", "pm", ".", "MapRange", "(", "container", ",", "hostIP", ",", "hostPort", ",", "hostPort", ",", "useProxy", ")", "\n", "}" ]

[ "Map", "maps", "the", "specified", "container", "transport", "address", "to", "the", "host", "s", "network", "address", "and", "transport", "port" ]

[ "func", "(", "pm", "*", "PortMapper", ")", "Unmap", "(", "host", "net", ".", "Addr", ")", "error", "{", "pm", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "pm", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "key", ":=", "getKey", "(", "host", ")", "\n", "data", ",", "exists", ":=", "pm", ".", "currentMappings", "[", "key", "]", "\n", "if", "!", "exists", "{", "return", "ErrPortNotMapped", "\n", "}", "\n\n", "if", "data", ".", "userlandProxy", "!=", "nil", "{", "data", ".", "userlandProxy", ".", "Stop", "(", ")", "\n", "}", "\n\n", "delete", "(", "pm", ".", "currentMappings", ",", "key", ")", "\n\n", "containerIP", ",", "containerPort", ":=", "getIPAndPort", "(", "data", ".", "container", ")", "\n", "hostIP", ",", "hostPort", ":=", "getIPAndPort", "(", "data", ".", "host", ")", "\n", "if", "err", ":=", "pm", ".", "DeleteForwardingTableEntry", "(", "data", ".", "proto", ",", "hostIP", ",", "hostPort", ",", "containerIP", ".", "String", "(", ")", ",", "containerPort", ")", ";", "err", "!=", "nil", "{", "logrus", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "switch", "a", ":=", "host", ".", "(", "type", ")", "{", "case", "*", "net", ".", "TCPAddr", ":", "return", "pm", ".", "Allocator", ".", "ReleasePort", "(", "a", ".", "IP", ",", "\"", "\"", ",", "a", ".", "Port", ")", "\n", "case", "*", "net", ".", "UDPAddr", ":", "return", "pm", ".", "Allocator", ".", "ReleasePort", "(", "a", ".", "IP", ",", "\"", "\"", ",", "a", ".", "Port", ")", "\n", "case", "*", "sctp", ".", "SCTPAddr", ":", "if", "len", "(", "a", ".", "IP", ")", "==", "0", "{", "return", "ErrSCTPAddrNoIP", "\n", "}", "\n", "return", "pm", ".", "Allocator", ".", "ReleasePort", "(", "a", ".", "IP", "[", "0", "]", ",", "\"", "\"", ",", "a", ".", "Port", ")", "\n", "}", "\n", "return", "ErrUnknownBackendAddressType", "\n", "}" ]

[ "Unmap", "removes", "stored", "mapping", "for", "the", "specified", "host", "transport", "address" ]