Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.5k

[ "func", "(", "c", "*", "Configuration", ")", "NodeObserver", "(", ")", "store", ".", "Observer", "{", "if", "c", ".", "nodeObserver", "!=", "nil", "{", "return", "c", ".", "nodeObserver", "\n", "}", "\n\n", "return", "nodeStore", ".", "NewNodeObserver", "(", "c", ".", "NodeManager", ")", "\n", "}" ]

[ "NodeObserver", "returns", "the", "node", "store", "observer", "of", "the", "configuration" ]

[ "func", "NewClusterMesh", "(", "c", "Configuration", ")", "(", "*", "ClusterMesh", ",", "error", ")", "{", "cm", ":=", "&", "ClusterMesh", "{", "conf", ":", "c", ",", "clusters", ":", "map", "[", "string", "]", "*", "remoteCluster", "{", "}", ",", "controllers", ":", "controller", ".", "NewManager", "(", ")", ",", "globalServices", ":", "newGlobalServiceCache", "(", ")", ",", "}", "\n\n", "w", ",", "err", ":=", "createConfigDirectoryWatcher", "(", "c", ".", "ConfigDirectory", ",", "cm", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "cm", ".", "configWatcher", "=", "w", "\n\n", "if", "err", ":=", "cm", ".", "configWatcher", ".", "watch", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "cm", ",", "nil", "\n", "}" ]

[ "NewClusterMesh", "creates", "a", "new", "remote", "cluster", "cache", "based", "on", "the", "provided", "configuration" ]

[ "func", "(", "cm", "*", "ClusterMesh", ")", "Close", "(", ")", "{", "cm", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "cm", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "cm", ".", "configWatcher", "!=", "nil", "{", "cm", ".", "configWatcher", ".", "close", "(", ")", "\n", "}", "\n\n", "for", "name", ",", "cluster", ":=", "range", "cm", ".", "clusters", "{", "cluster", ".", "onRemove", "(", ")", "\n", "delete", "(", "cm", ".", "clusters", ",", "name", ")", "\n", "}", "\n\n", "cm", ".", "controllers", ".", "RemoveAllAndWait", "(", ")", "\n", "}" ]

[ "Close", "stops", "watching", "for", "remote", "cluster", "configuration", "files", "to", "appear", "and", "will", "close", "all", "connections", "to", "remote", "clusters" ]

[ "func", "(", "cm", "*", "ClusterMesh", ")", "NumReadyClusters", "(", ")", "int", "{", "cm", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "cm", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "nready", ":=", "0", "\n", "for", "_", ",", "cm", ":=", "range", "cm", ".", "clusters", "{", "if", "cm", ".", "isReady", "(", ")", "{", "nready", "++", "\n", "}", "\n", "}", "\n\n", "return", "nready", "\n", "}" ]

[ "NumReadyClusters", "returns", "the", "number", "of", "remote", "clusters", "to", "which", "a", "connection", "has", "been", "established" ]

[ "func", "LogCurrentSystemLoad", "(", "logFunc", "LogFunc", ")", "{", "loadInfo", ",", "err", ":=", "load", ".", "Avg", "(", ")", "\n", "if", "err", "==", "nil", "{", "logFunc", "(", "\"", "\"", ",", "loadInfo", ".", "Load1", ",", "loadInfo", ".", "Load5", ",", "loadInfo", ".", "Load15", ")", "\n", "}", "\n\n", "memInfo", ",", "err", ":=", "mem", ".", "VirtualMemory", "(", ")", "\n", "if", "err", "==", "nil", "&&", "memInfo", "!=", "nil", "{", "logFunc", "(", "\"", "\"", ",", "toMB", "(", "memInfo", ".", "Total", ")", ",", "toMB", "(", "memInfo", ".", "Used", ")", ",", "memInfo", ".", "UsedPercent", ",", "toMB", "(", "memInfo", ".", "Free", ")", ",", "toMB", "(", "memInfo", ".", "Buffers", ")", ",", "toMB", "(", "memInfo", ".", "Cached", ")", ")", "\n", "}", "\n\n", "swapInfo", ",", "err", ":=", "mem", ".", "SwapMemory", "(", ")", "\n", "if", "err", "==", "nil", "&&", "swapInfo", "!=", "nil", "{", "logFunc", "(", "\"", "\"", ",", "toMB", "(", "swapInfo", ".", "Total", ")", ",", "toMB", "(", "swapInfo", ".", "Used", ")", ",", "swapInfo", ".", "UsedPercent", ",", "toMB", "(", "swapInfo", ".", "Free", ")", ")", "\n", "}", "\n\n", "procs", ",", "err", ":=", "process", ".", "Processes", "(", ")", "\n", "if", "err", "==", "nil", "{", "for", "_", ",", "p", ":=", "range", "procs", "{", "cpuPercent", ",", "_", ":=", "p", ".", "CPUPercent", "(", ")", "\n", "if", "cpuPercent", ">", "cpuWatermark", "{", "name", ",", "_", ":=", "p", ".", "Name", "(", ")", "\n", "status", ",", "_", ":=", "p", ".", "Status", "(", ")", "\n", "memPercent", ",", "_", ":=", "p", ".", "MemoryPercent", "(", ")", "\n", "cmdline", ",", "_", ":=", "p", ".", "Cmdline", "(", ")", "\n\n", "memExt", ":=", "\"", "\"", "\n", "if", "memInfo", ",", "err", ":=", "p", ".", "MemoryInfo", "(", ")", ";", "memInfo", "!=", "nil", "&&", "err", "==", "nil", "{", "memExt", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "toMB", "(", "memInfo", ".", "RSS", ")", ",", "toMB", "(", "memInfo", ".", "VMS", ")", ",", "toMB", "(", "memInfo", ".", "Data", ")", ",", "toMB", "(", "memInfo", ".", "Stack", ")", ",", "toMB", "(", "memInfo", ".", "Locked", ")", ",", "toMB", "(", "memInfo", ".", "Swap", ")", ")", "\n", "}", "\n\n", "logFunc", "(", "\"", "\"", ",", "name", ",", "status", ",", "p", ".", "Pid", ",", "cpuPercent", ",", "memPercent", ",", "cmdline", ",", "memExt", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "LogCurrentSystemLoad", "logs", "the", "current", "system", "load", "and", "lists", "all", "processes", "consuming", "more", "than", "cpuWatermark", "of", "the", "CPU" ]

[ "func", "LogPeriodicSystemLoad", "(", "logFunc", "LogFunc", ",", "interval", "time", ".", "Duration", ")", "CloseChan", "{", "closeChan", ":=", "make", "(", "CloseChan", ")", "\n", "go", "func", "(", ")", "{", "for", "{", "LogCurrentSystemLoad", "(", "logFunc", ")", "\n\n", "select", "{", "case", "<-", "closeChan", ":", "return", "\n", "default", ":", "}", "\n\n", "time", ".", "Sleep", "(", "interval", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "closeChan", "\n", "}" ]

[ "LogPeriodicSystemLoad", "logs", "the", "system", "load", "in", "the", "interval", "specified", "until", "the", "channel", "is", "closed" ]

[ "func", "ListAndWatch", "(", "name", ",", "prefix", "string", ",", "chanSize", "int", ")", "*", "Watcher", "{", "return", "Client", "(", ")", ".", "ListAndWatch", "(", "name", ",", "prefix", ",", "chanSize", ")", "\n", "}" ]

[ "ListAndWatch", "creates", "a", "new", "watcher", "which", "will", "watch", "the", "specified", "prefix", "for", "changes", ".", "Before", "doing", "this", "it", "will", "list", "the", "current", "keys", "matching", "the", "prefix", "and", "report", "them", "as", "new", "keys", ".", "Name", "can", "be", "set", "to", "anything", "and", "is", "used", "for", "logging", "messages", ".", "The", "Events", "channel", "is", "created", "with", "the", "specified", "sizes", ".", "Upon", "every", "change", "observed", "a", "KeyValueEvent", "will", "be", "sent", "to", "the", "Events", "channel", "Returns", "a", "watcher", "structure", "plus", "a", "channel", "that", "is", "closed", "when", "the", "initial", "list", "operation", "has", "been", "completed" ]

[ "func", "NewPolicyRepository", "(", ")", "*", "Repository", "{", "repoChangeQueue", ":=", "eventqueue", ".", "NewEventQueueBuffered", "(", "\"", "\"", ",", "option", ".", "Config", ".", "PolicyQueueSize", ")", "\n", "ruleReactionQueue", ":=", "eventqueue", ".", "NewEventQueueBuffered", "(", "\"", "\"", ",", "option", ".", "Config", ".", "PolicyQueueSize", ")", "\n", "repoChangeQueue", ".", "Run", "(", ")", "\n", "ruleReactionQueue", ".", "Run", "(", ")", "\n", "return", "&", "Repository", "{", "revision", ":", "1", ",", "RepositoryChangeQueue", ":", "repoChangeQueue", ",", "RuleReactionQueue", ":", "ruleReactionQueue", ",", "}", "\n", "}" ]

[ "NewPolicyRepository", "allocates", "a", "new", "policy", "repository" ]

[ "func", "(", "p", "*", "Repository", ")", "ResolveL4EgressPolicy", "(", "ctx", "*", "SearchContext", ")", "(", "*", "L4PolicyMap", ",", "error", ")", "{", "result", ",", "err", ":=", "p", ".", "rules", ".", "resolveL4EgressPolicy", "(", "ctx", ",", "p", ".", "GetRevision", "(", ")", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "result", ".", "Egress", ",", "nil", "\n", "}" ]

[ "ResolveL4EgressPolicy", "resolves", "the", "L4", "egress", "policy", "for", "a", "set", "of", "endpoints", "by", "searching", "the", "policy", "repository", "for", "PortRule", "rules", "that", "are", "attached", "to", "a", "Rule", "where", "the", "EndpointSelector", "matches", "ctx", ".", "From", ".", "ctx", ".", "To", "takes", "no", "effect", "and", "is", "ignored", "in", "the", "search", ".", "If", "multiple", "PortRule", "rules", "are", "found", "all", "rules", "are", "merged", "together", ".", "If", "rules", "contains", "overlapping", "port", "definitions", "the", "first", "rule", "found", "in", "the", "repository", "takes", "precedence", "." ]

[ "func", "(", "p", "*", "Repository", ")", "ResolveCIDRPolicy", "(", "ctx", "*", "SearchContext", ")", "*", "CIDRPolicy", "{", "return", "p", ".", "rules", ".", "resolveCIDRPolicy", "(", "ctx", ")", "\n", "}" ]

[ "ResolveCIDRPolicy", "resolves", "the", "L3", "policy", "for", "a", "set", "of", "endpoints", "by", "searching", "the", "policy", "repository", "for", "CIDR", "rules", "that", "are", "attached", "to", "a", "Rule", "where", "the", "EndpointSelector", "matches", "ctx", ".", "To", ".", "ctx", ".", "From", "takes", "no", "effect", "and", "is", "ignored", "in", "the", "search", "." ]

[ "func", "(", "p", "*", "Repository", ")", "AllowsIngressRLocked", "(", "ctx", "*", "SearchContext", ")", "api", ".", "Decision", "{", "// Lack of DPorts in the SearchContext means L3-only search", "if", "len", "(", "ctx", ".", "DPorts", ")", "==", "0", "{", "newCtx", ":=", "*", "ctx", "\n", "newCtx", ".", "DPorts", "=", "[", "]", "*", "models", ".", "Port", "{", "{", "Port", ":", "0", ",", "Protocol", ":", "models", ".", "PortProtocolANY", ",", "}", "}", "\n", "ctx", "=", "&", "newCtx", "\n", "}", "\n\n", "ctx", ".", "PolicyTrace", "(", "\"", "\"", ",", "ctx", ".", "String", "(", ")", ")", "\n", "ingressPolicy", ",", "err", ":=", "p", ".", "ResolveL4IngressPolicy", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n\n", "verdict", ":=", "api", ".", "Denied", "\n", "if", "err", "==", "nil", "&&", "len", "(", "*", "ingressPolicy", ")", ">", "0", "{", "verdict", "=", "ingressPolicy", ".", "IngressCoversContext", "(", "ctx", ")", "\n", "}", "\n\n", "ctx", ".", "PolicyTrace", "(", "\"", "\"", ",", "verdict", ".", "String", "(", ")", ")", "\n", "return", "verdict", "\n", "}" ]

[ "AllowsIngressRLocked", "evaluates", "the", "policy", "repository", "for", "the", "provided", "search", "context", "and", "returns", "the", "verdict", "for", "ingress", ".", "If", "no", "matching", "policy", "allows", "for", "the", "connection", "the", "request", "will", "be", "denied", ".", "The", "policy", "repository", "mutex", "must", "be", "held", "." ]

[ "func", "(", "p", "*", "Repository", ")", "AllowsEgressRLocked", "(", "ctx", "*", "SearchContext", ")", "api", ".", "Decision", "{", "// Lack of DPorts in the SearchContext means L3-only search", "if", "len", "(", "ctx", ".", "DPorts", ")", "==", "0", "{", "newCtx", ":=", "*", "ctx", "\n", "newCtx", ".", "DPorts", "=", "[", "]", "*", "models", ".", "Port", "{", "{", "Port", ":", "0", ",", "Protocol", ":", "models", ".", "PortProtocolANY", ",", "}", "}", "\n", "ctx", "=", "&", "newCtx", "\n", "}", "\n\n", "ctx", ".", "PolicyTrace", "(", "\"", "\\n", "\"", ",", "ctx", ".", "String", "(", ")", ")", "\n", "egressPolicy", ",", "err", ":=", "p", ".", "ResolveL4EgressPolicy", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "verdict", ":=", "api", ".", "Denied", "\n", "if", "err", "==", "nil", "&&", "len", "(", "*", "egressPolicy", ")", ">", "0", "{", "verdict", "=", "egressPolicy", ".", "EgressCoversContext", "(", "ctx", ")", "\n", "}", "\n\n", "ctx", ".", "PolicyTrace", "(", "\"", "\"", ",", "verdict", ".", "String", "(", ")", ")", "\n", "return", "verdict", "\n", "}" ]

[ "AllowsEgressRLocked", "evaluates", "the", "policy", "repository", "for", "the", "provided", "search", "context", "and", "returns", "the", "verdict", ".", "If", "no", "matching", "policy", "allows", "for", "the", "connection", "the", "request", "will", "be", "denied", ".", "The", "policy", "repository", "mutex", "must", "be", "held", "." ]

[ "func", "(", "p", "*", "Repository", ")", "SearchRLocked", "(", "labels", "labels", ".", "LabelArray", ")", "api", ".", "Rules", "{", "result", ":=", "api", ".", "Rules", "{", "}", "\n\n", "for", "_", ",", "r", ":=", "range", "p", ".", "rules", "{", "if", "r", ".", "Labels", ".", "Contains", "(", "labels", ")", "{", "result", "=", "append", "(", "result", ",", "&", "r", ".", "Rule", ")", "\n", "}", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "SearchRLocked", "searches", "the", "policy", "repository", "for", "rules", "which", "match", "the", "specified", "labels", "and", "will", "return", "an", "array", "of", "all", "rules", "which", "matched", "." ]

[ "func", "(", "p", "*", "Repository", ")", "AddListLocked", "(", "rules", "api", ".", "Rules", ")", "(", "ruleSlice", ",", "uint64", ")", "{", "newList", ":=", "make", "(", "ruleSlice", ",", "len", "(", "rules", ")", ")", "\n", "for", "i", ":=", "range", "rules", "{", "newRule", ":=", "&", "rule", "{", "Rule", ":", "*", "rules", "[", "i", "]", ",", "metadata", ":", "newRuleMetadata", "(", ")", ",", "}", "\n", "newList", "[", "i", "]", "=", "newRule", "\n", "}", "\n\n", "p", ".", "rules", "=", "append", "(", "p", ".", "rules", ",", "newList", "...", ")", "\n", "p", ".", "BumpRevision", "(", ")", "\n", "metrics", ".", "PolicyCount", ".", "Add", "(", "float64", "(", "len", "(", "newList", ")", ")", ")", "\n\n", "return", "newList", ",", "p", ".", "GetRevision", "(", ")", "\n", "}" ]

[ "AddListLocked", "inserts", "a", "rule", "into", "the", "policy", "repository", "with", "the", "repository", "already", "locked", "Expects", "that", "the", "entire", "rule", "list", "has", "already", "been", "sanitized", "." ]

[ "func", "(", "p", "*", "Repository", ")", "removeIdentityFromRuleCaches", "(", "identity", "*", "identity", ".", "Identity", ")", "*", "sync", ".", "WaitGroup", "{", "var", "wg", "sync", ".", "WaitGroup", "\n", "wg", ".", "Add", "(", "len", "(", "p", ".", "rules", ")", ")", "\n", "for", "_", ",", "r", ":=", "range", "p", ".", "rules", "{", "go", "func", "(", "rr", "*", "rule", ",", "wgg", "*", "sync", ".", "WaitGroup", ")", "{", "rr", ".", "metadata", ".", "delete", "(", "identity", ")", "\n", "wgg", ".", "Done", "(", ")", "\n", "}", "(", "r", ",", "&", "wg", ")", "\n", "}", "\n", "return", "&", "wg", "\n", "}" ]

[ "removeIdentityFromRuleCaches", "removes", "the", "identity", "from", "the", "selector", "cache", "in", "each", "rule", "in", "the", "repository", ".", "Returns", "a", "sync", ".", "WaitGroup", "that", "blocks", "until", "the", "policy", "operation", "is", "complete", ".", "The", "repository", "read", "lock", "must", "be", "held", "until", "the", "waitgroup", "is", "complete", "." ]

[ "func", "(", "p", "*", "Repository", ")", "LocalEndpointIdentityRemoved", "(", "identity", "*", "identity", ".", "Identity", ")", "{", "go", "func", "(", ")", "{", "scopedLog", ":=", "log", ".", "WithField", "(", "logfields", ".", "Identity", ",", "identity", ")", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "p", ".", "Mutex", ".", "RLock", "(", ")", "\n", "wg", ":=", "p", ".", "removeIdentityFromRuleCaches", "(", "identity", ")", "\n", "wg", ".", "Wait", "(", ")", "\n", "p", ".", "Mutex", ".", "RUnlock", "(", ")", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "(", ")", "\n", "}" ]

[ "LocalEndpointIdentityRemoved", "handles", "local", "identity", "removal", "events", "to", "remove", "references", "from", "rules", "in", "the", "repository", "to", "the", "specified", "identity", "." ]

[ "func", "(", "p", "*", "Repository", ")", "AddList", "(", "rules", "api", ".", "Rules", ")", "(", "ruleSlice", ",", "uint64", ")", "{", "p", ".", "Mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Mutex", ".", "Unlock", "(", ")", "\n", "return", "p", ".", "AddListLocked", "(", "rules", ")", "\n", "}" ]

[ "AddList", "inserts", "a", "rule", "into", "the", "policy", "repository", ".", "It", "is", "used", "for", "unit", "-", "testing", "purposes", "only", "." ]

[ "func", "(", "r", "ruleSlice", ")", "UpdateRulesEndpointsCaches", "(", "endpointsToBumpRevision", "*", "EndpointSet", ",", "endpointsToRegenerate", "*", "IDSet", ",", "policySelectionWG", "*", "sync", ".", "WaitGroup", ")", "{", "// No need to check whether endpoints need to be regenerated here since we", "// will unconditionally regenerate all endpoints later.", "if", "!", "option", ".", "Config", ".", "SelectiveRegeneration", "{", "return", "\n", "}", "\n\n", "endpointsToBumpRevision", ".", "ForEach", "(", "policySelectionWG", ",", "func", "(", "epp", "Endpoint", ")", "{", "endpointSelected", ",", "err", ":=", "r", ".", "updateEndpointsCaches", "(", "epp", ",", "endpointsToRegenerate", ")", "\n\n", "// If we could not evaluate the rules against the current endpoint, or", "// the endpoint is not selected by the rules, remove it from the set", "// of endpoints to bump the revision. If the error is non-nil, the", "// endpoint is no longer in either set (endpointsToBumpRevision or", "// endpointsToRegenerate, as we could not determine what to do for the", "// endpoint). This is usually the case when the endpoint is no longer", "// alive (i.e., it has been marked to be deleted).", "if", "endpointSelected", "||", "err", "!=", "nil", "{", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "endpointsToBumpRevision", ".", "Delete", "(", "epp", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "UpdateRulesEndpointsCaches", "updates", "the", "caches", "within", "each", "rule", "in", "r", "that", "specify", "whether", "the", "rule", "selects", "the", "endpoints", "in", "eps", ".", "If", "any", "rule", "matches", "the", "endpoints", "it", "is", "added", "to", "the", "provided", "IDSet", "and", "removed", "from", "the", "provided", "EndpointSet", ".", "The", "provided", "WaitGroup", "is", "signaled", "for", "a", "given", "endpoint", "when", "it", "is", "finished", "being", "processed", "." ]

[ "func", "(", "p", "*", "Repository", ")", "DeleteByLabelsLocked", "(", "labels", "labels", ".", "LabelArray", ")", "(", "ruleSlice", ",", "uint64", ",", "int", ")", "{", "deleted", ":=", "0", "\n", "new", ":=", "p", ".", "rules", "[", ":", "0", "]", "\n", "deletedRules", ":=", "ruleSlice", "{", "}", "\n\n", "for", "_", ",", "r", ":=", "range", "p", ".", "rules", "{", "if", "!", "r", ".", "Labels", ".", "Contains", "(", "labels", ")", "{", "new", "=", "append", "(", "new", ",", "r", ")", "\n", "}", "else", "{", "deletedRules", "=", "append", "(", "deletedRules", ",", "r", ")", "\n", "deleted", "++", "\n", "}", "\n", "}", "\n\n", "if", "deleted", ">", "0", "{", "p", ".", "BumpRevision", "(", ")", "\n", "p", ".", "rules", "=", "new", "\n", "metrics", ".", "PolicyCount", ".", "Sub", "(", "float64", "(", "deleted", ")", ")", "\n", "}", "\n\n", "return", "deletedRules", ",", "p", ".", "GetRevision", "(", ")", ",", "deleted", "\n", "}" ]

[ "DeleteByLabelsLocked", "deletes", "all", "rules", "in", "the", "policy", "repository", "which", "contain", "the", "specified", "labels", ".", "Returns", "the", "revision", "of", "the", "policy", "repository", "after", "deleting", "the", "rules", "as", "well", "as", "now", "many", "rules", "were", "deleted", "." ]

[ "func", "(", "p", "*", "Repository", ")", "DeleteByLabels", "(", "labels", "labels", ".", "LabelArray", ")", "(", "uint64", ",", "int", ")", "{", "p", ".", "Mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Mutex", ".", "Unlock", "(", ")", "\n", "_", ",", "rev", ",", "numDeleted", ":=", "p", ".", "DeleteByLabelsLocked", "(", "labels", ")", "\n", "return", "rev", ",", "numDeleted", "\n", "}" ]

[ "DeleteByLabels", "deletes", "all", "rules", "in", "the", "policy", "repository", "which", "contain", "the", "specified", "labels" ]

[ "func", "JSONMarshalRules", "(", "rules", "api", ".", "Rules", ")", "string", "{", "b", ",", "err", ":=", "json", ".", "MarshalIndent", "(", "rules", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", ".", "Error", "(", ")", "\n", "}", "\n", "return", "string", "(", "b", ")", "\n", "}" ]

[ "JSONMarshalRules", "returns", "a", "slice", "of", "policy", "rules", "as", "string", "in", "JSON", "representation" ]

[ "func", "(", "p", "*", "Repository", ")", "GetJSON", "(", ")", "string", "{", "p", ".", "Mutex", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "Mutex", ".", "RUnlock", "(", ")", "\n\n", "result", ":=", "api", ".", "Rules", "{", "}", "\n", "for", "_", ",", "r", ":=", "range", "p", ".", "rules", "{", "result", "=", "append", "(", "result", ",", "&", "r", ".", "Rule", ")", "\n", "}", "\n\n", "return", "JSONMarshalRules", "(", "result", ")", "\n", "}" ]

[ "GetJSON", "returns", "all", "rules", "of", "the", "policy", "repository", "as", "string", "in", "JSON", "representation" ]

[ "func", "(", "p", "*", "Repository", ")", "GetRulesMatching", "(", "labels", "labels", ".", "LabelArray", ")", "(", "ingressMatch", "bool", ",", "egressMatch", "bool", ")", "{", "ingressMatch", "=", "false", "\n", "egressMatch", "=", "false", "\n", "for", "_", ",", "r", ":=", "range", "p", ".", "rules", "{", "rulesMatch", ":=", "r", ".", "EndpointSelector", ".", "Matches", "(", "labels", ")", "\n", "if", "rulesMatch", "{", "if", "len", "(", "r", ".", "Ingress", ")", ">", "0", "{", "ingressMatch", "=", "true", "\n", "}", "\n", "if", "len", "(", "r", ".", "Egress", ")", ">", "0", "{", "egressMatch", "=", "true", "\n", "}", "\n", "}", "\n\n", "if", "ingressMatch", "&&", "egressMatch", "{", "return", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "GetRulesMatching", "returns", "whether", "any", "of", "the", "rules", "in", "a", "repository", "contain", "a", "rule", "with", "labels", "matching", "the", "labels", "in", "the", "provided", "LabelArray", ".", "Must", "be", "called", "with", "p", ".", "Mutex", "held" ]

[ "func", "(", "p", "*", "Repository", ")", "getMatchingRules", "(", "securityIdentity", "*", "identity", ".", "Identity", ")", "(", "ingressMatch", "bool", ",", "egressMatch", "bool", ",", "matchingRules", "ruleSlice", ")", "{", "matchingRules", "=", "[", "]", "*", "rule", "{", "}", "\n", "ingressMatch", "=", "false", "\n", "egressMatch", "=", "false", "\n", "for", "_", ",", "r", ":=", "range", "p", ".", "rules", "{", "if", "ruleMatches", ":=", "r", ".", "matches", "(", "securityIdentity", ")", ";", "ruleMatches", "{", "// Don't need to update whether ingressMatch is true if it already", "// has been determined to be true - allows us to not have to check", "// lenth of slice.", "if", "!", "ingressMatch", "&&", "len", "(", "r", ".", "Ingress", ")", ">", "0", "{", "ingressMatch", "=", "true", "\n", "}", "\n", "if", "!", "egressMatch", "&&", "len", "(", "r", ".", "Egress", ")", ">", "0", "{", "egressMatch", "=", "true", "\n", "}", "\n", "matchingRules", "=", "append", "(", "matchingRules", ",", "r", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "getMatchingRules", "returns", "whether", "any", "of", "the", "rules", "in", "a", "repository", "contain", "a", "rule", "with", "labels", "matching", "the", "labels", "in", "the", "provided", "LabelArray", "as", "well", "as", "a", "slice", "of", "all", "rules", "which", "match", ".", "Must", "be", "called", "with", "p", ".", "Mutex", "held" ]

[ "func", "(", "p", "*", "Repository", ")", "Empty", "(", ")", "bool", "{", "p", ".", "Mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Mutex", ".", "Unlock", "(", ")", "\n", "return", "p", ".", "NumRules", "(", ")", "==", "0", "\n", "}" ]

[ "Empty", "returns", "true", "if", "repository", "has", "no", "rules", "false", "otherwise", ".", "Must", "be", "called", "without", "p", ".", "Mutex", "held" ]

[ "func", "(", "p", "*", "Repository", ")", "TranslateRules", "(", "translator", "Translator", ")", "(", "*", "TranslationResult", ",", "error", ")", "{", "p", ".", "Mutex", ".", "Lock", "(", ")", "\n", "defer", "p", ".", "Mutex", ".", "Unlock", "(", ")", "\n\n", "result", ":=", "&", "TranslationResult", "{", "}", "\n\n", "for", "ruleIndex", ":=", "range", "p", ".", "rules", "{", "if", "err", ":=", "translator", ".", "Translate", "(", "&", "p", ".", "rules", "[", "ruleIndex", "]", ".", "Rule", ",", "result", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "TranslateRules", "traverses", "rules", "and", "applies", "provided", "translator", "to", "rules" ]

[ "func", "(", "p", "*", "Repository", ")", "BumpRevision", "(", ")", "{", "metrics", ".", "PolicyRevision", ".", "Inc", "(", ")", "\n", "atomic", ".", "AddUint64", "(", "&", "p", ".", "revision", ",", "1", ")", "\n", "}" ]

[ "BumpRevision", "allows", "forcing", "policy", "regeneration" ]

[ "func", "(", "p", "*", "Repository", ")", "GetRulesList", "(", ")", "*", "models", ".", "Policy", "{", "p", ".", "Mutex", ".", "RLock", "(", ")", "\n", "defer", "p", ".", "Mutex", ".", "RUnlock", "(", ")", "\n\n", "lbls", ":=", "labels", ".", "ParseSelectLabelArrayFromArray", "(", "[", "]", "string", "{", "}", ")", "\n", "ruleList", ":=", "p", ".", "SearchRLocked", "(", "lbls", ")", "\n\n", "return", "&", "models", ".", "Policy", "{", "Revision", ":", "int64", "(", "p", ".", "GetRevision", "(", ")", ")", ",", "Policy", ":", "JSONMarshalRules", "(", "ruleList", ")", ",", "}", "\n", "}" ]

[ "GetRulesList", "returns", "the", "current", "policy" ]

[ "func", "(", "p", "*", "Repository", ")", "ResolvePolicyLocked", "(", "securityIdentity", "*", "identity", ".", "Identity", ")", "(", "*", "SelectorPolicy", ",", "error", ")", "{", "// First obtain whether policy applies in both traffic directions, as well", "// as list of rules which actually select this endpoint. This allows us", "// to not have to iterate through the entire rule list multiple times and", "// perform the matching decision again when computing policy for each", "// protocol layer, which is quite costly in terms of performance.", "ingressEnabled", ",", "egressEnabled", ",", "matchingRules", ":=", "p", ".", "computePolicyEnforcementAndRules", "(", "securityIdentity", ")", "\n\n", "calculatedPolicy", ":=", "&", "SelectorPolicy", "{", "Revision", ":", "p", ".", "GetRevision", "(", ")", ",", "L4Policy", ":", "NewL4Policy", "(", ")", ",", "CIDRPolicy", ":", "NewCIDRPolicy", "(", ")", ",", "matchingRules", ":", "matchingRules", ",", "IngressPolicyEnabled", ":", "ingressEnabled", ",", "EgressPolicyEnabled", ":", "egressEnabled", ",", "}", "\n", "calculatedPolicy", ".", "IngressPolicyEnabled", "=", "ingressEnabled", "\n", "calculatedPolicy", ".", "EgressPolicyEnabled", "=", "egressEnabled", "\n\n", "labels", ":=", "securityIdentity", ".", "LabelArray", "\n", "ingressCtx", ":=", "SearchContext", "{", "To", ":", "labels", ",", "rulesSelect", ":", "true", ",", "skipL4RequirementsAggregation", ":", "false", ",", "}", "\n\n", "egressCtx", ":=", "SearchContext", "{", "From", ":", "labels", ",", "rulesSelect", ":", "true", ",", "skipL4RequirementsAggregation", ":", "false", ",", "}", "\n\n", "if", "option", ".", "Config", ".", "TracingEnabled", "(", ")", "{", "ingressCtx", ".", "Trace", "=", "TRACE_ENABLED", "\n", "egressCtx", ".", "Trace", "=", "TRACE_ENABLED", "\n", "}", "\n\n", "if", "ingressEnabled", "{", "newL4IngressPolicy", ",", "err", ":=", "matchingRules", ".", "resolveL4IngressPolicy", "(", "&", "ingressCtx", ",", "p", ".", "GetRevision", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "newCIDRIngressPolicy", ":=", "matchingRules", ".", "resolveCIDRPolicy", "(", "&", "ingressCtx", ")", "\n", "if", "err", ":=", "newCIDRIngressPolicy", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "calculatedPolicy", ".", "CIDRPolicy", ".", "Ingress", "=", "newCIDRIngressPolicy", ".", "Ingress", "\n", "calculatedPolicy", ".", "L4Policy", ".", "Ingress", "=", "newL4IngressPolicy", ".", "Ingress", "\n", "}", "\n\n", "if", "egressEnabled", "{", "newL4EgressPolicy", ",", "err", ":=", "matchingRules", ".", "resolveL4EgressPolicy", "(", "&", "egressCtx", ",", "p", ".", "GetRevision", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "newCIDREgressPolicy", ":=", "matchingRules", ".", "resolveCIDRPolicy", "(", "&", "egressCtx", ")", "\n", "if", "err", ":=", "newCIDREgressPolicy", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "calculatedPolicy", ".", "CIDRPolicy", ".", "Egress", "=", "newCIDREgressPolicy", ".", "Egress", "\n", "calculatedPolicy", ".", "L4Policy", ".", "Egress", "=", "newL4EgressPolicy", ".", "Egress", "\n", "}", "\n\n", "return", "calculatedPolicy", ",", "nil", "\n", "}" ]

[ "ResolvePolicyLocked", "returns", "the", "EndpointPolicy", "for", "the", "provided", "set", "of", "labels", "against", "the", "set", "of", "rules", "in", "the", "repository", "and", "the", "provided", "set", "of", "identities", ".", "If", "the", "policy", "cannot", "be", "generated", "due", "to", "conflicts", "at", "L4", "or", "L7", "returns", "an", "error", ".", "Must", "be", "performed", "while", "holding", "the", "Repository", "lock", "." ]

[ "func", "(", "p", "*", "Repository", ")", "computePolicyEnforcementAndRules", "(", "securityIdentity", "*", "identity", ".", "Identity", ")", "(", "ingress", "bool", ",", "egress", "bool", ",", "matchingRules", "ruleSlice", ")", "{", "lbls", ":=", "securityIdentity", ".", "LabelArray", "\n", "// Check if policy enforcement should be enabled at the daemon level.", "switch", "GetPolicyEnabled", "(", ")", "{", "case", "option", ".", "AlwaysEnforce", ":", "_", ",", "_", ",", "matchingRules", "=", "p", ".", "getMatchingRules", "(", "securityIdentity", ")", "\n", "// If policy enforcement is enabled for the daemon, then it has to be", "// enabled for the endpoint.", "return", "true", ",", "true", ",", "matchingRules", "\n", "case", "option", ".", "DefaultEnforcement", ":", "ingress", ",", "egress", ",", "matchingRules", "=", "p", ".", "getMatchingRules", "(", "securityIdentity", ")", "\n", "// If the endpoint has the reserved:init label, i.e. if it has not yet", "// received any labels, always enforce policy (default deny).", "if", "lbls", ".", "Has", "(", "labels", ".", "IDNameInit", ")", "{", "return", "true", ",", "true", ",", "matchingRules", "\n", "}", "\n\n", "// Default mode means that if rules contain labels that match this", "// endpoint, then enable policy enforcement for this endpoint.", "return", "ingress", ",", "egress", ",", "matchingRules", "\n", "default", ":", "// If policy enforcement isn't enabled, we do not enable policy", "// enforcement for the endpoint. We don't care about returning any", "// rules that match.", "return", "false", ",", "false", ",", "nil", "\n", "}", "\n", "}" ]

[ "computePolicyEnforcementAndRules", "returns", "whether", "policy", "applies", "at", "ingress", "or", "ingress", "for", "the", "given", "set", "of", "labels", "as", "well", "as", "a", "list", "of", "any", "rules", "which", "select", "the", "set", "of", "labels", ".", "Must", "be", "called", "with", "repo", "mutex", "held", "for", "reading", "." ]

[ "func", "NewGetIdentityID", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetIdentityIDHandler", ")", "*", "GetIdentityID", "{", "return", "&", "GetIdentityID", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetIdentityID", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "identity", "ID", "operation" ]

[ "func", "AddReservedIdentity", "(", "ni", "NumericIdentity", ",", "lbl", "string", ")", "{", "identity", ":=", "NewIdentity", "(", "ni", ",", "labels", ".", "Labels", "{", "lbl", ":", "labels", ".", "NewLabel", "(", "lbl", ",", "\"", "\"", ",", "labels", ".", "LabelSourceReserved", ")", "}", ")", "\n", "// Pre-calculate the SHA256 hash.", "identity", ".", "GetLabelsSHA256", "(", ")", "\n", "ReservedIdentityCache", "[", "ni", "]", "=", "identity", "\n", "}" ]

[ "AddReservedIdentity", "adds", "the", "reserved", "numeric", "identity", "with", "the", "respective", "label", "into", "the", "map", "of", "reserved", "identity", "cache", "." ]

[ "func", "NewPutEndpointID", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "PutEndpointIDHandler", ")", "*", "PutEndpointID", "{", "return", "&", "PutEndpointID", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewPutEndpointID", "creates", "a", "new", "http", ".", "Handler", "for", "the", "put", "endpoint", "ID", "operation" ]

[ "func", "NewCiliumHealthAPI", "(", "spec", "*", "loads", ".", "Document", ")", "*", "CiliumHealthAPI", "{", "return", "&", "CiliumHealthAPI", "{", "handlers", ":", "make", "(", "map", "[", "string", "]", "map", "[", "string", "]", "http", ".", "Handler", ")", ",", "formats", ":", "strfmt", ".", "Default", ",", "defaultConsumes", ":", "\"", "\"", ",", "defaultProduces", ":", "\"", "\"", ",", "customConsumers", ":", "make", "(", "map", "[", "string", "]", "runtime", ".", "Consumer", ")", ",", "customProducers", ":", "make", "(", "map", "[", "string", "]", "runtime", ".", "Producer", ")", ",", "ServerShutdown", ":", "func", "(", ")", "{", "}", ",", "spec", ":", "spec", ",", "ServeError", ":", "errors", ".", "ServeError", ",", "BasicAuthenticator", ":", "security", ".", "BasicAuth", ",", "APIKeyAuthenticator", ":", "security", ".", "APIKeyAuth", ",", "BearerAuthenticator", ":", "security", ".", "BearerAuth", ",", "JSONConsumer", ":", "runtime", ".", "JSONConsumer", "(", ")", ",", "JSONProducer", ":", "runtime", ".", "JSONProducer", "(", ")", ",", "GetHealthzHandler", ":", "GetHealthzHandlerFunc", "(", "func", "(", "params", "GetHealthzParams", ")", "middleware", ".", "Responder", "{", "return", "middleware", ".", "NotImplemented", "(", "\"", "\"", ")", "\n", "}", ")", ",", "GetHelloHandler", ":", "GetHelloHandlerFunc", "(", "func", "(", "params", "GetHelloParams", ")", "middleware", ".", "Responder", "{", "return", "middleware", ".", "NotImplemented", "(", "\"", "\"", ")", "\n", "}", ")", ",", "ConnectivityGetStatusHandler", ":", "connectivity", ".", "GetStatusHandlerFunc", "(", "func", "(", "params", "connectivity", ".", "GetStatusParams", ")", "middleware", ".", "Responder", "{", "return", "middleware", ".", "NotImplemented", "(", "\"", "\"", ")", "\n", "}", ")", ",", "ConnectivityPutStatusProbeHandler", ":", "connectivity", ".", "PutStatusProbeHandlerFunc", "(", "func", "(", "params", "connectivity", ".", "PutStatusProbeParams", ")", "middleware", ".", "Responder", "{", "return", "middleware", ".", "NotImplemented", "(", "\"", "\"", ")", "\n", "}", ")", ",", "}", "\n", "}" ]

[ "NewCiliumHealthAPI", "creates", "a", "new", "CiliumHealth", "instance" ]

[ "func", "(", "o", "*", "CiliumHealthAPI", ")", "Validate", "(", ")", "error", "{", "var", "unregistered", "[", "]", "string", "\n\n", "if", "o", ".", "JSONConsumer", "==", "nil", "{", "unregistered", "=", "append", "(", "unregistered", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "o", ".", "JSONProducer", "==", "nil", "{", "unregistered", "=", "append", "(", "unregistered", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "o", ".", "GetHealthzHandler", "==", "nil", "{", "unregistered", "=", "append", "(", "unregistered", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "o", ".", "GetHelloHandler", "==", "nil", "{", "unregistered", "=", "append", "(", "unregistered", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "o", ".", "ConnectivityGetStatusHandler", "==", "nil", "{", "unregistered", "=", "append", "(", "unregistered", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "o", ".", "ConnectivityPutStatusProbeHandler", "==", "nil", "{", "unregistered", "=", "append", "(", "unregistered", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "unregistered", ")", ">", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "unregistered", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "the", "registrations", "in", "the", "CiliumHealthAPI" ]

[ "func", "(", "o", "*", "CiliumHealthAPI", ")", "Context", "(", ")", "*", "middleware", ".", "Context", "{", "if", "o", ".", "context", "==", "nil", "{", "o", ".", "context", "=", "middleware", ".", "NewRoutableContext", "(", "o", ".", "spec", ",", "o", ",", "nil", ")", "\n", "}", "\n\n", "return", "o", ".", "context", "\n", "}" ]

[ "Context", "returns", "the", "middleware", "context", "for", "the", "cilium", "health", "API" ]

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

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

[ "func", "Lookup", "(", "epname", "string", ",", "remoteAddr", ",", "localAddr", "string", ",", "proto", "u8proto", ".", "U8proto", ",", "ingress", "bool", ")", "(", "*", "CtEntry", ",", "error", ")", "{", "key", ",", "err", ":=", "createTupleKey", "(", "remoteAddr", ",", "localAddr", ",", "proto", ",", "ingress", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "_", ",", "ipv4", ":=", "key", ".", "(", "*", "CtKey4", ")", "\n\n", "mapname", ":=", "getMapName", "(", "epname", ",", "ipv4", ",", "proto", ")", "\n\n", "m", ":=", "bpf", ".", "GetMap", "(", "mapname", ")", "\n", "if", "m", "==", "nil", "{", "// Open the map and leave it open", "m", ",", "err", "=", "bpf", ".", "OpenMap", "(", "mapname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "mapname", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "v", ",", "err", ":=", "m", ".", "Lookup", "(", "key", ")", "\n", "if", "err", "!=", "nil", "||", "v", "==", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "v", ".", "(", "*", "CtEntry", ")", ",", "err", "\n", "}" ]

[ "Lookup", "opens", "a", "conntrack", "map", "if", "necessary", "and", "does", "a", "lookup", "on", "it", "with", "a", "key", "constructed", "from", "the", "parameters", "epname", "is", "a", "5", "-", "digit", "represenation", "of", "the", "endpoint", "ID", "if", "local", "maps", "are", "to", "be", "used", "or", "global", "if", "global", "maps", "should", "be", "used", "." ]

[ "func", "CloseLocalMaps", "(", "mapname", "string", ")", "{", "// only close local maps. Global map is kept open as long as cilium-agent is running.", "if", "mapname", "!=", "\"", "\"", "{", "// close IPv4 maps, if any", "if", "m", ":=", "getMapWithName", "(", "mapname", ",", "true", ",", "u8proto", ".", "TCP", ")", ";", "m", "!=", "nil", "{", "m", ".", "Close", "(", ")", "\n", "}", "\n", "if", "m", ":=", "getMapWithName", "(", "mapname", ",", "true", ",", "u8proto", ".", "UDP", ")", ";", "m", "!=", "nil", "{", "m", ".", "Close", "(", ")", "\n", "}", "\n\n", "// close IPv6 maps, if any", "if", "m", ":=", "getMapWithName", "(", "mapname", ",", "false", ",", "u8proto", ".", "TCP", ")", ";", "m", "!=", "nil", "{", "m", ".", "Close", "(", ")", "\n", "}", "\n", "if", "m", ":=", "getMapWithName", "(", "mapname", ",", "false", ",", "u8proto", ".", "UDP", ")", ";", "m", "!=", "nil", "{", "m", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "CloseLocalMaps", "closes", "all", "local", "conntrack", "maps", "opened", "previously", "for", "lookup", "with", "the", "given", "mapname", "." ]

[ "func", "rulePortsCoverSearchContext", "(", "ports", "[", "]", "api", ".", "PortProtocol", ",", "ctx", "*", "SearchContext", ")", "bool", "{", "if", "len", "(", "ctx", ".", "DPorts", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "for", "_", ",", "p", ":=", "range", "ports", "{", "for", "_", ",", "dp", ":=", "range", "ctx", ".", "DPorts", "{", "tracePort", ":=", "api", ".", "PortProtocol", "{", "Port", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dp", ".", "Port", ")", ",", "Protocol", ":", "api", ".", "L4Proto", "(", "dp", ".", "Protocol", ")", ",", "}", "\n", "if", "p", ".", "Covers", "(", "tracePort", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "portRulesCoverContext", "determines", "whether", "L4", "portions", "of", "rules", "cover", "the", "specified", "port", "models", ".", "Returns", "true", "if", "the", "list", "of", "ports", "is", "0", "or", "the", "rules", "match", "the", "ports", "." ]

[ "func", "(", "r", "*", "rule", ")", "resolveCIDRPolicy", "(", "ctx", "*", "SearchContext", ",", "state", "*", "traceState", ",", "result", "*", "CIDRPolicy", ")", "*", "CIDRPolicy", "{", "// Don't select rule if it doesn't apply to the given context.", "if", "!", "ctx", ".", "rulesSelect", "{", "if", "!", "r", ".", "EndpointSelector", ".", "Matches", "(", "ctx", ".", "To", ")", "{", "state", ".", "unSelectRule", "(", "ctx", ",", "ctx", ".", "To", ",", "r", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "state", ".", "selectRule", "(", "ctx", ",", "r", ")", "\n", "found", ":=", "0", "\n\n", "for", "_", ",", "ingressRule", ":=", "range", "r", ".", "Ingress", "{", "// TODO (ianvernon): GH-1658", "var", "allCIDRs", "[", "]", "api", ".", "CIDR", "\n", "allCIDRs", "=", "append", "(", "allCIDRs", ",", "ingressRule", ".", "FromCIDR", "...", ")", "\n", "allCIDRs", "=", "append", "(", "allCIDRs", ",", "api", ".", "ComputeResultantCIDRSet", "(", "ingressRule", ".", "FromCIDRSet", ")", "...", ")", "\n\n", "// CIDR + L4 rules are handled via mergeIngress(),", "// skip them here.", "if", "len", "(", "allCIDRs", ")", ">", "0", "&&", "len", "(", "ingressRule", ".", "ToPorts", ")", ">", "0", "{", "continue", "\n", "}", "\n\n", "if", "cnt", ":=", "mergeCIDR", "(", "ctx", ",", "\"", "\"", ",", "allCIDRs", ",", "r", ".", "Labels", ",", "&", "result", ".", "Ingress", ")", ";", "cnt", ">", "0", "{", "found", "+=", "cnt", "\n", "}", "\n", "}", "\n\n", "// CIDR egress policy is used for visibility of desired state in", "// the API and for determining which prefix lengths are available,", "// however it does not determine the actual CIDRs in the BPF maps", "// for allowing traffic by CIDR!", "for", "_", ",", "egressRule", ":=", "range", "r", ".", "Egress", "{", "var", "allCIDRs", "[", "]", "api", ".", "CIDR", "\n", "allCIDRs", "=", "append", "(", "allCIDRs", ",", "egressRule", ".", "ToCIDR", "...", ")", "\n", "allCIDRs", "=", "append", "(", "allCIDRs", ",", "api", ".", "ComputeResultantCIDRSet", "(", "egressRule", ".", "ToCIDRSet", ")", "...", ")", "\n\n", "// Unlike the Ingress policy which only counts L3 policy in", "// this function, we count the CIDR+L4 policy in the", "// desired egress CIDR policy here as well. This ensures", "// proper computation of IPcache prefix lengths.", "if", "cnt", ":=", "mergeCIDR", "(", "ctx", ",", "\"", "\"", ",", "allCIDRs", ",", "r", ".", "Labels", ",", "&", "result", ".", "Egress", ")", ";", "cnt", ">", "0", "{", "found", "+=", "cnt", "\n", "}", "\n", "}", "\n\n", "if", "found", ">", "0", "{", "return", "result", "\n", "}", "\n\n", "ctx", ".", "PolicyTrace", "(", "\"", "\\n", "\"", ")", "\n", "return", "nil", "\n", "}" ]

[ "resolveCIDRPolicy", "inserts", "the", "CIDRs", "from", "the", "specified", "rule", "into", "result", "if", "the", "rule", "corresponds", "to", "the", "current", "SearchContext", ".", "It", "returns", "the", "resultant", "CIDRPolicy", "containing", "the", "added", "ingress", "and", "egress", "CIDRs", ".", "If", "no", "CIDRs", "are", "added", "to", "result", "a", "nil", "CIDRPolicy", "is", "returned", "." ]

[ "func", "(", "r", "*", "rule", ")", "canReachIngress", "(", "ctx", "*", "SearchContext", ",", "state", "*", "traceState", ")", "api", ".", "Decision", "{", "if", "!", "ctx", ".", "rulesSelect", "{", "if", "!", "r", ".", "EndpointSelector", ".", "Matches", "(", "ctx", ".", "To", ")", "{", "state", ".", "unSelectRule", "(", "ctx", ",", "ctx", ".", "To", ",", "r", ")", "\n", "return", "api", ".", "Undecided", "\n", "}", "\n", "}", "\n\n", "state", ".", "selectRule", "(", "ctx", ",", "r", ")", "\n\n", "// If a requirement explicitly denies access, we can return.", "if", "r", ".", "meetsRequirementsIngress", "(", "ctx", ",", "state", ")", "==", "api", ".", "Denied", "{", "return", "api", ".", "Denied", "\n", "}", "\n\n", "return", "r", ".", "canReachFromEndpoints", "(", "ctx", ",", "state", ")", "\n", "}" ]

[ "canReachIngress", "returns", "the", "decision", "as", "to", "whether", "the", "set", "of", "labels", "specified", "in", "ctx", ".", "From", "match", "with", "the", "label", "selectors", "specified", "in", "the", "ingress", "rules", "contained", "within", "r", "." ]

[ "func", "(", "r", "*", "rule", ")", "meetsRequirementsIngress", "(", "ctx", "*", "SearchContext", ",", "state", "*", "traceState", ")", "api", ".", "Decision", "{", "for", "_", ",", "r", ":=", "range", "r", ".", "Ingress", "{", "for", "_", ",", "sel", ":=", "range", "r", ".", "FromRequires", "{", "ctx", ".", "PolicyTrace", "(", "\"", "\"", ",", "sel", ")", "\n", "if", "!", "sel", ".", "Matches", "(", "ctx", ".", "From", ")", "{", "ctx", ".", "PolicyTrace", "(", "\"", "\\n", "\"", ",", "ctx", ".", "From", ")", "\n", "state", ".", "constrainedRules", "++", "\n", "return", "api", ".", "Denied", "\n", "}", "\n", "ctx", ".", "PolicyTrace", "(", "\"", "\\n", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "api", ".", "Undecided", "\n", "}" ]

[ "meetsRequirementsIngress", "returns", "whether", "the", "labels", "in", "ctx", ".", "From", "do", "not", "meet", "the", "requirements", "in", "the", "provided", "rule", ".", "If", "a", "rule", "does", "meet", "the", "requirements", "in", "the", "rule", "that", "does", "not", "mean", "that", "the", "rule", "allows", "traffic", "from", "the", "labels", "in", "ctx", ".", "From", "merely", "that", "the", "rule", "does", "not", "deny", "it", "." ]

[ "func", "(", "r", "*", "rule", ")", "meetsRequirementsEgress", "(", "ctx", "*", "SearchContext", ",", "state", "*", "traceState", ")", "api", ".", "Decision", "{", "for", "_", ",", "r", ":=", "range", "r", ".", "Egress", "{", "for", "_", ",", "sel", ":=", "range", "r", ".", "ToRequires", "{", "ctx", ".", "PolicyTrace", "(", "\"", "\"", ",", "sel", ")", "\n", "if", "!", "sel", ".", "Matches", "(", "ctx", ".", "To", ")", "{", "ctx", ".", "PolicyTrace", "(", "\"", "\\n", "\"", ",", "ctx", ".", "To", ")", "\n", "state", ".", "constrainedRules", "++", "\n", "return", "api", ".", "Denied", "\n", "}", "\n", "ctx", ".", "PolicyTrace", "(", "\"", "\\n", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "api", ".", "Undecided", "\n", "}" ]

[ "meetsRequirementsEgress", "returns", "whether", "the", "labels", "in", "ctx", ".", "To", "do", "not", "meet", "the", "requirements", "in", "the", "provided", "rule", ".", "If", "a", "rule", "does", "meet", "the", "requirements", "in", "the", "rule", "that", "does", "not", "mean", "that", "the", "rule", "allows", "traffic", "from", "the", "labels", "in", "ctx", ".", "To", "merely", "that", "the", "rule", "does", "not", "deny", "it", "." ]

[ "func", "(", "d", "Decision", ")", "String", "(", ")", "string", "{", "if", "v", ",", "exists", ":=", "decisionToString", "[", "d", "]", ";", "exists", "{", "return", "v", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "String", "returns", "the", "decision", "in", "human", "readable", "format" ]

[ "func", "(", "d", "*", "Decision", ")", "UnmarshalJSON", "(", "b", "[", "]", "byte", ")", "error", "{", "if", "d", "==", "nil", "{", "d", "=", "new", "(", "Decision", ")", "\n", "}", "\n", "if", "len", "(", "b", ")", "<=", "len", "(", "`\"\"`", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "b", ")", ")", "\n", "}", "\n", "if", "v", ",", "exists", ":=", "stringToDecision", "[", "string", "(", "b", "[", "1", ":", "len", "(", "b", ")", "-", "1", "]", ")", "]", ";", "exists", "{", "*", "d", "=", "v", "\n", "return", "nil", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "string", "(", "b", ")", ")", "\n", "}" ]

[ "UnmarshalJSON", "parses", "a", "JSON", "formatted", "buffer", "and", "returns", "a", "decision" ]

[ "func", "(", "d", "Decision", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "[", "]", "byte", "(", "fmt", ".", "Sprintf", "(", "`\"%s\"`", ",", "d", ")", ")", ",", "nil", "\n", "}" ]

[ "MarshalJSON", "returns", "the", "decision", "as", "JSON", "formatted", "buffer" ]

[ "func", "(", "f", "*", "sessionUDPFactory", ")", "SetSocketOptions", "(", "conn", "*", "net", ".", "UDPConn", ")", "error", "{", "// Set up the raw socket for sending responses.", "// - Must use a raw UDP socket for sending responses so that we can send", "// from a specific port without binding to it.", "// - The raw UDP socket must be bound to a specific IP address to prevent", "// it receiving ALL UDP packets on the host.", "// - We use oob data to override the source IP address when sending", "// - Must use separate sockets for IPv4/IPv6, as sending to a v6-mapped", "// v4 address from a socket bound to \"::1\" does not work due to kernel", "// checking that a route exists from the source address before", "// the source address is replaced with the (transparently) changed one", "udpOnce", ".", "Do", "(", "func", "(", ")", "{", "rawconn4", "=", "bindUDP", "(", "\"", "\"", ")", "// raw socket for sending IPv4", "\n", "rawconn6", "=", "bindUDP", "(", "\"", "\"", ")", "// raw socket for sending IPv6", "\n", "}", ")", "\n", "if", "rawconn4", "==", "nil", "||", "rawconn6", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SetSocketOptions", "set", "s", "up", "conn", "to", "be", "used", "with", "a", "SessionUDP", "." ]

[ "func", "(", "f", "*", "sessionUDPFactory", ")", "InitPool", "(", "msgSize", "int", ")", "{", "f", ".", "udpPool", ".", "New", "=", "func", "(", ")", "interface", "{", "}", "{", "return", "&", "sessionUDP", "{", "f", ":", "f", ",", "m", ":", "make", "(", "[", "]", "byte", ",", "msgSize", ")", ",", "oob", ":", "make", "(", "[", "]", "byte", ",", "udpOOBSize", ")", ",", "}", "\n", "}", "\n", "}" ]

[ "InitPool", "initializes", "a", "pool", "of", "buffers", "to", "be", "used", "with", "SessionUDP", "." ]

[ "func", "(", "f", "*", "sessionUDPFactory", ")", "ReadRequest", "(", "conn", "*", "net", ".", "UDPConn", ")", "(", "[", "]", "byte", ",", "dns", ".", "SessionUDP", ",", "error", ")", "{", "s", ":=", "f", ".", "udpPool", ".", "Get", "(", ")", ".", "(", "*", "sessionUDP", ")", "\n", "n", ",", "oobn", ",", "_", ",", "raddr", ",", "err", ":=", "conn", ".", "ReadMsgUDP", "(", "s", ".", "m", ",", "s", ".", "oob", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Discard", "(", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "s", ".", "conn", "=", "conn", "\n", "s", ".", "raddr", "=", "raddr", "\n", "s", ".", "m", "=", "s", ".", "m", "[", ":", "n", "]", "// Re-slice to the actual size", "\n", "s", ".", "oob", "=", "s", ".", "oob", "[", ":", "oobn", "]", "// Re-slice to the actual size", "\n", "s", ".", "laddr", ",", "err", "=", "parseDstFromOOB", "(", "s", ".", "oob", ")", "\n", "if", "err", "!=", "nil", "{", "s", ".", "Discard", "(", ")", "\n", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "s", ".", "m", ",", "s", ",", "err", "\n", "}" ]

[ "ReadRequest", "reads", "a", "single", "request", "from", "conn", "and", "returns", "the", "request", "context" ]

[ "func", "(", "s", "*", "sessionUDP", ")", "Discard", "(", ")", "{", "s", ".", "conn", "=", "nil", "\n", "s", ".", "raddr", "=", "nil", "\n", "s", ".", "laddr", "=", "nil", "\n", "s", ".", "m", "=", "s", ".", "m", "[", ":", "cap", "(", "s", ".", "m", ")", "]", "\n", "s", ".", "oob", "=", "s", ".", "oob", "[", ":", "cap", "(", "s", ".", "oob", ")", "]", "\n\n", "s", ".", "f", ".", "udpPool", ".", "Put", "(", "s", ")", "\n", "}" ]

[ "Discard", "returns", "s", "to", "the", "factory", "pool" ]

[ "func", "(", "s", "*", "sessionUDP", ")", "WriteResponse", "(", "b", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "// Must give the UDP header to get the source port right.", "// Reuse the msg buffer, figure out if golang can do gatter-scather IO", "// with raw sockets?", "bb", ":=", "bytes", ".", "NewBuffer", "(", "s", ".", "m", "[", ":", "0", "]", ")", "\n", "binary", ".", "Write", "(", "bb", ",", "binary", ".", "BigEndian", ",", "uint16", "(", "s", ".", "laddr", ".", "Port", ")", ")", "\n", "binary", ".", "Write", "(", "bb", ",", "binary", ".", "BigEndian", ",", "uint16", "(", "s", ".", "raddr", ".", "Port", ")", ")", "\n", "binary", ".", "Write", "(", "bb", ",", "binary", ".", "BigEndian", ",", "uint16", "(", "8", "+", "len", "(", "b", ")", ")", ")", "\n", "binary", ".", "Write", "(", "bb", ",", "binary", ".", "BigEndian", ",", "uint16", "(", "0", ")", ")", "// checksum", "\n", "bb", ".", "Write", "(", "b", ")", "\n", "buf", ":=", "bb", ".", "Bytes", "(", ")", "\n\n", "var", "n", "int", "\n", "var", "err", "error", "\n", "dst", ":=", "net", ".", "IPAddr", "{", "IP", ":", "s", ".", "raddr", ".", "IP", ",", "}", "\n", "if", "s", ".", "raddr", ".", "IP", ".", "To4", "(", ")", "==", "nil", "{", "n", ",", "_", ",", "err", "=", "rawconn6", ".", "WriteMsgIP", "(", "buf", ",", "s", ".", "controlMessage", "(", "s", ".", "laddr", ")", ",", "&", "dst", ")", "\n", "}", "else", "{", "n", ",", "_", ",", "err", "=", "rawconn4", ".", "WriteMsgIP", "(", "buf", ",", "s", ".", "controlMessage", "(", "s", ".", "laddr", ")", ",", "&", "dst", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "return", "n", ",", "err", "\n", "}" ]

[ "WriteResponse", "writes", "a", "response", "to", "a", "request", "received", "earlier" ]

[ "func", "parseDstFromOOB", "(", "oob", "[", "]", "byte", ")", "(", "*", "net", ".", "UDPAddr", ",", "error", ")", "{", "msgs", ",", "err", ":=", "syscall", ".", "ParseSocketControlMessage", "(", "oob", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "msg", ":=", "range", "msgs", "{", "if", "msg", ".", "Header", ".", "Level", "==", "unix", ".", "SOL_IP", "&&", "msg", ".", "Header", ".", "Type", "==", "unix", ".", "IP_ORIGDSTADDR", "{", "pp", ":=", "&", "syscall", ".", "RawSockaddrInet4", "{", "}", "\n", "// Address family is in native byte order", "family", ":=", "*", "(", "*", "uint16", ")", "(", "unsafe", ".", "Pointer", "(", "&", "msg", ".", "Data", "[", "unsafe", ".", "Offsetof", "(", "pp", ".", "Family", ")", "]", ")", ")", "\n", "if", "family", "!=", "unix", ".", "AF_INET", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// Port is in big-endian byte order", "if", "err", "=", "binary", ".", "Read", "(", "bytes", ".", "NewReader", "(", "msg", ".", "Data", ")", ",", "binary", ".", "BigEndian", ",", "pp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "laddr", ":=", "&", "net", ".", "UDPAddr", "{", "IP", ":", "net", ".", "IPv4", "(", "pp", ".", "Addr", "[", "0", "]", ",", "pp", ".", "Addr", "[", "1", "]", ",", "pp", ".", "Addr", "[", "2", "]", ",", "pp", ".", "Addr", "[", "3", "]", ")", ",", "Port", ":", "int", "(", "pp", ".", "Port", ")", ",", "}", "\n", "return", "laddr", ",", "nil", "\n", "}", "\n", "if", "msg", ".", "Header", ".", "Level", "==", "unix", ".", "SOL_IPV6", "&&", "msg", ".", "Header", ".", "Type", "==", "unix", ".", "IPV6_ORIGDSTADDR", "{", "pp", ":=", "&", "syscall", ".", "RawSockaddrInet6", "{", "}", "\n", "// Address family is in native byte order", "family", ":=", "*", "(", "*", "uint16", ")", "(", "unsafe", ".", "Pointer", "(", "&", "msg", ".", "Data", "[", "unsafe", ".", "Offsetof", "(", "pp", ".", "Family", ")", "]", ")", ")", "\n", "if", "family", "!=", "unix", ".", "AF_INET6", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// Scope ID is in native byte order", "scopeId", ":=", "*", "(", "*", "uint32", ")", "(", "unsafe", ".", "Pointer", "(", "&", "msg", ".", "Data", "[", "unsafe", ".", "Offsetof", "(", "pp", ".", "Scope_id", ")", "]", ")", ")", "\n", "// Rest of the data is big-endian (port)", "if", "err", "=", "binary", ".", "Read", "(", "bytes", ".", "NewReader", "(", "msg", ".", "Data", ")", ",", "binary", ".", "BigEndian", ",", "pp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "laddr", ":=", "&", "net", ".", "UDPAddr", "{", "IP", ":", "net", ".", "IP", "(", "pp", ".", "Addr", "[", ":", "]", ")", ",", "Port", ":", "int", "(", "pp", ".", "Port", ")", ",", "Zone", ":", "strconv", ".", "Itoa", "(", "int", "(", "scopeId", ")", ")", ",", "}", "\n", "return", "laddr", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "parseDstFromOOB", "takes", "oob", "data", "and", "returns", "the", "destination", "IP", "." ]

[ "func", "(", "s", "*", "sessionUDP", ")", "controlMessage", "(", "src", "*", "net", ".", "UDPAddr", ")", "[", "]", "byte", "{", "// If the src is definitely an IPv6, then use ipv6's ControlMessage to", "// respond otherwise use ipv4's because ipv6's marshal ignores ipv4", "// addresses.", "if", "src", ".", "IP", ".", "To4", "(", ")", "==", "nil", "{", "cm", ":=", "new", "(", "ipv6", ".", "ControlMessage", ")", "\n", "cm", ".", "Src", "=", "src", ".", "IP", "\n", "return", "cm", ".", "Marshal", "(", ")", "\n", "}", "\n", "cm", ":=", "new", "(", "ipv4", ".", "ControlMessage", ")", "\n", "cm", ".", "Src", "=", "src", ".", "IP", "\n", "return", "cm", ".", "Marshal", "(", ")", "\n", "}" ]

[ "correctSource", "returns", "the", "oob", "data", "with", "the", "given", "source", "address" ]

[ "func", "ParseProxyID", "(", "proxyID", "string", ")", "(", "endpointID", "uint16", ",", "ingress", "bool", ",", "protocol", "string", ",", "port", "uint16", ",", "err", "error", ")", "{", "comps", ":=", "strings", ".", "Split", "(", "proxyID", ",", "\"", "\"", ")", "\n", "if", "len", "(", "comps", ")", "!=", "4", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "proxyID", ")", "\n", "return", "\n", "}", "\n", "epID", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "comps", "[", "0", "]", ",", "10", ",", "16", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "endpointID", "=", "uint16", "(", "epID", ")", "\n", "ingress", "=", "comps", "[", "1", "]", "==", "\"", "\"", "\n", "protocol", "=", "comps", "[", "2", "]", "\n", "l4port", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "comps", "[", "3", "]", ",", "10", ",", "16", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "port", "=", "uint16", "(", "l4port", ")", "\n", "return", "\n", "}" ]

[ "ParseProxyID", "parses", "a", "proxy", "ID", "returned", "by", "ProxyID", "and", "returns", "its", "components", "." ]

[ "func", "(", "ps", "componentStatus", ")", "contains", "(", "s", "*", "statusLogMsg", ")", "bool", "{", "return", "ps", "[", "s", ".", "Status", ".", "Type", "]", "==", "s", "\n", "}" ]

[ "contains", "checks", "if", "the", "given", "s", "statusLogMsg", "is", "present", "in", "the", "priorityStatus", "." ]

[ "func", "(", "ps", "componentStatus", ")", "sortByPriority", "(", ")", "statusLog", "{", "prs", ":=", "statusTypeSlice", "{", "}", "\n", "for", "k", ":=", "range", "ps", "{", "prs", "=", "append", "(", "prs", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "prs", ")", "\n", "slogSorted", ":=", "statusLog", "{", "}", "\n", "for", "_", ",", "pr", ":=", "range", "prs", "{", "slogSorted", "=", "append", "(", "slogSorted", ",", "ps", "[", "pr", "]", ")", "\n", "}", "\n", "return", "slogSorted", "\n", "}" ]

[ "sortByPriority", "returns", "a", "statusLog", "ordered", "from", "highest", "priority", "to", "lowest", "." ]

[ "func", "(", "e", "*", "EndpointStatus", ")", "getAndIncIdx", "(", ")", "int", "{", "idx", ":=", "e", ".", "Index", "\n", "e", ".", "Index", "++", "\n", "if", "e", ".", "Index", ">=", "maxLogs", "{", "e", ".", "Index", "=", "0", "\n", "}", "\n", "// Lets skip the CurrentStatus message from the log to prevent removing", "// non-OK status!", "if", "e", ".", "Index", "<", "len", "(", "e", ".", "Log", ")", "&&", "e", ".", "CurrentStatuses", ".", "contains", "(", "e", ".", "Log", "[", "e", ".", "Index", "]", ")", "&&", "e", ".", "Log", "[", "e", ".", "Index", "]", ".", "Status", ".", "Code", "!=", "OK", "{", "e", ".", "Index", "++", "\n", "if", "e", ".", "Index", ">=", "maxLogs", "{", "e", ".", "Index", "=", "0", "\n", "}", "\n", "}", "\n", "return", "idx", "\n", "}" ]

[ "getAndIncIdx", "returns", "current", "free", "slot", "index", "and", "increments", "the", "index", "to", "the", "next", "index", "that", "can", "be", "overwritten", "." ]

[ "func", "(", "o", "*", "CiliumAPI", ")", "Context", "(", ")", "*", "middleware", ".", "Context", "{", "if", "o", ".", "context", "==", "nil", "{", "o", ".", "context", "=", "middleware", ".", "NewRoutableContext", "(", "o", ".", "spec", ",", "o", ",", "nil", ")", "\n", "}", "\n\n", "return", "o", ".", "context", "\n", "}" ]

[ "Context", "returns", "the", "middleware", "context", "for", "the", "cilium", "API" ]

[ "func", "(", "meta", "*", "Meta", ")", "UnmarshalBinary", "(", "data", "[", "]", "byte", ")", "error", "{", "return", "meta", ".", "ReadBinary", "(", "bytes", ".", "NewReader", "(", "data", ")", ")", "\n", "}" ]

[ "UnmarshalBinary", "decodes", "the", "metadata", "from", "its", "binary", "representation", "." ]

[ "func", "(", "meta", "*", "Meta", ")", "MarshalBinary", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "buf", "bytes", ".", "Buffer", "\n", "if", "err", ":=", "meta", ".", "WriteBinary", "(", "&", "buf", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "MarshalBinary", "encodes", "the", "metadata", "into", "its", "binary", "representation", "." ]

[ "func", "(", "meta", "*", "Meta", ")", "ReadBinary", "(", "r", "io", ".", "Reader", ")", "error", "{", "return", "binary", ".", "Read", "(", "r", ",", "byteorder", ".", "Native", ",", "meta", ")", "\n", "}" ]

[ "ReadBinary", "reads", "the", "metadata", "from", "its", "binary", "representation", "." ]

[ "func", "(", "meta", "*", "Meta", ")", "WriteBinary", "(", "w", "io", ".", "Writer", ")", "error", "{", "return", "binary", ".", "Write", "(", "w", ",", "byteorder", ".", "Native", ",", "meta", ")", "\n", "}" ]

[ "WriteBinary", "writes", "the", "metadata", "into", "its", "binary", "representation", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "Decode", "(", "data", "[", "]", "byte", ")", "error", "{", "// Note that this method can't be named UnmarshalBinary, because the gob encoder would call", "// this method, resulting in infinite recursion.", "return", "pl", ".", "ReadBinary", "(", "bytes", ".", "NewBuffer", "(", "data", ")", ")", "\n", "}" ]

[ "Decode", "decodes", "the", "payload", "from", "its", "binary", "representation", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "Encode", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// Note that this method can't be named MarshalBinary, because the gob encoder would call", "// this method, resulting in infinite recursion.", "var", "buf", "bytes", ".", "Buffer", "\n", "if", "err", ":=", "pl", ".", "WriteBinary", "(", "&", "buf", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "Encode", "encodes", "the", "payload", "into", "its", "binary", "representation", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "ReadBinary", "(", "r", "io", ".", "Reader", ")", "error", "{", "dec", ":=", "gob", ".", "NewDecoder", "(", "r", ")", "\n", "return", "pl", ".", "DecodeBinary", "(", "dec", ")", "\n", "}" ]

[ "ReadBinary", "reads", "the", "payload", "from", "its", "binary", "representation", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "WriteBinary", "(", "w", "io", ".", "Writer", ")", "error", "{", "enc", ":=", "gob", ".", "NewEncoder", "(", "w", ")", "\n", "return", "pl", ".", "EncodeBinary", "(", "enc", ")", "\n", "}" ]

[ "WriteBinary", "writes", "the", "payload", "into", "its", "binary", "representation", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "EncodeBinary", "(", "enc", "*", "gob", ".", "Encoder", ")", "error", "{", "return", "enc", ".", "Encode", "(", "pl", ")", "\n", "}" ]

[ "EncodeBinary", "writes", "the", "payload", "into", "its", "binary", "representation", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "DecodeBinary", "(", "dec", "*", "gob", ".", "Decoder", ")", "error", "{", "return", "dec", ".", "Decode", "(", "pl", ")", "\n", "}" ]

[ "DecodeBinary", "reads", "the", "payload", "from", "its", "binary", "representation", "." ]

[ "func", "ReadMetaPayload", "(", "r", "io", ".", "Reader", ",", "meta", "*", "Meta", ",", "pl", "*", "Payload", ")", "error", "{", "if", "err", ":=", "meta", ".", "ReadBinary", "(", "r", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Meta.Size is not necessary for framing/decoding, but is useful to validate the payload size.", "return", "pl", ".", "ReadBinary", "(", "io", ".", "LimitReader", "(", "r", ",", "int64", "(", "meta", ".", "Size", ")", ")", ")", "\n", "}" ]

[ "ReadMetaPayload", "reads", "a", "Meta", "and", "Payload", "from", "a", "Cilium", "monitor", "connection", "." ]

[ "func", "WriteMetaPayload", "(", "w", "io", ".", "Writer", ",", "meta", "*", "Meta", ",", "pl", "*", "Payload", ")", "error", "{", "payloadBuf", ",", "err", ":=", "pl", ".", "Encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "meta", ".", "Size", "=", "uint32", "(", "len", "(", "payloadBuf", ")", ")", "\n", "meta", ".", "WriteBinary", "(", "w", ")", "\n", "_", ",", "err", "=", "w", ".", "Write", "(", "payloadBuf", ")", "\n", "return", "err", "\n", "}" ]

[ "WriteMetaPayload", "writes", "a", "Meta", "and", "Payload", "into", "a", "Cilium", "monitor", "connection", ".", "meta", ".", "Size", "is", "set", "to", "the", "size", "of", "the", "encoded", "Payload", "." ]

[ "func", "(", "pl", "*", "Payload", ")", "BuildMessage", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "plBuf", ",", "err", ":=", "pl", ".", "Encode", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "meta", ":=", "&", "Meta", "{", "Size", ":", "uint32", "(", "len", "(", "plBuf", ")", ")", "}", "\n", "metaBuf", ",", "err", ":=", "meta", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "append", "(", "metaBuf", ",", "plBuf", "...", ")", ",", "nil", "\n", "}" ]

[ "BuildMessage", "builds", "the", "binary", "message", "to", "be", "sent", "and", "returns", "it" ]

[ "func", "Endpoint2IfName", "(", "endpointID", "string", ")", "string", "{", "sum", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sha256", ".", "Sum256", "(", "[", "]", "byte", "(", "endpointID", ")", ")", ")", "\n", "// returned string length should be < unix.IFNAMSIZ", "truncateLength", ":=", "uint", "(", "unix", ".", "IFNAMSIZ", "-", "len", "(", "temporaryInterfacePrefix", ")", "-", "1", ")", "\n", "return", "hostInterfacePrefix", "+", "truncateString", "(", "sum", ",", "truncateLength", ")", "\n", "}" ]

[ "Endpoint2IfName", "returns", "the", "host", "interface", "name", "for", "the", "given", "endpointID", "." ]

[ "func", "WriteSysConfig", "(", "fileName", ",", "value", "string", ")", "error", "{", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "fileName", ",", "os", ".", "O_WRONLY", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_TRUNC", ",", "0666", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "f", ".", "WriteString", "(", "value", ")", "\n", "if", "err", "!=", "nil", "{", "f", ".", "Close", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "f", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "WriteSysConfig", "tries", "to", "emulate", "a", "sysctl", "call", "by", "writing", "directly", "to", "the", "given", "fileName", "the", "given", "value", "." ]

[ "func", "GetNetInfoFromPID", "(", "pid", "int", ")", "(", "int", ",", "string", ",", "net", ".", "IP", ",", "error", ")", "{", "netNs", ",", "err", ":=", "ns", ".", "GetNS", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pid", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "\"", "\"", ",", "nil", ",", "err", "\n", "}", "\n", "defer", "netNs", ".", "Close", "(", ")", "\n\n", "var", "(", "lxcMAC", "string", "\n", "parentIndex", "int", "\n", "ip", "net", ".", "IP", "\n", ")", "\n\n", "err", "=", "netNs", ".", "Do", "(", "func", "(", "_", "ns", ".", "NetNS", ")", "error", "{", "links", ",", "err", ":=", "netlink", ".", "LinkList", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "l", ":=", "range", "links", "{", "addrs", ",", "err", ":=", "netlink", ".", "AddrList", "(", "l", ",", "netlink", ".", "FAMILY_V4", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "addr", ":=", "range", "addrs", "{", "if", "addr", ".", "IP", ".", "IsGlobalUnicast", "(", ")", "{", "ip", "=", "addr", ".", "IP", "\n", "lxcMAC", "=", "l", ".", "Attrs", "(", ")", ".", "HardwareAddr", ".", "String", "(", ")", "\n", "parentIndex", "=", "l", ".", "Attrs", "(", ")", ".", "ParentIndex", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "l", ".", "Attrs", "(", ")", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "return", "parentIndex", ",", "lxcMAC", ",", "ip", ",", "err", "\n", "}" ]

[ "GetNetInfoFromPID", "returns", "the", "index", "of", "the", "interface", "parent", "the", "MAC", "address", "and", "IP", "address", "of", "the", "first", "interface", "that", "contains", "an", "IP", "address", "with", "global", "scope", "." ]

[ "func", "(", "m", "*", "DebugInfo", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateCiliumStatus", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateEndpointList", "(", "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", "err", ":=", "m", ".", "validateServiceList", "(", "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", "debug", "info" ]

[ "func", "(", "lk", "*", "localKeys", ")", "allocate", "(", "key", "string", ",", "val", "idpool", ".", "ID", ")", "(", "idpool", ".", "ID", ",", "error", ")", "{", "lk", ".", "Lock", "(", ")", "\n", "defer", "lk", ".", "Unlock", "(", ")", "\n\n", "if", "k", ",", "ok", ":=", "lk", ".", "keys", "[", "key", "]", ";", "ok", "{", "if", "val", "!=", "k", ".", "val", "{", "return", "idpool", ".", "NoID", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "val", ",", "k", ".", "val", ")", "\n", "}", "\n\n", "k", ".", "refcnt", "++", "\n", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "nil", ",", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", ",", "fieldID", ":", "val", ",", "fieldRefCnt", ":", "k", ".", "refcnt", "}", ")", "\n", "return", "k", ".", "val", ",", "nil", "\n", "}", "\n\n", "k", ":=", "&", "localKey", "{", "key", ":", "key", ",", "val", ":", "val", ",", "refcnt", ":", "1", "}", "\n", "lk", ".", "keys", "[", "key", "]", "=", "k", "\n", "lk", ".", "ids", "[", "val", "]", "=", "k", "\n", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "nil", ",", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", ",", "fieldID", ":", "val", ",", "fieldRefCnt", ":", "1", "}", ")", "\n", "return", "val", ",", "nil", "\n", "}" ]

[ "allocate", "creates", "an", "entry", "for", "key", "in", "localKeys", "if", "needed", "and", "increments", "the", "refcnt", ".", "The", "value", "associated", "with", "the", "key", "must", "match", "the", "local", "cache", "or", "an", "error", "is", "returned" ]

[ "func", "(", "lk", "*", "localKeys", ")", "lookupID", "(", "id", "idpool", ".", "ID", ")", "string", "{", "lk", ".", "RLock", "(", ")", "\n", "defer", "lk", ".", "RUnlock", "(", ")", "\n\n", "if", "k", ",", "ok", ":=", "lk", ".", "ids", "[", "id", "]", ";", "ok", "{", "return", "k", ".", "key", "\n", "}", "\n\n", "return", "\"", "\"", "\n", "}" ]

[ "lookupID", "returns", "the", "key", "for", "a", "given", "ID", "or", "an", "empty", "string" ]

[ "func", "(", "lk", "*", "localKeys", ")", "use", "(", "key", "string", ")", "idpool", ".", "ID", "{", "lk", ".", "Lock", "(", ")", "\n", "defer", "lk", ".", "Unlock", "(", ")", "\n\n", "if", "k", ",", "ok", ":=", "lk", ".", "keys", "[", "key", "]", ";", "ok", "{", "// unverified keys behave as if they do not exist", "if", "!", "k", ".", "verified", "{", "return", "idpool", ".", "NoID", "\n", "}", "\n\n", "k", ".", "refcnt", "++", "\n", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "nil", ",", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", ",", "fieldID", ":", "k", ".", "val", ",", "fieldRefCnt", ":", "k", ".", "refcnt", "}", ")", "\n", "return", "k", ".", "val", "\n", "}", "\n\n", "return", "idpool", ".", "NoID", "\n", "}" ]

[ "use", "increments", "the", "refcnt", "of", "the", "key", "and", "returns", "its", "value" ]

[ "func", "(", "lk", "*", "localKeys", ")", "release", "(", "key", "string", ")", "(", "lastUse", "bool", ",", "err", "error", ")", "{", "lk", ".", "Lock", "(", ")", "\n", "defer", "lk", ".", "Unlock", "(", ")", "\n", "if", "k", ",", "ok", ":=", "lk", ".", "keys", "[", "key", "]", ";", "ok", "{", "k", ".", "refcnt", "--", "\n", "kvstore", ".", "Trace", "(", "\"", "\"", ",", "nil", ",", "logrus", ".", "Fields", "{", "fieldKey", ":", "key", ",", "fieldID", ":", "k", ".", "val", ",", "fieldRefCnt", ":", "k", ".", "refcnt", "}", ")", "\n", "if", "k", ".", "refcnt", "==", "0", "{", "delete", "(", "lk", ".", "keys", ",", "key", ")", "\n", "delete", "(", "lk", ".", "ids", ",", "k", ".", "val", ")", "\n", "return", "true", ",", "nil", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}", "\n\n", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "release", "releases", "the", "refcnt", "of", "a", "key", ".", "When", "the", "last", "reference", "was", "released", "the", "key", "is", "deleted", "and", "the", "returned", "lastUse", "value", "is", "true", "." ]

[ "func", "(", "d", "*", "digest", ")", "Copy", "(", ")", "(", "ResumableHash", ",", "error", ")", "{", "newHash", ":=", "hash", ".", "Hash", "(", "sha1", ".", "New", "(", ")", ")", "\n", "state", ",", "err", ":=", "d", ".", "Hash", ".", "(", "encoding", ".", "BinaryMarshaler", ")", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "newHash", ".", "(", "encoding", ".", "BinaryUnmarshaler", ")", ".", "UnmarshalBinary", "(", "state", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "digest", "{", "newHash", ",", "}", ",", "nil", "\n", "}" ]

[ "Copy", "duplicates", "the", "hash", "and", "returns", "the", "copy", "." ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "post", "Ip", "a", "m", "created", "response" ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "post", "Ip", "a", "m", "failure", "response" ]

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

[ "GetPrefilter", "returns", "a", "list", "of", "all", "CIDR", "prefixes" ]

[ "func", "(", "c", "*", "Client", ")", "PatchPrefilter", "(", "spec", "*", "models", ".", "PrefilterSpec", ")", "(", "*", "models", ".", "Prefilter", ",", "error", ")", "{", "params", ":=", "prefilter", ".", "NewPatchPrefilterParams", "(", ")", ".", "WithPrefilterSpec", "(", "spec", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Prefilter", ".", "PatchPrefilter", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "PatchPrefilter", "sets", "a", "list", "of", "CIDR", "prefixes" ]

[ "func", "(", "c", "*", "Client", ")", "DeletePrefilter", "(", "spec", "*", "models", ".", "PrefilterSpec", ")", "error", "{", "current", ",", "err", ":=", "c", ".", "GetPrefilter", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Hint", "(", "err", ")", "\n", "}", "\n\n", "deleteSet", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "keepList", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "delCIDR", ":=", "range", "spec", ".", "Deny", "{", "deleteSet", "[", "delCIDR", "]", "=", "true", "\n", "}", "\n\n", "if", "current", ".", "Status", "!=", "nil", "&&", "current", ".", "Status", ".", "Realized", "!=", "nil", "{", "for", "_", ",", "keepCIDR", ":=", "range", "current", ".", "Status", ".", "Realized", ".", "Deny", "{", "if", "!", "deleteSet", "[", "keepCIDR", "]", "{", "keepList", "=", "append", "(", "keepList", ",", "keepCIDR", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "update", ":=", "current", ".", "Status", ".", "Realized", "\n", "update", ".", "Deny", "=", "keepList", "\n", "_", ",", "err", "=", "c", ".", "PatchPrefilter", "(", "update", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "DeletePrefilter", "deletes", "a", "list", "of", "CIDR", "prefixes" ]

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

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

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

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

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

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

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "get", "fqdn", "cache", "Id", "o", "k", "response" ]

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

[ "WithPayload", "adds", "the", "payload", "to", "the", "get", "fqdn", "cache", "Id", "bad", "request", "response" ]

[ "func", "Validate", "(", "pattern", "string", ")", "(", "matcher", "*", "regexp", ".", "Regexp", ",", "err", "error", ")", "{", "pattern", "=", "strings", ".", "TrimSpace", "(", "pattern", ")", "\n", "pattern", "=", "strings", ".", "ToLower", "(", "pattern", ")", "\n\n", "// error check", "if", "strings", ".", "ContainsAny", "(", "pattern", ",", "\"", "\"", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "`Only alphanumeric ASCII characters, the hyphen \"-\", \".\" and \"*\" are allowed in a matchPattern`", ")", "\n", "}", "\n\n", "return", "regexp", ".", "Compile", "(", "ToRegexp", "(", "pattern", ")", ")", "\n", "}" ]

[ "Validate", "ensures", "that", "pattern", "is", "a", "parseable", "matchPattern", ".", "It", "returns", "the", "regexp", "generated", "when", "validating", "." ]

[ "func", "Sanitize", "(", "pattern", "string", ")", "string", "{", "if", "pattern", "==", "\"", "\"", "{", "return", "pattern", "\n", "}", "\n\n", "return", "strings", ".", "ToLower", "(", "dns", ".", "Fqdn", "(", "pattern", ")", ")", "\n", "}" ]

[ "Sanitize", "canonicalized", "the", "pattern", "for", "use", "by", "ToRegexp" ]

[ "func", "NewCIDR", "(", "ipnet", "*", "net", ".", "IPNet", ")", "*", "CIDR", "{", "if", "ipnet", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "&", "CIDR", "{", "ipnet", "}", "\n", "}" ]

[ "NewCIDR", "returns", "a", "new", "CIDR", "using", "a", "net", ".", "IPNet" ]

[ "func", "(", "n", "*", "CIDR", ")", "DeepCopy", "(", ")", "*", "CIDR", "{", "if", "n", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "&", "CIDR", "{", "&", "net", ".", "IPNet", "{", "IP", ":", "make", "(", "[", "]", "byte", ",", "len", "(", "n", ".", "IP", ")", ")", ",", "Mask", ":", "make", "(", "[", "]", "byte", ",", "len", "(", "n", ".", "Mask", ")", ")", ",", "}", ",", "}", "\n", "copy", "(", "out", ".", "IP", ",", "n", ".", "IP", ")", "\n", "copy", "(", "out", ".", "Mask", ",", "n", ".", "Mask", ")", "\n", "return", "out", "\n", "}" ]

[ "DeepCopy", "creates", "a", "deep", "copy", "of", "a", "CIDR" ]

[ "func", "ParseCIDR", "(", "str", "string", ")", "(", "*", "CIDR", ",", "error", ")", "{", "_", ",", "ipnet", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "NewCIDR", "(", "ipnet", ")", ",", "nil", "\n", "}" ]

[ "ParseCIDR", "parses", "the", "CIDR", "string", "using", "net", ".", "ParseCIDR" ]

[ "func", "MustParseCIDR", "(", "str", "string", ")", "*", "CIDR", "{", "c", ",", "err", ":=", "ParseCIDR", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "str", ",", "err", ")", ")", "\n", "}", "\n", "return", "c", "\n", "}" ]

[ "MustParseCIDR", "parses", "the", "CIDR", "string", "using", "net", ".", "ParseCIDR", "and", "panics", "if", "the", "CIDR", "cannot", "be", "parsed" ]

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

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

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

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

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

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