Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.5k

[ "func", "(", "cc", "*", "CorrelationCache", ")", "HandleRequest", "(", "req", "*", "RequestMessage", ",", "finishFunc", "FinishFunc", ")", "{", "cc", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cc", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// save the original correlation ID", "origCorrelationID", ":=", "req", ".", "GetCorrelationID", "(", ")", "\n\n", "// Use a sequence number to generate a correlation ID that is", "// guaranteed to be unique", "newCorrelationID", ":=", "cc", ".", "nextSequenceNumber", "\n", "cc", ".", "nextSequenceNumber", "++", "\n\n", "// Overwrite the correlation ID in the request to allow correlating the", "// response later on. The original correlation ID will be restored when", "// forwarding the response", "req", ".", "SetCorrelationID", "(", "newCorrelationID", ")", "\n\n", "if", "_", ",", "ok", ":=", "cc", ".", "cache", "[", "newCorrelationID", "]", ";", "ok", "{", "log", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cc", ".", "cache", "[", "newCorrelationID", "]", "=", "&", "correlationEntry", "{", "request", ":", "req", ",", "created", ":", "time", ".", "Now", "(", ")", ",", "origCorrelationID", ":", "origCorrelationID", ",", "finishFunc", ":", "finishFunc", ",", "}", "\n", "}" ]

[ "HandleRequest", "must", "be", "called", "when", "a", "request", "is", "forwarded", "to", "the", "broker", "will", "keep", "track", "of", "the", "request", "and", "rewrite", "the", "correlation", "ID", "inside", "of", "the", "request", "to", "a", "sequence", "number", ".", "This", "sequence", "number", "is", "guaranteed", "to", "be", "unique", "within", "the", "connection", "covered", "by", "the", "cache", "." ]

[ "func", "(", "cc", "*", "CorrelationCache", ")", "correlate", "(", "id", "CorrelationID", ")", "*", "correlationEntry", "{", "cc", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "cc", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "entry", ",", "_", ":=", "cc", ".", "cache", "[", "id", "]", "\n", "return", "entry", "\n", "}" ]

[ "correlate", "returns", "the", "request", "message", "with", "the", "matching", "correlation", "ID" ]

[ "func", "(", "cc", "*", "CorrelationCache", ")", "CorrelateResponse", "(", "res", "*", "ResponseMessage", ")", "*", "RequestMessage", "{", "cc", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cc", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "correlationID", ":=", "res", ".", "GetCorrelationID", "(", ")", "\n", "if", "entry", ":=", "cc", ".", "cache", "[", "correlationID", "]", ";", "entry", "!=", "nil", "{", "res", ".", "SetCorrelationID", "(", "entry", ".", "origCorrelationID", ")", "\n\n", "if", "entry", ".", "finishFunc", "!=", "nil", "{", "entry", ".", "finishFunc", "(", "entry", ".", "request", ")", "\n", "}", "\n\n", "delete", "(", "cc", ".", "cache", ",", "correlationID", ")", "\n", "return", "entry", ".", "request", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CorrelateResponse", "extracts", "the", "correlation", "ID", "from", "the", "response", "message", "correlates", "the", "corresponding", "request", "restores", "the", "original", "correlation", "ID", "in", "the", "response", "and", "returns", "the", "original", "request" ]

[ "func", "NewNamedMapOptions", "(", "name", "string", ",", "values", "*", "map", "[", "string", "]", "string", ",", "validator", "Validator", ")", "*", "NamedMapOptions", "{", "return", "&", "NamedMapOptions", "{", "name", ":", "name", ",", "MapOptions", ":", "*", "NewMapOpts", "(", "*", "values", ",", "validator", ")", ",", "}", "\n", "}" ]

[ "NewNamedMapOptions", "creates", "a", "reference", "to", "a", "new", "NamedMapOpts", "struct", "." ]

[ "func", "NewMapOpts", "(", "values", "map", "[", "string", "]", "string", ",", "validator", "Validator", ")", "*", "MapOptions", "{", "if", "values", "==", "nil", "{", "values", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "return", "&", "MapOptions", "{", "vals", ":", "values", ",", "validator", ":", "validator", ",", "}", "\n", "}" ]

[ "NewMapOpts", "creates", "a", "new", "MapOpts", "with", "the", "specified", "map", "of", "values", "and", "an", "optional", "validator", "." ]

[ "func", "(", "opts", "*", "MapOptions", ")", "Set", "(", "value", "string", ")", "error", "{", "if", "opts", ".", "validator", "!=", "nil", "{", "v", ",", "err", ":=", "opts", ".", "validator", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "value", "=", "v", "\n", "}", "\n", "vals", ":=", "strings", ".", "SplitN", "(", "value", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "vals", ")", "==", "1", "{", "(", "opts", ".", "vals", ")", "[", "vals", "[", "0", "]", "]", "=", "\"", "\"", "\n", "}", "else", "{", "(", "opts", ".", "vals", ")", "[", "vals", "[", "0", "]", "]", "=", "vals", "[", "1", "]", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Set", "validates", "if", "needed", "the", "input", "value", "and", "adds", "it", "to", "the", "internal", "map", "by", "splitting", "on", "=", "." ]

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

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

[ "func", "ParseMonitorAggregationLevel", "(", "value", "string", ")", "(", "OptionSetting", ",", "error", ")", "{", "// First, attempt the string representation.", "if", "level", ",", "ok", ":=", "monitorAggregationOption", "[", "strings", ".", "ToLower", "(", "value", ")", "]", ";", "ok", "{", "return", "level", ",", "nil", "\n", "}", "\n\n", "// If it's not a valid string option, attempt to parse an integer.", "valueParsed", ",", "err", ":=", "strconv", ".", "Atoi", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "value", ")", "\n", "return", "MonitorAggregationLevelNone", ",", "err", "\n", "}", "\n", "parsed", ":=", "OptionSetting", "(", "valueParsed", ")", "\n", "if", "parsed", "<", "MonitorAggregationLevelNone", "||", "parsed", ">", "MonitorAggregationLevelMax", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "MonitorAggregationLevelNone", ",", "MonitorAggregationLevelMax", ")", "\n", "return", "MonitorAggregationLevelNone", ",", "err", "\n", "}", "\n", "return", "parsed", ",", "nil", "\n", "}" ]

[ "ParseMonitorAggregationLevel", "turns", "a", "string", "into", "a", "monitor", "aggregation", "level", ".", "The", "string", "may", "contain", "an", "integer", "value", "or", "a", "string", "representation", "of", "a", "particular", "monitor", "aggregation", "level", "." ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "patch", "config", "bad", "request", "response" ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "patch", "config", "failure", "response" ]

[ "func", "(", "c", "*", "Client", ")", "ConfigGet", "(", ")", "(", "*", "models", ".", "DaemonConfiguration", ",", "error", ")", "{", "resp", ",", "err", ":=", "c", ".", "Daemon", ".", "GetConfig", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "ConfigGet", "returns", "a", "daemon", "configuration", "." ]

[ "func", "(", "c", "*", "Client", ")", "ConfigPatch", "(", "cfg", "models", ".", "DaemonConfigurationSpec", ")", "error", "{", "fullCfg", ",", "err", ":=", "c", ".", "ConfigGet", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "opt", ",", "value", ":=", "range", "cfg", ".", "Options", "{", "fullCfg", ".", "Spec", ".", "Options", "[", "opt", "]", "=", "value", "\n", "}", "\n", "if", "cfg", ".", "PolicyEnforcement", "!=", "\"", "\"", "{", "fullCfg", ".", "Spec", ".", "PolicyEnforcement", "=", "cfg", ".", "PolicyEnforcement", "\n", "}", "\n\n", "params", ":=", "daemon", ".", "NewPatchConfigParams", "(", ")", ".", "WithConfiguration", "(", "fullCfg", ".", "Spec", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "err", "=", "c", ".", "Daemon", ".", "PatchConfig", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "ConfigPatch", "modifies", "the", "daemon", "configuration", "." ]

[ "func", "(", "m", "*", "TraceFrom", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateLabels", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "len", "(", "res", ")", ">", "0", "{", "return", "errors", ".", "CompositeValidationError", "(", "res", "...", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "this", "trace", "from" ]

[ "func", "DumpJSONToSlice", "(", "data", "interface", "{", "}", ",", "jsonPath", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "jsonPath", ")", "==", "0", "{", "result", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "data", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "fmt", ".", "Println", "(", "string", "(", "result", ")", ")", "\n", "return", "nil", ",", "nil", "\n", "}", "\n\n", "parser", ":=", "jsonpath", ".", "New", "(", "\"", "\"", ")", ".", "AllowMissingKeys", "(", "true", ")", "\n", "if", "err", ":=", "parser", ".", "Parse", "(", "jsonPath", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "if", "err", ":=", "parser", ".", "Execute", "(", "buf", ",", "data", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "nil", ",", "err", "\n\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "DumpJSONToSlice", "dumps", "the", "contents", "of", "data", "into", "a", "byte", "slice", ".", "If", "jsonpath", "is", "non", "-", "empty", "will", "attempt", "to", "do", "jsonpath", "filtering", "using", "said", "string", ".", "Returns", "byte", "array", "containing", "the", "JSON", "in", "data", "or", "an", "error", "if", "any", "JSON", "marshaling", "parsing", "operations", "fail", "." ]

[ "func", "dumpJSON", "(", "data", "interface", "{", "}", ",", "jsonPath", "string", ")", "error", "{", "jsonBytes", ",", "err", ":=", "DumpJSONToSlice", "(", "data", ",", "jsonPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "fmt", ".", "Println", "(", "string", "(", "jsonBytes", "[", ":", "]", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "dumpJSON", "dump", "the", "data", "variable", "to", "the", "stdout", "as", "json", ".", "If", "somethings", "fail", "it", "ll", "return", "an", "error", "If", "jsonPath", "is", "passed", "it", "ll", "run", "the", "json", "query", "over", "data", "var", "." ]

[ "func", "(", "c", "*", "consulClient", ")", "Disconnected", "(", ")", "<-", "chan", "struct", "{", "}", "{", "c", ".", "disconnectedMu", ".", "RLock", "(", ")", "\n", "ch", ":=", "c", ".", "disconnected", "\n", "c", ".", "disconnectedMu", ".", "RUnlock", "(", ")", "\n", "return", "ch", "\n", "}" ]

[ "Disconnected", "closes", "the", "returned", "channel", "when", "consul", "detects", "the", "client", "is", "disconnected", "from", "the", "server", "." ]

[ "func", "(", "c", "*", "consulClient", ")", "Update", "(", "ctx", "context", ".", "Context", ",", "key", "string", ",", "value", "[", "]", "byte", ",", "lease", "bool", ")", "error", "{", "k", ":=", "&", "consulAPI", ".", "KVPair", "{", "Key", ":", "key", ",", "Value", ":", "value", "}", "\n\n", "if", "lease", "{", "k", ".", "Session", "=", "c", ".", "lease", "\n", "}", "\n\n", "opts", ":=", "&", "consulAPI", ".", "WriteOptions", "{", "}", "\n\n", "duration", ":=", "spanstat", ".", "Start", "(", ")", "\n", "_", ",", "err", ":=", "c", ".", "KV", "(", ")", ".", "Put", "(", "k", ",", "opts", ".", "WithContext", "(", "ctx", ")", ")", "\n", "increaseMetric", "(", "key", ",", "metricSet", ",", "\"", "\"", ",", "duration", ".", "EndError", "(", "err", ")", ".", "Total", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}" ]

[ "Update", "creates", "or", "updates", "a", "key", "with", "the", "value" ]

[ "func", "(", "c", "*", "consulClient", ")", "createIfExists", "(", "condKey", ",", "key", "string", ",", "value", "[", "]", "byte", ",", "lease", "bool", ")", "error", "{", "// Consul does not support transactions which would allow to check for", "// the presence of a conditional key if the key is not the key being", "// manipulated", "//", "// Lock the conditional key to serialize all CreateIfExists() calls", "l", ",", "err", ":=", "LockPath", "(", "context", ".", "Background", "(", ")", ",", "condKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "defer", "l", ".", "Unlock", "(", ")", "\n\n", "// Create the key if it does not exist", "if", "_", ",", "err", ":=", "c", ".", "CreateOnly", "(", "context", ".", "TODO", "(", ")", ",", "key", ",", "value", ",", "lease", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Consul does not support transactions which would allow to check for", "// the presence of another key", "masterKey", ",", "err", ":=", "c", ".", "Get", "(", "condKey", ")", "\n", "if", "err", "!=", "nil", "||", "masterKey", "==", "nil", "{", "c", ".", "Delete", "(", "key", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "createIfExists", "creates", "a", "key", "with", "the", "value", "only", "if", "key", "condKey", "exists" ]

[ "func", "(", "c", "*", "consulClient", ")", "ListPrefix", "(", "prefix", "string", ")", "(", "KeyValuePairs", ",", "error", ")", "{", "duration", ":=", "spanstat", ".", "Start", "(", ")", "\n", "pairs", ",", "_", ",", "err", ":=", "c", ".", "KV", "(", ")", ".", "List", "(", "prefix", ",", "nil", ")", "\n", "increaseMetric", "(", "prefix", ",", "metricRead", ",", "\"", "\"", ",", "duration", ".", "EndError", "(", "err", ")", ".", "Total", "(", ")", ",", "err", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "p", ":=", "KeyValuePairs", "(", "make", "(", "map", "[", "string", "]", "[", "]", "byte", ",", "len", "(", "pairs", ")", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "pairs", ")", ";", "i", "++", "{", "p", "[", "pairs", "[", "i", "]", ".", "Key", "]", "=", "pairs", "[", "i", "]", ".", "Value", "\n", "}", "\n\n", "return", "p", ",", "nil", "\n", "}" ]

[ "ListPrefix", "returns", "a", "map", "of", "matching", "keys" ]

[ "func", "(", "c", "*", "consulClient", ")", "Close", "(", ")", "{", "if", "c", ".", "controllers", "!=", "nil", "{", "c", ".", "controllers", ".", "RemoveAll", "(", ")", "\n", "}", "\n", "if", "c", ".", "lease", "!=", "\"", "\"", "{", "c", ".", "Session", "(", ")", ".", "Destroy", "(", "c", ".", "lease", ",", "nil", ")", "\n", "}", "\n", "}" ]

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

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

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

[ "func", "Allocate", "(", ")", "uint16", "{", "id", ":=", "pool", ".", "AllocateID", "(", ")", "\n\n", "// Out of endpoint IDs", "if", "id", "==", "idpool", ".", "NoID", "{", "return", "uint16", "(", "0", ")", "\n", "}", "\n\n", "return", "uint16", "(", "id", ")", "\n", "}" ]

[ "Allocate", "returns", "a", "new", "random", "ID", "from", "the", "pool" ]

[ "func", "Reuse", "(", "id", "uint16", ")", "error", "{", "if", "idpool", ".", "ID", "(", "id", ")", "<", "minID", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ",", "minID", ")", "\n", "}", "\n\n", "// When restoring endpoints, the existing endpoint ID can be outside of", "// the range. This is fine (tm) and we can just skip to reserve the ID", "// from the pool as the pool will not cover it.", "if", "idpool", ".", "ID", "(", "id", ")", ">", "maxID", "{", "return", "nil", "\n", "}", "\n\n", "if", "!", "pool", ".", "Remove", "(", "idpool", ".", "ID", "(", "id", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Reuse", "grabs", "a", "specific", "endpoint", "ID", "for", "reuse", ".", "This", "can", "be", "used", "when", "restoring", "endpoints", "." ]

[ "func", "Release", "(", "id", "uint16", ")", "error", "{", "if", "!", "pool", ".", "Insert", "(", "idpool", ".", "ID", "(", "id", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Release", "releases", "an", "endpoint", "ID", "that", "was", "previously", "allocated", "or", "reused" ]

[ "func", "(", "o", "*", "GetMapNameParams", ")", "bindName", "(", "rawData", "[", "]", "string", ",", "hasKey", "bool", ",", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "raw", "string", "\n", "if", "len", "(", "rawData", ")", ">", "0", "{", "raw", "=", "rawData", "[", "len", "(", "rawData", ")", "-", "1", "]", "\n", "}", "\n\n", "// Required: true", "// Parameter is provided by construction from the route", "o", ".", "Name", "=", "raw", "\n\n", "return", "nil", "\n", "}" ]

[ "bindName", "binds", "and", "validates", "parameter", "Name", "from", "path", "." ]

[ "func", "getLPMValue", "(", "ip", "net", ".", "IP", ",", "entries", "map", "[", "string", "]", "[", "]", "string", ")", "(", "interface", "{", "}", ",", "bool", ")", "{", "type", "lpmEntry", "struct", "{", "prefix", "[", "]", "byte", "\n", "identity", "[", "]", "string", "\n", "}", "\n\n", "isV4", ":=", "isIPV4", "(", "ip", ")", "\n\n", "// Convert ip to 4-byte representation if IPv4.", "if", "isV4", "{", "ip", "=", "ip", ".", "To4", "(", ")", "\n", "}", "\n\n", "var", "lpmEntries", "[", "]", "lpmEntry", "\n", "for", "cidr", ",", "identity", ":=", "range", "entries", "{", "currIP", ",", "subnet", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "cidr", ")", "\n\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "cidr", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "// No need to include IPv6 addresses if the argument is", "// IPv4 and vice versa.", "if", "isIPV4", "(", "currIP", ")", "!=", "isV4", "{", "continue", "\n", "}", "\n\n", "// Convert ip to 4-byte representation if IPv4.", "if", "isV4", "{", "currIP", "=", "currIP", ".", "To4", "(", ")", "\n", "}", "\n\n", "ones", ",", "_", ":=", "subnet", ".", "Mask", ".", "Size", "(", ")", "\n", "prefix", ":=", "getPrefix", "(", "currIP", ",", "ones", ")", "\n\n", "lpmEntries", "=", "append", "(", "lpmEntries", ",", "lpmEntry", "{", "prefix", ",", "identity", "}", ")", "\n", "}", "\n\n", "r", ":=", "iradix", ".", "New", "(", ")", "\n", "for", "_", ",", "e", ":=", "range", "lpmEntries", "{", "r", ",", "_", ",", "_", "=", "r", ".", "Insert", "(", "e", ".", "prefix", ",", "e", ".", "identity", ")", "\n", "}", "\n\n", "// Look-up using all bits in the argument ip", "var", "mask", "int", "\n", "if", "isV4", "{", "mask", "=", "8", "*", "net", ".", "IPv4len", "\n", "}", "else", "{", "mask", "=", "8", "*", "net", ".", "IPv6len", "\n", "}", "\n\n", "_", ",", "v", ",", "exists", ":=", "r", ".", "Root", "(", ")", ".", "LongestPrefix", "(", "getPrefix", "(", "ip", ",", "mask", ")", ")", "\n", "return", "v", ",", "exists", "\n", "}" ]

[ "getLPMValue", "calculates", "the", "longest", "prefix", "matching", "ip", "amongst", "the", "keys", "in", "entries", ".", "The", "keys", "in", "entries", "must", "be", "specified", "in", "CIDR", "notation", ".", "If", "LPM", "is", "found", "the", "value", "associated", "with", "that", "entry", "is", "returned", "along", "with", "boolean", "true", ".", "Otherwise", "false", "is", "returned", "." ]

[ "func", "getPrefix", "(", "ip", "net", ".", "IP", ",", "maskSize", "int", ")", "[", "]", "byte", "{", "bytes", ":=", "make", "(", "[", "]", "byte", ",", "maskSize", ")", "\n", "var", "i", ",", "j", "uint8", "\n", "var", "n", "int", "\n\n", "for", "n", "<", "maskSize", "{", "for", "j", "=", "0", ";", "j", "<", "8", "&&", "n", "<", "maskSize", ";", "j", "++", "{", "mask", ":=", "uint8", "(", "128", ")", ">>", "uint8", "(", "j", ")", "\n\n", "if", "mask", "&", "ip", "[", "i", "]", "==", "0", "{", "bytes", "[", "i", "*", "8", "+", "j", "]", "=", "0x0", "\n", "}", "else", "{", "bytes", "[", "i", "*", "8", "+", "j", "]", "=", "0x1", "\n", "}", "\n", "n", "++", "\n", "}", "\n", "i", "++", "\n", "}", "\n\n", "return", "bytes", "\n", "}" ]

[ "getPrefix", "converts", "the", "most", "significant", "maskSize", "bits", "in", "ip", "into", "a", "byte", "slice", "-", "each", "bit", "is", "represented", "using", "one", "byte", "." ]

[ "func", "getMaxID", "(", "key", "string", ",", "firstID", "uint32", ")", "(", "uint32", ",", "error", ")", "{", "client", ":=", "kvstore", ".", "Client", "(", ")", "\n", "k", ",", "err", ":=", "client", ".", "Get", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "k", "==", "nil", "{", "// FreeID is empty? We should set it out!", "if", "err", ":=", "initializeFreeID", "(", "key", ",", "firstID", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "// Due other goroutine can take the ID, still need to get the key from the kvstore.", "k", ",", "err", "=", "client", ".", "Get", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "if", "k", "==", "nil", "{", "// Something is really wrong", "errMsg", ":=", "\"", "\\n", "\"", "\n", "log", ".", "Error", "(", "errMsg", ")", "\n", "return", "0", ",", "fmt", ".", "Errorf", "(", "errMsg", ")", "\n", "}", "\n", "}", "\n", "var", "freeID", "uint32", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "k", ",", "&", "freeID", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "return", "freeID", ",", "nil", "\n", "}" ]

[ "getMaxID", "returns", "the", "maximum", "possible", "free", "UUID", "stored", "." ]

[ "func", "gasNewL3n4AddrID", "(", "l3n4AddrID", "*", "loadbalancer", ".", "L3n4AddrID", ",", "baseID", "uint32", ")", "error", "{", "client", ":=", "kvstore", ".", "Client", "(", ")", "\n\n", "if", "baseID", "==", "0", "{", "var", "err", "error", "\n", "baseID", ",", "err", "=", "getGlobalMaxServiceID", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "setIDtoL3n4Addr", ":=", "func", "(", "id", "uint32", ")", "error", "{", "l3n4AddrID", ".", "ID", "=", "loadbalancer", ".", "ID", "(", "id", ")", "\n", "marshaledL3n4AddrID", ",", "err", ":=", "json", ".", "Marshal", "(", "l3n4AddrID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "keyPath", ":=", "path", ".", "Join", "(", "ServiceIDKeyPath", ",", "strconv", ".", "FormatUint", "(", "uint64", "(", "l3n4AddrID", ".", "ID", ")", ",", "10", ")", ")", "\n", "if", "err", ":=", "client", ".", "Set", "(", "keyPath", ",", "marshaledL3n4AddrID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "setMaxID", "(", "LastFreeServiceIDKeyPath", ",", "FirstFreeServiceID", ",", "id", "+", "1", ")", "\n", "}", "\n\n", "acquireFreeID", ":=", "func", "(", "firstID", "uint32", ",", "incID", "*", "uint32", ")", "(", "bool", ",", "error", ")", "{", "keyPath", ":=", "path", ".", "Join", "(", "ServiceIDKeyPath", ",", "strconv", ".", "FormatUint", "(", "uint64", "(", "*", "incID", ")", ",", "10", ")", ")", "\n\n", "locker", ",", "err", ":=", "client", ".", "LockPath", "(", "context", ".", "Background", "(", ")", ",", "keyPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "defer", "locker", ".", "Unlock", "(", ")", "\n\n", "value", ",", "err", ":=", "client", ".", "Get", "(", "keyPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "value", "==", "nil", "{", "return", "false", ",", "setIDtoL3n4Addr", "(", "*", "incID", ")", "\n", "}", "\n", "var", "kvstoreL3n4AddrID", "loadbalancer", ".", "L3n4AddrID", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "value", ",", "&", "kvstoreL3n4AddrID", ")", ";", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "kvstoreL3n4AddrID", ".", "ID", "==", "0", "{", "log", ".", "WithField", "(", "logfields", ".", "Identity", ",", "*", "incID", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "false", ",", "setIDtoL3n4Addr", "(", "*", "incID", ")", "\n", "}", "\n\n", "*", "incID", "++", "\n", "if", "*", "incID", ">", "MaxSetOfServiceID", "{", "*", "incID", "=", "FirstFreeServiceID", "\n", "}", "\n", "if", "firstID", "==", "*", "incID", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// Only retry if we have incremented the service ID", "return", "true", ",", "nil", "\n", "}", "\n\n", "beginning", ":=", "baseID", "\n", "for", "{", "retry", ",", "err", ":=", "acquireFreeID", "(", "beginning", ",", "&", "baseID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "!", "retry", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "gasNewL3n4AddrID", "gets", "and", "sets", "a", "new", "L3n4Addr", "ID", ".", "If", "baseID", "is", "different", "than", "zero", "KVStore", "tries", "to", "assign", "that", "ID", "first", "." ]

[ "func", "acquireGlobalID", "(", "l3n4Addr", "loadbalancer", ".", "L3n4Addr", ",", "baseID", "uint32", ")", "(", "*", "loadbalancer", ".", "L3n4AddrID", ",", "error", ")", "{", "// Retrieve unique SHA256Sum for service", "sha256Sum", ":=", "l3n4Addr", ".", "SHA256Sum", "(", ")", "\n", "svcPath", ":=", "path", ".", "Join", "(", "common", ".", "ServicesKeyPath", ",", "sha256Sum", ")", "\n\n", "// Lock that sha256Sum", "lockKey", ",", "err", ":=", "kvstore", ".", "LockPath", "(", "context", ".", "Background", "(", ")", ",", "svcPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "lockKey", ".", "Unlock", "(", ")", "\n\n", "// After lock complete, get svc's path", "rmsg", ",", "err", ":=", "kvstore", ".", "Client", "(", ")", ".", "Get", "(", "svcPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "sl4KV", ":=", "loadbalancer", ".", "L3n4AddrID", "{", "}", "\n", "if", "rmsg", "!=", "nil", "{", "if", "err", ":=", "json", ".", "Unmarshal", "(", "rmsg", ",", "&", "sl4KV", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "if", "sl4KV", ".", "ID", "==", "0", "{", "sl4KV", ".", "L3n4Addr", "=", "l3n4Addr", "\n", "if", "err", ":=", "gasNewL3n4AddrID", "(", "&", "sl4KV", ",", "baseID", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "marshaledSl4Kv", ",", "err", ":=", "json", ".", "Marshal", "(", "sl4KV", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "err", "=", "kvstore", ".", "Client", "(", ")", ".", "Set", "(", "svcPath", ",", "marshaledSl4Kv", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "&", "sl4KV", ",", "err", "\n", "}" ]

[ "acquireGlobalID", "stores", "the", "given", "service", "in", "the", "kvstore", "and", "returns", "the", "L3n4AddrID", "created", "for", "the", "given", "l3n4Addr", ".", "If", "baseID", "is", "different", "than", "0", "it", "tries", "to", "acquire", "that", "ID", "to", "the", "l3n4Addr", "." ]

[ "func", "getGlobalID", "(", "id", "uint32", ")", "(", "*", "loadbalancer", ".", "L3n4AddrID", ",", "error", ")", "{", "strID", ":=", "strconv", ".", "FormatUint", "(", "uint64", "(", "id", ")", ",", "10", ")", "\n", "log", ".", "WithField", "(", "logfields", ".", "L3n4AddrID", ",", "strID", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "getL3n4AddrID", "(", "path", ".", "Join", "(", "ServiceIDKeyPath", ",", "strID", ")", ")", "\n", "}" ]

[ "getGlobalID", "returns", "the", "L3n4AddrID", "that", "belongs", "to", "the", "given", "id", "." ]

[ "func", "deleteGlobalID", "(", "id", "uint32", ")", "error", "{", "l3n4AddrID", ",", "err", ":=", "getGlobalID", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "l3n4AddrID", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "deleteL3n4AddrIDBySHA256", "(", "l3n4AddrID", ".", "SHA256Sum", "(", ")", ")", "\n", "}" ]

[ "deleteGlobalID", "deletes", "the", "L3n4AddrID", "belonging", "to", "the", "given", "id", "from", "the", "kvstore", "." ]

[ "func", "deleteL3n4AddrIDBySHA256", "(", "sha256Sum", "string", ")", "error", "{", "log", ".", "WithField", "(", "logfields", ".", "SHA", ",", "sha256Sum", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "sha256Sum", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "svcPath", ":=", "path", ".", "Join", "(", "common", ".", "ServicesKeyPath", ",", "sha256Sum", ")", "\n", "// Lock that sha256Sum", "lockKey", ",", "err", ":=", "kvstore", ".", "LockPath", "(", "context", ".", "Background", "(", ")", ",", "svcPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "lockKey", ".", "Unlock", "(", ")", "\n\n", "// After lock complete, get label's path", "rmsg", ",", "err", ":=", "kvstore", ".", "Client", "(", ")", ".", "Get", "(", "svcPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "rmsg", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "var", "l3n4AddrID", "loadbalancer", ".", "L3n4AddrID", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "rmsg", ",", "&", "l3n4AddrID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "oldL3n4ID", ":=", "l3n4AddrID", ".", "ID", "\n", "l3n4AddrID", ".", "ID", "=", "0", "\n\n", "// update the value in the kvstore", "if", "err", ":=", "updateL3n4AddrIDRef", "(", "oldL3n4ID", ",", "l3n4AddrID", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "marshaledL3n4AddrID", ",", "err", ":=", "json", ".", "Marshal", "(", "l3n4AddrID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "kvstore", ".", "Client", "(", ")", ".", "Set", "(", "svcPath", ",", "marshaledL3n4AddrID", ")", "\n", "}" ]

[ "deleteL3n4AddrIDBySHA256", "deletes", "the", "L3n4AddrID", "from", "the", "kvstore", "corresponding", "to", "the", "service", "s", "sha256Sum", "." ]

[ "func", "GetMap", "(", "name", "string", ")", "*", "Map", "{", "mutex", ".", "RLock", "(", ")", "\n", "defer", "mutex", ".", "RUnlock", "(", ")", "\n\n", "if", "!", "path", ".", "IsAbs", "(", "name", ")", "{", "name", "=", "MapPath", "(", "name", ")", "\n", "}", "\n\n", "return", "mapRegister", "[", "name", "]", "\n", "}" ]

[ "GetMap", "returns", "the", "registered", "map", "with", "the", "given", "name", "or", "absolute", "path" ]

[ "func", "NewGetFqdnCacheID", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetFqdnCacheIDHandler", ")", "*", "GetFqdnCacheID", "{", "return", "&", "GetFqdnCacheID", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

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

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

[ "WithTimeout", "adds", "the", "timeout", "to", "the", "get", "fqdn", "cache", "params" ]

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

[ "WithContext", "adds", "the", "context", "to", "the", "get", "fqdn", "cache", "params" ]

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

[ "WithHTTPClient", "adds", "the", "HTTPClient", "to", "the", "get", "fqdn", "cache", "params" ]

[ "func", "(", "o", "*", "GetFqdnCacheParams", ")", "WithCidr", "(", "cidr", "*", "string", ")", "*", "GetFqdnCacheParams", "{", "o", ".", "SetCidr", "(", "cidr", ")", "\n", "return", "o", "\n", "}" ]

[ "WithCidr", "adds", "the", "cidr", "to", "the", "get", "fqdn", "cache", "params" ]

[ "func", "(", "o", "*", "GetFqdnCacheParams", ")", "WithMatchpattern", "(", "matchpattern", "*", "string", ")", "*", "GetFqdnCacheParams", "{", "o", ".", "SetMatchpattern", "(", "matchpattern", ")", "\n", "return", "o", "\n", "}" ]

[ "WithMatchpattern", "adds", "the", "matchpattern", "to", "the", "get", "fqdn", "cache", "params" ]

[ "func", "NewLoggingHook", "(", "component", "string", ")", "*", "LoggingHook", "{", "// NOTE(mrostecki): For now errors and warning metric exists only for Cilium", "// daemon, but support of Prometheus metrics in some other components (i.e.", "// cilium-health - GH-4268) is planned.", "// Pick a metric for the component.", "var", "metric", "*", "prometheus", ".", "CounterVec", "\n", "switch", "component", "{", "case", "components", ".", "CiliumAgentName", ":", "metric", "=", "ErrorsWarnings", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "component", ")", ")", "\n", "}", "\n\n", "return", "&", "LoggingHook", "{", "metric", ":", "metric", "}", "\n", "}" ]

[ "NewLoggingHook", "returns", "a", "new", "instance", "of", "LoggingHook", "for", "the", "given", "Cilium", "component", "." ]

[ "func", "(", "h", "*", "LoggingHook", ")", "Levels", "(", ")", "[", "]", "logrus", ".", "Level", "{", "return", "[", "]", "logrus", ".", "Level", "{", "logrus", ".", "ErrorLevel", ",", "logrus", ".", "WarnLevel", ",", "}", "\n", "}" ]

[ "Levels", "returns", "the", "list", "of", "logging", "levels", "on", "which", "the", "hook", "is", "triggered", "." ]

[ "func", "(", "h", "*", "LoggingHook", ")", "Fire", "(", "entry", "*", "logrus", ".", "Entry", ")", "error", "{", "// Get information about subsystem from logging entry field.", "iSubsystem", ",", "ok", ":=", "entry", ".", "Data", "[", "logfields", ".", "LogSubsys", "]", "\n", "if", "!", "ok", "{", "serializedEntry", ",", "err", ":=", "entry", ".", "String", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "serializedEntry", ")", "\n", "}", "\n", "subsystem", ",", "ok", ":=", "iSubsystem", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "iSubsystem", ")", ")", "\n", "}", "\n\n", "// Increment the metric.", "h", ".", "metric", ".", "WithLabelValues", "(", "entry", ".", "Level", ".", "String", "(", ")", ",", "subsystem", ")", ".", "Inc", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Fire", "is", "the", "main", "method", "which", "is", "called", "every", "time", "when", "logger", "has", "an", "error", "or", "warning", "message", "." ]

[ "func", "NewGetPolicy", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetPolicyHandler", ")", "*", "GetPolicy", "{", "return", "&", "GetPolicy", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetPolicy", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "policy", "operation" ]

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

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

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "put", "endpoint", "Id", "failed", "response" ]

[ "func", "(", "s", "*", "Server", ")", "getNodes", "(", ")", "(", "nodeMap", ",", "error", ")", "{", "scopedLog", ":=", "log", "\n", "if", "s", ".", "CiliumURI", "!=", "\"", "\"", "{", "scopedLog", "=", "log", ".", "WithField", "(", "\"", "\"", ",", "s", ".", "CiliumURI", ")", "\n", "}", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "resp", ",", "err", ":=", "s", ".", "Daemon", ".", "GetHealthz", "(", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "if", "resp", "==", "nil", "||", "resp", ".", "Payload", "==", "nil", "||", "resp", ".", "Payload", ".", "Cluster", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "resp", ".", "Payload", ".", "Cluster", ".", "Self", "!=", "\"", "\"", "{", "s", ".", "RWMutex", ".", "Lock", "(", ")", "\n", "s", ".", "localStatus", "=", "&", "healthModels", ".", "SelfStatus", "{", "Name", ":", "resp", ".", "Payload", ".", "Cluster", ".", "Self", ",", "}", "\n", "s", ".", "RWMutex", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "nodes", ":=", "make", "(", "nodeMap", ")", "\n", "for", "_", ",", "n", ":=", "range", "resp", ".", "Payload", ".", "Cluster", ".", "Nodes", "{", "if", "n", ".", "PrimaryAddress", "!=", "nil", "{", "if", "n", ".", "PrimaryAddress", ".", "IPV4", "!=", "nil", "{", "nodes", "[", "ipString", "(", "n", ".", "PrimaryAddress", ".", "IPV4", ".", "IP", ")", "]", "=", "NewHealthNode", "(", "n", ")", "\n", "}", "\n", "if", "n", ".", "PrimaryAddress", ".", "IPV6", "!=", "nil", "{", "nodes", "[", "ipString", "(", "n", ".", "PrimaryAddress", ".", "IPV6", ".", "IP", ")", "]", "=", "NewHealthNode", "(", "n", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "addr", ":=", "range", "n", ".", "SecondaryAddresses", "{", "nodes", "[", "ipString", "(", "addr", ".", "IP", ")", "]", "=", "NewHealthNode", "(", "n", ")", "\n", "}", "\n", "if", "n", ".", "HealthEndpointAddress", "!=", "nil", "{", "if", "n", ".", "HealthEndpointAddress", ".", "IPV4", "!=", "nil", "{", "nodes", "[", "ipString", "(", "n", ".", "HealthEndpointAddress", ".", "IPV4", ".", "IP", ")", "]", "=", "NewHealthNode", "(", "n", ")", "\n", "}", "\n", "if", "n", ".", "HealthEndpointAddress", ".", "IPV6", "!=", "nil", "{", "nodes", "[", "ipString", "(", "n", ".", "HealthEndpointAddress", ".", "IPV6", ".", "IP", ")", "]", "=", "NewHealthNode", "(", "n", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nodes", ",", "nil", "\n", "}" ]

[ "getNodes", "fetches", "the", "latest", "set", "of", "nodes", "in", "the", "cluster", "from", "the", "Cilium", "daemon", "and", "updates", "the", "Server", "s", "nodes", "map", "." ]

[ "func", "(", "s", "*", "Server", ")", "updateCluster", "(", "report", "*", "healthReport", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "if", "s", ".", "connectivity", ".", "startTime", ".", "Before", "(", "report", ".", "startTime", ")", "{", "s", ".", "connectivity", "=", "report", "\n", "}", "\n", "}" ]

[ "updateCluster", "makes", "the", "specified", "health", "report", "visible", "to", "the", "API", ".", "It", "only", "updates", "the", "server", "s", "API", "-", "visible", "health", "report", "if", "the", "provided", "report", "started", "after", "the", "current", "report", "." ]

[ "func", "(", "s", "*", "Server", ")", "GetStatusResponse", "(", ")", "*", "healthModels", ".", "HealthStatusResponse", "{", "s", ".", "RLock", "(", ")", "\n", "defer", "s", ".", "RUnlock", "(", ")", "\n\n", "var", "name", "string", "\n", "// Check if localStatus is populated already. If not, the name is empty", "if", "s", ".", "localStatus", "!=", "nil", "{", "name", "=", "s", ".", "localStatus", ".", "Name", "\n", "}", "\n\n", "return", "&", "healthModels", ".", "HealthStatusResponse", "{", "Local", ":", "&", "healthModels", ".", "SelfStatus", "{", "Name", ":", "name", ",", "}", ",", "Nodes", ":", "s", ".", "connectivity", ".", "nodes", ",", "Timestamp", ":", "s", ".", "connectivity", ".", "startTime", ".", "Format", "(", "time", ".", "RFC3339", ")", ",", "}", "\n", "}" ]

[ "GetStatusResponse", "returns", "the", "most", "recent", "cluster", "connectivity", "status", "." ]

[ "func", "(", "s", "*", "Server", ")", "FetchStatusResponse", "(", ")", "(", "*", "healthModels", ".", "HealthStatusResponse", ",", "error", ")", "{", "nodes", ",", "err", ":=", "s", ".", "getNodes", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "prober", ":=", "newProber", "(", "s", ",", "nodes", ")", "\n", "if", "err", ":=", "prober", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "s", ".", "updateCluster", "(", "prober", ".", "getResults", "(", ")", ")", "\n\n", "return", "s", ".", "GetStatusResponse", "(", ")", ",", "nil", "\n", "}" ]

[ "FetchStatusResponse", "updates", "the", "cluster", "with", "the", "latest", "set", "of", "nodes", "runs", "a", "synchronous", "probe", "across", "the", "cluster", "updates", "the", "connectivity", "cache", "and", "returns", "the", "results", "." ]

[ "func", "NewServer", "(", "config", "Config", ")", "(", "*", "Server", ",", "error", ")", "{", "server", ":=", "&", "Server", "{", "startTime", ":", "time", ".", "Now", "(", ")", ",", "Config", ":", "config", ",", "tcpServers", ":", "[", "]", "*", "healthApi", ".", "Server", "{", "}", ",", "connectivity", ":", "&", "healthReport", "{", "}", ",", "}", "\n\n", "swaggerSpec", ",", "err", ":=", "loads", ".", "Analyzed", "(", "healthApi", ".", "SwaggerJSON", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "!", "config", ".", "Passive", "{", "cl", ",", "err", ":=", "ciliumPkg", ".", "NewClient", "(", "config", ".", "CiliumURI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "server", ".", "Client", "=", "cl", "\n", "server", ".", "Server", "=", "*", "server", ".", "newServer", "(", "swaggerSpec", ",", "0", ")", "\n", "}", "\n", "for", "port", ":=", "range", "PortToPaths", "{", "srv", ":=", "server", ".", "newServer", "(", "swaggerSpec", ",", "port", ")", "\n", "server", ".", "tcpServers", "=", "append", "(", "server", ".", "tcpServers", ",", "srv", ")", "\n", "}", "\n\n", "return", "server", ",", "nil", "\n", "}" ]

[ "NewServer", "creates", "a", "server", "to", "handle", "health", "requests", "." ]

[ "func", "UpdateCNPInformation", "(", ")", "{", "cnpToUpdate", ":=", "groupsCNPCache", ".", "GetAllCNP", "(", ")", "\n", "sem", ":=", "make", "(", "chan", "bool", ",", "maxConcurrentUpdates", ")", "\n", "for", "_", ",", "cnp", ":=", "range", "cnpToUpdate", "{", "sem", "<-", "true", "\n", "go", "func", "(", "cnp", "*", "cilium_v2", ".", "CiliumNetworkPolicy", ")", "{", "defer", "func", "(", ")", "{", "<-", "sem", "}", "(", ")", "\n", "addDerivativeCNP", "(", "cnp", ")", "\n\n", "}", "(", "cnp", ")", "\n", "}", "\n", "}" ]

[ "UpdateCNPInformation", "retrieves", "all", "the", "CNP", "that", "has", "currently", "a", "derivative", "policy", "and", "creates", "the", "new", "derivatives", "policies", "with", "the", "latest", "information", "from", "providers", ".", "To", "avoid", "issues", "with", "rate", "-", "limiting", "this", "function", "will", "execute", "the", "addDerivative", "function", "with", "a", "max", "number", "of", "concurrent", "calls", "defined", "on", "maxConcurrentUpdates", "." ]

[ "func", "(", "entry", "*", "cacheEntry", ")", "isExpiredBy", "(", "pointInTime", "time", ".", "Time", ")", "bool", "{", "return", "pointInTime", ".", "After", "(", "entry", ".", "ExpirationTime", ")", "\n", "}" ]

[ "isExpiredBy", "returns", "true", "if", "entry", "is", "no", "longer", "valid", "at", "pointInTime" ]

[ "func", "(", "s", "ipEntries", ")", "getIPs", "(", "now", "time", ".", "Time", ")", "[", "]", "net", ".", "IP", "{", "ips", ":=", "make", "(", "[", "]", "net", ".", "IP", ",", "0", ",", "len", "(", "s", ")", ")", "// worst case size", "\n", "for", "ip", ",", "entry", ":=", "range", "s", "{", "if", "entry", "!=", "nil", "&&", "!", "entry", ".", "isExpiredBy", "(", "now", ")", "{", "ips", "=", "append", "(", "ips", ",", "net", ".", "ParseIP", "(", "ip", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "ip", ".", "KeepUniqueIPs", "(", "ips", ")", "// sorts IPs", "\n", "}" ]

[ "getIPs", "returns", "a", "sorted", "list", "of", "non", "-", "expired", "unique", "IPs", ".", "This", "needs", "a", "read", "-", "lock" ]

[ "func", "NewDNSCache", "(", "minTTL", "int", ")", "*", "DNSCache", "{", "c", ":=", "&", "DNSCache", "{", "forward", ":", "make", "(", "map", "[", "string", "]", "ipEntries", ")", ",", "reverse", ":", "make", "(", "map", "[", "string", "]", "nameEntries", ")", ",", "lastCleanup", ":", "time", ".", "Now", "(", ")", ",", "cleanup", ":", "map", "[", "int64", "]", "[", "]", "string", "{", "}", ",", "overLimit", ":", "map", "[", "string", "]", "bool", "{", "}", ",", "perHostLimit", ":", "0", ",", "minTTL", ":", "minTTL", ",", "}", "\n", "return", "c", "\n", "}" ]

[ "NewDNSCache", "returns", "an", "initialized", "DNSCache" ]

[ "func", "NewDNSCacheWithLimit", "(", "minTTL", "int", ",", "limit", "int", ")", "*", "DNSCache", "{", "c", ":=", "NewDNSCache", "(", "minTTL", ")", "\n", "c", ".", "perHostLimit", "=", "limit", "\n", "return", "c", "\n", "}" ]

[ "NewDNSCache", "returns", "an", "initialized", "DNSCache", "and", "set", "the", "max", "host", "limit", "to", "the", "given", "argument" ]

[ "func", "(", "c", "*", "DNSCache", ")", "updateWithEntry", "(", "entry", "*", "cacheEntry", ")", "bool", "{", "changed", ":=", "false", "\n", "entries", ",", "exists", ":=", "c", ".", "forward", "[", "entry", ".", "Name", "]", "\n", "if", "!", "exists", "{", "changed", "=", "true", "\n", "entries", "=", "make", "(", "map", "[", "string", "]", "*", "cacheEntry", ")", "\n", "c", ".", "forward", "[", "entry", ".", "Name", "]", "=", "entries", "\n", "}", "\n\n", "if", "c", ".", "updateWithEntryIPs", "(", "entries", ",", "entry", ")", "{", "changed", "=", "true", "\n", "}", "\n\n", "// When lookupTime is much earlier than time.Now(), we may not expire all", "// entries that should be expired, leaving more work for .Lookup.", "if", "c", ".", "removeExpired", "(", "entries", ",", "time", ".", "Now", "(", ")", ",", "time", ".", "Time", "{", "}", ")", "{", "changed", "=", "true", "\n", "}", "\n\n", "if", "c", ".", "perHostLimit", ">", "0", "&&", "len", "(", "entries", ")", ">", "c", ".", "perHostLimit", "{", "c", ".", "overLimit", "[", "entry", ".", "Name", "]", "=", "true", "\n", "}", "\n", "return", "changed", "\n", "}" ]

[ "updateWithEntry", "implements", "the", "insertion", "of", "a", "cacheEntry", ".", "It", "is", "used", "by", "DNSCache", ".", "Update", "and", "DNSCache", ".", "UpdateWithEntry", ".", "This", "needs", "a", "write", "lock" ]

[ "func", "(", "c", "*", "DNSCache", ")", "addNameToCleanup", "(", "entry", "*", "cacheEntry", ")", "{", "if", "entry", ".", "ExpirationTime", ".", "Before", "(", "c", ".", "lastCleanup", ")", "{", "// ExpirationTime can be before the lastCleanup don't add that value to", "// prevent leaks on the map.", "return", "\n", "}", "\n", "expiration", ":=", "entry", ".", "ExpirationTime", ".", "Unix", "(", ")", "\n", "expiredEntries", ",", "exists", ":=", "c", ".", "cleanup", "[", "expiration", "]", "\n", "if", "!", "exists", "{", "expiredEntries", "=", "[", "]", "string", "{", "}", "\n", "}", "\n", "c", ".", "cleanup", "[", "expiration", "]", "=", "append", "(", "expiredEntries", ",", "entry", ".", "Name", ")", "\n", "}" ]

[ "AddNameToCleanup", "adds", "the", "IP", "with", "the", "given", "TTL", "to", "the", "the", "cleanup", "map", "to", "delete", "the", "entry", "from", "the", "policy", "when", "it", "expires", ".", "Need", "to", "be", "called", "with", "a", "write", "lock" ]

[ "func", "(", "c", "*", "DNSCache", ")", "cleanupExpiredEntries", "(", "expires", "time", ".", "Time", ")", "(", "[", "]", "string", ",", "time", ".", "Time", ")", "{", "timediff", ":=", "int", "(", "expires", ".", "Sub", "(", "c", ".", "lastCleanup", ")", ".", "Seconds", "(", ")", ")", "\n", "startTime", ":=", "c", ".", "lastCleanup", "\n", "expiredEntries", ":=", "[", "]", "string", "{", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "int", "(", "timediff", ")", ";", "i", "++", "{", "expiredTime", ":=", "c", ".", "lastCleanup", ".", "Add", "(", "time", ".", "Second", ")", "\n", "key", ":=", "expiredTime", ".", "Unix", "(", ")", "\n", "c", ".", "lastCleanup", "=", "expiredTime", "\n", "entries", ",", "exists", ":=", "c", ".", "cleanup", "[", "key", "]", "\n", "if", "!", "exists", "{", "continue", "\n", "}", "\n", "expiredEntries", "=", "append", "(", "expiredEntries", ",", "entries", "...", ")", "\n", "delete", "(", "c", ".", "cleanup", ",", "key", ")", "\n", "}", "\n\n", "result", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "name", ":=", "range", "KeepUniqueNames", "(", "expiredEntries", ")", "{", "if", "entries", ",", "exists", ":=", "c", ".", "forward", "[", "name", "]", ";", "exists", "{", "if", "!", "c", ".", "removeExpired", "(", "entries", ",", "c", ".", "lastCleanup", ",", "time", ".", "Time", "{", "}", ")", "{", "continue", "\n", "}", "\n", "result", "=", "append", "(", "result", ",", "name", ")", "\n", "}", "\n", "}", "\n", "return", "result", ",", "startTime", "\n", "}" ]

[ "cleanupExpiredEntries", "cleans", "all", "the", "expired", "entries", "from", "the", "lastTime", "that", "runs", "to", "the", "give", "time", ".", "It", "will", "lock", "the", "struct", "until", "retrieves", "all", "the", "data", ".", "It", "returns", "the", "list", "of", "names", "that", "need", "to", "be", "deleted", "from", "the", "policies", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "cleanupOverLimitEntries", "(", ")", "[", "]", "string", "{", "type", "IPEntry", "struct", "{", "ip", "string", "\n", "entry", "*", "cacheEntry", "\n", "}", "\n", "affectedNames", ":=", "[", "]", "string", "{", "}", "\n\n", "// For global cache the limit maybe is not used at all.", "if", "c", ".", "perHostLimit", "==", "0", "{", "return", "affectedNames", "\n", "}", "\n\n", "for", "dnsName", ":=", "range", "c", ".", "overLimit", "{", "entries", ",", "ok", ":=", "c", ".", "forward", "[", "dnsName", "]", "\n", "if", "!", "ok", "{", "continue", "\n", "}", "\n", "overlimit", ":=", "len", "(", "entries", ")", "-", "c", ".", "perHostLimit", "\n", "if", "overlimit", "<=", "0", "{", "continue", "\n", "}", "\n", "sortedEntries", ":=", "[", "]", "IPEntry", "{", "}", "\n", "for", "ip", ",", "entry", ":=", "range", "entries", "{", "sortedEntries", "=", "append", "(", "sortedEntries", ",", "IPEntry", "{", "ip", ",", "entry", "}", ")", "\n", "}", "\n\n", "sort", ".", "Slice", "(", "sortedEntries", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "sortedEntries", "[", "i", "]", ".", "entry", ".", "ExpirationTime", ".", "Before", "(", "sortedEntries", "[", "j", "]", ".", "entry", ".", "ExpirationTime", ")", "\n", "}", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "overlimit", ";", "i", "++", "{", "key", ":=", "sortedEntries", "[", "i", "]", "\n", "delete", "(", "entries", ",", "key", ".", "ip", ")", "\n", "c", ".", "removeReverse", "(", "key", ".", "ip", ",", "key", ".", "entry", ")", "\n", "}", "\n", "affectedNames", "=", "append", "(", "affectedNames", ",", "dnsName", ")", "\n", "}", "\n", "c", ".", "overLimit", "=", "map", "[", "string", "]", "bool", "{", "}", "\n", "return", "affectedNames", "\n", "}" ]

[ "cleanupOverLimitEntries", "returns", "the", "names", "that", "has", "reached", "the", "max", "number", "of", "IP", "per", "host", ".", "Internally", "the", "function", "sort", "the", "entries", "by", "the", "expiration", "time", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "GC", "(", ")", "[", "]", "string", "{", "c", ".", "Lock", "(", ")", "\n", "expiredEntries", ",", "_", ":=", "c", ".", "cleanupExpiredEntries", "(", "time", ".", "Now", "(", ")", ")", "\n", "overLimitEntries", ":=", "c", ".", "cleanupOverLimitEntries", "(", ")", "\n", "c", ".", "Unlock", "(", ")", "\n", "return", "KeepUniqueNames", "(", "append", "(", "expiredEntries", ",", "overLimitEntries", "...", ")", ")", "\n", "}" ]

[ "GC", "garbage", "collector", "function", "that", "clean", "expired", "entries", "and", "return", "the", "entries", "that", "are", "deleted", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "UpdateFromCache", "(", "update", "*", "DNSCache", ",", "namesToUpdate", "[", "]", "string", ")", "{", "if", "update", "==", "nil", "{", "return", "\n", "}", "\n\n", "update", ".", "RLock", "(", ")", "\n", "defer", "update", ".", "RUnlock", "(", ")", "\n\n", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "if", "len", "(", "namesToUpdate", ")", "==", "0", "{", "for", "name", ":=", "range", "update", ".", "forward", "{", "namesToUpdate", "=", "append", "(", "namesToUpdate", ",", "name", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "name", ":=", "range", "namesToUpdate", "{", "newEntries", ",", "exists", ":=", "update", ".", "forward", "[", "name", "]", "\n", "if", "!", "exists", "{", "continue", "\n", "}", "\n", "for", "_", ",", "newEntry", ":=", "range", "newEntries", "{", "c", ".", "updateWithEntry", "(", "newEntry", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "UpdateFromCache", "is", "a", "utility", "function", "that", "allows", "updating", "a", "DNSCache", "instance", "with", "all", "the", "internal", "entries", "of", "another", ".", "Latest", "-", "Expiration", "still", "applies", "thus", "the", "merged", "outcome", "is", "consistent", "with", "adding", "the", "entries", "individually", ".", "When", "namesToUpdate", "has", "non", "-", "zero", "length", "only", "those", "names", "are", "updated", "from", "update", "otherwise", "all", "DNS", "names", "in", "update", "are", "used", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "Lookup", "(", "name", "string", ")", "(", "ips", "[", "]", "net", ".", "IP", ")", "{", "c", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "lookupByTime", "(", "time", ".", "Now", "(", ")", ",", "name", ")", "\n", "}" ]

[ "Lookup", "returns", "a", "set", "of", "unique", "IPs", "that", "are", "currently", "unexpired", "for", "name", "if", "any", "exist", ".", "An", "empty", "list", "indicates", "no", "valid", "records", "exist", ".", "The", "IPs", "are", "returned", "sorted", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "lookupByTime", "(", "now", "time", ".", "Time", ",", "name", "string", ")", "(", "ips", "[", "]", "net", ".", "IP", ")", "{", "entries", ",", "found", ":=", "c", ".", "forward", "[", "name", "]", "\n", "if", "!", "found", "{", "return", "nil", "\n", "}", "\n\n", "return", "entries", ".", "getIPs", "(", "now", ")", "\n", "}" ]

[ "lookupByTime", "takes", "a", "timestamp", "for", "expiration", "comparisions", "and", "is", "only", "intended", "for", "testing", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "LookupByRegexp", "(", "re", "*", "regexp", ".", "Regexp", ")", "(", "matches", "map", "[", "string", "]", "[", "]", "net", ".", "IP", ")", "{", "return", "c", ".", "lookupByRegexpByTime", "(", "time", ".", "Now", "(", ")", ",", "re", ")", "\n", "}" ]

[ "LookupByRegexp", "returns", "all", "non", "-", "expired", "cache", "entries", "that", "match", "re", "as", "a", "map", "of", "name", "-", ">", "IPs" ]

[ "func", "(", "c", "*", "DNSCache", ")", "lookupByRegexpByTime", "(", "now", "time", ".", "Time", ",", "re", "*", "regexp", ".", "Regexp", ")", "(", "matches", "map", "[", "string", "]", "[", "]", "net", ".", "IP", ")", "{", "matches", "=", "make", "(", "map", "[", "string", "]", "[", "]", "net", ".", "IP", ")", "\n\n", "c", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "RUnlock", "(", ")", "\n\n", "for", "name", ",", "entry", ":=", "range", "c", ".", "forward", "{", "if", "re", ".", "MatchString", "(", "name", ")", "{", "matches", "[", "name", "]", "=", "append", "(", "matches", "[", "name", "]", ",", "entry", ".", "getIPs", "(", "now", ")", "...", ")", "\n", "}", "\n", "}", "\n\n", "return", "matches", "\n", "}" ]

[ "lookupByRegexpByTime", "takes", "a", "timestamp", "for", "expiration", "comparisions", "and", "is", "only", "intended", "for", "testing", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "LookupIP", "(", "ip", "net", ".", "IP", ")", "(", "names", "[", "]", "string", ")", "{", "c", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "lookupIPByTime", "(", "time", ".", "Now", "(", ")", ",", "ip", ")", "\n", "}" ]

[ "LookupIP", "returns", "all", "DNS", "names", "in", "entries", "that", "include", "that", "IP", ".", "The", "cache", "maintains", "the", "latest", "-", "expiring", "entry", "per", "-", "name", "per", "-", "IP", ".", "This", "means", "that", "multiple", "names", "referrring", "to", "the", "same", "IP", "will", "expire", "from", "the", "cache", "at", "different", "times", "and", "only", "1", "entry", "for", "each", "name", "-", "IP", "pair", "is", "internally", "retained", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "lookupIPByTime", "(", "now", "time", ".", "Time", ",", "ip", "net", ".", "IP", ")", "(", "names", "[", "]", "string", ")", "{", "ipKey", ":=", "ip", ".", "String", "(", ")", "\n", "cacheEntries", ",", "found", ":=", "c", ".", "reverse", "[", "ipKey", "]", "\n", "if", "!", "found", "{", "return", "nil", "\n", "}", "\n\n", "for", "name", ",", "entry", ":=", "range", "cacheEntries", "{", "if", "entry", "!=", "nil", "&&", "!", "entry", ".", "isExpiredBy", "(", "now", ")", "{", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "}", "\n\n", "sort", ".", "Strings", "(", "names", ")", "\n", "return", "names", "\n", "}" ]

[ "lookupIPByTime", "takes", "a", "timestamp", "for", "expiration", "comparisions", "and", "is", "only", "intended", "for", "testing", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "upsertReverse", "(", "ip", "string", ",", "entry", "*", "cacheEntry", ")", "{", "entries", ",", "exists", ":=", "c", ".", "reverse", "[", "ip", "]", "\n", "if", "entries", "==", "nil", "||", "!", "exists", "{", "entries", "=", "make", "(", "map", "[", "string", "]", "*", "cacheEntry", ")", "\n", "c", ".", "reverse", "[", "ip", "]", "=", "entries", "\n", "}", "\n", "entries", "[", "entry", ".", "Name", "]", "=", "entry", "\n", "}" ]

[ "upsertReverse", "updates", "the", "reverse", "DNS", "cache", "for", "ip", "with", "entry", "if", "it", "expires", "later", "than", "the", "already", "-", "stored", "entry", ".", "It", "is", "assumed", "that", "entry", "includes", "ip", ".", "This", "needs", "a", "write", "lock" ]

[ "func", "(", "c", "*", "DNSCache", ")", "removeReverse", "(", "ip", "string", ",", "entry", "*", "cacheEntry", ")", "{", "entries", ",", "exists", ":=", "c", ".", "reverse", "[", "ip", "]", "\n", "if", "entries", "==", "nil", "||", "!", "exists", "{", "return", "\n", "}", "\n", "delete", "(", "entries", ",", "entry", ".", "Name", ")", "\n", "if", "len", "(", "entries", ")", "==", "0", "{", "delete", "(", "c", ".", "reverse", ",", "ip", ")", "\n", "}", "\n", "}" ]

[ "removeReverse", "removes", "the", "reference", "between", "ip", "and", "the", "name", "stored", "in", "entry", ".", "When", "no", "more", "refrences", "from", "ip", "to", "any", "name", "exist", "the", "map", "entry", "is", "deleted", "outright", ".", "It", "is", "assumed", "that", "entry", "includes", "ip", ".", "This", "needs", "a", "write", "lock" ]

[ "func", "(", "c", "*", "DNSCache", ")", "ForceExpireByNames", "(", "expireLookupsBefore", "time", ".", "Time", ",", "names", "[", "]", "string", ")", "(", "namesAffected", "[", "]", "string", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "entries", ",", "exists", ":=", "c", ".", "forward", "[", "name", "]", "\n", "if", "!", "exists", "{", "continue", "\n", "}", "\n\n", "// We pass expireLookupsBefore as the `now` parameter but it is redundant", "// because LookupTime must be before ExpirationTime.", "// The second expireLookupsBefore actually matches lookup times, and will", "// delete the entries completely.", "nameNeedsRegen", ":=", "c", ".", "removeExpired", "(", "entries", ",", "expireLookupsBefore", ",", "expireLookupsBefore", ")", "\n", "if", "nameNeedsRegen", "{", "namesAffected", "=", "append", "(", "namesAffected", ",", "name", ")", "\n", "}", "\n", "}", "\n\n", "return", "namesAffected", "\n", "}" ]

[ "ForceExpireByNames", "is", "the", "same", "function", "as", "ForceExpire", "but", "uses", "the", "exact", "names", "to", "delete", "the", "entries", "." ]

[ "func", "(", "c", "*", "DNSCache", ")", "Dump", "(", ")", "(", "lookups", "[", "]", "*", "cacheEntry", ")", "{", "c", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "RUnlock", "(", ")", "\n\n", "now", ":=", "time", ".", "Now", "(", ")", "\n\n", "// Collect all the still-valid entries", "lookups", "=", "make", "(", "[", "]", "*", "cacheEntry", ",", "0", ",", "len", "(", "c", ".", "forward", ")", ")", "\n", "for", "_", ",", "entries", ":=", "range", "c", ".", "forward", "{", "for", "_", ",", "entry", ":=", "range", "entries", "{", "if", "!", "entry", ".", "isExpiredBy", "(", "now", ")", "{", "lookups", "=", "append", "(", "lookups", ",", "entry", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Dedup the entries. They are created once and are immutable so the address", "// is a unique identifier.", "// We iterate through the list, keeping unique pointers. This is correct", "// because the list is sorted and, if two consecutive entries are the same,", "// it is safe to overwrite the second duplicate.", "sort", ".", "Slice", "(", "lookups", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "uintptr", "(", "unsafe", ".", "Pointer", "(", "lookups", "[", "i", "]", ")", ")", "<", "uintptr", "(", "unsafe", ".", "Pointer", "(", "lookups", "[", "j", "]", ")", ")", "\n", "}", ")", "\n\n", "deduped", ":=", "lookups", "[", ":", "0", "]", "// len==0 but cap==cap(lookups)", "\n", "for", "readIdx", ",", "lookup", ":=", "range", "lookups", "{", "if", "readIdx", "==", "0", "||", "deduped", "[", "len", "(", "deduped", ")", "-", "1", "]", "!=", "lookups", "[", "readIdx", "]", "{", "deduped", "=", "append", "(", "deduped", ",", "lookup", ")", "\n", "}", "\n", "}", "\n\n", "return", "deduped", "\n", "}" ]

[ "Dump", "returns", "unexpired", "cache", "entries", "in", "the", "cache", ".", "They", "are", "deduplicated", "but", "not", "usefully", "sorted", ".", "These", "objects", "should", "not", "be", "modified", "." ]

[ "func", "(", "proxyStat", "*", "ProxyRequestContext", ")", "IsTimeout", "(", ")", "bool", "{", "netErr", ",", "isNetErr", ":=", "proxyStat", ".", "Err", ".", "(", "net", ".", "Error", ")", "\n", "if", "isNetErr", "&&", "netErr", ".", "Timeout", "(", ")", "{", "return", "true", "\n\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsTimeout", "return", "true", "if", "the", "ProxyRequest", "timeout" ]

[ "func", "StartDNSProxy", "(", "address", "string", ",", "port", "uint16", ",", "lookupEPFunc", "LookupEndpointIDByIPFunc", ",", "notifyFunc", "NotifyOnDNSMsgFunc", ")", "(", "*", "DNSProxy", ",", "error", ")", "{", "if", "port", "==", "0", "{", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "lookupEPFunc", "==", "nil", "||", "notifyFunc", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "p", ":=", "&", "DNSProxy", "{", "LookupEndpointIDByIP", ":", "lookupEPFunc", ",", "NotifyOnDNSMsg", ":", "notifyFunc", ",", "lookupTargetDNSServer", ":", "lookupTargetDNSServer", ",", "allowed", ":", "regexpmap", ".", "NewRegexpMap", "(", ")", ",", "rejectReply", ":", "dns", ".", "RcodeRefused", ",", "}", "\n\n", "// Start the DNS listeners on UDP and TCP", "var", "(", "UDPConn", "*", "net", ".", "UDPConn", "\n", "TCPListener", "*", "net", ".", "TCPListener", "\n", "err", "error", "\n", ")", "\n\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "for", "time", ".", "Since", "(", "start", ")", "<", "ProxyBindTimeout", "{", "UDPConn", ",", "TCPListener", ",", "err", "=", "bindToAddr", "(", "address", ",", "port", ")", "\n", "if", "err", "==", "nil", "{", "break", "\n", "}", "\n", "log", ".", "WithError", "(", "err", ")", ".", "Warnf", "(", "\"", "\"", ",", "ProxyBindRetryInterval", ")", "\n", "time", ".", "Sleep", "(", "ProxyBindRetryInterval", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "p", ".", "BindAddr", "=", "UDPConn", ".", "LocalAddr", "(", ")", ".", "String", "(", ")", "\n", "p", ".", "BindPort", "=", "uint16", "(", "UDPConn", ".", "LocalAddr", "(", ")", ".", "(", "*", "net", ".", "UDPAddr", ")", ".", "Port", ")", "\n", "p", ".", "UDPServer", "=", "&", "dns", ".", "Server", "{", "PacketConn", ":", "UDPConn", ",", "Addr", ":", "p", ".", "BindAddr", ",", "Net", ":", "\"", "\"", ",", "Handler", ":", "p", ",", "SessionUDPFactory", ":", "ciliumSessionUDPFactory", ",", "}", "\n", "p", ".", "TCPServer", "=", "&", "dns", ".", "Server", "{", "Listener", ":", "TCPListener", ",", "Addr", ":", "p", ".", "BindAddr", ",", "Net", ":", "\"", "\"", ",", "Handler", ":", "p", "}", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "p", ".", "BindAddr", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "for", "_", ",", "s", ":=", "range", "[", "]", "*", "dns", ".", "Server", "{", "p", ".", "UDPServer", ",", "p", ".", "TCPServer", "}", "{", "go", "func", "(", "server", "*", "dns", ".", "Server", ")", "{", "// try 5 times during a single ProxyBindTimeout period. We fatal here", "// because we have no other way to indicate failure this late.", "start", ":=", "time", ".", "Now", "(", ")", "\n", "for", "time", ".", "Since", "(", "start", ")", "<", "ProxyBindTimeout", "{", "if", "err", ":=", "server", ".", "ActivateAndServe", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "server", ".", "Net", ",", "server", ".", "Addr", ")", "\n", "}", "\n", "time", ".", "Sleep", "(", "ProxyBindRetryInterval", ")", "\n", "}", "\n", "log", ".", "Fatalf", "(", "\"", "\"", ",", "server", ".", "Net", ",", "server", ".", "Addr", ")", "\n", "}", "(", "s", ")", "\n", "}", "\n\n", "// Bind the DNS forwarding clients on UDP and TCP", "p", ".", "UDPClient", "=", "&", "dns", ".", "Client", "{", "Net", ":", "\"", "\"", ",", "Timeout", ":", "ProxyForwardTimeout", ",", "SingleInflight", ":", "true", "}", "\n", "p", ".", "TCPClient", "=", "&", "dns", ".", "Client", "{", "Net", ":", "\"", "\"", ",", "Timeout", ":", "ProxyForwardTimeout", ",", "SingleInflight", ":", "true", "}", "\n\n", "return", "p", ",", "nil", "\n", "}" ]

[ "address", "and", "port", ".", "address", "is", "the", "bind", "address", "to", "listen", "on", ".", "Empty", "binds", "to", "all", "local", "addresses", ".", "port", "is", "the", "port", "to", "bind", "to", "for", "both", "UDP", "and", "TCP", ".", "0", "causes", "the", "kernel", "to", "select", "a", "free", "port", ".", "lookupEPFunc", "will", "be", "called", "with", "the", "source", "IP", "of", "DNS", "requests", "and", "expects", "a", "unique", "identifier", "for", "the", "endpoint", "that", "made", "the", "request", ".", "notifyFunc", "will", "be", "called", "with", "DNS", "response", "data", "that", "is", "returned", "to", "a", "requesting", "endpoint", ".", "Note", "that", "denied", "requests", "will", "not", "trigger", "this", "callback", "." ]

[ "func", "(", "p", "*", "DNSProxy", ")", "AddAllowed", "(", "reStr", ",", "endpointID", "string", ")", "{", "log", ".", "WithField", "(", "logfields", ".", "DNSName", ",", "reStr", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "p", ".", "UpdateAllowed", "(", "[", "]", "string", "{", "reStr", "}", ",", "nil", ",", "endpointID", ")", "\n", "}" ]

[ "AddAllowed", "adds", "reStr", "a", "regexp", "to", "the", "DNS", "lookups", "the", "proxy", "allows", "." ]

[ "func", "(", "p", "*", "DNSProxy", ")", "UpdateAllowed", "(", "reStrToAdd", ",", "reStrToRemove", "[", "]", "string", ",", "endpointID", "string", ")", "{", "for", "i", ":=", "range", "reStrToAdd", "{", "reStrToAdd", "[", "i", "]", "=", "prepareNameMatch", "(", "reStrToAdd", "[", "i", "]", ")", "\n", "}", "\n", "for", "i", ":=", "range", "reStrToRemove", "{", "reStrToRemove", "[", "i", "]", "=", "prepareNameMatch", "(", "reStrToRemove", "[", "i", "]", ")", "\n", "}", "\n\n", "p", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "reStr", ":=", "range", "reStrToRemove", "{", "p", ".", "allowed", ".", "Remove", "(", "reStr", ",", "endpointID", ")", "\n", "}", "\n", "for", "_", ",", "reStr", ":=", "range", "reStrToAdd", "{", "p", ".", "allowed", ".", "Add", "(", "reStr", ",", "endpointID", ")", "\n", "}", "\n", "}" ]

[ "UpdateAllowed", "adds", "and", "removes", "reStr", "while", "holding", "the", "lock", ".", "This", "is", "a", "bit", "of", "a", "hack", "to", "ensure", "atomic", "updates", "of", "rules", "until", "we", "replace", "the", "tracking", "with", "something", "better", "." ]

[ "func", "(", "p", "*", "DNSProxy", ")", "sendRefused", "(", "scopedLog", "*", "logrus", ".", "Entry", ",", "w", "dns", ".", "ResponseWriter", ",", "request", "*", "dns", ".", "Msg", ")", "(", "err", "error", ")", "{", "refused", ":=", "new", "(", "dns", ".", "Msg", ")", "\n", "refused", ".", "SetRcode", "(", "request", ",", "p", ".", "rejectReply", ")", "\n\n", "if", "err", "=", "w", ".", "WriteMsg", "(", "refused", ")", ";", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "sendRefused", "creates", "and", "sends", "a", "REFUSED", "response", "for", "request", "to", "w", "The", "returned", "error", "is", "logged", "with", "scopedLog", "and", "is", "returned", "for", "convenience" ]

[ "func", "(", "p", "*", "DNSProxy", ")", "SetRejectReply", "(", "opt", "string", ")", "{", "switch", "strings", ".", "ToLower", "(", "opt", ")", "{", "case", "strings", ".", "ToLower", "(", "option", ".", "FQDNProxyDenyWithNameError", ")", ":", "p", ".", "rejectReply", "=", "dns", ".", "RcodeNameError", "\n", "case", "strings", ".", "ToLower", "(", "option", ".", "FQDNProxyDenyWithRefused", ")", ":", "p", ".", "rejectReply", "=", "dns", ".", "RcodeRefused", "\n", "default", ":", "log", ".", "Infof", "(", "\"", "\"", ",", "opt", ",", "option", ".", "FQDNRejectOptions", ")", "\n", "return", "\n", "}", "\n", "}" ]

[ "SetRejectReply", "sets", "the", "default", "reject", "reply", "on", "denied", "dns", "responses", "." ]

[ "func", "ExtractMsgDetails", "(", "msg", "*", "dns", ".", "Msg", ")", "(", "qname", "string", ",", "responseIPs", "[", "]", "net", ".", "IP", ",", "TTL", "uint32", ",", "CNAMEs", "[", "]", "string", ",", "rcode", "int", ",", "answerTypes", "[", "]", "uint16", ",", "qTypes", "[", "]", "uint16", ",", "err", "error", ")", "{", "if", "len", "(", "msg", ".", "Question", ")", "==", "0", "{", "return", "\"", "\"", ",", "nil", ",", "0", ",", "nil", ",", "0", ",", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "qname", "=", "strings", ".", "ToLower", "(", "string", "(", "msg", ".", "Question", "[", "0", "]", ".", "Name", ")", ")", "\n\n", "// rrName is the name the next RR should include.", "// This will change when we see CNAMEs.", "rrName", ":=", "strings", ".", "ToLower", "(", "qname", ")", "\n\n", "TTL", "=", "math", ".", "MaxUint32", "// a TTL must exist in the RRs", "\n\n", "answerTypes", "=", "make", "(", "[", "]", "uint16", ",", "0", ",", "len", "(", "msg", ".", "Answer", ")", ")", "\n", "for", "_", ",", "ans", ":=", "range", "msg", ".", "Answer", "{", "// Ensure we have records for DNS names we expect", "if", "strings", ".", "ToLower", "(", "ans", ".", "Header", "(", ")", ".", "Name", ")", "!=", "rrName", "{", "return", "qname", ",", "nil", ",", "0", ",", "nil", ",", "0", ",", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ans", ",", "rrName", ",", "qname", ")", "\n", "}", "\n\n", "// Handle A, AAAA and CNAME records by accumulating IPs and lowest TTL", "switch", "ans", ":=", "ans", ".", "(", "type", ")", "{", "case", "*", "dns", ".", "A", ":", "responseIPs", "=", "append", "(", "responseIPs", ",", "ans", ".", "A", ")", "\n", "if", "TTL", ">", "ans", ".", "Hdr", ".", "Ttl", "{", "TTL", "=", "ans", ".", "Hdr", ".", "Ttl", "\n", "}", "\n", "case", "*", "dns", ".", "AAAA", ":", "responseIPs", "=", "append", "(", "responseIPs", ",", "ans", ".", "AAAA", ")", "\n", "if", "TTL", ">", "ans", ".", "Hdr", ".", "Ttl", "{", "TTL", "=", "ans", ".", "Hdr", ".", "Ttl", "\n", "}", "\n", "case", "*", "dns", ".", "CNAME", ":", "// We still track the TTL because the lowest TTL in the chain", "// determines the valid caching time for the whole response.", "if", "TTL", ">", "ans", ".", "Hdr", ".", "Ttl", "{", "TTL", "=", "ans", ".", "Hdr", ".", "Ttl", "\n", "}", "\n", "rrName", "=", "strings", ".", "ToLower", "(", "ans", ".", "Target", ")", "\n", "CNAMEs", "=", "append", "(", "CNAMEs", ",", "ans", ".", "Target", ")", "\n", "}", "\n", "answerTypes", "=", "append", "(", "answerTypes", ",", "ans", ".", "Header", "(", ")", ".", "Rrtype", ")", "\n", "}", "\n\n", "qTypes", "=", "make", "(", "[", "]", "uint16", ",", "0", ",", "len", "(", "msg", ".", "Question", ")", ")", "\n", "for", "_", ",", "q", ":=", "range", "msg", ".", "Question", "{", "qTypes", "=", "append", "(", "qTypes", ",", "q", ".", "Qtype", ")", "\n", "}", "\n\n", "return", "qname", ",", "responseIPs", ",", "TTL", ",", "CNAMEs", ",", "msg", ".", "Rcode", ",", "answerTypes", ",", "qTypes", ",", "nil", "\n", "}" ]

[ "ExtractMsgDetails", "extracts", "a", "canonical", "query", "name", "any", "IPs", "in", "a", "response", "the", "lowest", "applicable", "TTL", "rcode", "anwer", "rr", "types", "and", "question", "types", "When", "a", "CNAME", "is", "returned", "the", "chain", "is", "collapsed", "down", "keeping", "the", "lowest", "TTL", "and", "CNAME", "targets", "are", "returned", "." ]

[ "func", "NewNodeMonitor", "(", "queueSize", "int", ")", "*", "NodeMonitor", "{", "nm", ":=", "&", "NodeMonitor", "{", "queue", ":", "make", "(", "chan", "[", "]", "byte", ",", "queueSize", ")", ",", "}", "\n\n", "go", "nm", ".", "eventDrainer", "(", ")", "\n\n", "return", "nm", "\n", "}" ]

[ "NewNodeMonitor", "returns", "a", "new", "node", "monitor" ]

[ "func", "(", "nm", "*", "NodeMonitor", ")", "run", "(", "sockPath", ",", "bpfRoot", "string", ")", "error", "{", "os", ".", "Remove", "(", "sockPath", ")", "\n", "if", "err", ":=", "syscall", ".", "Mkfifo", "(", "sockPath", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sockPath", ",", "err", ")", "\n", "}", "\n\n", "defer", "os", ".", "Remove", "(", "sockPath", ")", "\n\n", "pipe", ",", "err", ":=", "os", ".", "OpenFile", "(", "sockPath", ",", "os", ".", "O_RDWR", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "defer", "pipe", ".", "Close", "(", ")", "\n\n", "nm", ".", "pipeLock", ".", "Lock", "(", ")", "\n", "nm", ".", "pipe", "=", "pipe", "\n", "nm", ".", "pipeLock", ".", "Unlock", "(", ")", "\n\n", "nm", ".", "Launcher", ".", "SetArgs", "(", "[", "]", "string", "{", "\"", "\"", ",", "bpfRoot", "}", ")", "\n", "if", "err", ":=", "nm", ".", "Launcher", ".", "Run", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "metrics", ".", "SubprocessStart", ".", "WithLabelValues", "(", "targetName", ")", ".", "Inc", "(", ")", "\n\n", "r", ":=", "bufio", ".", "NewReader", "(", "nm", ".", "GetStdout", "(", ")", ")", "\n", "for", "nm", ".", "GetProcess", "(", ")", "!=", "nil", "{", "l", ",", "err", ":=", "r", ".", "ReadBytes", "(", "'\\n'", ")", "// this is a blocking read", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "var", "tmp", "*", "models", ".", "MonitorStatus", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "l", ",", "&", "tmp", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "nm", ".", "setState", "(", "tmp", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "run", "creates", "a", "FIFO", "at", "sockPath", "launches", "the", "monitor", "as", "sub", "process", "and", "then", "reads", "stdout", "from", "the", "monitor", "and", "updates", "nm", ".", "state", "accordingly", ".", "The", "function", "returns", "with", "an", "error", "if", "the", "FIFO", "cannot", "be", "created", "opened", "or", "if", "the", "an", "error", "was", "encountered", "while", "reading", "stdout", "from", "the", "monitor", ".", "The", "FIFO", "is", "always", "removed", "again", "when", "the", "function", "returns", "." ]

[ "func", "(", "nm", "*", "NodeMonitor", ")", "Run", "(", "sockPath", ",", "bpfRoot", "string", ")", "{", "backoffConfig", ":=", "backoff", ".", "Exponential", "{", "Min", ":", "time", ".", "Second", ",", "Max", ":", "2", "*", "time", ".", "Minute", "}", "\n\n", "nm", ".", "SetTarget", "(", "targetName", ")", "\n", "for", "{", "if", "err", ":=", "nm", ".", "run", "(", "sockPath", ",", "bpfRoot", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n\n", "backoffConfig", ".", "Wait", "(", "context", ".", "TODO", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "Run", "starts", "the", "node", "monitor", "and", "keeps", "on", "restarting", "it", ".", "The", "function", "will", "never", "return", "." ]

[ "func", "(", "nm", "*", "NodeMonitor", ")", "State", "(", ")", "*", "models", ".", "MonitorStatus", "{", "nm", ".", "Mutex", ".", "RLock", "(", ")", "\n", "state", ":=", "nm", ".", "state", "\n", "nm", ".", "Mutex", ".", "RUnlock", "(", ")", "\n", "return", "state", "\n", "}" ]

[ "State", "returns", "the", "monitor", "status", "." ]

[ "func", "(", "nm", "*", "NodeMonitor", ")", "setState", "(", "state", "*", "models", ".", "MonitorStatus", ")", "{", "nm", ".", "Mutex", ".", "Lock", "(", ")", "\n", "nm", ".", "state", "=", "state", "\n", "nm", ".", "Mutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "setState", "sets", "the", "internal", "state", "monitor", "with", "the", "given", "state", "." ]

[ "func", "(", "nm", "*", "NodeMonitor", ")", "SendEvent", "(", "typ", "int", ",", "event", "interface", "{", "}", ")", "error", "{", "var", "buf", "bytes", ".", "Buffer", "\n\n", "if", "err", ":=", "gob", ".", "NewEncoder", "(", "&", "buf", ")", ".", "Encode", "(", "event", ")", ";", "err", "!=", "nil", "{", "nm", ".", "bumpLost", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "select", "{", "case", "nm", ".", "queue", "<-", "append", "(", "[", "]", "byte", "{", "byte", "(", "typ", ")", "}", ",", "buf", ".", "Bytes", "(", ")", "...", ")", ":", "default", ":", "nm", ".", "bumpLost", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SendEvent", "sends", "an", "event", "to", "the", "node", "monitor", "which", "will", "then", "distribute", "to", "all", "monitor", "listeners" ]

[ "func", "(", "nm", "*", "NodeMonitor", ")", "bumpLost", "(", ")", "{", "nm", ".", "pipeLock", ".", "Lock", "(", ")", "\n", "nm", ".", "lost", "++", "\n", "nm", ".", "pipeLock", ".", "Unlock", "(", ")", "\n", "}" ]

[ "bumpLost", "accounts", "for", "a", "lost", "notification" ]

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

[ "WithTimeout", "adds", "the", "timeout", "to", "the", "put", "status", "probe", "params" ]

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

[ "WithContext", "adds", "the", "context", "to", "the", "put", "status", "probe", "params" ]

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

[ "WithHTTPClient", "adds", "the", "HTTPClient", "to", "the", "put", "status", "probe", "params" ]

[ "func", "GetEnvoyVersion", "(", ")", "string", "{", "out", ",", "err", ":=", "exec", ".", "Command", "(", "ciliumEnvoy", ",", "\"", "\"", ")", ".", "Output", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Fatalf", "(", "\"", "\"", ",", "ciliumEnvoy", ")", "\n", "}", "\n", "return", "strings", ".", "TrimSpace", "(", "string", "(", "out", ")", ")", "\n", "}" ]

[ "GetEnvoyVersion", "returns", "the", "envoy", "binary", "version", "string" ]

[ "func", "newEnvoyLogPiper", "(", ")", "io", ".", "WriteCloser", "{", "reader", ",", "writer", ":=", "io", ".", "Pipe", "(", ")", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "reader", ")", "\n", "go", "func", "(", ")", "{", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "LogSubsys", ":", "\"", "\"", ",", "logfields", ".", "ThreadID", ":", "\"", "\"", ",", "}", ")", "\n", "level", ":=", "\"", "\"", "\n\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "var", "msg", "string", "\n\n", "parts", ":=", "strings", ".", "SplitN", "(", "line", ",", "\"", "\"", ",", "4", ")", "\n", "// Parse the line as a log message written by Envoy, assuming it", "// uses the configured format: \"%t|%l|%n|%v\".", "if", "len", "(", "parts", ")", "==", "4", "{", "threadID", ":=", "parts", "[", "0", "]", "\n", "level", "=", "parts", "[", "1", "]", "\n", "loggerName", ":=", "parts", "[", "2", "]", "\n", "// TODO: Parse msg to extract the source filename, line number, etc.", "msg", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "parts", "[", "3", "]", ")", "\n\n", "scopedLog", "=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "LogSubsys", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "loggerName", ")", ",", "logfields", ".", "ThreadID", ":", "threadID", ",", "}", ")", "\n", "}", "else", "{", "// If this line can't be parsed, it continues a multi-line log", "// message. In this case, log it at the same level and with the", "// same fields as the previous line.", "msg", "=", "line", "\n", "}", "\n\n", "if", "len", "(", "msg", ")", "==", "0", "{", "continue", "\n", "}", "\n\n", "// Map the Envoy log level to a logrus level.", "switch", "level", "{", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "scopedLog", ".", "Error", "(", "msg", ")", "\n", "case", "\"", "\"", ":", "scopedLog", ".", "Warn", "(", "msg", ")", "\n", "case", "\"", "\"", ":", "scopedLog", ".", "Info", "(", "msg", ")", "\n", "case", "\"", "\"", ",", "\"", "\"", ":", "scopedLog", ".", "Debug", "(", "msg", ")", "\n", "default", ":", "scopedLog", ".", "Debug", "(", "msg", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "reader", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "return", "writer", "\n", "}" ]

[ "newEnvoyLogPiper", "creates", "a", "writer", "that", "parses", "and", "logs", "log", "messages", "written", "by", "Envoy", "." ]

[ "func", "isEOF", "(", "err", "error", ")", "bool", "{", "strerr", ":=", "err", ".", "Error", "(", ")", "\n", "errlen", ":=", "len", "(", "strerr", ")", "\n", "return", "errlen", ">=", "3", "&&", "strerr", "[", "errlen", "-", "3", ":", "]", "==", "io", ".", "EOF", ".", "Error", "(", ")", "\n", "}" ]

[ "isEOF", "returns", "true", "if", "the", "error", "message", "ends", "in", "EOF", ".", "ReadMsgUnix", "returns", "extra", "info", "in", "the", "beginning", "." ]

[ "func", "(", "e", "*", "Envoy", ")", "StopEnvoy", "(", ")", "error", "{", "close", "(", "e", ".", "stopCh", ")", "\n", "err", ",", "ok", ":=", "<-", "e", ".", "errCh", "\n", "if", "ok", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "StopEnvoy", "kills", "the", "Envoy", "process", "started", "with", "StartEnvoy", ".", "The", "gRPC", "API", "streams", "are", "terminated", "first", "." ]

[ "func", "(", "e", "*", "Envoy", ")", "ChangeLogLevel", "(", "level", "logrus", ".", "Level", ")", "{", "e", ".", "admin", ".", "changeLogLevel", "(", "level", ")", "\n", "}" ]

[ "ChangeLogLevel", "changes", "Envoy", "log", "level", "to", "correspond", "to", "the", "logrus", "log", "level", "level", "." ]

[ "func", "New", "(", "code", "int", ",", "msg", "string", ",", "args", "...", "interface", "{", "}", ")", "*", "APIError", "{", "if", "code", "<=", "0", "{", "code", "=", "500", "\n", "}", "\n\n", "if", "len", "(", "args", ")", ">", "0", "{", "return", "&", "APIError", "{", "code", ":", "code", ",", "msg", ":", "fmt", ".", "Sprintf", "(", "msg", ",", "args", "...", ")", "}", "\n", "}", "\n", "return", "&", "APIError", "{", "code", ":", "code", ",", "msg", ":", "msg", "}", "\n", "}" ]

[ "New", "creates", "a", "API", "error", "from", "the", "code", "msg", "and", "extra", "arguments", "." ]

[ "func", "Error", "(", "code", "int", ",", "err", "error", ")", "*", "APIError", "{", "if", "err", "==", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "New", "(", "code", ",", "err", ".", "Error", "(", ")", ")", "\n", "}" ]

[ "Error", "creates", "a", "new", "API", "error", "from", "the", "code", "and", "error", "." ]

[ "func", "(", "a", "*", "APIError", ")", "GetModel", "(", ")", "*", "models", ".", "Error", "{", "m", ":=", "models", ".", "Error", "(", "a", ".", "msg", ")", "\n", "return", "&", "m", "\n", "}" ]

[ "GetModel", "returns", "model", "error", "." ]

[ "func", "(", "a", "*", "APIError", ")", "WriteResponse", "(", "rw", "http", ".", "ResponseWriter", ",", "producer", "runtime", ".", "Producer", ")", "{", "rw", ".", "WriteHeader", "(", "a", ".", "code", ")", "\n", "m", ":=", "a", ".", "GetModel", "(", ")", "\n", "if", "err", ":=", "producer", ".", "Produce", "(", "rw", ",", "m", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "}" ]

[ "WriteResponse", "to", "the", "client", "." ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "put", "status", "probe", "o", "k", "response" ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "put", "status", "probe", "failed", "response" ]