Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.5k

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

[ "WithTimeout", "adds", "the", "timeout", "to", "the", "get", "service", "ID", "params" ]

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

[ "WithContext", "adds", "the", "context", "to", "the", "get", "service", "ID", "params" ]

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

[ "WithHTTPClient", "adds", "the", "HTTPClient", "to", "the", "get", "service", "ID", "params" ]

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

[ "WithID", "adds", "the", "id", "to", "the", "get", "service", "ID", "params" ]

[ "func", "GetPolicyLabels", "(", "ns", ",", "name", "string", ",", "uid", "types", ".", "UID", ",", "derivedFrom", "string", ")", "labels", ".", "LabelArray", "{", "// Keep labels sorted by the key.", "return", "labels", ".", "LabelArray", "{", "labels", ".", "NewLabel", "(", "k8sConst", ".", "PolicyLabelDerivedFrom", ",", "derivedFrom", ",", "labels", ".", "LabelSourceK8s", ")", ",", "labels", ".", "NewLabel", "(", "k8sConst", ".", "PolicyLabelName", ",", "name", ",", "labels", ".", "LabelSourceK8s", ")", ",", "labels", ".", "NewLabel", "(", "k8sConst", ".", "PolicyLabelNamespace", ",", "ns", ",", "labels", ".", "LabelSourceK8s", ")", ",", "labels", ".", "NewLabel", "(", "k8sConst", ".", "PolicyLabelUID", ",", "string", "(", "uid", ")", ",", "labels", ".", "LabelSourceK8s", ")", ",", "}", "\n", "}" ]

[ "GetPolicyLabels", "returns", "a", "LabelArray", "for", "the", "given", "namespace", "and", "name", "." ]

[ "func", "getEndpointSelector", "(", "namespace", "string", ",", "labelSelector", "*", "metav1", ".", "LabelSelector", ",", "addK8sPrefix", ",", "matchesInit", "bool", ")", "api", ".", "EndpointSelector", "{", "es", ":=", "api", ".", "NewESFromK8sLabelSelector", "(", "\"", "\"", ",", "labelSelector", ")", "\n\n", "// The k8s prefix must not be added to reserved labels.", "if", "addK8sPrefix", "&&", "es", ".", "HasKeyPrefix", "(", "labels", ".", "LabelSourceReservedKeyPrefix", ")", "{", "return", "es", "\n", "}", "\n\n", "// The user can explicitly specify the namespace in the", "// FromEndpoints selector. If omitted, we limit the", "// scope to the namespace the policy lives in.", "//", "// Policies applying on initializing pods are a special case.", "// Those pods don't have any labels, so they don't have a namespace label either.", "// Don't add a namespace label to those endpoint selectors, or we wouldn't be", "// able to match on those pods.", "if", "!", "matchesInit", "&&", "!", "es", ".", "HasKey", "(", "podPrefixLbl", ")", "&&", "!", "es", ".", "HasKey", "(", "podAnyPrefixLbl", ")", "{", "es", ".", "AddMatch", "(", "podPrefixLbl", ",", "namespace", ")", "\n", "}", "\n\n", "return", "es", "\n", "}" ]

[ "getEndpointSelector", "converts", "the", "provided", "labelSelector", "into", "an", "EndpointSelector", "adding", "the", "relevant", "matches", "for", "namespaces", "based", "on", "the", "provided", "options", "." ]

[ "func", "namespacesAreValid", "(", "namespace", "string", ",", "userNamespaces", "[", "]", "string", ")", "bool", "{", "return", "len", "(", "userNamespaces", ")", "==", "0", "||", "(", "len", "(", "userNamespaces", ")", "==", "1", "&&", "userNamespaces", "[", "0", "]", "==", "namespace", ")", "\n", "}" ]

[ "namespacesAreValid", "checks", "the", "set", "of", "namespaces", "from", "a", "rule", "returns", "true", "if", "they", "are", "not", "specified", "or", "if", "they", "are", "specified", "and", "match", "the", "namespace", "where", "the", "rule", "is", "being", "inserted", "." ]

[ "func", "ParseToCiliumRule", "(", "namespace", ",", "name", "string", ",", "uid", "types", ".", "UID", ",", "r", "*", "api", ".", "Rule", ")", "*", "api", ".", "Rule", "{", "retRule", ":=", "&", "api", ".", "Rule", "{", "}", "\n", "if", "r", ".", "EndpointSelector", ".", "LabelSelector", "!=", "nil", "{", "retRule", ".", "EndpointSelector", "=", "api", ".", "NewESFromK8sLabelSelector", "(", "\"", "\"", ",", "r", ".", "EndpointSelector", ".", "LabelSelector", ")", "\n", "// The PodSelector should only reflect to the same namespace", "// the policy is being stored, thus we add the namespace to", "// the MatchLabels map.", "//", "// Policies applying on initializing pods are a special case.", "// Those pods don't have any labels, so they don't have a namespace label either.", "// Don't add a namespace label to those endpoint selectors, or we wouldn't be", "// able to match on those pods.", "if", "!", "retRule", ".", "EndpointSelector", ".", "HasKey", "(", "podInitLbl", ")", "{", "userNamespace", ",", "present", ":=", "r", ".", "EndpointSelector", ".", "GetMatch", "(", "podPrefixLbl", ")", "\n", "if", "present", "&&", "!", "namespacesAreValid", "(", "namespace", ",", "userNamespace", ")", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "K8sNamespace", ":", "namespace", ",", "logfields", ".", "CiliumNetworkPolicyName", ":", "name", ",", "logfields", ".", "K8sNamespace", "+", "\"", "\"", ":", "userNamespace", ",", "}", ")", ".", "Warn", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "}", "\n", "retRule", ".", "EndpointSelector", ".", "AddMatch", "(", "podPrefixLbl", ",", "namespace", ")", "\n", "}", "\n", "}", "\n\n", "parseToCiliumIngressRule", "(", "namespace", ",", "r", ",", "retRule", ")", "\n", "parseToCiliumEgressRule", "(", "namespace", ",", "r", ",", "retRule", ")", "\n\n", "retRule", ".", "Labels", "=", "ParseToCiliumLabels", "(", "namespace", ",", "name", ",", "uid", ",", "r", ".", "Labels", ")", "\n\n", "retRule", ".", "Description", "=", "r", ".", "Description", "\n\n", "return", "retRule", "\n", "}" ]

[ "ParseToCiliumRule", "returns", "an", "api", ".", "Rule", "with", "all", "the", "labels", "parsed", "into", "cilium", "labels", "." ]

[ "func", "ParseToCiliumLabels", "(", "namespace", ",", "name", "string", ",", "uid", "types", ".", "UID", ",", "ruleLbs", "labels", ".", "LabelArray", ")", "labels", ".", "LabelArray", "{", "policyLbls", ":=", "GetPolicyLabels", "(", "namespace", ",", "name", ",", "uid", ",", "ResourceTypeCiliumNetworkPolicy", ")", "\n", "return", "append", "(", "policyLbls", ",", "ruleLbs", "...", ")", ".", "Sort", "(", ")", "\n", "}" ]

[ "ParseToCiliumLabels", "returns", "all", "ruleLbls", "appended", "with", "a", "specific", "label", "that", "represents", "the", "given", "namespace", "and", "name", "along", "with", "a", "label", "that", "specifies", "these", "labels", "were", "derived", "from", "a", "CiliumNetworkPolicy", "." ]

[ "func", "(", "m", "*", "IptablesManager", ")", "Init", "(", ")", "{", "modulesManager", ":=", "&", "modules", ".", "ModulesManager", "{", "}", "\n", "ip6tables", ":=", "true", "\n", "if", "err", ":=", "modulesManager", ".", "Init", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "modulesManager", ".", "FindOrLoadModules", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "modulesManager", ".", "FindOrLoadModules", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "if", "option", ".", "Config", ".", "EnableIPv6", "{", "log", ".", "WithError", "(", "err", ")", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "log", ".", "WithError", "(", "err", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "ip6tables", "=", "false", "\n", "}", "\n", "m", ".", "ip6tables", "=", "ip6tables", "\n", "}" ]

[ "Init", "initializes", "the", "iptables", "manager", "and", "checks", "for", "iptables", "kernel", "modules", "availability", "." ]

[ "func", "(", "m", "*", "IptablesManager", ")", "RemoveRules", "(", ")", "{", "// Set of tables that have had iptables rules in any Cilium version", "tables", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "for", "_", ",", "t", ":=", "range", "tables", "{", "removeCiliumRules", "(", "t", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Set of tables that have had ip6tables rules in any Cilium version", "if", "m", ".", "ip6tables", "{", "tables6", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "for", "_", ",", "t", ":=", "range", "tables6", "{", "removeCiliumRules", "(", "t", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "c", ":=", "range", "ciliumChains", "{", "c", ".", "remove", "(", ")", "\n", "}", "\n", "}" ]

[ "RemoveRules", "removes", "iptables", "rules", "installed", "by", "Cilium", "." ]

[ "func", "iptProxyRules", "(", "cmd", "string", ",", "proxyPort", "uint16", ",", "ingress", "bool", ",", "name", "string", ")", "error", "{", "// Redirect packets to the host proxy via TPROXY, as directed by the Cilium", "// datapath bpf programs via skb marks (egress) or DSCP (ingress).", "if", "ingress", "{", "if", "err", ":=", "iptIngressProxyRule", "(", "cmd", ",", "\"", "\"", ",", "proxyPort", ",", "name", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "iptIngressProxyRule", "(", "cmd", ",", "\"", "\"", ",", "proxyPort", ",", "name", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "if", "err", ":=", "iptEgressProxyRule", "(", "cmd", ",", "\"", "\"", ",", "proxyPort", ",", "name", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "iptEgressProxyRule", "(", "cmd", ",", "\"", "\"", ",", "proxyPort", ",", "name", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "install", "or", "remove", "rules", "for", "a", "single", "proxy", "port" ]

[ "func", "(", "m", "*", "EndpointHealth", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateBpf", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateOverallHealth", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validatePolicy", "(", "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", "endpoint", "health" ]

[ "func", "(", "m", "*", "PrefilterStatus", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateRealized", "(", "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", "prefilter", "status" ]

[ "func", "NewGetMetrics", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetMetricsHandler", ")", "*", "GetMetrics", "{", "return", "&", "GetMetrics", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetMetrics", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "metrics", "operation" ]

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

[ "WithTimeout", "adds", "the", "timeout", "to", "the", "post", "IP", "a", "m", "params" ]

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

[ "WithContext", "adds", "the", "context", "to", "the", "post", "IP", "a", "m", "params" ]

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

[ "WithHTTPClient", "adds", "the", "HTTPClient", "to", "the", "post", "IP", "a", "m", "params" ]

[ "func", "(", "o", "*", "PostIPAMParams", ")", "WithFamily", "(", "family", "*", "string", ")", "*", "PostIPAMParams", "{", "o", ".", "SetFamily", "(", "family", ")", "\n", "return", "o", "\n", "}" ]

[ "WithFamily", "adds", "the", "family", "to", "the", "post", "IP", "a", "m", "params" ]

[ "func", "(", "o", "*", "PostIPAMParams", ")", "WithOwner", "(", "owner", "*", "string", ")", "*", "PostIPAMParams", "{", "o", ".", "SetOwner", "(", "owner", ")", "\n", "return", "o", "\n", "}" ]

[ "WithOwner", "adds", "the", "owner", "to", "the", "post", "IP", "a", "m", "params" ]

[ "func", "(", "r", "*", "Rule", ")", "WithEndpointSelector", "(", "es", "EndpointSelector", ")", "*", "Rule", "{", "r", ".", "EndpointSelector", "=", "es", "\n", "return", "r", "\n", "}" ]

[ "WithEndpointSelector", "configures", "the", "Rule", "with", "the", "specified", "selector", "." ]

[ "func", "(", "r", "*", "Rule", ")", "WithIngressRules", "(", "rules", "[", "]", "IngressRule", ")", "*", "Rule", "{", "r", ".", "Ingress", "=", "rules", "\n", "return", "r", "\n", "}" ]

[ "WithIngressRules", "configures", "the", "Rule", "with", "the", "specified", "rules", "." ]

[ "func", "(", "r", "*", "Rule", ")", "WithEgressRules", "(", "rules", "[", "]", "EgressRule", ")", "*", "Rule", "{", "r", ".", "Egress", "=", "rules", "\n", "return", "r", "\n", "}" ]

[ "WithEgressRules", "configures", "the", "Rule", "with", "the", "specified", "rules", "." ]

[ "func", "(", "r", "*", "Rule", ")", "WithLabels", "(", "labels", "labels", ".", "LabelArray", ")", "*", "Rule", "{", "r", ".", "Labels", "=", "labels", "\n", "return", "r", "\n", "}" ]

[ "WithLabels", "configures", "the", "Rule", "with", "the", "specified", "labels", "metadata", "." ]

[ "func", "(", "r", "*", "Rule", ")", "WithDescription", "(", "desc", "string", ")", "*", "Rule", "{", "r", ".", "Description", "=", "desc", "\n", "return", "r", "\n", "}" ]

[ "WithDescription", "configures", "the", "Rule", "with", "the", "specified", "description", "metadata", "." ]

[ "func", "(", "r", "*", "Rule", ")", "RequiresDerivative", "(", ")", "bool", "{", "for", "_", ",", "rule", ":=", "range", "r", ".", "Egress", "{", "if", "rule", ".", "RequiresDerivative", "(", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "RequiresDerivative", "it", "return", "true", "if", "the", "rule", "has", "a", "derivative", "rule", "." ]

[ "func", "(", "r", "*", "Rule", ")", "CreateDerivative", "(", ")", "(", "*", "Rule", ",", "error", ")", "{", "newRule", ":=", "r", ".", "DeepCopy", "(", ")", "\n", "newRule", ".", "Egress", "=", "[", "]", "EgressRule", "{", "}", "\n\n", "for", "_", ",", "egressRule", ":=", "range", "r", ".", "Egress", "{", "derivativeEgressRule", ",", "err", ":=", "egressRule", ".", "CreateDerivative", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "newRule", ",", "err", "\n", "}", "\n", "newRule", ".", "Egress", "=", "append", "(", "newRule", ".", "Egress", ",", "*", "derivativeEgressRule", ")", "\n", "}", "\n", "return", "newRule", ",", "nil", "\n", "}" ]

[ "CreateDerivative", "will", "return", "a", "new", "Rule", "with", "the", "new", "data", "based", "gather", "by", "the", "rules", "that", "autogenerated", "new", "Rule" ]

[ "func", "(", "e", "*", "Endpoint", ")", "PolicyMapPathLocked", "(", ")", "string", "{", "return", "bpf", ".", "LocalMapPath", "(", "policymap", ".", "MapName", ",", "e", ".", "ID", ")", "\n", "}" ]

[ "PolicyMapPathLocked", "returns", "the", "path", "to", "the", "policy", "map", "of", "endpoint", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "CallsMapPathLocked", "(", ")", "string", "{", "return", "bpf", ".", "LocalMapPath", "(", "loader", ".", "CallsMapName", ",", "e", ".", "ID", ")", "\n", "}" ]

[ "CallsMapPathLocked", "returns", "the", "path", "to", "cilium", "tail", "calls", "map", "of", "an", "endpoint", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "BPFConfigMapPath", "(", ")", "string", "{", "return", "bpf", ".", "LocalMapPath", "(", "bpfconfig", ".", "MapNamePrefix", ",", "e", ".", "ID", ")", "\n", "}" ]

[ "BPFConfigMapPath", "returns", "the", "path", "to", "the", "BPF", "config", "map", "of", "endpoint", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "addNewRedirects", "(", "owner", "Owner", ",", "m", "*", "policy", ".", "L4Policy", ",", "proxyWaitGroup", "*", "completion", ".", "WaitGroup", ")", "(", "desiredRedirects", "map", "[", "string", "]", "bool", ",", "err", "error", ",", "finalizeFunc", "revert", ".", "FinalizeFunc", ",", "revertFunc", "revert", ".", "RevertFunc", ")", "{", "desiredRedirects", "=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "var", "finalizeList", "revert", ".", "FinalizeList", "\n", "var", "revertStack", "revert", ".", "RevertStack", "\n\n", "var", "ff", "revert", ".", "FinalizeFunc", "\n", "var", "rf", "revert", ".", "RevertFunc", "\n\n", "err", ",", "ff", ",", "rf", "=", "e", ".", "addNewRedirectsFromMap", "(", "owner", ",", "m", ".", "Ingress", ",", "desiredRedirects", ",", "proxyWaitGroup", ")", "\n", "if", "err", "!=", "nil", "{", "return", "desiredRedirects", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ",", "nil", ",", "nil", "\n", "}", "\n", "finalizeList", ".", "Append", "(", "ff", ")", "\n", "revertStack", ".", "Push", "(", "rf", ")", "\n\n", "err", ",", "ff", ",", "rf", "=", "e", ".", "addNewRedirectsFromMap", "(", "owner", ",", "m", ".", "Egress", ",", "desiredRedirects", ",", "proxyWaitGroup", ")", "\n", "if", "err", "!=", "nil", "{", "revertStack", ".", "Revert", "(", ")", "// Ignore errors while reverting. This is best-effort.", "\n", "return", "desiredRedirects", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ",", "nil", ",", "nil", "\n", "}", "\n", "finalizeList", ".", "Append", "(", "ff", ")", "\n", "revertStack", ".", "Push", "(", "rf", ")", "\n\n", "return", "desiredRedirects", ",", "nil", ",", "finalizeList", ".", "Finalize", ",", "func", "(", ")", "error", "{", "e", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "err", ":=", "revertStack", ".", "Revert", "(", ")", "\n\n", "e", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "err", "\n", "}", "\n", "}" ]

[ "addNewRedirects", "must", "be", "called", "while", "holding", "the", "endpoint", "lock", "for", "writing", ".", "On", "success", "returns", "nil", ";", "otherwise", "returns", "an", "error", "indicating", "the", "problem", "that", "occurred", "while", "adding", "an", "l7", "redirect", "for", "the", "specified", "policy", ".", "The", "returned", "map", "contains", "the", "exact", "set", "of", "IDs", "of", "proxy", "redirects", "that", "is", "required", "to", "implement", "the", "given", "L4", "policy", ".", "Must", "be", "called", "with", "endpoint", ".", "Mutex", "held", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "removeOldRedirects", "(", "owner", "Owner", ",", "desiredRedirects", "map", "[", "string", "]", "bool", ",", "proxyWaitGroup", "*", "completion", ".", "WaitGroup", ")", "(", "revert", ".", "FinalizeFunc", ",", "revert", ".", "RevertFunc", ")", "{", "if", "option", ".", "Config", ".", "DryMode", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "var", "finalizeList", "revert", ".", "FinalizeList", "\n", "var", "revertStack", "revert", ".", "RevertStack", "\n", "removedRedirects", ":=", "make", "(", "map", "[", "string", "]", "uint16", ",", "len", "(", "e", ".", "realizedRedirects", ")", ")", "\n", "updatedStats", ":=", "make", "(", "map", "[", "uint16", "]", "*", "models", ".", "ProxyStatistics", ",", "len", "(", "e", ".", "realizedRedirects", ")", ")", "\n\n", "for", "id", ",", "redirectPort", ":=", "range", "e", ".", "realizedRedirects", "{", "// Remove only the redirects that are not required.", "if", "desiredRedirects", "[", "id", "]", "{", "continue", "\n", "}", "\n\n", "err", ",", "finalizeFunc", ",", "revertFunc", ":=", "owner", ".", "RemoveProxyRedirect", "(", "e", ",", "id", ",", "proxyWaitGroup", ")", "\n", "if", "err", "!=", "nil", "{", "e", ".", "getLogger", "(", ")", ".", "WithError", "(", "err", ")", ".", "WithField", "(", "logfields", ".", "L4PolicyID", ",", "id", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n", "finalizeList", ".", "Append", "(", "finalizeFunc", ")", "\n", "revertStack", ".", "Push", "(", "revertFunc", ")", "\n\n", "delete", "(", "e", ".", "realizedRedirects", ",", "id", ")", "\n", "removedRedirects", "[", "id", "]", "=", "redirectPort", "\n\n", "// Update the endpoint API model to report that no redirect is", "// active or known for that port anymore. We never delete stats", "// until an endpoint is deleted, so we only set the redirect port", "// to 0.", "//", "// We don't know the L7 protocol of the redirect, so we can't just", "// build a ProxyStatistics and lookup e.proxyStatistics by key.", "// We have to loop to find which entry has the same redirect port.", "// Looping is acceptable since there should be only a few redirects", "// for each endpoint.", "e", ".", "proxyStatisticsMutex", ".", "Lock", "(", ")", "\n", "for", "_", ",", "stats", ":=", "range", "e", ".", "proxyStatistics", "{", "if", "stats", ".", "AllocatedProxyPort", "==", "int64", "(", "redirectPort", ")", "{", "updatedStats", "[", "redirectPort", "]", "=", "stats", "\n", "stats", ".", "AllocatedProxyPort", "=", "0", "\n", "break", "\n", "}", "\n", "}", "\n", "e", ".", "proxyStatisticsMutex", ".", "Unlock", "(", ")", "\n", "}", "\n\n", "return", "finalizeList", ".", "Finalize", ",", "func", "(", ")", "error", "{", "e", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Restore the proxy stats.", "e", ".", "proxyStatisticsMutex", ".", "Lock", "(", ")", "\n", "for", "redirectPort", ",", "stats", ":=", "range", "updatedStats", "{", "stats", ".", "AllocatedProxyPort", "=", "int64", "(", "redirectPort", ")", "\n", "}", "\n", "e", ".", "proxyStatisticsMutex", ".", "Unlock", "(", ")", "\n\n", "for", "id", ",", "redirectPort", ":=", "range", "removedRedirects", "{", "e", ".", "realizedRedirects", "[", "id", "]", "=", "redirectPort", "\n", "}", "\n\n", "err", ":=", "revertStack", ".", "Revert", "(", ")", "\n\n", "e", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "err", "\n", "}", "\n", "}" ]

[ "Must", "be", "called", "with", "endpoint", ".", "Mutex", "held", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "DeleteMapsLocked", "(", ")", "[", "]", "error", "{", "var", "errors", "[", "]", "error", "\n\n", "maps", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "e", ".", "BPFConfigMapPath", "(", ")", ",", "\"", "\"", ":", "e", ".", "PolicyMapPathLocked", "(", ")", ",", "\"", "\"", ":", "e", ".", "CallsMapPathLocked", "(", ")", ",", "\"", "\"", ":", "e", ".", "BPFIpvlanMapPath", "(", ")", ",", "}", "\n", "for", "name", ",", "path", ":=", "range", "maps", "{", "if", "err", ":=", "os", ".", "RemoveAll", "(", "path", ")", ";", "err", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "path", ",", "err", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "e", ".", "ConntrackLocalLocked", "(", ")", "{", "// Remove local connection tracking maps", "for", "_", ",", "m", ":=", "range", "ctmap", ".", "LocalMaps", "(", "e", ",", "option", ".", "Config", ".", "EnableIPv4", ",", "option", ".", "Config", ".", "EnableIPv6", ")", "{", "ctPath", ",", "err", ":=", "m", ".", "Path", "(", ")", "\n", "if", "err", "==", "nil", "{", "err", "=", "os", ".", "RemoveAll", "(", "ctPath", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctPath", ",", "err", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Remove handle_policy() tail call entry for EP", "if", "err", ":=", "policymap", ".", "RemoveGlobalMapping", "(", "uint32", "(", "e", ".", "ID", ")", ")", ";", "err", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", ")", "\n", "}", "\n\n", "return", "errors", "\n", "}" ]

[ "DeleteMapsLocked", "releases", "references", "to", "all", "BPF", "maps", "associated", "with", "this", "endpoint", ".", "For", "each", "error", "that", "occurs", "while", "releasing", "these", "references", "an", "error", "is", "added", "to", "the", "resulting", "error", "slice", "which", "is", "returned", ".", "Returns", "nil", "on", "success", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "DeleteBPFProgramLocked", "(", ")", "error", "{", "e", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "loader", ".", "DeleteDatapath", "(", "context", ".", "TODO", "(", ")", ",", "e", ".", "IfName", ",", "\"", "\"", ")", "\n", "}" ]

[ "DeleteBPFProgramLocked", "delete", "the", "BPF", "program", "associated", "with", "the", "endpoint", "s", "veth", "interface", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "SkipStateClean", "(", ")", "{", "// Mark conntrack as already cleaned", "e", ".", "UnconditionalLock", "(", ")", "\n", "e", ".", "ctCleaned", "=", "true", "\n", "e", ".", "Unlock", "(", ")", "\n", "}" ]

[ "SkipStateClean", "can", "be", "called", "on", "a", "endpoint", "before", "its", "first", "build", "to", "skip", "the", "cleaning", "of", "state", "such", "as", "the", "conntrack", "table", ".", "This", "is", "useful", "when", "an", "endpoint", "is", "being", "restored", "from", "state", "and", "the", "datapath", "state", "should", "not", "be", "claned", ".", "The", "endpoint", "lock", "must", "NOT", "be", "held", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "GetBPFKeys", "(", ")", "[", "]", "*", "lxcmap", ".", "EndpointKey", "{", "keys", ":=", "[", "]", "*", "lxcmap", ".", "EndpointKey", "{", "}", "\n", "if", "e", ".", "IPv6", ".", "IsSet", "(", ")", "{", "keys", "=", "append", "(", "keys", ",", "lxcmap", ".", "NewEndpointKey", "(", "e", ".", "IPv6", ".", "IP", "(", ")", ")", ")", "\n", "}", "\n\n", "if", "e", ".", "IPv4", ".", "IsSet", "(", ")", "{", "keys", "=", "append", "(", "keys", ",", "lxcmap", ".", "NewEndpointKey", "(", "e", ".", "IPv4", ".", "IP", "(", ")", ")", ")", "\n", "}", "\n\n", "return", "keys", "\n", "}" ]

[ "GetBPFKeys", "returns", "all", "keys", "which", "should", "represent", "this", "endpoint", "in", "the", "BPF", "endpoints", "map" ]

[ "func", "(", "e", "*", "Endpoint", ")", "GetBPFValue", "(", ")", "(", "*", "lxcmap", ".", "EndpointInfo", ",", "error", ")", "{", "mac", ",", "err", ":=", "e", ".", "LXCMAC", ".", "Uint64", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "nodeMAC", ",", "err", ":=", "e", ".", "NodeMAC", ".", "Uint64", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "info", ":=", "&", "lxcmap", ".", "EndpointInfo", "{", "IfIndex", ":", "uint32", "(", "e", ".", "IfIndex", ")", ",", "// Store security identity in network byte order so it can be", "// written into the packet without an additional byte order", "// conversion.", "LxcID", ":", "e", ".", "ID", ",", "MAC", ":", "lxcmap", ".", "MAC", "(", "mac", ")", ",", "NodeMAC", ":", "lxcmap", ".", "MAC", "(", "nodeMAC", ")", ",", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "GetBPFValue", "returns", "the", "value", "which", "should", "represent", "this", "endpoint", "in", "the", "BPF", "endpoints", "map" ]

[ "func", "NewCollector", "(", "probes", "[", "]", "Probe", ",", "config", "Config", ")", "*", "Collector", "{", "c", ":=", "&", "Collector", "{", "config", ":", "config", ",", "stop", ":", "make", "(", "chan", "struct", "{", "}", ",", "0", ")", ",", "staleProbes", ":", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", ",", "probeStartTime", ":", "make", "(", "map", "[", "string", "]", "time", ".", "Time", ")", ",", "}", "\n\n", "if", "c", ".", "config", ".", "Interval", "==", "time", ".", "Duration", "(", "0", ")", "{", "c", ".", "config", ".", "Interval", "=", "defaults", ".", "StatusCollectorInterval", "\n", "}", "\n\n", "if", "c", ".", "config", ".", "FailureThreshold", "==", "time", ".", "Duration", "(", "0", ")", "{", "c", ".", "config", ".", "FailureThreshold", "=", "defaults", ".", "StatusCollectorFailureThreshold", "\n", "}", "\n\n", "if", "c", ".", "config", ".", "WarningThreshold", "==", "time", ".", "Duration", "(", "0", ")", "{", "c", ".", "config", ".", "WarningThreshold", "=", "defaults", ".", "StatusCollectorWarningThreshold", "\n", "}", "\n\n", "for", "i", ":=", "range", "probes", "{", "c", ".", "spawnProbe", "(", "&", "probes", "[", "i", "]", ")", "\n", "}", "\n\n", "return", "c", "\n", "}" ]

[ "NewCollector", "creates", "a", "collector", "and", "starts", "the", "given", "probes", ".", "Each", "probe", "runs", "in", "a", "separate", "goroutine", "." ]

[ "func", "(", "c", "*", "Collector", ")", "GetStaleProbes", "(", ")", "map", "[", "string", "]", "time", ".", "Time", "{", "c", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "RUnlock", "(", ")", "\n\n", "probes", ":=", "make", "(", "map", "[", "string", "]", "time", ".", "Time", ")", "\n\n", "for", "p", ":=", "range", "c", ".", "staleProbes", "{", "probes", "[", "p", "]", "=", "c", ".", "probeStartTime", "[", "p", "]", "\n", "}", "\n\n", "return", "probes", "\n", "}" ]

[ "GetStaleProbes", "returns", "a", "map", "of", "stale", "probes", "which", "key", "is", "a", "probe", "name", "and", "value", "is", "a", "time", "when", "the", "last", "instance", "of", "the", "probe", "has", "been", "started", ".", "A", "probe", "is", "declared", "stale", "if", "it", "hasn", "t", "returned", "in", "FailureThreshold", "." ]

[ "func", "(", "c", "*", "Collector", ")", "spawnProbe", "(", "p", "*", "Probe", ")", "{", "go", "func", "(", ")", "{", "for", "{", "c", ".", "runProbe", "(", "p", ")", "\n\n", "interval", ":=", "c", ".", "config", ".", "Interval", "\n", "if", "p", ".", "Interval", "!=", "nil", "{", "interval", "=", "p", ".", "Interval", "(", "p", ".", "consecutiveFailures", ")", "\n", "}", "\n\n", "select", "{", "case", "<-", "c", ".", "stop", ":", "// collector is closed, stop looping", "return", "\n", "case", "<-", "time", ".", "After", "(", "interval", ")", ":", "// keep looping", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "spawnProbe", "starts", "a", "goroutine", "which", "invokes", "the", "probe", "at", "the", "particular", "interval", "." ]

[ "func", "(", "c", "*", "Collector", ")", "runProbe", "(", "p", "*", "Probe", ")", "{", "var", "(", "statusData", "interface", "{", "}", "\n", "err", "error", "\n", "warningThreshold", "=", "time", ".", "After", "(", "c", ".", "config", ".", "WarningThreshold", ")", "\n", "hardTimeout", "=", "false", "\n", "probeReturned", "=", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", "\n", "ctx", ",", "cancel", "=", "context", ".", "WithTimeout", "(", "context", ".", "Background", "(", ")", ",", "c", ".", "config", ".", "FailureThreshold", ")", "\n", "ctxTimeout", "=", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", "\n", ")", "\n\n", "c", ".", "Lock", "(", ")", "\n", "c", ".", "probeStartTime", "[", "p", ".", "Name", "]", "=", "time", ".", "Now", "(", ")", "\n", "c", ".", "Unlock", "(", ")", "\n\n", "go", "func", "(", ")", "{", "statusData", ",", "err", "=", "p", ".", "Probe", "(", "ctx", ")", "\n", "close", "(", "probeReturned", ")", "\n", "}", "(", ")", "\n\n", "go", "func", "(", ")", "{", "// Once ctx.Done() has been closed, we notify the polling loop by", "// sending to the ctxTimeout channel. We cannot just close the channel,", "// because otherwise the loop will always enter the \"<-ctxTimeout\" case.", "<-", "ctx", ".", "Done", "(", ")", "\n", "ctxTimeout", "<-", "struct", "{", "}", "{", "}", "\n", "}", "(", ")", "\n\n", "// This is a loop so that, when we hit a FailureThreshold, we still do", "// not return until the probe returns. This is to ensure the same probe", "// does not run again while it is blocked.", "for", "{", "select", "{", "case", "<-", "c", ".", "stop", ":", "// Collector was closed. The probe will complete in the background", "// and won't be restarted again.", "cancel", "(", ")", "\n", "return", "\n\n", "case", "<-", "warningThreshold", ":", "// Just warn and continue waiting for probe", "log", ".", "WithField", "(", "logfields", ".", "Probe", ",", "p", ".", "Name", ")", ".", "Warnf", "(", "\"", "\"", ",", "c", ".", "config", ".", "WarningThreshold", ".", "Seconds", "(", ")", ")", "\n\n", "case", "<-", "probeReturned", ":", "// The probe completed and we can return from runProbe", "switch", "{", "case", "hardTimeout", ":", "// FailureThreshold was already reached. Keep the failure error", "// message", "case", "err", "!=", "nil", ":", "c", ".", "updateProbeStatus", "(", "p", ",", "nil", ",", "false", ",", "err", ")", "\n", "default", ":", "c", ".", "updateProbeStatus", "(", "p", ",", "statusData", ",", "false", ",", "nil", ")", "\n", "}", "\n\n", "cancel", "(", ")", "\n", "return", "\n\n", "case", "<-", "ctxTimeout", ":", "// We have timed out. Report a status and mark that we timed out so we", "// do not emit status later.", "staleErr", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "p", ".", "Name", ",", "c", ".", "config", ".", "FailureThreshold", ".", "Seconds", "(", ")", ")", "\n", "c", ".", "updateProbeStatus", "(", "p", ",", "nil", ",", "true", ",", "staleErr", ")", "\n", "hardTimeout", "=", "true", "\n", "}", "\n", "}", "\n", "}" ]

[ "runProbe", "runs", "the", "given", "probe", "and", "returns", "either", "after", "the", "probe", "has", "returned", "or", "after", "the", "collector", "has", "been", "closed", "." ]

[ "func", "NewDeleteFqdnCache", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "DeleteFqdnCacheHandler", ")", "*", "DeleteFqdnCache", "{", "return", "&", "DeleteFqdnCache", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewDeleteFqdnCache", "creates", "a", "new", "http", ".", "Handler", "for", "the", "delete", "fqdn", "cache", "operation" ]

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

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

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

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

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

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

[ "func", "(", "o", "*", "GetPolicyResolveParams", ")", "WithTraceSelector", "(", "traceSelector", "*", "models", ".", "TraceSelector", ")", "*", "GetPolicyResolveParams", "{", "o", ".", "SetTraceSelector", "(", "traceSelector", ")", "\n", "return", "o", "\n", "}" ]

[ "WithTraceSelector", "adds", "the", "traceSelector", "to", "the", "get", "policy", "resolve", "params" ]

[ "func", "InitIdentityAllocator", "(", "owner", "IdentityAllocatorOwner", ")", "{", "setupMutex", ".", "Lock", "(", ")", "\n", "defer", "setupMutex", ".", "Unlock", "(", ")", "\n\n", "if", "IdentityAllocator", "!=", "nil", "{", "log", ".", "Panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "identity", ".", "InitWellKnownIdentities", "(", ")", "\n\n", "log", ".", "Info", "(", "\"", "\"", ")", "\n\n", "minID", ":=", "idpool", ".", "ID", "(", "identity", ".", "MinimalAllocationIdentity", ")", "\n", "maxID", ":=", "idpool", ".", "ID", "(", "identity", ".", "MaximumAllocationIdentity", ")", "\n", "events", ":=", "make", "(", "allocator", ".", "AllocatorEventChan", ",", "1024", ")", "\n\n", "// It is important to start listening for events before calling", "// NewAllocator() as it will emit events while filling the", "// initial cache", "watcher", ".", "watch", "(", "owner", ",", "events", ")", "\n\n", "a", ",", "err", ":=", "allocator", ".", "NewAllocator", "(", "IdentitiesPath", ",", "globalIdentity", "{", "}", ",", "allocator", ".", "WithMax", "(", "maxID", ")", ",", "allocator", ".", "WithMin", "(", "minID", ")", ",", "allocator", ".", "WithSuffix", "(", "owner", ".", "GetNodeSuffix", "(", ")", ")", ",", "allocator", ".", "WithEvents", "(", "events", ")", ",", "allocator", ".", "WithMasterKeyProtection", "(", ")", ",", "allocator", ".", "WithPrefixMask", "(", "idpool", ".", "ID", "(", "option", ".", "Config", ".", "ClusterID", "<<", "identity", ".", "ClusterIDShift", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n\n", "IdentityAllocator", "=", "a", "\n", "close", "(", "identityAllocatorInitialized", ")", "\n", "localIdentities", "=", "newLocalIdentityCache", "(", "1", ",", "0xFFFFFF", ",", "events", ")", "\n\n", "}" ]

[ "InitIdentityAllocator", "creates", "the", "the", "identity", "allocator", ".", "Only", "the", "first", "invocation", "of", "this", "function", "will", "have", "an", "effect", "." ]

[ "func", "WaitForInitialIdentities", "(", "ctx", "context", ".", "Context", ")", "error", "{", "select", "{", "case", "<-", "identityAllocatorInitialized", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n\n", "return", "IdentityAllocator", ".", "WaitForInitialSync", "(", "ctx", ")", "\n", "}" ]

[ "WaitForInitialIdentities", "waits", "for", "the", "initial", "set", "of", "security", "identities", "to", "have", "been", "received", "and", "populated", "into", "the", "allocator", "cache" ]

[ "func", "AllocateIdentity", "(", "ctx", "context", ".", "Context", ",", "lbls", "labels", ".", "Labels", ")", "(", "*", "identity", ".", "Identity", ",", "bool", ",", "error", ")", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "IdentityLabels", ":", "lbls", ".", "String", "(", ")", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// If there is only one label with the \"reserved\" source and a well-known", "// key, use the well-known identity for that key.", "if", "reservedIdentity", ":=", "LookupReservedIdentityByLabels", "(", "lbls", ")", ";", "reservedIdentity", "!=", "nil", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Identity", ":", "reservedIdentity", ".", "ID", ",", "logfields", ".", "IdentityLabels", ":", "lbls", ".", "String", "(", ")", ",", "\"", "\"", ":", "false", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "reservedIdentity", ",", "false", ",", "nil", "\n", "}", "\n\n", "if", "!", "identity", ".", "RequiresGlobalIdentity", "(", "lbls", ")", "&&", "localIdentities", "!=", "nil", "{", "return", "localIdentities", ".", "lookupOrCreate", "(", "lbls", ")", "\n", "}", "\n\n", "// This will block until the kvstore can be accessed and all identities", "// were succesfully synced", "WaitForInitialIdentities", "(", "ctx", ")", "\n\n", "if", "IdentityAllocator", "==", "nil", "{", "return", "nil", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "id", ",", "isNew", ",", "err", ":=", "IdentityAllocator", ".", "Allocate", "(", "ctx", ",", "globalIdentity", "{", "lbls", ".", "LabelArray", "(", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n\n", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Identity", ":", "id", ",", "logfields", ".", "IdentityLabels", ":", "lbls", ".", "String", "(", ")", ",", "\"", "\"", ":", "isNew", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "identity", ".", "NewIdentity", "(", "identity", ".", "NumericIdentity", "(", "id", ")", ",", "lbls", ")", ",", "isNew", ",", "nil", "\n", "}" ]

[ "AllocateIdentity", "allocates", "an", "identity", "described", "by", "the", "specified", "labels", ".", "If", "an", "identity", "for", "the", "specified", "set", "of", "labels", "already", "exist", "the", "identity", "is", "re", "-", "used", "and", "reference", "counting", "is", "performed", "otherwise", "a", "new", "identity", "is", "allocated", "via", "the", "kvstore", "." ]

[ "func", "ReleaseSlice", "(", "ctx", "context", ".", "Context", ",", "identities", "[", "]", "*", "identity", ".", "Identity", ")", "error", "{", "var", "err", "error", "\n", "for", "_", ",", "id", ":=", "range", "identities", "{", "if", "id", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "_", ",", "err2", ":=", "Release", "(", "ctx", ",", "id", ")", ";", "err2", "!=", "nil", "{", "log", ".", "WithError", "(", "err2", ")", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Identity", ":", "id", ",", "}", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "err", "=", "err2", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "ReleaseSlice", "attempts", "to", "release", "a", "set", "of", "identities", ".", "It", "is", "a", "helper", "function", "that", "may", "be", "useful", "for", "cleaning", "up", "multiple", "identities", "in", "paths", "where", "several", "identities", "may", "be", "allocated", "and", "another", "error", "means", "that", "they", "should", "all", "be", "released", "." ]

[ "func", "WatchRemoteIdentities", "(", "backend", "kvstore", ".", "BackendOperations", ")", "*", "allocator", ".", "RemoteCache", "{", "<-", "identityAllocatorInitialized", "\n", "return", "IdentityAllocator", ".", "WatchRemoteKVStore", "(", "backend", ",", "IdentitiesPath", ")", "\n", "}" ]

[ "WatchRemoteIdentities", "starts", "watching", "for", "identities", "in", "another", "kvstore", "and", "syncs", "all", "identities", "to", "the", "local", "identity", "cache", "." ]

[ "func", "DeleteService", "(", "key", "ServiceKey", ")", "error", "{", "mutex", ".", "Lock", "(", ")", "\n", "defer", "mutex", ".", "Unlock", "(", ")", "\n\n", "err", ":=", "deleteServiceLocked", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteService", "deletes", "a", "legacy", "service", "from", "the", "lbmap", ".", "The", "given", "key", "has", "to", "be", "of", "the", "master", "service", "." ]

[ "func", "updateServiceWeights", "(", "key", "ServiceKey", ",", "value", "*", "RRSeqValue", ")", "error", "{", "if", "_", ",", "err", ":=", "key", ".", "RRMap", "(", ")", ".", "OpenOrCreate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "key", ".", "RRMap", "(", ")", ".", "Update", "(", "key", ".", "ToNetwork", "(", ")", ",", "value", ")", "\n", "}" ]

[ "updateServiceWeights", "updates", "cilium_lb6_rr_seq", "or", "cilium_lb4_rr_seq", "bpf", "maps", "." ]

[ "func", "lookupAndDeleteServiceWeights", "(", "key", "ServiceKey", ")", "error", "{", "_", ",", "err", ":=", "key", ".", "RRMap", "(", ")", ".", "Lookup", "(", "key", ".", "ToNetwork", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// Ignore if entry is not found.", "return", "nil", "\n", "}", "\n\n", "return", "key", ".", "RRMap", "(", ")", ".", "Delete", "(", "key", ".", "ToNetwork", "(", ")", ")", "\n", "}" ]

[ "lookupAndDeleteServiceWeights", "deletes", "entry", "from", "cilium_lb6_rr_seq", "or", "cilium_lb4_rr_seq" ]

[ "func", "gcd", "(", "x", ",", "y", "uint16", ")", "uint16", "{", "for", "y", "!=", "0", "{", "x", ",", "y", "=", "y", ",", "x", "%", "y", "\n", "}", "\n", "return", "x", "\n", "}" ]

[ "gcd", "computes", "the", "gcd", "of", "two", "numbers", "." ]

[ "func", "generateWrrSeq", "(", "weights", "[", "]", "uint16", ")", "(", "*", "RRSeqValue", ",", "error", ")", "{", "svcRRSeq", ":=", "RRSeqValue", "{", "}", "\n\n", "n", ":=", "len", "(", "weights", ")", "\n", "if", "n", "<", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "g", ":=", "uint16", "(", "0", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "n", ";", "i", "++", "{", "if", "weights", "[", "i", "]", "!=", "0", "{", "g", "=", "gcd", "(", "g", ",", "weights", "[", "i", "]", ")", "\n", "}", "\n", "}", "\n\n", "// This means all the weights are 0.", "if", "g", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "sum", ":=", "uint16", "(", "0", ")", "\n", "for", "i", ":=", "range", "weights", "{", "// Normalize the weights.", "weights", "[", "i", "]", "=", "weights", "[", "i", "]", "/", "g", "\n", "sum", "+=", "weights", "[", "i", "]", "\n", "}", "\n\n", "// Check if Generated seq fits in our array.", "if", "int", "(", "sum", ")", ">", "len", "(", "svcRRSeq", ".", "Idx", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "svcRRSeq", ".", "Idx", ")", ")", "\n", "}", "\n\n", "// Generate the Sequence.", "i", ":=", "uint16", "(", "0", ")", "\n", "k", ":=", "uint16", "(", "0", ")", "\n", "for", "{", "j", ":=", "uint16", "(", "0", ")", "\n", "for", "j", "<", "weights", "[", "k", "]", "{", "svcRRSeq", ".", "Idx", "[", "i", "]", "=", "k", "\n", "i", "++", "\n", "j", "++", "\n", "}", "\n", "if", "i", ">=", "sum", "{", "break", "\n", "}", "\n", "k", "++", "\n", "}", "\n", "svcRRSeq", ".", "Count", "=", "sum", "\n", "return", "&", "svcRRSeq", ",", "nil", "\n", "}" ]

[ "generateWrrSeq", "generates", "a", "wrr", "sequence", "based", "on", "provided", "weights", "." ]

[ "func", "DumpBackendMapsToUserspace", "(", ")", "(", "map", "[", "BackendAddrID", "]", "*", "loadbalancer", ".", "LBBackEnd", ",", "error", ")", "{", "backendValueMap", ":=", "map", "[", "loadbalancer", ".", "BackendID", "]", "BackendValue", "{", "}", "\n", "lbBackends", ":=", "map", "[", "BackendAddrID", "]", "*", "loadbalancer", ".", "LBBackEnd", "{", "}", "\n\n", "parseBackendEntries", ":=", "func", "(", "key", "bpf", ".", "MapKey", ",", "value", "bpf", ".", "MapValue", ")", "{", "backendKey", ":=", "key", ".", "(", "BackendKey", ")", "\n", "backendValue", ":=", "value", ".", "(", "BackendValue", ")", "\n", "backendValueMap", "[", "backendKey", ".", "GetID", "(", ")", "]", "=", "backendValue", "\n", "}", "\n\n", "if", "option", ".", "Config", ".", "EnableIPv4", "{", "err", ":=", "Backend4Map", ".", "DumpWithCallback", "(", "parseBackendEntries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "option", ".", "Config", ".", "EnableIPv6", "{", "err", ":=", "Backend6Map", ".", "DumpWithCallback", "(", "parseBackendEntries", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "for", "backendID", ",", "backendVal", ":=", "range", "backendValueMap", "{", "ip", ":=", "backendVal", ".", "GetAddress", "(", ")", "\n", "port", ":=", "backendVal", ".", "GetPort", "(", ")", "\n", "weight", ":=", "uint16", "(", "0", ")", "// FIXME(brb): set weight when we support it", "\n", "proto", ":=", "loadbalancer", ".", "NONE", "\n", "lbBackend", ":=", "loadbalancer", ".", "NewLBBackEnd", "(", "backendID", ",", "proto", ",", "ip", ",", "port", ",", "weight", ")", "\n", "lbBackends", "[", "backendVal", ".", "BackendAddrID", "(", ")", "]", "=", "lbBackend", "\n", "}", "\n\n", "return", "lbBackends", ",", "nil", "\n", "}" ]

[ "DumpBackendMapsToUserspace", "dumps", "the", "backend", "entries", "from", "the", "BPF", "maps", "." ]

[ "func", "DumpRevNATMapsToUserspace", "(", ")", "(", "loadbalancer", ".", "RevNATMap", ",", "[", "]", "error", ")", "{", "newRevNATMap", ":=", "loadbalancer", ".", "RevNATMap", "{", "}", "\n", "errors", ":=", "[", "]", "error", "{", "}", "\n\n", "parseRevNATEntries", ":=", "func", "(", "key", "bpf", ".", "MapKey", ",", "value", "bpf", ".", "MapValue", ")", "{", "revNatK", ":=", "key", ".", "(", "RevNatKey", ")", "\n", "revNatV", ":=", "value", ".", "(", "RevNatValue", ")", "\n", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "BPFMapKey", ":", "revNatK", ",", "logfields", ".", "BPFMapValue", ":", "revNatV", ",", "}", ")", "\n\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "fe", ":=", "revNatValue2L3n4AddrID", "(", "revNatK", ",", "revNatV", ")", "\n", "newRevNATMap", "[", "loadbalancer", ".", "ServiceID", "(", "fe", ".", "ID", ")", "]", "=", "fe", ".", "L3n4Addr", "\n", "}", "\n\n", "mutex", ".", "RLock", "(", ")", "\n", "defer", "mutex", ".", "RUnlock", "(", ")", "\n\n", "if", "option", ".", "Config", ".", "EnableIPv4", "{", "if", "err", ":=", "RevNat4Map", ".", "DumpWithCallback", "(", "parseRevNATEntries", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "errors", "=", "append", "(", "errors", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "option", ".", "Config", ".", "EnableIPv6", "{", "if", "err", ":=", "RevNat6Map", ".", "DumpWithCallback", "(", "parseRevNATEntries", ")", ";", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "errors", "=", "append", "(", "errors", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "newRevNATMap", ",", "errors", "\n", "}" ]

[ "DumpRevNATMapsToUserspace", "dumps", "the", "contents", "of", "both", "the", "IPv6", "and", "IPv4", "revNAT", "BPF", "maps", "and", "stores", "the", "contents", "of", "said", "dumps", "in", "a", "RevNATMap", ".", "Returns", "the", "errors", "that", "occurred", "while", "dumping", "the", "maps", "." ]

[ "func", "RestoreService", "(", "svc", "loadbalancer", ".", "LBSVC", ",", "v2Exists", "bool", ")", "error", "{", "return", "cache", ".", "restoreService", "(", "svc", ",", "v2Exists", ")", "\n", "}" ]

[ "RestoreService", "restores", "a", "single", "service", "in", "the", "cache", ".", "This", "is", "required", "to", "guarantee", "consistent", "backend", "ordering", "slave", "slot", "and", "backend", "by", "backend", "address", "ID", "lookups", "." ]

[ "func", "updateServiceWeightsV2", "(", "key", "ServiceKeyV2", ",", "value", "*", "RRSeqValue", ")", "error", "{", "if", "_", ",", "err", ":=", "key", ".", "RRMap", "(", ")", ".", "OpenOrCreate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "key", ".", "RRMap", "(", ")", ".", "Update", "(", "key", ".", "ToNetwork", "(", ")", ",", "value", ")", "\n", "}" ]

[ "updateServiceWeightsV2", "updates", "cilium_lb6_rr_seq_v2", "or", "cilium_lb4_rr_seq_v2", "bpf", "maps", "." ]

[ "func", "lookupAndDeleteServiceWeightsV2", "(", "key", "ServiceKeyV2", ")", "error", "{", "_", ",", "err", ":=", "key", ".", "RRMap", "(", ")", ".", "Lookup", "(", "key", ".", "ToNetwork", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// Ignore if entry is not found.", "return", "nil", "\n", "}", "\n\n", "return", "key", ".", "RRMap", "(", ")", ".", "Delete", "(", "key", ".", "ToNetwork", "(", ")", ")", "\n", "}" ]

[ "lookupAndDeleteServiceWeightsV2", "deletes", "entry", "from", "cilium_lb6_rr_seq", "or", "cilium_lb4_rr_seq" ]

[ "func", "DeleteServiceV2", "(", "svc", "loadbalancer", ".", "L3n4AddrID", ",", "releaseBackendID", "func", "(", "loadbalancer", ".", "BackendID", ")", ")", "error", "{", "var", "(", "backendKey", "BackendKey", "\n", "svcKey", "ServiceKeyV2", "\n", ")", "\n\n", "mutex", ".", "Lock", "(", ")", "\n", "defer", "mutex", ".", "Unlock", "(", ")", "\n\n", "isIPv6", ":=", "svc", ".", "IsIPv6", "(", ")", "\n\n", "log", ".", "WithField", "(", "logfields", ".", "ServiceName", ",", "svc", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "if", "isIPv6", "{", "svcKey", "=", "NewService6KeyV2", "(", "svc", ".", "IP", ",", "svc", ".", "Port", ",", "u8proto", ".", "All", ",", "0", ")", "\n", "}", "else", "{", "svcKey", "=", "NewService4KeyV2", "(", "svc", ".", "IP", ",", "svc", ".", "Port", ",", "u8proto", ".", "All", ",", "0", ")", "\n", "}", "\n\n", "backendsToRemove", ",", "backendsCount", ",", "err", ":=", "cache", ".", "removeServiceV2", "(", "svcKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "slot", ":=", "0", ";", "slot", "<=", "backendsCount", ";", "slot", "++", "{", "svcKey", ".", "SetSlave", "(", "slot", ")", "\n", "if", "err", ":=", "svcKey", ".", "MapDelete", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "isIPv6", "{", "backendKey", "=", "NewBackend6Key", "(", "0", ")", "\n", "}", "else", "{", "backendKey", "=", "NewBackend4Key", "(", "0", ")", "\n", "}", "\n\n", "for", "_", ",", "id", ":=", "range", "backendsToRemove", "{", "backendKey", ".", "SetID", "(", "id", ")", "\n", "if", "err", ":=", "deleteBackendLocked", "(", "backendKey", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ",", "err", ")", "\n", "}", "\n", "releaseBackendID", "(", "id", ")", "\n", "log", ".", "WithField", "(", "logfields", ".", "BackendID", ",", "id", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteServiceV2", "deletes", "a", "service", "from", "the", "lbmap", "and", "deletes", "backends", "of", "it", "if", "they", "are", "not", "used", "by", "any", "other", "service", ".", "The", "given", "key", "has", "to", "be", "of", "the", "master", "service", "." ]

[ "func", "DeleteServiceCache", "(", "svc", "loadbalancer", ".", "L3n4AddrID", ")", "{", "var", "svcKey", "ServiceKey", "\n\n", "if", "!", "svc", ".", "IsIPv6", "(", ")", "{", "svcKey", "=", "NewService4Key", "(", "svc", ".", "IP", ",", "svc", ".", "Port", ",", "0", ")", "\n", "}", "else", "{", "svcKey", "=", "NewService6Key", "(", "svc", ".", "IP", ",", "svc", ".", "Port", ",", "0", ")", "\n", "}", "\n\n", "cache", ".", "delete", "(", "svcKey", ")", "\n", "}" ]

[ "DeleteServiceCache", "deletes", "the", "service", "cache", "." ]

[ "func", "Init", "(", "dp", "datapath", ".", "Datapath", ",", "nodeCfg", "*", "datapath", ".", "LocalNodeConfiguration", ")", "{", "once", ".", "Do", "(", "func", "(", ")", "{", "templateCache", "=", "NewObjectCache", "(", "dp", ",", "nodeCfg", ")", "\n", "ignorePrefixes", ":=", "ignoredELFPrefixes", "\n", "if", "!", "option", ".", "Config", ".", "EnableIPv4", "{", "ignorePrefixes", "=", "append", "(", "ignorePrefixes", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "option", ".", "Config", ".", "EnableIPv6", "{", "ignorePrefixes", "=", "append", "(", "ignorePrefixes", ",", "\"", "\"", ")", "\n", "}", "\n", "elf", ".", "IgnoreSymbolPrefixes", "(", "ignorePrefixes", ")", "\n", "}", ")", "\n", "templateCache", ".", "Update", "(", "nodeCfg", ")", "\n", "}" ]

[ "Init", "initializes", "the", "datapath", "cache", "with", "base", "program", "hashes", "derived", "from", "the", "LocalNodeConfiguration", "." ]

[ "func", "RestoreTemplates", "(", "stateDir", "string", ")", "error", "{", "// Simplest implementation: Just garbage-collect everything.", "// In future we should make this smarter.", "path", ":=", "filepath", ".", "Join", "(", "stateDir", ",", "defaults", ".", "TemplatesDir", ")", "\n", "err", ":=", "os", ".", "RemoveAll", "(", "path", ")", "\n", "if", "err", "==", "nil", "||", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", "\n", "}", "\n", "return", "&", "os", ".", "PathError", "{", "Op", ":", "\"", "\"", ",", "Path", ":", "path", ",", "Err", ":", "err", ",", "}", "\n", "}" ]

[ "RestoreTemplates", "populates", "the", "object", "cache", "from", "templates", "on", "the", "filesystem", "at", "the", "specified", "path", "." ]

[ "func", "NewObjectCache", "(", "dp", "datapath", ".", "Datapath", ",", "nodeCfg", "*", "datapath", ".", "LocalNodeConfiguration", ")", "*", "objectCache", "{", "return", "newObjectCache", "(", "dp", ",", "nodeCfg", ",", "option", ".", "Config", ".", "StateDir", ")", "\n", "}" ]

[ "NewObjectCache", "creates", "a", "new", "cache", "for", "datapath", "objects", "basing", "the", "hash", "upon", "the", "configuration", "of", "the", "datapath", "and", "the", "specified", "node", "configuration", "." ]

[ "func", "(", "o", "*", "objectCache", ")", "Update", "(", "nodeCfg", "*", "datapath", ".", "LocalNodeConfiguration", ")", "{", "newHash", ":=", "hashDatapath", "(", "o", ".", "Datapath", ",", "nodeCfg", ",", "nil", ",", "nil", ")", "\n\n", "o", ".", "Lock", "(", ")", "\n", "defer", "o", ".", "Unlock", "(", ")", "\n", "o", ".", "baseHash", "=", "newHash", "\n", "}" ]

[ "Update", "may", "be", "called", "to", "update", "the", "base", "hash", "for", "configuration", "of", "datapath", "configuration", "that", "applies", "across", "the", "node", "." ]

[ "func", "(", "o", "*", "objectCache", ")", "serialize", "(", "hash", "string", ")", "(", "fq", "*", "serializer", ".", "FunctionQueue", ",", "found", "bool", ")", "{", "o", ".", "Lock", "(", ")", "\n", "defer", "o", ".", "Unlock", "(", ")", "\n\n", "fq", ",", "compiled", ":=", "o", ".", "compileQueue", "[", "hash", "]", "\n", "if", "!", "compiled", "{", "fq", "=", "serializer", ".", "NewFunctionQueue", "(", "1", ")", "\n", "o", ".", "compileQueue", "[", "hash", "]", "=", "fq", "\n", "}", "\n", "return", "fq", ",", "compiled", "\n", "}" ]

[ "serialize", "finds", "the", "channel", "that", "serializes", "builds", "against", "the", "same", "hash", ".", "Returns", "the", "channel", "and", "whether", "or", "not", "the", "caller", "needs", "to", "compile", "the", "datapath", "for", "this", "hash", "." ]

[ "func", "(", "o", "*", "objectCache", ")", "build", "(", "ctx", "context", ".", "Context", ",", "cfg", "*", "templateCfg", ",", "hash", "string", ")", "error", "{", "templatePath", ":=", "filepath", ".", "Join", "(", "o", ".", "workingDirectory", ",", "defaults", ".", "TemplatesDir", ",", "hash", ")", "\n", "headerPath", ":=", "filepath", ".", "Join", "(", "templatePath", ",", "common", ".", "CHeaderFileName", ")", "\n", "objectPath", ":=", "filepath", ".", "Join", "(", "templatePath", ",", "endpointObj", ")", "\n\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "templatePath", ",", "defaults", ".", "StateDirRights", ")", ";", "err", "!=", "nil", "{", "return", "&", "os", ".", "PathError", "{", "Op", ":", "\"", "\"", ",", "Path", ":", "templatePath", ",", "Err", ":", "err", ",", "}", "\n", "}", "\n\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "headerPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "os", ".", "PathError", "{", "Op", ":", "\"", "\"", ",", "Path", ":", "headerPath", ",", "Err", ":", "err", ",", "}", "\n", "}", "\n\n", "if", "err", "=", "o", ".", "Datapath", ".", "WriteEndpointConfig", "(", "f", ",", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "&", "os", ".", "PathError", "{", "Op", ":", "\"", "\"", ",", "Path", ":", "headerPath", ",", "Err", ":", "err", ",", "}", "\n", "}", "\n\n", "cfg", ".", "stats", ".", "bpfCompilation", ".", "Start", "(", ")", "\n", "err", "=", "compileTemplate", "(", "ctx", ",", "templatePath", ")", "\n", "cfg", ".", "stats", ".", "bpfCompilation", ".", "End", "(", "err", "==", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "os", ".", "PathError", "{", "Op", ":", "\"", "\"", ",", "Path", ":", "templatePath", ",", "Err", ":", "err", ",", "}", "\n", "}", "\n\n", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Path", ":", "objectPath", ",", "logfields", ".", "BPFCompilationTime", ":", "cfg", ".", "stats", ".", "bpfCompilation", ".", "Total", "(", ")", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "o", ".", "insert", "(", "hash", ",", "objectPath", ")", "\n", "return", "nil", "\n", "}" ]

[ "build", "attempts", "to", "compile", "and", "cache", "a", "datapath", "template", "object", "file", "corresponding", "to", "the", "specified", "endpoint", "configuration", "." ]

[ "func", "(", "o", "*", "objectCache", ")", "fetchOrCompile", "(", "ctx", "context", ".", "Context", ",", "cfg", "datapath", ".", "EndpointConfiguration", ",", "stats", "*", "SpanStat", ")", "(", "path", "string", ",", "compiled", "bool", ",", "err", "error", ")", "{", "var", "hash", "string", "\n", "hash", ",", "err", "=", "o", ".", "baseHash", ".", "sumEndpoint", "(", "o", ",", "cfg", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "false", ",", "err", "\n", "}", "\n\n", "// Capture the time spent waiting for the template to compile.", "if", "stats", "!=", "nil", "{", "stats", ".", "bpfWaitForELF", ".", "Start", "(", ")", "\n", "defer", "func", "(", ")", "{", "// Wrap to ensure that \"err\" is compared upon return.", "stats", ".", "bpfWaitForELF", ".", "End", "(", "err", "==", "nil", ")", "\n", "}", "(", ")", "\n", "}", "\n\n", "scopedLog", ":=", "log", ".", "WithField", "(", "logfields", ".", "BPFHeaderfileHash", ",", "hash", ")", "\n\n", "// Serializes attempts to compile this cfg.", "fq", ",", "compiled", ":=", "o", ".", "serialize", "(", "hash", ")", "\n", "if", "!", "compiled", "{", "fq", ".", "Enqueue", "(", "func", "(", ")", "error", "{", "defer", "fq", ".", "Stop", "(", ")", "\n", "templateCfg", ":=", "wrap", "(", "cfg", ",", "stats", ")", "\n", "err", ":=", "o", ".", "build", "(", "ctx", ",", "templateCfg", ",", "hash", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}", ",", "serializer", ".", "NoRetry", ")", "\n", "}", "\n\n", "// Wait until the build completes.", "if", "err", "=", "fq", ".", "Wait", "(", "ctx", ")", ";", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "\"", "\"", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Fetch the result of the compilation.", "path", ",", "ok", ":=", "o", ".", "lookup", "(", "hash", ")", "\n", "if", "!", "ok", "{", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "\"", "\"", ",", "false", ",", "err", "\n", "}", "\n\n", "return", "path", ",", "!", "compiled", ",", "nil", "\n", "}" ]

[ "fetchOrCompile", "attempts", "to", "fetch", "the", "path", "to", "the", "datapath", "object", "corresponding", "to", "the", "provided", "endpoint", "configuration", "or", "if", "this", "configuration", "is", "not", "yet", "compiled", "compiles", "it", ".", "It", "will", "block", "if", "multiple", "threads", "attempt", "to", "concurrently", "fetchOrCompile", "a", "template", "binary", "for", "the", "same", "set", "of", "EndpointConfiguration", ".", "Returns", "the", "path", "to", "the", "compiled", "template", "datapath", "object", "and", "whether", "the", "object", "was", "compiled", "or", "an", "error", "." ]

[ "func", "EndpointHash", "(", "cfg", "datapath", ".", "EndpointConfiguration", ")", "(", "string", ",", "error", ")", "{", "return", "templateCache", ".", "baseHash", ".", "sumEndpoint", "(", "templateCache", ",", "cfg", ",", "true", ")", "\n", "}" ]

[ "EndpointHash", "hashes", "the", "specified", "endpoint", "configuration", "with", "the", "current", "datapath", "hash", "cache", "and", "returns", "the", "hash", "as", "string", "." ]

[ "func", "NewCache", "(", ")", "*", "Cache", "{", "return", "&", "Cache", "{", "BaseObservableResourceSource", ":", "NewBaseObservableResourceSource", "(", ")", ",", "resources", ":", "make", "(", "map", "[", "cacheKey", "]", "cacheValue", ")", ",", "version", ":", "1", ",", "}", "\n", "}" ]

[ "NewCache", "creates", "a", "new", "empty", "cache", "with", "0", "as", "its", "current", "version", "." ]

[ "func", "(", "c", "*", "Cache", ")", "Lookup", "(", "typeURL", "string", ",", "resourceName", "string", ")", "(", "proto", ".", "Message", ",", "error", ")", "{", "res", ",", "err", ":=", "c", ".", "GetResources", "(", "context", ".", "Background", "(", ")", ",", "typeURL", ",", "0", ",", "nil", ",", "[", "]", "string", "{", "resourceName", "}", ")", "\n", "if", "err", "!=", "nil", "||", "res", "==", "nil", "||", "len", "(", "res", ".", "Resources", ")", "==", "0", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "res", ".", "Resources", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "Lookup", "finds", "the", "resource", "corresponding", "to", "the", "specified", "typeURL", "and", "resourceName", "if", "available", "and", "returns", "it", ".", "Otherwise", "returns", "nil", ".", "If", "an", "error", "occurs", "while", "fetching", "the", "resource", "also", "returns", "the", "error", "." ]

[ "func", "(", "e", "*", "ExtraOptions", ")", "StatusCheckInterval", "(", "allConnected", "bool", ")", "time", ".", "Duration", "{", "interval", ":=", "30", "*", "time", ".", "Second", "\n\n", "// Reduce the interval while connectivity issues are being detected", "if", "!", "allConnected", "{", "interval", "=", "5", "*", "time", ".", "Second", "\n", "}", "\n\n", "if", "e", "!=", "nil", "&&", "e", ".", "ClusterSizeDependantInterval", "!=", "nil", "{", "interval", "=", "e", ".", "ClusterSizeDependantInterval", "(", "interval", ")", "\n", "}", "\n", "return", "interval", "\n", "}" ]

[ "StatusCheckInterval", "returns", "the", "interval", "of", "status", "checks", "depending", "on", "the", "cluster", "size", "and", "the", "current", "connectivity", "state", "nodes", "OK", "Failing", "1", "20s", "3s", "4", "45s", "7s", "8", "1m05s", "11s", "32", "1m45s", "18s", "128", "2m25s", "24s", "512", "3m07s", "32s", "2048", "3m46s", "38s", "8192", "4m30s", "45s" ]

[ "func", "registerBackend", "(", "name", "string", ",", "module", "backendModule", ")", "{", "if", "_", ",", "ok", ":=", "registeredBackends", "[", "name", "]", ";", "ok", "{", "log", ".", "Panicf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "registeredBackends", "[", "name", "]", "=", "module", "\n", "}" ]

[ "registerBackend", "must", "be", "called", "by", "kvstore", "backends", "to", "register", "themselves" ]

[ "func", "getBackend", "(", "name", "string", ")", "backendModule", "{", "if", "backend", ",", "ok", ":=", "registeredBackends", "[", "name", "]", ";", "ok", "{", "return", "backend", ".", "createInstance", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "getBackend", "finds", "a", "registered", "backend", "by", "name" ]

[ "func", "getEnvName", "(", "option", "string", ")", "string", "{", "under", ":=", "strings", ".", "Replace", "(", "option", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "upper", ":=", "strings", ".", "ToUpper", "(", "under", ")", "\n", "return", "ciliumEnvPrefix", "+", "upper", "\n", "}" ]

[ "getEnvName", "returns", "the", "environment", "variable", "to", "be", "used", "for", "the", "given", "option", "name", "." ]

[ "func", "BindEnv", "(", "optName", "string", ")", "{", "registerOpt", "(", "optName", ")", "\n", "viper", ".", "BindEnv", "(", "optName", ",", "getEnvName", "(", "optName", ")", ")", "\n", "}" ]

[ "BindEnv", "binds", "the", "option", "name", "with", "an", "deterministic", "generated", "environment", "variable", "which", "s", "based", "on", "the", "given", "optName", ".", "If", "the", "same", "optName", "is", "bind", "more", "than", "1", "time", "this", "function", "panics", "." ]

[ "func", "BindEnvWithLegacyEnvFallback", "(", "optName", ",", "legacyEnvName", "string", ")", "{", "registerOpt", "(", "optName", ")", "\n\n", "envName", ":=", "getEnvName", "(", "optName", ")", "\n", "if", "os", ".", "Getenv", "(", "envName", ")", "==", "\"", "\"", "{", "envName", "=", "legacyEnvName", "\n", "}", "\n\n", "viper", ".", "BindEnv", "(", "optName", ",", "envName", ")", "\n", "}" ]

[ "BindEnvWithLegacyEnvFallback", "binds", "the", "given", "option", "name", "with", "either", "the", "same", "environment", "variable", "as", "BindEnv", "if", "it", "s", "set", "or", "with", "the", "given", "legacyEnvName", ".", "The", "function", "is", "used", "to", "work", "around", "the", "viper", ".", "BindEnv", "limitation", "that", "only", "one", "environment", "variable", "can", "be", "bound", "for", "an", "option", "and", "we", "need", "multiple", "environment", "variables", "due", "to", "backward", "compatibility", "reasons", "." ]

[ "func", "LogRegisteredOptions", "(", "entry", "*", "logrus", ".", "Entry", ")", "{", "keys", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "RegisteredOptions", ")", ")", "\n", "for", "k", ":=", "range", "RegisteredOptions", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "entry", ".", "Infof", "(", "\"", "\"", ",", "k", ",", "viper", ".", "GetString", "(", "k", ")", ")", "\n", "}", "\n", "}" ]

[ "LogRegisteredOptions", "logs", "all", "options", "that", "where", "bind", "to", "viper", "." ]

[ "func", "(", "c", "*", "DaemonConfig", ")", "GetNodeConfigPath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "c", ".", "GetGlobalsDir", "(", ")", ",", "common", ".", "NodeConfigFile", ")", "\n", "}" ]

[ "GetNodeConfigPath", "returns", "the", "full", "path", "of", "the", "NodeConfigFile", "." ]

[ "func", "(", "c", "*", "DaemonConfig", ")", "WorkloadsEnabled", "(", ")", "bool", "{", "for", "_", ",", "w", ":=", "range", "c", ".", "Workloads", "{", "if", "w", "==", "\"", "\"", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "len", "(", "c", ".", "Workloads", ")", ">", "0", "\n", "}" ]

[ "WorkloadsEnabled", "returns", "true", "if", "any", "workload", "runtimes", "are", "enabled" ]

[ "func", "(", "c", "*", "DaemonConfig", ")", "AlwaysAllowLocalhost", "(", ")", "bool", "{", "switch", "c", ".", "AllowLocalhost", "{", "case", "AllowLocalhostAlways", ":", "return", "true", "\n", "case", "AllowLocalhostAuto", ",", "AllowLocalhostPolicy", ":", "return", "false", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "AlwaysAllowLocalhost", "returns", "true", "if", "the", "daemon", "has", "the", "option", "set", "that", "localhost", "can", "always", "reach", "local", "endpoints" ]

[ "func", "(", "c", "*", "DaemonConfig", ")", "Validate", "(", ")", "error", "{", "if", "err", ":=", "c", ".", "validateIPv6ClusterAllocCIDR", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "IPv6ClusterAllocCIDR", ",", "IPv6ClusterAllocCIDRName", ",", "err", ")", "\n", "}", "\n\n", "if", "c", ".", "MTU", "<", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "MTU", ")", "\n", "}", "\n\n", "switch", "c", ".", "Tunnel", "{", "case", "TunnelVXLAN", ",", "TunnelGeneve", ",", "\"", "\"", ":", "case", "TunnelDisabled", ":", "if", "c", ".", "UseSingleClusterRoute", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "SingleClusterRouteName", ",", "TunnelName", ",", "TunnelDisabled", ")", "\n", "}", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "Tunnel", ",", "GetTunnelModes", "(", ")", ")", "\n", "}", "\n\n", "if", "c", ".", "ClusterID", "<", "ClusterIDMin", "||", "c", ".", "ClusterID", ">", "ClusterIDMax", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "ClusterID", ",", "ClusterIDMin", ",", "ClusterIDMax", ")", "\n", "}", "\n\n", "if", "c", ".", "ClusterID", "!=", "0", "{", "if", "c", ".", "ClusterName", "==", "defaults", ".", "ClusterName", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "defaults", ".", "ClusterName", ",", "ClusterIDName", ")", "\n", "}", "\n", "}", "\n\n", "ctTableMin", ":=", "1", "<<", "10", "// 1Ki entries", "\n", "ctTableMax", ":=", "1", "<<", "24", "// 16Mi entries (~1GiB of entries per map)", "\n", "if", "c", ".", "CTMapEntriesGlobalTCP", "<", "ctTableMin", "||", "c", ".", "CTMapEntriesGlobalAny", "<", "ctTableMin", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "CTMapEntriesGlobalTCP", ",", "c", ".", "CTMapEntriesGlobalAny", ",", "ctTableMin", ")", "\n", "}", "\n", "if", "c", ".", "CTMapEntriesGlobalTCP", ">", "ctTableMax", "||", "c", ".", "CTMapEntriesGlobalAny", ">", "ctTableMax", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "c", ".", "CTMapEntriesGlobalTCP", ",", "c", ".", "CTMapEntriesGlobalAny", ",", "ctTableMax", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "the", "daemon", "configuration" ]

[ "func", "ReadDirConfig", "(", "dirName", "string", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "m", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "fi", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "dirName", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "fi", "{", "if", "f", ".", "Mode", "(", ")", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n", "fName", ":=", "filepath", ".", "Join", "(", "dirName", ",", "f", ".", "Name", "(", ")", ")", "\n\n", "// the file can still be a symlink to a directory", "if", "f", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "==", "0", "{", "absFileName", ",", "err", ":=", "filepath", ".", "EvalSymlinks", "(", "fName", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "absFileName", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "fName", "=", "absFileName", "\n", "}", "\n\n", "f", ",", "err", "=", "os", ".", "Stat", "(", "fName", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "fName", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "if", "f", ".", "Mode", "(", ")", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n\n", "b", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "fName", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "fName", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "m", "[", "f", ".", "Name", "(", ")", "]", "=", "string", "(", "bytes", ".", "TrimSpace", "(", "b", ")", ")", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "ReadDirConfig", "reads", "the", "given", "directory", "and", "returns", "a", "map", "that", "maps", "the", "filename", "to", "the", "contents", "of", "that", "file", "." ]

[ "func", "MergeConfig", "(", "m", "map", "[", "string", "]", "interface", "{", "}", ")", "error", "{", "err", ":=", "viper", ".", "MergeConfigMap", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "MergeConfig", "merges", "the", "given", "configuration", "map", "with", "viper", "s", "configuration", "." ]

[ "func", "ReplaceDeprecatedFields", "(", "m", "map", "[", "string", "]", "interface", "{", "}", ")", "{", "deprecatedFields", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "MonitorAggregationName", ",", "\"", "\"", ":", "CTMapEntriesGlobalTCPName", ",", "\"", "\"", ":", "CTMapEntriesGlobalAnyName", ",", "}", "\n", "for", "deprecatedOption", ",", "newOption", ":=", "range", "deprecatedFields", "{", "if", "deprecatedValue", ",", "ok", ":=", "m", "[", "deprecatedOption", "]", ";", "ok", "{", "if", "_", ",", "ok", ":=", "m", "[", "newOption", "]", ";", "!", "ok", "{", "m", "[", "newOption", "]", "=", "deprecatedValue", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReplaceDeprecatedFields", "replaces", "the", "deprecated", "options", "set", "with", "the", "new", "set", "of", "options", "that", "overwrite", "the", "deprecated", "ones", ".", "This", "function", "replaces", "the", "deprecated", "fields", "used", "by", "environment", "variables", "with", "a", "different", "name", "than", "the", "option", "they", "are", "setting", ".", "This", "also", "replaces", "the", "deprecated", "names", "used", "in", "the", "Kubernetes", "ConfigMap", ".", "Once", "we", "remove", "them", "from", "this", "function", "we", "also", "need", "to", "remove", "them", "from", "daemon_main", ".", "go", "and", "warn", "users", "about", "the", "old", "environment", "variable", "nor", "the", "option", "in", "the", "configuration", "map", "have", "any", "effect", "." ]

[ "func", "(", "m", "DatapathMode", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "// value enum", "if", "err", ":=", "m", ".", "validateDatapathModeEnum", "(", "\"", "\"", ",", "\"", "\"", ",", "m", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "len", "(", "res", ")", ">", "0", "{", "return", "errors", ".", "CompositeValidationError", "(", "res", "...", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "this", "datapath", "mode" ]

[ "func", "(", "m", "*", "IpvlanConfiguration", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateOperationMode", "(", "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", "ipvlan", "configuration" ]

[ "func", "(", "m", "*", "BPFMapEntry", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateDesiredAction", "(", "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", "b", "p", "f", "map", "entry" ]

[ "func", "(", "l", "*", "linuxDatapath", ")", "WriteNetdevConfig", "(", "w", "io", ".", "Writer", ",", "cfg", "datapath", ".", "DeviceConfiguration", ")", "error", "{", "fw", ":=", "bufio", ".", "NewWriter", "(", "w", ")", "\n", "l", ".", "writeNetdevConfig", "(", "fw", ",", "cfg", ")", "\n", "return", "fw", ".", "Flush", "(", ")", "\n", "}" ]

[ "WriteNetdevConfig", "writes", "the", "BPF", "configuration", "for", "the", "endpoint", "to", "a", "writer", "." ]

[ "func", "(", "l", "*", "linuxDatapath", ")", "WriteEndpointConfig", "(", "w", "io", ".", "Writer", ",", "e", "datapath", ".", "EndpointConfiguration", ")", "error", "{", "fw", ":=", "bufio", ".", "NewWriter", "(", "w", ")", "\n\n", "writeIncludes", "(", "w", ")", "\n", "l", ".", "writeStaticData", "(", "fw", ",", "e", ")", "\n\n", "return", "l", ".", "writeTemplateConfig", "(", "fw", ",", "e", ")", "\n", "}" ]

[ "WriteEndpointConfig", "writes", "the", "BPF", "configuration", "for", "the", "endpoint", "to", "a", "writer", "." ]

[ "func", "(", "l", "*", "linuxDatapath", ")", "WriteTemplateConfig", "(", "w", "io", ".", "Writer", ",", "e", "datapath", ".", "EndpointConfiguration", ")", "error", "{", "fw", ":=", "bufio", ".", "NewWriter", "(", "w", ")", "\n", "return", "l", ".", "writeTemplateConfig", "(", "fw", ",", "e", ")", "\n", "}" ]

[ "WriteEndpointConfig", "writes", "the", "BPF", "configuration", "for", "the", "template", "to", "a", "writer", "." ]

[ "func", "updateStaleEntriesFunction", "(", "keysToRemove", "map", "[", "string", "]", "*", "ipcacheMap", ".", "Key", ")", "bpf", ".", "DumpCallback", "{", "return", "func", "(", "key", "bpf", ".", "MapKey", ",", "value", "bpf", ".", "MapValue", ")", "{", "k", ":=", "key", ".", "(", "*", "ipcacheMap", ".", "Key", ")", "\n", "keyToIP", ":=", "k", ".", "String", "(", ")", "\n\n", "// Don't RLock as part of the same goroutine.", "if", "i", ",", "exists", ":=", "ipcache", ".", "IPIdentityCache", ".", "LookupByPrefixRLocked", "(", "keyToIP", ")", ";", "!", "exists", "{", "switch", "i", ".", "Source", "{", "case", "ipcache", ".", "FromKVStore", ",", "ipcache", ".", "FromAgentLocal", ":", "// Cannot delete from map during callback because DumpWithCallback", "// RLocks the map.", "keysToRemove", "[", "keyToIP", "]", "=", "k", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "updateStaleEntriesFunction", "returns", "a", "DumpCallback", "that", "will", "update", "the", "specified", "keysToRemove", "map", "with", "entries", "that", "exist", "in", "the", "BPF", "map", "which", "do", "not", "exist", "in", "the", "in", "-", "memory", "ipcache", ".", "Must", "be", "called", "while", "holding", "ipcache", ".", "IPIdentityCache", ".", "Lock", "for", "reading", "." ]

[ "func", "handleMapShuffleFailure", "(", "src", ",", "dst", "string", ")", "{", "backupPath", ":=", "bpf", ".", "MapPath", "(", "src", ")", "\n", "realizedPath", ":=", "bpf", ".", "MapPath", "(", "dst", ")", "\n\n", "if", "err", ":=", "os", ".", "Rename", "(", "backupPath", ",", "realizedPath", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "BPFMapPath", ":", "realizedPath", ",", "}", ")", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "handleMapShuffleFailure", "attempts", "to", "move", "the", "map", "with", "name", "backup", "back", "to", "realized", "and", "logs", "a", "warning", "message", "if", "this", "can", "t", "be", "achieved", "." ]

[ "func", "shuffleMaps", "(", "realized", ",", "backup", ",", "pending", "string", ")", "error", "{", "realizedPath", ":=", "bpf", ".", "MapPath", "(", "realized", ")", "\n", "backupPath", ":=", "bpf", ".", "MapPath", "(", "backup", ")", "\n", "pendingPath", ":=", "bpf", ".", "MapPath", "(", "pending", ")", "\n\n", "if", "err", ":=", "os", ".", "Rename", "(", "realizedPath", ",", "backupPath", ")", ";", "err", "!=", "nil", "&&", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "Rename", "(", "pendingPath", ",", "realizedPath", ")", ";", "err", "!=", "nil", "{", "handleMapShuffleFailure", "(", "backup", ",", "realized", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "shuffleMaps", "attempts", "to", "move", "the", "map", "with", "name", "realized", "to", "backup", "and", "pending", "to", "realized", ".", "If", "an", "error", "occurs", "attempts", "to", "return", "the", "maps", "back", "to", "their", "original", "paths", "." ]

[ "func", "(", "l", "*", "BPFListener", ")", "OnIPIdentityCacheGC", "(", ")", "{", "// This controller ensures that the in-memory IP-identity cache is in-sync", "// with the BPF map on disk. These can get out of sync if the cilium-agent", "// is offline for some time, as the maps persist on the BPF filesystem.", "// In the case that there is some loss of event history in the key-value", "// store (e.g., compaction in etcd), we cannot rely upon the key-value store", "// fully to give us the history of all events. As such, periodically check", "// for inconsistencies in the data-path with that in the agent to ensure", "// consistent state.", "controller", ".", "NewManager", "(", ")", ".", "UpdateController", "(", "\"", "\"", ",", "controller", ".", "ControllerParams", "{", "DoFunc", ":", "l", ".", "garbageCollect", ",", "RunInterval", ":", "5", "*", "time", ".", "Minute", ",", "}", ",", ")", "\n", "}" ]

[ "OnIPIdentityCacheGC", "spawns", "a", "controller", "which", "synchronizes", "the", "BPF", "IPCache", "Map", "with", "the", "in", "-", "memory", "IP", "-", "Identity", "cache", "." ]

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

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

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

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

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

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