Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.5k

[ "func", "(", "d", "*", "Daemon", ")", "RemoveFromEndpointQueue", "(", "epID", "uint64", ")", "{", "d", ".", "uniqueIDMU", ".", "Lock", "(", ")", "\n", "if", "cancel", ",", "queued", ":=", "d", ".", "uniqueID", "[", "epID", "]", ";", "queued", "&&", "cancel", "!=", "nil", "{", "delete", "(", "d", ".", "uniqueID", ",", "epID", ")", "\n", "cancel", "(", ")", "\n", "}", "\n", "d", ".", "uniqueIDMU", ".", "Unlock", "(", ")", "\n", "}" ]

[ "RemoveFromEndpointQueue", "removes", "the", "endpoint", "from", "the", "build", "permit", "queue", "canceling", "the", "wait", "for", "the", "build", "permit", "if", "still", "waiting", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "DebugEnabled", "(", ")", "bool", "{", "return", "option", ".", "Config", ".", "Opts", ".", "IsEnabled", "(", "option", ".", "Debug", ")", "\n", "}" ]

[ "DebugEnabled", "returns", "if", "debug", "mode", "is", "enabled", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "writePreFilterHeader", "(", "dir", "string", ")", "error", "{", "headerPath", ":=", "filepath", ".", "Join", "(", "dir", ",", "common", ".", "PreFilterHeaderFileName", ")", "\n", "log", ".", "WithField", "(", "logfields", ".", "Path", ",", "headerPath", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "headerPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "headerPath", ",", "err", ")", "\n\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n", "fw", ":=", "bufio", ".", "NewWriter", "(", "f", ")", "\n", "fmt", ".", "Fprint", "(", "fw", ",", "\"", "\\n", "\"", ")", "\n", "fmt", ".", "Fprintf", "(", "fw", ",", "\"", "\\n", "\"", ",", "option", ".", "Config", ".", "DevicePreFilter", ")", "\n", "fmt", ".", "Fprintf", "(", "fw", ",", "\"", "\\n", "\"", ",", "option", ".", "Config", ".", "ModePreFilter", ")", "\n", "fmt", ".", "Fprint", "(", "fw", ",", "\"", "\\n", "\\n", "\"", ")", "\n", "d", ".", "preFilter", ".", "WriteConfig", "(", "fw", ")", "\n", "return", "fw", ".", "Flush", "(", ")", "\n", "}" ]

[ "Must", "be", "called", "with", "option", ".", "Config", ".", "EnablePolicyMU", "locked", "." ]

[ "func", "createPrefixLengthCounter", "(", ")", "*", "counter", ".", "PrefixLengthCounter", "{", "prefixLengths4", ":=", "ipcachemap", ".", "IPCache", ".", "GetMaxPrefixLengths", "(", "false", ")", "\n", "prefixLengths6", ":=", "ipcachemap", ".", "IPCache", ".", "GetMaxPrefixLengths", "(", "true", ")", "\n", "counter", ":=", "counter", ".", "NewPrefixLengthCounter", "(", "prefixLengths6", ",", "prefixLengths4", ")", "\n\n", "// This is a bit ugly, but there's not a great way to define an IPNet", "// without parsing strings, etc.", "defaultPrefixes", ":=", "[", "]", "*", "net", ".", "IPNet", "{", "// IPv4", "createIPNet", "(", "0", ",", "net", ".", "IPv4len", "*", "8", ")", ",", "// world", "createIPNet", "(", "net", ".", "IPv4len", "*", "8", ",", "net", ".", "IPv4len", "*", "8", ")", ",", "// hosts", "// IPv6", "createIPNet", "(", "0", ",", "net", ".", "IPv6len", "*", "8", ")", ",", "// world", "createIPNet", "(", "net", ".", "IPv6len", "*", "8", ",", "net", ".", "IPv6len", "*", "8", ")", ",", "// hosts", "}", "\n", "_", ",", "err", ":=", "counter", ".", "Add", "(", "defaultPrefixes", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "counter", "\n", "}" ]

[ "createPrefixLengthCounter", "wraps", "around", "the", "counter", "library", "providing", "references", "to", "prefix", "lengths", "that", "will", "always", "be", "present", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "Close", "(", ")", "{", "if", "d", ".", "policyTrigger", "!=", "nil", "{", "d", ".", "policyTrigger", ".", "Shutdown", "(", ")", "\n", "}", "\n", "d", ".", "nodeDiscovery", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "shuts", "down", "a", "daemon" ]

[ "func", "(", "d", "*", "Daemon", ")", "TriggerReloadWithoutCompile", "(", "reason", "string", ")", "(", "*", "sync", ".", "WaitGroup", ",", "error", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "reason", ")", "\n", "if", "err", ":=", "d", ".", "compileBase", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reason", ",", "err", ")", "\n", "}", "\n\n", "regenRequest", ":=", "&", "endpoint", ".", "ExternalRegenerationMetadata", "{", "Reason", ":", "reason", ",", "RegenerationLevel", ":", "endpoint", ".", "RegenerateWithDatapathLoad", ",", "}", "\n", "return", "endpointmanager", ".", "RegenerateAllEndpoints", "(", "d", ",", "regenRequest", ")", ",", "nil", "\n", "}" ]

[ "TriggerReloadWithoutCompile", "causes", "all", "BPF", "programs", "and", "maps", "to", "be", "reloaded", "without", "recompiling", "the", "datapath", "logic", "for", "each", "endpoint", ".", "It", "first", "attempts", "to", "recompile", "the", "base", "programs", "and", "if", "this", "fails", "returns", "an", "error", ".", "If", "base", "program", "load", "is", "successful", "it", "subsequently", "triggers", "regeneration", "of", "all", "endpoints", "and", "returns", "a", "waitgroup", "that", "may", "be", "used", "by", "the", "caller", "to", "wait", "for", "all", "endpoint", "regeneration", "to", "complete", ".", "If", "an", "error", "is", "returned", "then", "no", "regeneration", "was", "successful", ".", "If", "no", "error", "is", "returned", "then", "the", "base", "programs", "were", "successfully", "regenerated", "but", "endpoints", "may", "or", "may", "not", "have", "successfully", "regenerated", "." ]

[ "func", "listFilterIfs", "(", "filter", "func", "(", "netlink", ".", "Link", ")", "int", ")", "(", "map", "[", "int", "]", "netlink", ".", "Link", ",", "error", ")", "{", "ifs", ",", "err", ":=", "netlink", ".", "LinkList", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "vethLXCIdxs", ":=", "map", "[", "int", "]", "netlink", ".", "Link", "{", "}", "\n", "for", "_", ",", "intf", ":=", "range", "ifs", "{", "if", "idx", ":=", "filter", "(", "intf", ")", ";", "idx", "!=", "-", "1", "{", "vethLXCIdxs", "[", "idx", "]", "=", "intf", "\n", "}", "\n", "}", "\n", "return", "vethLXCIdxs", ",", "nil", "\n", "}" ]

[ "listFilterIfs", "returns", "a", "map", "of", "interfaces", "based", "on", "the", "given", "filter", ".", "The", "filter", "should", "take", "a", "link", "and", "if", "found", "return", "the", "index", "of", "that", "interface", "if", "not", "found", "return", "-", "1", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "clearCiliumVeths", "(", ")", "error", "{", "log", ".", "Info", "(", "\"", "\"", ")", "\n\n", "leftVeths", ",", "err", ":=", "listFilterIfs", "(", "func", "(", "intf", "netlink", ".", "Link", ")", "int", "{", "// Filter by veth and return the index of the interface.", "if", "intf", ".", "Type", "(", ")", "==", "\"", "\"", "{", "return", "intf", ".", "Attrs", "(", ")", ".", "Index", "\n", "}", "\n", "return", "-", "1", "\n", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "v", ":=", "range", "leftVeths", "{", "peerIndex", ":=", "v", ".", "Attrs", "(", ")", ".", "ParentIndex", "\n", "parentVeth", ",", "found", ":=", "leftVeths", "[", "peerIndex", "]", "\n", "if", "found", "&&", "peerIndex", "!=", "0", "&&", "strings", ".", "HasPrefix", "(", "parentVeth", ".", "Attrs", "(", ")", ".", "Name", ",", "\"", "\"", ")", "{", "err", ":=", "netlink", ".", "LinkDel", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warningf", "(", "\"", "\"", ",", "v", ".", "Attrs", "(", ")", ".", "Name", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "clearCiliumVeths", "checks", "all", "veths", "created", "by", "cilium", "and", "removes", "all", "that", "are", "considered", "a", "leftover", "from", "failed", "attempts", "to", "connect", "the", "container", "." ]

[ "func", "numWorkerThreads", "(", ")", "int", "{", "ncpu", ":=", "runtime", ".", "NumCPU", "(", ")", "\n", "minWorkerThreads", ":=", "2", "\n\n", "if", "ncpu", "<", "minWorkerThreads", "{", "return", "minWorkerThreads", "\n", "}", "\n", "return", "ncpu", "\n", "}" ]

[ "numWorkerThreads", "returns", "the", "number", "of", "worker", "threads", "with", "a", "minimum", "of", "4", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "GetServiceList", "(", ")", "[", "]", "*", "models", ".", "Service", "{", "list", ":=", "[", "]", "*", "models", ".", "Service", "{", "}", "\n\n", "d", ".", "loadBalancer", ".", "BPFMapMU", ".", "RLock", "(", ")", "\n", "defer", "d", ".", "loadBalancer", ".", "BPFMapMU", ".", "RUnlock", "(", ")", "\n\n", "for", "_", ",", "v", ":=", "range", "d", ".", "loadBalancer", ".", "SVCMap", "{", "list", "=", "append", "(", "list", ",", "v", ".", "GetModel", "(", ")", ")", "\n", "}", "\n", "return", "list", "\n", "}" ]

[ "GetServiceList", "returns", "list", "of", "services" ]

[ "func", "(", "d", "*", "Daemon", ")", "SendNotification", "(", "typ", "monitorAPI", ".", "AgentNotification", ",", "text", "string", ")", "error", "{", "if", "option", ".", "Config", ".", "DryMode", "{", "return", "nil", "\n", "}", "\n", "event", ":=", "monitorAPI", ".", "AgentNotify", "{", "Type", ":", "typ", ",", "Text", ":", "text", "}", "\n", "return", "d", ".", "nodeMonitor", ".", "SendEvent", "(", "monitorAPI", ".", "MessageTypeAgent", ",", "event", ")", "\n", "}" ]

[ "SendNotification", "sends", "an", "agent", "notification", "to", "the", "monitor" ]

[ "func", "(", "d", "*", "Daemon", ")", "NewProxyLogRecord", "(", "l", "*", "logger", ".", "LogRecord", ")", "error", "{", "return", "d", ".", "nodeMonitor", ".", "SendEvent", "(", "monitorAPI", ".", "MessageTypeAccessLog", ",", "l", ".", "LogRecord", ")", "\n", "}" ]

[ "NewProxyLogRecord", "is", "invoked", "by", "the", "proxy", "accesslog", "on", "each", "new", "access", "log", "entry" ]

[ "func", "(", "d", "*", "Daemon", ")", "GetNodeSuffix", "(", ")", "string", "{", "var", "ip", "net", ".", "IP", "\n\n", "switch", "{", "case", "option", ".", "Config", ".", "EnableIPv4", ":", "ip", "=", "node", ".", "GetExternalIPv4", "(", ")", "\n", "case", "option", ".", "Config", ".", "EnableIPv6", ":", "ip", "=", "node", ".", "GetIPv6", "(", ")", "\n", "}", "\n\n", "if", "ip", "==", "nil", "{", "log", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "ip", ".", "String", "(", ")", "\n", "}" ]

[ "GetNodeSuffix", "returns", "the", "suffix", "to", "be", "appended", "to", "kvstore", "keys", "of", "this", "agent" ]

[ "func", "(", "req", "*", "RequestMessage", ")", "String", "(", ")", "string", "{", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "req", ".", "request", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", ".", "Error", "(", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "req", ".", "kind", ",", "req", ".", "version", ",", "len", "(", "req", ".", "rawMsg", ")", ",", "string", "(", "b", ")", ")", "\n", "}" ]

[ "String", "returns", "a", "human", "readable", "representation", "of", "the", "request", "message" ]

[ "func", "(", "req", "*", "RequestMessage", ")", "GetTopics", "(", ")", "[", "]", "string", "{", "if", "req", ".", "request", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "switch", "val", ":=", "req", ".", "request", ".", "(", "type", ")", "{", "case", "*", "proto", ".", "ProduceReq", ":", "return", "produceTopics", "(", "val", ")", "\n", "case", "*", "proto", ".", "FetchReq", ":", "return", "fetchTopics", "(", "val", ")", "\n", "case", "*", "proto", ".", "OffsetReq", ":", "return", "offsetTopics", "(", "val", ")", "\n", "case", "*", "proto", ".", "MetadataReq", ":", "return", "metadataTopics", "(", "val", ")", "\n", "case", "*", "proto", ".", "OffsetCommitReq", ":", "return", "offsetCommitTopics", "(", "val", ")", "\n", "case", "*", "proto", ".", "OffsetFetchReq", ":", "return", "offsetFetchTopics", "(", "val", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetTopics", "returns", "the", "Kafka", "request", "list", "of", "topics" ]

[ "func", "(", "req", "*", "RequestMessage", ")", "CreateResponse", "(", "err", "error", ")", "(", "*", "ResponseMessage", ",", "error", ")", "{", "switch", "val", ":=", "req", ".", "request", ".", "(", "type", ")", "{", "case", "*", "proto", ".", "ProduceReq", ":", "return", "createProduceResponse", "(", "val", ",", "err", ")", "\n", "case", "*", "proto", ".", "FetchReq", ":", "return", "createFetchResponse", "(", "val", ",", "err", ")", "\n", "case", "*", "proto", ".", "OffsetReq", ":", "return", "createOffsetResponse", "(", "val", ",", "err", ")", "\n", "case", "*", "proto", ".", "MetadataReq", ":", "return", "createMetadataResponse", "(", "val", ",", "err", ")", "\n", "case", "*", "proto", ".", "ConsumerMetadataReq", ":", "return", "createConsumerMetadataResponse", "(", "val", ",", "err", ")", "\n", "case", "*", "proto", ".", "OffsetCommitReq", ":", "return", "createOffsetCommitResponse", "(", "val", ",", "err", ")", "\n", "case", "*", "proto", ".", "OffsetFetchReq", ":", "return", "createOffsetFetchResponse", "(", "val", ",", "err", ")", "\n", "case", "nil", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "req", ".", "kind", ")", "\n", "default", ":", "// The switch cases above must correspond exactly to the switch cases", "// in ReadRequest.", "log", ".", "Panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "req", ".", "kind", ")", ")", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "CreateResponse", "creates", "a", "response", "message", "based", "on", "the", "provided", "request", "message", ".", "The", "response", "will", "have", "the", "specified", "error", "code", "set", "in", "all", "topics", "and", "embedded", "partitions", "." ]

[ "func", "ReadRequest", "(", "reader", "io", ".", "Reader", ")", "(", "*", "RequestMessage", ",", "error", ")", "{", "req", ":=", "&", "RequestMessage", "{", "}", "\n", "var", "err", "error", "\n\n", "req", ".", "kind", ",", "req", ".", "rawMsg", ",", "err", "=", "proto", ".", "ReadReq", "(", "reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "req", ".", "rawMsg", ")", "<", "12", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "req", ".", "version", "=", "req", ".", "extractVersion", "(", ")", "\n\n", "var", "nilSlice", "[", "]", "byte", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "append", "(", "nilSlice", ",", "req", ".", "rawMsg", "...", ")", ")", "\n\n", "switch", "req", ".", "kind", "{", "case", "proto", ".", "ProduceReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadProduceReq", "(", "buf", ")", "\n", "case", "proto", ".", "FetchReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadFetchReq", "(", "buf", ")", "\n", "case", "proto", ".", "OffsetReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadOffsetReq", "(", "buf", ")", "\n", "case", "proto", ".", "MetadataReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadMetadataReq", "(", "buf", ")", "\n", "case", "proto", ".", "ConsumerMetadataReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadConsumerMetadataReq", "(", "buf", ")", "\n", "case", "proto", ".", "OffsetCommitReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadOffsetCommitReq", "(", "buf", ")", "\n", "case", "proto", ".", "OffsetFetchReqKind", ":", "req", ".", "request", ",", "err", "=", "proto", ".", "ReadOffsetFetchReq", "(", "buf", ")", "\n", "default", ":", "log", ".", "WithField", "(", "fieldRequest", ",", "req", ".", "String", "(", ")", ")", ".", "Debugf", "(", "\"", "\"", ",", "req", ".", "kind", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "flowdebug", ".", "Log", "(", "log", ".", "WithField", "(", "fieldRequest", ",", "req", ".", "String", "(", ")", ")", ".", "WithError", "(", "err", ")", ",", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "req", ",", "nil", "\n", "}" ]

[ "ReadRequest", "will", "read", "a", "Kafka", "request", "from", "an", "io", ".", "Reader", "and", "return", "the", "message", "or", "an", "error", "." ]

[ "func", "(", "k", "*", "TupleKey6", ")", "ToNetwork", "(", ")", "TupleKey", "{", "n", ":=", "*", "k", "\n", "n", ".", "SourcePort", "=", "byteorder", ".", "HostToNetwork", "(", "n", ".", "SourcePort", ")", ".", "(", "uint16", ")", "\n", "n", ".", "DestPort", "=", "byteorder", ".", "HostToNetwork", "(", "n", ".", "DestPort", ")", ".", "(", "uint16", ")", "\n", "return", "&", "n", "\n", "}" ]

[ "ToNetwork", "converts", "TupleKey6", "ports", "to", "network", "byte", "order", "." ]

[ "func", "(", "k", "*", "TupleKey6", ")", "ToHost", "(", ")", "TupleKey", "{", "n", ":=", "*", "k", "\n", "n", ".", "SourcePort", "=", "byteorder", ".", "NetworkToHost", "(", "n", ".", "SourcePort", ")", ".", "(", "uint16", ")", "\n", "n", ".", "DestPort", "=", "byteorder", ".", "NetworkToHost", "(", "n", ".", "DestPort", ")", ".", "(", "uint16", ")", "\n", "return", "&", "n", "\n", "}" ]

[ "ToHost", "converts", "TupleKey6", "ports", "to", "network", "byte", "order", "." ]

[ "func", "(", "k", "*", "TupleKey6Global", ")", "ToNetwork", "(", ")", "TupleKey", "{", "return", "&", "TupleKey6Global", "{", "TupleKey6", ":", "*", "k", ".", "TupleKey6", ".", "ToNetwork", "(", ")", ".", "(", "*", "TupleKey6", ")", ",", "}", "\n", "}" ]

[ "ToNetwork", "converts", "ports", "to", "network", "byte", "order", ".", "This", "is", "necessary", "to", "prevent", "callers", "from", "implicitly", "converting", "the", "TupleKey6Global", "type", "here", "into", "a", "local", "key", "type", "in", "the", "nested", "TupleKey6", "field", "." ]

[ "func", "(", "k", "*", "TupleKey6Global", ")", "ToHost", "(", ")", "TupleKey", "{", "return", "&", "TupleKey6Global", "{", "TupleKey6", ":", "*", "k", ".", "TupleKey6", ".", "ToHost", "(", ")", ".", "(", "*", "TupleKey6", ")", ",", "}", "\n", "}" ]

[ "ToHost", "converts", "ports", "to", "host", "byte", "order", ".", "This", "is", "necessary", "to", "prevent", "callers", "from", "implicitly", "converting", "the", "TupleKey6Global", "type", "here", "into", "a", "local", "key", "type", "in", "the", "nested", "TupleKey6", "field", "." ]

[ "func", "NewDatapath", "(", "config", "DatapathConfiguration", ")", "datapath", ".", "Datapath", "{", "dp", ":=", "&", "linuxDatapath", "{", "nodeAddressing", ":", "NewNodeAddressing", "(", ")", ",", "config", ":", "config", ",", "}", "\n\n", "dp", ".", "node", "=", "NewNodeHandler", "(", "config", ",", "dp", ".", "nodeAddressing", ")", "\n\n", "return", "dp", "\n", "}" ]

[ "NewDatapath", "creates", "a", "new", "Linux", "datapath" ]

[ "func", "(", "i", "*", "IngressRule", ")", "GetSourceEndpointSelectors", "(", ")", "EndpointSelectorSlice", "{", "if", "i", ".", "aggregatedSelectors", "==", "nil", "{", "i", ".", "SetAggregatedSelectors", "(", ")", "\n", "}", "\n", "return", "i", ".", "aggregatedSelectors", "\n", "}" ]

[ "GetSourceEndpointSelectors", "returns", "a", "slice", "of", "endpoints", "selectors", "covering", "all", "L3", "source", "selectors", "of", "the", "ingress", "rule" ]

[ "func", "(", "i", "*", "IngressRule", ")", "IsLabelBased", "(", ")", "bool", "{", "return", "len", "(", "i", ".", "FromRequires", ")", "+", "len", "(", "i", ".", "FromCIDR", ")", "+", "len", "(", "i", ".", "FromCIDRSet", ")", "==", "0", "\n", "}" ]

[ "IsLabelBased", "returns", "true", "whether", "the", "L3", "source", "endpoints", "are", "selected", "based", "on", "labels", "i", ".", "e", ".", "either", "by", "setting", "FromEndpoints", "or", "FromEntities", "or", "not", "setting", "any", "From", "field", "." ]

[ "func", "Hint", "(", "err", "error", ")", "error", "{", "switch", "err", "{", "case", "ctx", ".", "DeadlineExceeded", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "default", ":", "return", "err", "\n", "}", "\n", "}" ]

[ "Hint", "tries", "to", "improve", "the", "error", "message", "displayed", "to", "te", "user", "." ]

[ "func", "(", "e", "*", "etcdClient", ")", "GetLeaseID", "(", ")", "client", ".", "LeaseID", "{", "e", ".", "RWMutex", ".", "RLock", "(", ")", "\n", "l", ":=", "e", ".", "session", ".", "Lease", "(", ")", "\n", "e", ".", "RWMutex", ".", "RUnlock", "(", ")", "\n", "return", "l", "\n", "}" ]

[ "GetLeaseID", "returns", "the", "current", "lease", "ID", "." ]

[ "func", "(", "e", "*", "etcdClient", ")", "closeSession", "(", "leaseID", "client", ".", "LeaseID", ")", "{", "e", ".", "RWMutex", ".", "RLock", "(", ")", "\n", "// only mark a session as orphan if the leaseID is the same as the", "// session ID to avoid making any other sessions as orphan.", "if", "e", ".", "session", ".", "Lease", "(", ")", "==", "leaseID", "{", "e", ".", "session", ".", "Orphan", "(", ")", "\n", "}", "\n", "e", ".", "RWMutex", ".", "RUnlock", "(", ")", "\n", "}" ]

[ "closeSession", "closes", "the", "current", "session", "." ]

[ "func", "(", "e", "*", "etcdClient", ")", "Disconnected", "(", ")", "<-", "chan", "struct", "{", "}", "{", "<-", "e", ".", "firstSession", "\n", "e", ".", "RLock", "(", ")", "\n", "ch", ":=", "e", ".", "session", ".", "Done", "(", ")", "\n", "e", ".", "RUnlock", "(", ")", "\n", "return", "ch", "\n", "}" ]

[ "Disconnected", "closes", "the", "returned", "channel", "when", "the", "etcd", "client", "is", "disconnected", "after", "being", "reconnected", ".", "Blocks", "until", "the", "etcd", "client", "is", "first", "connected", "with", "the", "kvstore", "." ]

[ "func", "(", "e", "*", "etcdClient", ")", "checkMinVersion", "(", ")", "error", "{", "eps", ":=", "e", ".", "client", ".", "Endpoints", "(", ")", "\n\n", "for", "_", ",", "ep", ":=", "range", "eps", "{", "v", ",", "err", ":=", "getEPVersion", "(", "e", ".", "client", ".", "Maintenance", ",", "ep", ",", "versionCheckTimeout", ")", "\n", "if", "err", "!=", "nil", "{", "e", ".", "getLogger", "(", ")", ".", "WithError", "(", "Hint", "(", "err", ")", ")", ".", "WithField", "(", "fieldEtcdEndpoint", ",", "ep", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n\n", "if", "!", "minRequiredVersion", ".", "Check", "(", "v", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ep", ",", "minRequiredVersion", ".", "String", "(", ")", ",", "v", ".", "String", "(", ")", ")", "\n", "}", "\n\n", "e", ".", "getLogger", "(", ")", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "fieldEtcdEndpoint", ":", "ep", ",", "\"", "\"", ":", "v", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "eps", ")", "==", "0", "{", "e", ".", "getLogger", "(", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkMinVersion", "checks", "the", "minimal", "version", "running", "on", "etcd", "cluster", ".", "This", "function", "should", "be", "run", "whenever", "the", "etcd", "client", "is", "connected", "for", "the", "first", "time", "and", "whenever", "the", "session", "is", "renewed", "." ]

[ "func", "(", "e", "*", "etcdClient", ")", "Update", "(", "ctx", "context", ".", "Context", ",", "key", "string", ",", "value", "[", "]", "byte", ",", "lease", "bool", ")", "error", "{", "select", "{", "case", "<-", "e", ".", "firstSession", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n\n", "if", "lease", "{", "duration", ":=", "spanstat", ".", "Start", "(", ")", "\n", "leaseID", ":=", "e", ".", "GetLeaseID", "(", ")", "\n", "e", ".", "limiter", ".", "Wait", "(", "ctx", ")", "\n", "_", ",", "err", ":=", "e", ".", "client", ".", "Put", "(", "ctx", ",", "key", ",", "string", "(", "value", ")", ",", "client", ".", "WithLease", "(", "leaseID", ")", ")", "\n", "e", ".", "checkSession", "(", "err", ",", "leaseID", ")", "\n", "increaseMetric", "(", "key", ",", "metricSet", ",", "\"", "\"", ",", "duration", ".", "EndError", "(", "err", ")", ".", "Total", "(", ")", ",", "err", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}", "\n\n", "duration", ":=", "spanstat", ".", "Start", "(", ")", "\n", "e", ".", "limiter", ".", "Wait", "(", "ctx", ")", "\n", "_", ",", "err", ":=", "e", ".", "client", ".", "Put", "(", "ctx", ",", "key", ",", "string", "(", "value", ")", ")", "\n", "increaseMetric", "(", "key", ",", "metricSet", ",", "\"", "\"", ",", "duration", ".", "EndError", "(", "err", ")", ".", "Total", "(", ")", ",", "err", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "Update", "creates", "or", "updates", "a", "key" ]

[ "func", "(", "e", "*", "etcdClient", ")", "Close", "(", ")", "{", "close", "(", "e", ".", "stopStatusChecker", ")", "\n", "<-", "e", ".", "firstSession", "\n", "if", "e", ".", "controllers", "!=", "nil", "{", "e", ".", "controllers", ".", "RemoveAll", "(", ")", "\n", "}", "\n", "e", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "RUnlock", "(", ")", "\n", "e", ".", "session", ".", "Close", "(", ")", "\n", "e", ".", "client", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "closes", "the", "etcd", "session" ]

[ "func", "(", "e", "*", "etcdClient", ")", "ListAndWatch", "(", "name", ",", "prefix", "string", ",", "chanSize", "int", ")", "*", "Watcher", "{", "w", ":=", "newWatcher", "(", "name", ",", "prefix", ",", "chanSize", ")", "\n\n", "e", ".", "getLogger", "(", ")", ".", "WithField", "(", "fieldWatcher", ",", "w", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "go", "e", ".", "Watch", "(", "w", ")", "\n\n", "return", "w", "\n", "}" ]

[ "ListAndWatch", "implements", "the", "BackendOperations", ".", "ListAndWatch", "using", "etcd" ]

[ "func", "IsEtcdOperator", "(", "selectedBackend", "string", ",", "opts", "map", "[", "string", "]", "string", ",", "k8sNamespace", "string", ")", "bool", "{", "if", "selectedBackend", "!=", "EtcdBackendName", "{", "return", "false", "\n", "}", "\n\n", "fqdnIsEtcdOperator", ":=", "func", "(", "address", "string", ")", "bool", "{", "u", ",", "err", ":=", "url", ".", "Parse", "(", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "// typical service name \"cilium-etcd-client.kube-system.svc\"", "names", ":=", "strings", ".", "Split", "(", "u", ".", "Hostname", "(", ")", ",", "\"", "\"", ")", "\n", "return", "len", "(", "names", ")", ">=", "2", "&&", "names", "[", "0", "]", "==", "\"", "\"", "&&", "names", "[", "1", "]", "==", "k8sNamespace", "\n", "}", "\n\n", "fqdn", ":=", "opts", "[", "addrOption", "]", "\n", "if", "len", "(", "fqdn", ")", "!=", "0", "{", "return", "fqdnIsEtcdOperator", "(", "fqdn", ")", "\n", "}", "\n\n", "bm", ":=", "newEtcdModule", "(", ")", "\n", "err", ":=", "bm", ".", "setConfig", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n", "etcdConfig", ":=", "bm", ".", "getConfig", "(", ")", "[", "EtcdOptionConfig", "]", "\n", "if", "len", "(", "etcdConfig", ")", "==", "0", "{", "return", "false", "\n", "}", "\n\n", "cfg", ",", "err", ":=", "clientyaml", ".", "NewConfig", "(", "etcdConfig", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "false", "\n", "}", "\n", "for", "_", ",", "endpoint", ":=", "range", "cfg", ".", "Endpoints", "{", "if", "fqdnIsEtcdOperator", "(", "endpoint", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "IsEtcdOperator", "returns", "true", "if", "the", "configuration", "is", "setting", "up", "an", "etcd", "-", "operator", "and", "false", "otherwise", "." ]

[ "func", "(", "o", "*", "GetPolicyResolveOK", ")", "WithPayload", "(", "payload", "*", "models", ".", "PolicyTraceResult", ")", "*", "GetPolicyResolveOK", "{", "o", ".", "Payload", "=", "payload", "\n", "return", "o", "\n", "}" ]

[ "WithPayload", "adds", "the", "payload", "to", "the", "get", "policy", "resolve", "o", "k", "response" ]

[ "func", "(", "l", "*", "LogRecordNotify", ")", "DumpInfo", "(", ")", "{", "switch", "l", ".", "Type", "{", "case", "accesslog", ".", "TypeRequest", ":", "fmt", ".", "Printf", "(", "\"", "\"", ",", "l", ".", "direction", "(", ")", ",", "l", ".", "Type", ",", "l", ".", "l7Proto", "(", ")", ",", "l", ".", "SourceEndpoint", ".", "ID", ",", "l", ".", "SourceEndpoint", ".", "Labels", ",", "l", ".", "DestinationEndpoint", ".", "ID", ",", "l", ".", "DestinationEndpoint", ".", "Labels", ",", "l", ".", "SourceEndpoint", ".", "Identity", ",", "l", ".", "DestinationEndpoint", ".", "Identity", ",", "l", ".", "Verdict", ")", "\n\n", "case", "accesslog", ".", "TypeResponse", ":", "fmt", ".", "Printf", "(", "\"", "\"", ",", "l", ".", "direction", "(", ")", ",", "l", ".", "Type", ",", "l", ".", "l7Proto", "(", ")", ",", "l", ".", "SourceEndpoint", ".", "ID", ",", "l", ".", "SourceEndpoint", ".", "Labels", ",", "l", ".", "DestinationEndpoint", ".", "ID", ",", "l", ".", "DestinationEndpoint", ".", "Labels", ",", "l", ".", "SourceEndpoint", ".", "Identity", ",", "l", ".", "DestinationEndpoint", ".", "Identity", ",", "l", ".", "Verdict", ")", "\n", "}", "\n\n", "if", "http", ":=", "l", ".", "HTTP", ";", "http", "!=", "nil", "{", "url", ":=", "\"", "\"", "\n", "if", "http", ".", "URL", "!=", "nil", "{", "url", "=", "http", ".", "URL", ".", "String", "(", ")", "\n", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "http", ".", "Method", ",", "url", ",", "http", ".", "Code", ")", "\n", "}", "\n\n", "if", "kafka", ":=", "l", ".", "Kafka", ";", "kafka", "!=", "nil", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "kafka", ".", "APIKey", ",", "kafka", ".", "Topic", ".", "Topic", ",", "kafka", ".", "ErrorCode", ")", "\n", "}", "\n\n", "if", "l", ".", "DNS", "!=", "nil", "{", "types", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "t", ":=", "range", "l", ".", "DNS", ".", "QTypes", "{", "types", "=", "append", "(", "types", ",", "dns", ".", "TypeToString", "[", "t", "]", ")", "\n", "}", "\n", "qTypeStr", ":=", "strings", ".", "Join", "(", "types", ",", "\"", "\"", ")", "\n\n", "switch", "{", "case", "l", ".", "Type", "==", "accesslog", ".", "TypeRequest", ":", "fmt", ".", "Printf", "(", "\"", "\"", ",", "l", ".", "DNS", ".", "Query", ",", "qTypeStr", ")", "\n\n", "case", "l", ".", "Type", "==", "accesslog", ".", "TypeResponse", ":", "sourceType", ":=", "\"", "\"", "\n", "if", "l", ".", "DNS", ".", "ObservationSource", "==", "accesslog", ".", "DNSSourceAgentPoller", "{", "sourceType", "=", "\"", "\"", "\n", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\"", ",", "sourceType", ",", "l", ".", "DNS", ".", "Query", ",", "qTypeStr", ")", "\n\n", "ips", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "l", ".", "DNS", ".", "IPs", ")", ")", "\n", "for", "_", ",", "ip", ":=", "range", "l", ".", "DNS", ".", "IPs", "{", "ips", "=", "append", "(", "ips", ",", "ip", ".", "String", "(", ")", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\"", ",", "l", ".", "DNS", ".", "TTL", ",", "strings", ".", "Join", "(", "ips", ",", "\"", "\"", ")", ")", "\n\n", "if", "len", "(", "l", ".", "DNS", ".", "CNAMEs", ")", ">", "0", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "l", ".", "DNS", ".", "CNAMEs", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "}", "\n\n", "if", "l7", ":=", "l", ".", "L7", ";", "l7", "!=", "nil", "{", "status", ":=", "\"", "\"", "\n", "for", "k", ",", "v", ":=", "range", "l7", ".", "Fields", "{", "if", "k", "==", "\"", "\"", "{", "status", "=", "v", "\n", "}", "else", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "k", ",", "v", ")", "\n", "}", "\n", "}", "\n", "if", "status", "!=", "\"", "\"", "{", "fmt", ".", "Printf", "(", "\"", "\"", ",", "status", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "}", "\n", "}" ]

[ "DumpInfo", "dumps", "an", "access", "log", "notification" ]

[ "func", "LogRecordNotifyToVerbose", "(", "n", "*", "LogRecordNotify", ")", "LogRecordNotifyVerbose", "{", "return", "LogRecordNotifyVerbose", "{", "Type", ":", "\"", "\"", ",", "ObservationPoint", ":", "n", ".", "ObservationPoint", ",", "FlowType", ":", "n", ".", "Type", ",", "L7Proto", ":", "n", ".", "l7Proto", "(", ")", ",", "SrcEpID", ":", "n", ".", "SourceEndpoint", ".", "ID", ",", "SrcEpLabels", ":", "n", ".", "SourceEndpoint", ".", "Labels", ",", "SrcIdentity", ":", "n", ".", "SourceEndpoint", ".", "Identity", ",", "DstEpID", ":", "n", ".", "DestinationEndpoint", ".", "ID", ",", "DstEpLabels", ":", "n", ".", "DestinationEndpoint", ".", "Labels", ",", "DstIdentity", ":", "n", ".", "DestinationEndpoint", ".", "Identity", ",", "Verdict", ":", "n", ".", "Verdict", ",", "HTTP", ":", "n", ".", "HTTP", ",", "Kafka", ":", "n", ".", "Kafka", ",", "DNS", ":", "n", ".", "DNS", ",", "L7", ":", "n", ".", "L7", ",", "}", "\n", "}" ]

[ "LogRecordNotifyToVerbose", "turns", "LogRecordNotify", "into", "json", "-", "friendly", "Verbose", "structure" ]

[ "func", "(", "o", "*", "DeleteEndpointIDErrors", ")", "WithPayload", "(", "payload", "int64", ")", "*", "DeleteEndpointIDErrors", "{", "o", ".", "Payload", "=", "payload", "\n", "return", "o", "\n", "}" ]

[ "WithPayload", "adds", "the", "payload", "to", "the", "delete", "endpoint", "Id", "errors", "response" ]

[ "func", "(", "o", "*", "DeleteEndpointIDInvalid", ")", "WithPayload", "(", "payload", "models", ".", "Error", ")", "*", "DeleteEndpointIDInvalid", "{", "o", ".", "Payload", "=", "payload", "\n", "return", "o", "\n", "}" ]

[ "WithPayload", "adds", "the", "payload", "to", "the", "delete", "endpoint", "Id", "invalid", "response" ]

[ "func", "WithMin", "(", "id", "idpool", ".", "ID", ")", "AllocatorOption", "{", "return", "func", "(", "a", "*", "Allocator", ")", "{", "a", ".", "min", "=", "id", "}", "\n", "}" ]

[ "WithMin", "sets", "the", "minimum", "identifier", "to", "be", "allocated" ]

[ "func", "WithMax", "(", "id", "idpool", ".", "ID", ")", "AllocatorOption", "{", "return", "func", "(", "a", "*", "Allocator", ")", "{", "a", ".", "max", "=", "id", "}", "\n", "}" ]

[ "WithMax", "sets", "the", "maximum", "identifier", "to", "be", "allocated" ]

[ "func", "WithPrefixMask", "(", "mask", "idpool", ".", "ID", ")", "AllocatorOption", "{", "return", "func", "(", "a", "*", "Allocator", ")", "{", "a", ".", "prefixMask", "=", "mask", "}", "\n", "}" ]

[ "WithPrefixMask", "sets", "the", "prefix", "used", "for", "all", "ID", "allocations", ".", "If", "set", "the", "mask", "will", "be", "ORed", "to", "all", "selected", "IDs", "prior", "to", "allocation", ".", "It", "is", "the", "responsibility", "of", "the", "caller", "to", "ensure", "that", "the", "mask", "is", "not", "conflicting", "with", "min", "..", "max", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "Delete", "(", ")", "{", "close", "(", "a", ".", "stopGC", ")", "\n", "a", ".", "mainCache", ".", "stop", "(", ")", "\n\n", "if", "a", ".", "events", "!=", "nil", "{", "close", "(", "a", ".", "events", ")", "\n", "}", "\n", "}" ]

[ "Delete", "deletes", "an", "allocator", "and", "stops", "the", "garbage", "collector" ]

[ "func", "(", "a", "*", "Allocator", ")", "WaitForInitialSync", "(", "ctx", "context", ".", "Context", ")", "error", "{", "select", "{", "case", "<-", "a", ".", "initialListDone", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "WaitForInitialSync", "waits", "until", "the", "initial", "sync", "is", "complete" ]

[ "func", "(", "a", "*", "Allocator", ")", "lockPath", "(", "ctx", "context", ".", "Context", ",", "key", "string", ")", "(", "*", "kvstore", ".", "Lock", ",", "error", ")", "{", "suffix", ":=", "strings", ".", "TrimPrefix", "(", "key", ",", "a", ".", "basePrefix", ")", "\n", "return", "kvstore", ".", "LockPath", "(", "ctx", ",", "path", ".", "Join", "(", "a", ".", "lockPrefix", ",", "suffix", ")", ")", "\n", "}" ]

[ "lockPath", "locks", "a", "key", "in", "the", "scope", "of", "an", "allocator" ]

[ "func", "(", "a", "*", "Allocator", ")", "ForeachCache", "(", "cb", "RangeFunc", ")", "{", "a", ".", "mainCache", ".", "foreach", "(", "cb", ")", "\n\n", "a", ".", "remoteCachesMutex", ".", "RLock", "(", ")", "\n", "for", "rc", ":=", "range", "a", ".", "remoteCaches", "{", "rc", ".", "cache", ".", "foreach", "(", "cb", ")", "\n", "}", "\n", "a", ".", "remoteCachesMutex", ".", "RUnlock", "(", ")", "\n", "}" ]

[ "ForeachCache", "iterates", "over", "the", "allocator", "cache", "and", "calls", "RangeFunc", "on", "each", "cached", "entry" ]

[ "func", "(", "a", "*", "Allocator", ")", "selectAvailableID", "(", ")", "(", "idpool", ".", "ID", ",", "string", ",", "idpool", ".", "ID", ")", "{", "if", "id", ":=", "a", ".", "idPool", ".", "LeaseAvailableID", "(", ")", ";", "id", "!=", "idpool", ".", "NoID", "{", "unmaskedID", ":=", "id", "\n", "id", "|=", "a", ".", "prefixMask", "\n", "return", "id", ",", "id", ".", "String", "(", ")", ",", "unmaskedID", "\n", "}", "\n\n", "return", "0", ",", "\"", "\"", ",", "0", "\n", "}" ]

[ "Selects", "an", "available", "ID", ".", "Returns", "a", "triple", "of", "the", "selected", "ID", "ORed", "with", "prefixMask", "the", "ID", "string", "and", "the", "originally", "selected", "ID", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "Allocate", "(", "ctx", "context", ".", "Context", ",", "key", "AllocatorKey", ")", "(", "idpool", ".", "ID", ",", "bool", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "value", "idpool", ".", "ID", "\n", "isNew", "bool", "\n", "k", "=", "key", ".", "GetKey", "(", ")", "\n", ")", "\n\n", "log", ".", "WithField", "(", "fieldKey", ",", "key", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "select", "{", "case", "<-", "a", ".", "initialListDone", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "0", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n\n", "// Check our list of local keys already in use and increment the", "// refcnt. The returned key must be released afterwards. No kvstore", "// operation was performed for this allocation", "if", "val", ":=", "a", ".", "localKeys", ".", "use", "(", "k", ")", ";", "val", "!=", "idpool", ".", "NoID", "{", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "nil", ",", "logrus", ".", "Fields", "{", "fieldID", ":", "val", ",", "fieldKey", ":", "key", "}", ")", "\n", "a", ".", "mainCache", ".", "insert", "(", "key", ",", "val", ")", "\n", "return", "val", ",", "false", ",", "nil", "\n", "}", "\n\n", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "nil", ",", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", "}", ")", "\n\n", "// make a copy of the template and customize it", "boff", ":=", "a", ".", "backoffTemplate", "\n", "boff", ".", "Name", "=", "key", ".", "String", "(", ")", "\n\n", "for", "attempt", ":=", "0", ";", "attempt", "<", "maxAllocAttempts", ";", "attempt", "++", "{", "// FIXME: Add non-locking variant", "value", ",", "isNew", ",", "err", "=", "a", ".", "lockedAllocate", "(", "ctx", ",", "key", ")", "\n", "if", "err", "==", "nil", "{", "a", ".", "mainCache", ".", "insert", "(", "key", ",", "value", ")", "\n", "return", "value", ",", "isNew", ",", "nil", "\n", "}", "\n\n", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", ",", "logfields", ".", "Attempt", ":", "attempt", ",", "}", ")", "\n\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "scopedLog", ".", "WithError", "(", "ctx", ".", "Err", "(", ")", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "0", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "default", ":", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "waitErr", ":=", "boff", ".", "Wait", "(", "ctx", ")", ";", "waitErr", "!=", "nil", "{", "return", "0", ",", "false", ",", "waitErr", "\n", "}", "\n", "}", "\n\n", "return", "0", ",", "false", ",", "err", "\n", "}" ]

[ "Allocate", "will", "retrieve", "the", "ID", "for", "the", "provided", "key", ".", "If", "no", "ID", "has", "been", "allocated", "for", "this", "key", "yet", "a", "key", "will", "be", "allocated", ".", "If", "allocation", "fails", "most", "likely", "due", "to", "a", "parallel", "allocation", "of", "the", "same", "ID", "by", "another", "user", "allocation", "is", "re", "-", "attempted", "for", "maxAllocAttempts", "times", ".", "Returns", "the", "ID", "allocated", "to", "the", "key", "if", "the", "ID", "had", "to", "be", "allocated", "then", "true", "is", "returned", ".", "An", "error", "is", "returned", "in", "case", "of", "failure", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "Get", "(", "ctx", "context", ".", "Context", ",", "key", "AllocatorKey", ")", "(", "idpool", ".", "ID", ",", "error", ")", "{", "if", "id", ":=", "a", ".", "mainCache", ".", "get", "(", "key", ".", "GetKey", "(", ")", ")", ";", "id", "!=", "idpool", ".", "NoID", "{", "return", "id", ",", "nil", "\n", "}", "\n\n", "return", "a", ".", "GetNoCache", "(", "ctx", ",", "key", ")", "\n", "}" ]

[ "Get", "returns", "the", "ID", "which", "is", "allocated", "to", "a", "key", ".", "Returns", "an", "ID", "of", "NoID", "if", "no", "ID", "has", "been", "allocated", "to", "this", "key", "yet", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "GetNoCache", "(", "ctx", "context", ".", "Context", ",", "key", "AllocatorKey", ")", "(", "idpool", ".", "ID", ",", "error", ")", "{", "// GetPrefix() will choose any \"first\" key with the same prefix as the", "// specified key. In the worst case this may alternate between", "// returning the prefix that is specified and returning a key with a", "// longer prefix (even if this exact prefix already exists in the", "// kvstore). In that case, we will potentially allocate duplicate", "// identities for the same set of labels. This is not efficient, but", "// should have the correct identity properties.", "prefix", ":=", "path", ".", "Join", "(", "a", ".", "valuePrefix", ",", "key", ".", "GetKey", "(", ")", ")", "\n", "k", ",", "v", ",", "err", ":=", "kvstore", ".", "GetPrefix", "(", "ctx", ",", "prefix", ")", "\n", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "err", ",", "logrus", ".", "Fields", "{", "fieldPrefix", ":", "prefix", ",", "fieldKey", ":", "k", ",", "fieldValue", ":", "v", "}", ")", "\n", "if", "err", "!=", "nil", "||", "v", "==", "nil", "||", "!", "prefixMatchesKey", "(", "prefix", ",", "k", ")", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "id", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "string", "(", "v", ")", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "idpool", ".", "NoID", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ",", "err", ")", "\n", "}", "\n\n", "return", "idpool", ".", "ID", "(", "id", ")", ",", "nil", "\n", "}" ]

[ "Get", "returns", "the", "ID", "which", "is", "allocated", "to", "a", "key", "in", "the", "kvstore" ]

[ "func", "(", "a", "*", "Allocator", ")", "GetByID", "(", "id", "idpool", ".", "ID", ")", "(", "AllocatorKey", ",", "error", ")", "{", "if", "key", ":=", "a", ".", "mainCache", ".", "getByID", "(", "id", ")", ";", "key", "!=", "nil", "{", "return", "key", ",", "nil", "\n", "}", "\n\n", "v", ",", "err", ":=", "kvstore", ".", "Get", "(", "path", ".", "Join", "(", "a", ".", "idPrefix", ",", "id", ".", "String", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "a", ".", "keyType", ".", "PutKey", "(", "string", "(", "v", ")", ")", "\n", "}" ]

[ "GetByID", "returns", "the", "key", "associated", "with", "an", "ID", ".", "Returns", "nil", "if", "no", "key", "is", "associated", "with", "the", "ID", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "Release", "(", "ctx", "context", ".", "Context", ",", "key", "AllocatorKey", ")", "(", "lastUse", "bool", ",", "err", "error", ")", "{", "log", ".", "WithField", "(", "fieldKey", ",", "key", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "select", "{", "case", "<-", "a", ".", "initialListDone", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n\n", "k", ":=", "key", ".", "GetKey", "(", ")", "\n", "// release the key locally, if it was the last use, remove the node", "// specific value key to remove the global reference mark", "lastUse", ",", "err", "=", "a", ".", "localKeys", ".", "release", "(", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "if", "lastUse", "{", "valueKey", ":=", "path", ".", "Join", "(", "a", ".", "valuePrefix", ",", "k", ",", "a", ".", "suffix", ")", "\n", "if", "err", ":=", "kvstore", ".", "Delete", "(", "valueKey", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", "}", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// if a.lockless {", "// FIXME: etcd 3.3 will make it possible to do a lockless", "// cleanup of the ID and release it right away. For now we rely", "// on the GC to kick in a release unused IDs.", "// }", "}", "\n\n", "return", "\n", "}" ]

[ "Release", "releases", "the", "use", "of", "an", "ID", "associated", "with", "the", "provided", "key", ".", "After", "the", "last", "user", "has", "released", "the", "ID", "the", "key", "is", "removed", "in", "the", "KVstore", "and", "the", "returned", "lastUse", "value", "is", "true", "." ]

[ "func", "(", "a", "*", "Allocator", ")", "RunGC", "(", ")", "error", "{", "// fetch list of all /id/ keys", "allocated", ",", "err", ":=", "kvstore", ".", "ListPrefix", "(", "a", ".", "idPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// iterate over /id/", "for", "key", ",", "v", ":=", "range", "allocated", "{", "// if a.lockless {", "// FIXME: Add DeleteOnZeroCount support", "// }", "lock", ",", "err", ":=", "a", ".", "lockPath", "(", "context", ".", "Background", "(", ")", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "WithField", "(", "fieldKey", ",", "key", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n\n", "// fetch list of all /value/<key> keys", "valueKeyPrefix", ":=", "path", ".", "Join", "(", "a", ".", "valuePrefix", ",", "string", "(", "v", ")", ")", "\n", "uses", ",", "err", ":=", "kvstore", ".", "ListPrefix", "(", "valueKeyPrefix", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "WithField", "(", "fieldPrefix", ",", "valueKeyPrefix", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "lock", ".", "Unlock", "(", ")", "\n", "continue", "\n", "}", "\n\n", "// if ID has no user, delete it", "if", "len", "(", "uses", ")", "==", "0", "{", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", ",", "fieldID", ":", "path", ".", "Base", "(", "key", ")", ",", "}", ")", "\n", "if", "err", ":=", "kvstore", ".", "Delete", "(", "key", ")", ";", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "else", "{", "scopedLog", ".", "Info", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "lock", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "RunGC", "scans", "the", "kvstore", "for", "unused", "master", "keys", "and", "removes", "them" ]

[ "func", "(", "a", "*", "Allocator", ")", "syncLocalKeys", "(", ")", "error", "{", "// Create a local copy of all local allocations to not require to hold", "// any locks while performing kvstore operations. Local use can", "// disappear while we perform the sync but that is fine as worst case,", "// a master key is created for a slave key that no longer exists. The", "// garbage collector will remove it again.", "ids", ":=", "a", ".", "localKeys", ".", "getVerifiedIDs", "(", ")", "\n\n", "for", "id", ",", "value", ":=", "range", "ids", "{", "a", ".", "recreateMasterKey", "(", "id", ",", "value", ",", "false", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "syncLocalKeys", "checks", "the", "kvstore", "and", "verifies", "that", "a", "master", "key", "exists", "for", "all", "locally", "used", "allocations", ".", "This", "will", "restore", "master", "keys", "if", "deleted", "for", "some", "reason", "." ]

[ "func", "(", "rc", "*", "RemoteCache", ")", "Close", "(", ")", "{", "rc", ".", "allocator", ".", "remoteCachesMutex", ".", "Lock", "(", ")", "\n", "delete", "(", "rc", ".", "allocator", ".", "remoteCaches", ",", "rc", ")", "\n", "rc", ".", "allocator", ".", "remoteCachesMutex", ".", "Unlock", "(", ")", "\n\n", "rc", ".", "cache", ".", "stop", "(", ")", "\n", "}" ]

[ "Close", "stops", "watching", "for", "identities", "in", "the", "kvstore", "associated", "with", "the", "remote", "cache", "and", "will", "clear", "the", "local", "cache", "." ]

[ "func", "RemoveCIDRs", "(", "allowCIDRs", ",", "removeCIDRs", "[", "]", "*", "net", ".", "IPNet", ")", "(", "[", "]", "*", "net", ".", "IPNet", ",", "error", ")", "{", "// Ensure that we iterate through the provided CIDRs in order of largest", "// subnet first.", "sort", ".", "Sort", "(", "NetsByMask", "(", "removeCIDRs", ")", ")", "\n\n", "PreLoop", ":", "// Remove CIDRs which are contained within CIDRs that we want to remove;", "// such CIDRs are redundant.", "for", "j", ",", "removeCIDR", ":=", "range", "removeCIDRs", "{", "for", "i", ",", "removeCIDR2", ":=", "range", "removeCIDRs", "{", "if", "i", "==", "j", "{", "continue", "\n", "}", "\n", "if", "removeCIDR", ".", "Contains", "(", "removeCIDR2", ".", "IP", ")", "{", "removeCIDRs", "=", "append", "(", "removeCIDRs", "[", ":", "i", "]", ",", "removeCIDRs", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "// Re-trigger loop since we have modified the slice we are iterating over.", "goto", "PreLoop", "\n", "}", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "remove", ":=", "range", "removeCIDRs", "{", "Loop", ":", "for", "i", ",", "allowCIDR", ":=", "range", "allowCIDRs", "{", "// Don't allow comparison of different address spaces.", "if", "allowCIDR", ".", "IP", ".", "To4", "(", ")", "!=", "nil", "&&", "remove", ".", "IP", ".", "To4", "(", ")", "==", "nil", "||", "allowCIDR", ".", "IP", ".", "To4", "(", ")", "==", "nil", "&&", "remove", ".", "IP", ".", "To4", "(", ")", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Only remove CIDR if it is contained in the subnet we are allowing.", "if", "allowCIDR", ".", "Contains", "(", "remove", ".", "IP", ".", "Mask", "(", "remove", ".", "Mask", ")", ")", "{", "nets", ",", "err", ":=", "removeCIDR", "(", "allowCIDR", ",", "remove", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Remove CIDR that we have just processed and append new CIDRs", "// that we computed from removing the CIDR to remove.", "allowCIDRs", "=", "append", "(", "allowCIDRs", "[", ":", "i", "]", ",", "allowCIDRs", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "allowCIDRs", "=", "append", "(", "allowCIDRs", ",", "nets", "...", ")", "\n", "goto", "Loop", "\n", "}", "else", "if", "remove", ".", "Contains", "(", "allowCIDR", ".", "IP", ".", "Mask", "(", "allowCIDR", ".", "Mask", ")", ")", "{", "// If a CIDR that we want to remove contains a CIDR in the list", "// that is allowed, then we can just remove the CIDR to allow.", "allowCIDRs", "=", "append", "(", "allowCIDRs", "[", ":", "i", "]", ",", "allowCIDRs", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "goto", "Loop", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "allowCIDRs", ",", "nil", "\n", "}" ]

[ "RemoveCIDRs", "removes", "the", "specified", "CIDRs", "from", "another", "set", "of", "CIDRs", ".", "If", "a", "CIDR", "to", "remove", "is", "not", "contained", "within", "the", "CIDR", "the", "CIDR", "to", "remove", "is", "ignored", ".", "A", "slice", "of", "CIDRs", "is", "returned", "which", "contains", "the", "set", "of", "CIDRs", "provided", "minus", "the", "set", "of", "CIDRs", "which", "were", "removed", ".", "Both", "input", "slices", "may", "be", "modified", "by", "calling", "this", "function", "." ]

[ "func", "GetNextIP", "(", "ip", "net", ".", "IP", ")", "net", ".", "IP", "{", "if", "ip", ".", "Equal", "(", "upperIPv4", ")", "||", "ip", ".", "Equal", "(", "upperIPv6", ")", "{", "return", "ip", "\n", "}", "\n\n", "nextIP", ":=", "make", "(", "net", ".", "IP", ",", "len", "(", "ip", ")", ")", "\n", "switch", "len", "(", "ip", ")", "{", "case", "net", ".", "IPv4len", ":", "ipU32", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "ip", ")", "\n", "ipU32", "++", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "nextIP", ",", "ipU32", ")", "\n", "return", "nextIP", "\n", "case", "net", ".", "IPv6len", ":", "ipU64", ":=", "binary", ".", "BigEndian", ".", "Uint64", "(", "ip", "[", "net", ".", "IPv6len", "/", "2", ":", "]", ")", "\n", "ipU64", "++", "\n", "binary", ".", "BigEndian", ".", "PutUint64", "(", "nextIP", "[", "net", ".", "IPv6len", "/", "2", ":", "]", ",", "ipU64", ")", "\n", "if", "ipU64", "==", "0", "{", "ipU64", "=", "binary", ".", "BigEndian", ".", "Uint64", "(", "ip", "[", ":", "net", ".", "IPv6len", "/", "2", "]", ")", "\n", "ipU64", "++", "\n", "binary", ".", "BigEndian", ".", "PutUint64", "(", "nextIP", "[", ":", "net", ".", "IPv6len", "/", "2", "]", ",", "ipU64", ")", "\n", "}", "else", "{", "copy", "(", "nextIP", "[", ":", "net", ".", "IPv6len", "/", "2", "]", ",", "ip", "[", ":", "net", ".", "IPv6len", "/", "2", "]", ")", "\n", "}", "\n", "return", "nextIP", "\n", "default", ":", "return", "ip", "\n", "}", "\n", "}" ]

[ "GetNextIP", "returns", "the", "next", "IP", "from", "the", "given", "IP", "address", ".", "If", "the", "given", "IP", "is", "the", "last", "IP", "of", "a", "v4", "or", "v6", "range", "the", "same", "IP", "is", "returned", "." ]

[ "func", "rangeToCIDRs", "(", "firstIP", ",", "lastIP", "net", ".", "IP", ")", "[", "]", "*", "net", ".", "IPNet", "{", "// First, create a CIDR that spans both IPs.", "spanningCIDR", ":=", "createSpanningCIDR", "(", "netWithRange", "{", "&", "firstIP", ",", "&", "lastIP", ",", "nil", "}", ")", "\n", "spanningRange", ":=", "ipNetToRange", "(", "spanningCIDR", ")", "\n", "firstIPSpanning", ":=", "spanningRange", ".", "First", "\n", "lastIPSpanning", ":=", "spanningRange", ".", "Last", "\n\n", "cidrList", ":=", "[", "]", "*", "net", ".", "IPNet", "{", "}", "\n\n", "// If the first IP of the spanning CIDR passes the lower bound (firstIP),", "// we need to split the spanning CIDR and only take the IPs that are", "// greater than the value which we split on, as we do not want the lesser", "// values since they are less than the lower-bound (firstIP).", "if", "bytes", ".", "Compare", "(", "*", "firstIPSpanning", ",", "firstIP", ")", "<", "0", "{", "// Split on the previous IP of the first IP so that the right list of IPs", "// of the partition includes the firstIP.", "prevFirstRangeIP", ":=", "getPreviousIP", "(", "firstIP", ")", "\n", "var", "bitLen", "int", "\n", "if", "prevFirstRangeIP", ".", "To4", "(", ")", "!=", "nil", "{", "bitLen", "=", "ipv4BitLen", "\n", "}", "else", "{", "bitLen", "=", "ipv6BitLen", "\n", "}", "\n", "_", ",", "_", ",", "right", ":=", "partitionCIDR", "(", "spanningCIDR", ",", "net", ".", "IPNet", "{", "IP", ":", "prevFirstRangeIP", ",", "Mask", ":", "net", ".", "CIDRMask", "(", "bitLen", ",", "bitLen", ")", "}", ")", "\n\n", "// Append all CIDRs but the first, as this CIDR includes the upper", "// bound of the spanning CIDR, which we still need to partition on.", "cidrList", "=", "append", "(", "cidrList", ",", "right", "...", ")", "\n", "spanningCIDR", "=", "*", "right", "[", "0", "]", "\n", "cidrList", "=", "cidrList", "[", "1", ":", "]", "\n", "}", "\n\n", "// Conversely, if the last IP of the spanning CIDR passes the upper bound", "// (lastIP), we need to split the spanning CIDR and only take the IPs that", "// are greater than the value which we split on, as we do not want the greater", "// values since they are greater than the upper-bound (lastIP).", "if", "bytes", ".", "Compare", "(", "*", "lastIPSpanning", ",", "lastIP", ")", ">", "0", "{", "// Split on the next IP of the last IP so that the left list of IPs", "// of the partition include the lastIP.", "nextFirstRangeIP", ":=", "GetNextIP", "(", "lastIP", ")", "\n", "var", "bitLen", "int", "\n", "if", "nextFirstRangeIP", ".", "To4", "(", ")", "!=", "nil", "{", "bitLen", "=", "ipv4BitLen", "\n", "}", "else", "{", "bitLen", "=", "ipv6BitLen", "\n", "}", "\n", "left", ",", "_", ",", "_", ":=", "partitionCIDR", "(", "spanningCIDR", ",", "net", ".", "IPNet", "{", "IP", ":", "nextFirstRangeIP", ",", "Mask", ":", "net", ".", "CIDRMask", "(", "bitLen", ",", "bitLen", ")", "}", ")", "\n", "cidrList", "=", "append", "(", "cidrList", ",", "left", "...", ")", "\n", "}", "else", "{", "// Otherwise, there is no need to partition; just use add the spanning", "// CIDR to the list of networks.", "cidrList", "=", "append", "(", "cidrList", ",", "&", "spanningCIDR", ")", "\n", "}", "\n", "return", "cidrList", "\n", "}" ]

[ "rangeToCIDRs", "converts", "the", "range", "of", "IPs", "covered", "by", "firstIP", "and", "lastIP", "to", "a", "list", "of", "CIDRs", "that", "contains", "all", "of", "the", "IPs", "covered", "by", "the", "range", "." ]

[ "func", "IsPublicAddr", "(", "ip", "net", ".", "IP", ")", "bool", "{", "for", "_", ",", "block", ":=", "range", "privateIPBlocks", "{", "if", "block", ".", "Contains", "(", "ip", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "IsPublicAddr", "returns", "whether", "a", "given", "global", "IP", "is", "from", "a", "public", "range", "." ]

[ "func", "useNodeCIDR", "(", "n", "*", "node", ".", "Node", ")", "{", "if", "n", ".", "IPv4AllocCIDR", "!=", "nil", "&&", "option", ".", "Config", ".", "EnableIPv4", "{", "node", ".", "SetIPv4AllocRange", "(", "n", ".", "IPv4AllocCIDR", ")", "\n", "}", "\n", "if", "n", ".", "IPv6AllocCIDR", "!=", "nil", "&&", "option", ".", "Config", ".", "EnableIPv6", "{", "if", "err", ":=", "node", ".", "SetIPv6NodeRange", "(", "n", ".", "IPv6AllocCIDR", ".", "IPNet", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Node", ":", "n", ".", "Name", ",", "logfields", ".", "V6Prefix", ":", "n", ".", "IPv6AllocCIDR", ",", "}", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "useNodeCIDR", "sets", "the", "ipv4", "-", "range", "and", "ipv6", "-", "range", "values", "values", "from", "the", "addresses", "defined", "in", "the", "given", "node", "." ]

[ "func", "NewIDPool", "(", "minID", "ID", ",", "maxID", "ID", ")", "*", "IDPool", "{", "p", ":=", "&", "IDPool", "{", "minID", ":", "minID", ",", "maxID", ":", "maxID", ",", "}", "\n\n", "p", ".", "idCache", "=", "newIDCache", "(", "p", ".", "minID", ",", "p", ".", "maxID", ")", "\n\n", "return", "p", "\n", "}" ]

[ "NewIDPool", "returns", "a", "new", "ID", "pool" ]

[ "func", "(", "p", "*", "IDPool", ")", "LeaseAvailableID", "(", ")", "ID", "{", "p", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "return", "p", ".", "idCache", ".", "leaseAvailableID", "(", ")", "\n", "}" ]

[ "LeaseAvailableID", "returns", "an", "available", "ID", "at", "random", "from", "the", "pool", ".", "Returns", "an", "ID", "or", "NoID", "if", "no", "there", "is", "no", "available", "ID", "in", "the", "pool", "." ]

[ "func", "(", "p", "*", "IDPool", ")", "Use", "(", "id", "ID", ")", "bool", "{", "p", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "return", "p", ".", "idCache", ".", "use", "(", "id", ")", "\n", "}" ]

[ "Use", "makes", "a", "leased", "ID", "unavailable", "in", "the", "pool", "and", "has", "no", "effect", "otherwise", ".", "Returns", "true", "if", "the", "ID", "was", "made", "unavailable", "as", "a", "result", "of", "this", "call", "." ]

[ "func", "(", "p", "*", "IDPool", ")", "Insert", "(", "id", "ID", ")", "bool", "{", "p", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "return", "p", ".", "idCache", ".", "insert", "(", "id", ")", "\n", "}" ]

[ "Insert", "makes", "an", "unavailable", "ID", "available", "in", "the", "pool", "and", "has", "no", "effect", "otherwise", ".", "Returns", "true", "if", "the", "ID", "was", "added", "back", "to", "the", "pool", "." ]

[ "func", "(", "p", "*", "IDPool", ")", "Remove", "(", "id", "ID", ")", "bool", "{", "p", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "return", "p", ".", "idCache", ".", "remove", "(", "id", ")", "\n", "}" ]

[ "Remove", "makes", "an", "ID", "unavailable", "in", "the", "pool", ".", "Returns", "true", "if", "the", "ID", "was", "previously", "available", "in", "the", "pool", "." ]

[ "func", "(", "c", "*", "idCache", ")", "allocateID", "(", ")", "ID", "{", "for", "id", ":=", "range", "c", ".", "ids", "{", "delete", "(", "c", ".", "ids", ",", "id", ")", "\n", "return", "id", "\n", "}", "\n\n", "return", "NoID", "\n", "}" ]

[ "allocateID", "returns", "a", "random", "available", "ID", "without", "leasing", "it" ]

[ "func", "(", "c", "*", "idCache", ")", "leaseAvailableID", "(", ")", "ID", "{", "id", ":=", "c", ".", "allocateID", "(", ")", "\n", "if", "id", "==", "NoID", "{", "return", "NoID", "\n", "}", "\n\n", "// Mark as leased", "c", ".", "leased", "[", "id", "]", "=", "struct", "{", "}", "{", "}", "\n\n", "return", "id", "\n", "}" ]

[ "leaseAvailableID", "returns", "a", "random", "available", "ID", "." ]

[ "func", "(", "c", "*", "idCache", ")", "release", "(", "id", "ID", ")", "bool", "{", "if", "_", ",", "exists", ":=", "c", ".", "leased", "[", "id", "]", ";", "!", "exists", "{", "return", "false", "\n", "}", "\n\n", "delete", "(", "c", ".", "leased", ",", "id", ")", "\n", "c", ".", "insert", "(", "id", ")", "\n\n", "return", "true", "\n", "}" ]

[ "release", "makes", "the", "ID", "available", "again", "if", "it", "is", "currently", "leased", "and", "has", "no", "effect", "otherwise", ".", "Returns", "true", "if", "the", "ID", "was", "made", "available", "as", "a", "result", "of", "this", "call", "." ]

[ "func", "(", "c", "*", "idCache", ")", "use", "(", "id", "ID", ")", "bool", "{", "if", "_", ",", "exists", ":=", "c", ".", "leased", "[", "id", "]", ";", "!", "exists", "{", "return", "false", "\n", "}", "\n\n", "delete", "(", "c", ".", "leased", ",", "id", ")", "\n", "return", "true", "\n", "}" ]

[ "use", "makes", "the", "ID", "unavailable", "if", "it", "is", "currently", "leased", "and", "has", "no", "effect", "otherwise", ".", "Returns", "true", "if", "the", "ID", "was", "made", "unavailable", "as", "a", "result", "of", "this", "call", "." ]

[ "func", "(", "c", "*", "idCache", ")", "insert", "(", "id", "ID", ")", "bool", "{", "if", "_", ",", "ok", ":=", "c", ".", "ids", "[", "id", "]", ";", "ok", "{", "return", "false", "\n", "}", "\n\n", "if", "_", ",", "exists", ":=", "c", ".", "leased", "[", "id", "]", ";", "exists", "{", "return", "false", "\n", "}", "\n\n", "c", ".", "ids", "[", "id", "]", "=", "struct", "{", "}", "{", "}", "\n", "return", "true", "\n", "}" ]

[ "insert", "adds", "the", "ID", "into", "the", "cache", "if", "it", "is", "currently", "unavailable", ".", "Returns", "true", "if", "the", "ID", "was", "added", "to", "the", "cache", "." ]

[ "func", "(", "c", "*", "idCache", ")", "remove", "(", "id", "ID", ")", "bool", "{", "delete", "(", "c", ".", "leased", ",", "id", ")", "\n\n", "if", "_", ",", "ok", ":=", "c", ".", "ids", "[", "id", "]", ";", "ok", "{", "delete", "(", "c", ".", "ids", ",", "id", ")", "\n", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "remove", "removes", "the", "ID", "from", "the", "cache", ".", "Returns", "true", "if", "the", "ID", "was", "available", "in", "the", "cache", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "LockAlive", "(", ")", "error", "{", "e", ".", "mutex", ".", "Lock", "(", ")", "\n", "if", "e", ".", "IsDisconnecting", "(", ")", "{", "e", ".", "mutex", ".", "Unlock", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LockAlive", "returns", "error", "if", "endpoint", "was", "removed", "locks", "underlying", "mutex", "otherwise" ]

[ "func", "(", "e", "*", "Endpoint", ")", "RLockAlive", "(", ")", "error", "{", "e", ".", "mutex", ".", "RLock", "(", ")", "\n", "if", "e", ".", "IsDisconnecting", "(", ")", "{", "e", ".", "mutex", ".", "RUnlock", "(", ")", "\n", "return", "ErrNotAlive", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RLockAlive", "returns", "error", "if", "endpoint", "was", "removed", "read", "locks", "underlying", "mutex", "otherwise" ]

[ "func", "(", "e", "*", "Endpoint", ")", "LogDisconnectedMutexAction", "(", "err", "error", ",", "context", "string", ")", "{", "e", ".", "getLogger", "(", ")", ".", "WithError", "(", "err", ")", ".", "Error", "(", "context", ")", "\n", "}" ]

[ "LogDisconnectedMutexAction", "gets", "the", "logger", "and", "logs", "given", "error", "with", "context" ]

[ "func", "(", "in", "*", "ClusterService", ")", "DeepCopy", "(", ")", "*", "ClusterService", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "new", "(", "ClusterService", ")", "\n", "in", ".", "DeepCopyInto", "(", "out", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "is", "an", "autogenerated", "deepcopy", "function", "copying", "the", "receiver", "creating", "a", "new", "ClusterService", "." ]

[ "func", "(", "l", "*", "localIdentityCache", ")", "getNextFreeNumericIdentity", "(", ")", "(", "identity", ".", "NumericIdentity", ",", "error", ")", "{", "firstID", ":=", "l", ".", "nextNumericIdentity", "\n", "for", "{", "idCandidate", ":=", "l", ".", "nextNumericIdentity", "|", "identity", ".", "LocalIdentityFlag", "\n", "if", "_", ",", "ok", ":=", "l", ".", "identitiesByID", "[", "idCandidate", "]", ";", "!", "ok", "{", "l", ".", "bumpNextNumericIdentity", "(", ")", "\n", "return", "idCandidate", ",", "nil", "\n", "}", "\n\n", "l", ".", "bumpNextNumericIdentity", "(", ")", "\n", "if", "l", ".", "nextNumericIdentity", "==", "firstID", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "getNextFreeNumericIdentity", "returns", "the", "next", "available", "numeric", "identity", "or", "an", "error", "The", "l", ".", "mutex", "must", "be", "held" ]

[ "func", "(", "l", "*", "localIdentityCache", ")", "release", "(", "id", "*", "identity", ".", "Identity", ")", "bool", "{", "l", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "stringRepresentation", ":=", "string", "(", "id", ".", "Labels", ".", "SortedList", "(", ")", ")", "\n", "if", "id", ",", "ok", ":=", "l", ".", "identitiesByLabels", "[", "stringRepresentation", "]", ";", "ok", "{", "switch", "{", "case", "id", ".", "ReferenceCount", ">", "1", ":", "id", ".", "ReferenceCount", "--", "\n", "return", "false", "\n\n", "case", "id", ".", "ReferenceCount", "==", "1", ":", "// Release is only attempted once, when the reference count is", "// hitting the last use", "stringRepresentation", ":=", "string", "(", "id", ".", "Labels", ".", "SortedList", "(", ")", ")", "\n", "delete", "(", "l", ".", "identitiesByLabels", ",", "stringRepresentation", ")", "\n", "delete", "(", "l", ".", "identitiesByID", ",", "id", ".", "ID", ")", "\n\n", "if", "l", ".", "events", "!=", "nil", "{", "l", ".", "events", "<-", "allocator", ".", "AllocatorEvent", "{", "Typ", ":", "kvstore", ".", "EventTypeDelete", ",", "ID", ":", "idpool", ".", "ID", "(", "id", ".", "ID", ")", ",", "}", "\n", "}", "\n\n", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "release", "releases", "a", "local", "identity", "from", "the", "cache", ".", "true", "is", "returned", "when", "the", "last", "use", "of", "the", "identity", "has", "been", "released", "and", "the", "identity", "has", "been", "forgotten", "." ]

[ "func", "(", "l", "*", "localIdentityCache", ")", "lookup", "(", "lbls", "labels", ".", "Labels", ")", "*", "identity", ".", "Identity", "{", "l", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "stringRepresentation", ":=", "string", "(", "lbls", ".", "SortedList", "(", ")", ")", "\n", "if", "id", ",", "ok", ":=", "l", ".", "identitiesByLabels", "[", "stringRepresentation", "]", ";", "ok", "{", "return", "id", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "lookup", "searches", "for", "a", "local", "identity", "matching", "the", "given", "labels", "and", "returns", "it", ".", "If", "found", "the", "reference", "count", "is", "NOT", "incremented", "and", "thus", "release", "must", "NOT", "be", "called", "." ]

[ "func", "(", "l", "*", "localIdentityCache", ")", "lookupByID", "(", "id", "identity", ".", "NumericIdentity", ")", "*", "identity", ".", "Identity", "{", "l", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "if", "id", ",", "ok", ":=", "l", ".", "identitiesByID", "[", "id", "]", ";", "ok", "{", "return", "id", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "lookupByID", "searches", "for", "a", "local", "identity", "matching", "the", "given", "ID", "and", "returns", "it", ".", "If", "found", "the", "reference", "count", "is", "NOT", "incremented", "and", "thus", "release", "must", "NOT", "be", "called", "." ]

[ "func", "(", "l", "*", "localIdentityCache", ")", "GetIdentities", "(", ")", "map", "[", "identity", ".", "NumericIdentity", "]", "*", "identity", ".", "Identity", "{", "cache", ":=", "map", "[", "identity", ".", "NumericIdentity", "]", "*", "identity", ".", "Identity", "{", "}", "\n\n", "l", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "l", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "for", "key", ",", "id", ":=", "range", "l", ".", "identitiesByID", "{", "cache", "[", "key", "]", "=", "id", "\n", "}", "\n\n", "return", "cache", "\n", "}" ]

[ "GetIdentities", "returns", "all", "local", "identities" ]

[ "func", "(", "group", "*", "ToGroups", ")", "GetCidrSet", "(", ")", "(", "[", "]", "CIDRRule", ",", "error", ")", "{", "var", "ips", "[", "]", "net", ".", "IP", "\n", "// Get per provider CIDRSet", "if", "group", ".", "AWS", "!=", "nil", "{", "callbackInterface", ",", "ok", ":=", "providers", ".", "Load", "(", "AWSProvider", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "AWSProvider", ")", "\n", "}", "\n", "callback", ",", "ok", ":=", "callbackInterface", ".", "(", "GroupProviderFunc", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "AWSProvider", ")", "\n", "}", "\n", "awsIPs", ",", "err", ":=", "callback", "(", "group", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "AWSProvider", ",", "err", ")", "\n", "}", "\n", "ips", "=", "append", "(", "ips", ",", "awsIPs", "...", ")", "\n", "}", "\n\n", "resultIps", ":=", "ip", ".", "KeepUniqueIPs", "(", "ips", ")", "\n", "return", "IPsToCIDRRules", "(", "resultIps", ")", ",", "nil", "\n", "}" ]

[ "GetCidrSet", "will", "return", "the", "CIDRRule", "for", "the", "rule", "using", "the", "callbacks", "that", "are", "register", "in", "the", "platform", "." ]

[ "func", "(", "o", "*", "GetDebuginfoOK", ")", "WithPayload", "(", "payload", "*", "models", ".", "DebugInfo", ")", "*", "GetDebuginfoOK", "{", "o", ".", "Payload", "=", "payload", "\n", "return", "o", "\n", "}" ]

[ "WithPayload", "adds", "the", "payload", "to", "the", "get", "debuginfo", "o", "k", "response" ]

[ "func", "(", "o", "*", "GetDebuginfoFailure", ")", "WithPayload", "(", "payload", "models", ".", "Error", ")", "*", "GetDebuginfoFailure", "{", "o", ".", "Payload", "=", "payload", "\n", "return", "o", "\n", "}" ]

[ "WithPayload", "adds", "the", "payload", "to", "the", "get", "debuginfo", "failure", "response" ]

[ "func", "(", "o", "*", "GetPolicyParams", ")", "WithTimeout", "(", "timeout", "time", ".", "Duration", ")", "*", "GetPolicyParams", "{", "o", ".", "SetTimeout", "(", "timeout", ")", "\n", "return", "o", "\n", "}" ]

[ "WithTimeout", "adds", "the", "timeout", "to", "the", "get", "policy", "params" ]

[ "func", "(", "o", "*", "GetPolicyParams", ")", "WithContext", "(", "ctx", "context", ".", "Context", ")", "*", "GetPolicyParams", "{", "o", ".", "SetContext", "(", "ctx", ")", "\n", "return", "o", "\n", "}" ]

[ "WithContext", "adds", "the", "context", "to", "the", "get", "policy", "params" ]

[ "func", "(", "o", "*", "GetPolicyParams", ")", "WithHTTPClient", "(", "client", "*", "http", ".", "Client", ")", "*", "GetPolicyParams", "{", "o", ".", "SetHTTPClient", "(", "client", ")", "\n", "return", "o", "\n", "}" ]

[ "WithHTTPClient", "adds", "the", "HTTPClient", "to", "the", "get", "policy", "params" ]

[ "func", "(", "o", "*", "GetPolicyParams", ")", "WithLabels", "(", "labels", "models", ".", "Labels", ")", "*", "GetPolicyParams", "{", "o", ".", "SetLabels", "(", "labels", ")", "\n", "return", "o", "\n", "}" ]

[ "WithLabels", "adds", "the", "labels", "to", "the", "get", "policy", "params" ]

[ "func", "(", "o", "*", "PatchEndpointIDParams", ")", "WithTimeout", "(", "timeout", "time", ".", "Duration", ")", "*", "PatchEndpointIDParams", "{", "o", ".", "SetTimeout", "(", "timeout", ")", "\n", "return", "o", "\n", "}" ]

[ "WithTimeout", "adds", "the", "timeout", "to", "the", "patch", "endpoint", "ID", "params" ]

[ "func", "(", "o", "*", "PatchEndpointIDParams", ")", "WithContext", "(", "ctx", "context", ".", "Context", ")", "*", "PatchEndpointIDParams", "{", "o", ".", "SetContext", "(", "ctx", ")", "\n", "return", "o", "\n", "}" ]

[ "WithContext", "adds", "the", "context", "to", "the", "patch", "endpoint", "ID", "params" ]

[ "func", "(", "o", "*", "PatchEndpointIDParams", ")", "WithHTTPClient", "(", "client", "*", "http", ".", "Client", ")", "*", "PatchEndpointIDParams", "{", "o", ".", "SetHTTPClient", "(", "client", ")", "\n", "return", "o", "\n", "}" ]

[ "WithHTTPClient", "adds", "the", "HTTPClient", "to", "the", "patch", "endpoint", "ID", "params" ]

[ "func", "(", "o", "*", "PatchEndpointIDParams", ")", "WithEndpoint", "(", "endpoint", "*", "models", ".", "EndpointChangeRequest", ")", "*", "PatchEndpointIDParams", "{", "o", ".", "SetEndpoint", "(", "endpoint", ")", "\n", "return", "o", "\n", "}" ]

[ "WithEndpoint", "adds", "the", "endpoint", "to", "the", "patch", "endpoint", "ID", "params" ]

[ "func", "(", "o", "*", "PatchEndpointIDParams", ")", "WithID", "(", "id", "string", ")", "*", "PatchEndpointIDParams", "{", "o", ".", "SetID", "(", "id", ")", "\n", "return", "o", "\n", "}" ]

[ "WithID", "adds", "the", "id", "to", "the", "patch", "endpoint", "ID", "params" ]

[ "func", "Remove", "(", "path", "string", ")", "{", "scopedLog", ":=", "log", ".", "WithField", "(", "logfields", ".", "PIDFile", ",", "path", ")", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "os", ".", "Remove", "(", "path", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Remove", "deletes", "the", "pidfile", "at", "the", "specified", "path", ".", "This", "does", "not", "clean", "up", "the", "corresponding", "process", "so", "should", "only", "be", "used", "when", "it", "is", "known", "that", "the", "PID", "contained", "in", "the", "file", "at", "the", "specified", "path", "is", "no", "longer", "running", "." ]

[ "func", "Write", "(", "path", "string", ")", "error", "{", "pid", ":=", "os", ".", "Getpid", "(", ")", "\n", "return", "write", "(", "path", ",", "pid", ")", "\n", "}" ]

[ "Write", "the", "pid", "of", "the", "process", "to", "the", "specified", "path", "and", "attach", "a", "cleanup", "handler", "to", "the", "exit", "of", "the", "program", "so", "it", "s", "removed", "afterwards", "." ]

[ "func", "kill", "(", "buf", "[", "]", "byte", ",", "pidfile", "string", ")", "error", "{", "pidStr", ":=", "strings", ".", "TrimSpace", "(", "string", "(", "buf", ")", ")", "\n", "pid", ",", "err", ":=", "strconv", ".", "Atoi", "(", "pidStr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pidStr", ",", "err", ")", "\n", "}", "\n", "oldProc", ",", "err", ":=", "os", ".", "FindProcess", "(", "pid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pid", ",", "err", ")", "\n", "}", "\n", "// According to the golang/pkg/os documentation:", "// \"On Unix systems, FindProcess always succeeds and returns a Process", "// for the given pid, regardless of whether the process exists.\"", "//", "// It could return \"os: process already finished\", so just log it at", "// a low level and ignore the error.", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "PID", ":", "pid", ",", "logfields", ".", "PIDFile", ":", "pidfile", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "oldProc", ".", "Kill", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "oldProc", ".", "Release", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pid", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "kill", "parses", "the", "PID", "in", "the", "provided", "slice", "and", "attempts", "to", "kill", "the", "process", "associated", "with", "that", "PID", "." ]

[ "func", "Kill", "(", "pidfilePath", "string", ")", "error", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "pidfilePath", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n\n", "pidfile", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "pidfilePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "kill", "(", "pidfile", ",", "pidfilePath", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "os", ".", "RemoveAll", "(", "pidfilePath", ")", "\n", "}" ]

[ "Kill", "opens", "the", "pidfile", "at", "the", "specified", "path", "attempts", "to", "read", "the", "PID", "and", "kill", "the", "process", "represented", "by", "that", "PID", ".", "If", "the", "file", "doesn", "t", "exist", "the", "corresponding", "process", "doesn", "t", "exist", "or", "the", "process", "is", "successfully", "killed", "returns", "nil", ".", "Otherwise", "returns", "an", "error", "indicating", "the", "failure", "to", "kill", "the", "process", ".", "On", "success", "deletes", "the", "pidfile", "from", "the", "filesystem", ".", "Otherwise", "leaves", "it", "in", "place", "." ]

[ "func", "NewGetFqdnCache", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetFqdnCacheHandler", ")", "*", "GetFqdnCache", "{", "return", "&", "GetFqdnCache", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetFqdnCache", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "fqdn", "cache", "operation" ]

[ "func", "(", "i", "*", "Uint16Flags", ")", "String", "(", ")", "string", "{", "pieces", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "*", "i", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "*", "i", "{", "pieces", "=", "append", "(", "pieces", ",", "strconv", ".", "Itoa", "(", "int", "(", "v", ")", ")", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "pieces", ",", "\"", "\"", ")", "\n", "}" ]

[ "String", "provides", "a", "human", "-", "readable", "string", "format", "of", "the", "received", "variable", "." ]

[ "func", "(", "i", "*", "Uint16Flags", ")", "Set", "(", "value", "string", ")", "error", "{", "v", ",", "err", ":=", "strconv", ".", "Atoi", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "*", "i", "=", "append", "(", "*", "i", ",", "uint16", "(", "v", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Set", "converts", "the", "specified", "value", "into", "an", "integer", "and", "appends", "it", "to", "the", "flags", ".", "Returns", "an", "error", "if", "the", "value", "cannot", "be", "converted", "to", "a", "16", "-", "bit", "unsigned", "value", "." ]

[ "func", "(", "c", "*", "CtEntry", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "c", ".", "Lifetime", ",", "c", ".", "RxPackets", ",", "c", ".", "RxBytes", ",", "c", ".", "RxFlagsSeen", ",", "c", ".", "LastRxReport", ",", "c", ".", "TxPackets", ",", "c", ".", "TxBytes", ",", "c", ".", "TxFlagsSeen", ",", "c", ".", "LastTxReport", ",", "c", ".", "Flags", ",", "byteorder", ".", "NetworkToHost", "(", "c", ".", "RevNAT", ")", ",", "c", ".", "Slave", ",", "c", ".", "SourceSecurityID", ")", "\n", "}" ]

[ "String", "returns", "the", "readable", "format" ]

[ "func", "NewCorrelationCache", "(", ")", "*", "CorrelationCache", "{", "cc", ":=", "&", "CorrelationCache", "{", "cache", ":", "requestsCache", "{", "}", ",", "nextSequenceNumber", ":", "1", ",", "stopGc", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n\n", "go", "cc", ".", "garbageCollector", "(", ")", "\n\n", "return", "cc", "\n", "}" ]

[ "NewCorrelationCache", "returns", "a", "new", "correlation", "cache" ]