Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.4k

[ "func", "(", "m", "*", "DaemonConfigurationSpec", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateOptions", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validatePolicyEnforcement", "(", "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", "daemon", "configuration", "spec" ]

[ "func", "replaceDatapath", "(", "ctx", "context", ".", "Context", ",", "ifName", "string", ",", "objPath", "string", ",", "progSec", "string", ")", "error", "{", "err", ":=", "replaceQdisc", "(", "ifName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ifName", ",", "err", ")", "\n", "}", "\n\n", "// FIXME: Replace cilium-map-migrate with Golang map migration", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "objPath", ")", "\n", "cmd", ".", "Env", "=", "bpf", ".", "Environment", "(", ")", "\n", "if", "_", ",", "err", "=", "cmd", ".", "CombinedOutput", "(", "log", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "var", "retCode", "string", "\n", "if", "err", "==", "nil", "{", "retCode", "=", "\"", "\"", "\n", "}", "else", "{", "retCode", "=", "\"", "\"", "\n", "}", "\n", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "objPath", ",", "\"", "\"", ",", "retCode", "}", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "args", "...", ")", "\n", "cmd", ".", "Env", "=", "bpf", ".", "Environment", "(", ")", "\n", "_", ",", "_", "=", "cmd", ".", "CombinedOutput", "(", "log", ",", "true", ")", "// ignore errors", "\n", "}", "(", ")", "\n\n", "// FIXME: replace exec with native call", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "ifName", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "objPath", ",", "\"", "\"", ",", "progSec", ",", "}", "\n", "cmd", "=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "args", "...", ")", ".", "WithFilters", "(", "libbpfFixupMsg", ")", "\n", "_", ",", "err", "=", "cmd", ".", "CombinedOutput", "(", "log", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "replaceDatapath", "the", "qdisc", "and", "BPF", "program", "for", "a", "endpoint" ]

[ "func", "DeleteDatapath", "(", "ctx", "context", ".", "Context", ",", "ifName", ",", "direction", "string", ")", "error", "{", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "ifName", ",", "direction", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "cmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "\"", "\"", ",", "args", "...", ")", ".", "WithFilters", "(", "libbpfFixupMsg", ")", "\n", "_", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", "log", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteDatapath", "filter", "from", "the", "given", "ifName" ]

[ "func", "(", "kr", "*", "PortRuleKafka", ")", "CheckAPIKeyRole", "(", "kind", "int16", ")", "bool", "{", "// wildcard expression", "if", "len", "(", "kr", ".", "apiKeyInt", ")", "==", "0", "{", "return", "true", "\n", "}", "\n\n", "// Check kind", "for", "_", ",", "apiKey", ":=", "range", "kr", ".", "apiKeyInt", "{", "if", "apiKey", "==", "kind", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "CheckAPIKeyRole", "checks", "the", "apiKey", "value", "in", "the", "request", "and", "returns", "true", "if", "it", "is", "allowed", "else", "false" ]

[ "func", "(", "kr", "*", "PortRuleKafka", ")", "GetAPIVersion", "(", ")", "(", "int16", ",", "bool", ")", "{", "if", "kr", ".", "apiVersionInt", "==", "nil", "{", "return", "0", ",", "true", "\n", "}", "\n\n", "return", "*", "kr", ".", "apiVersionInt", ",", "false", "\n", "}" ]

[ "GetAPIVersion", "returns", "the", "APIVersion", "as", "integer", "or", "the", "bool", "set", "to", "true", "if", "any", "API", "version", "is", "allowed" ]

[ "func", "(", "kr", "*", "PortRuleKafka", ")", "MapRoleToAPIKey", "(", ")", "error", "{", "// Expand the kr.apiKeyInt array based on the Role.", "// For produce role, we need to add mandatory apiKeys produce, metadata and", "// apiversions. While for consume, we need to add mandatory apiKeys like", "// fetch, offsets, offsetcommit, offsetfetch, apiversions, metadata,", "// findcoordinator, joingroup, heartbeat,", "// leavegroup and syncgroup.", "switch", "strings", ".", "ToLower", "(", "kr", ".", "Role", ")", "{", "case", "ProduceRole", ":", "kr", ".", "apiKeyInt", "=", "KafkaRole", "{", "ProduceKey", ",", "MetadataKey", ",", "APIVersionsKey", "}", "\n", "return", "nil", "\n", "case", "ConsumeRole", ":", "kr", ".", "apiKeyInt", "=", "KafkaRole", "{", "FetchKey", ",", "OffsetsKey", ",", "MetadataKey", ",", "OffsetCommitKey", ",", "OffsetFetchKey", ",", "FindCoordinatorKey", ",", "JoinGroupKey", ",", "HeartbeatKey", ",", "LeaveGroupKey", ",", "SyncgroupKey", ",", "APIVersionsKey", "}", "\n", "return", "nil", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "kr", ".", "Role", ")", "\n", "}", "\n", "}" ]

[ "MapRoleToAPIKey", "maps", "the", "Role", "to", "the", "low", "level", "set", "of", "APIKeys", "for", "that", "role" ]

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

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

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "GetPolicyStatus", "(", "nodeName", "string", ")", "CiliumNetworkPolicyNodeStatus", "{", "if", "r", ".", "Status", ".", "Nodes", "==", "nil", "{", "return", "CiliumNetworkPolicyNodeStatus", "{", "}", "\n", "}", "\n", "return", "r", ".", "Status", ".", "Nodes", "[", "nodeName", "]", "\n", "}" ]

[ "GetPolicyStatus", "returns", "the", "CiliumNetworkPolicyNodeStatus", "corresponding", "to", "nodeName", "in", "the", "provided", "CiliumNetworkPolicy", ".", "If", "Nodes", "within", "the", "rule", "s", "Status", "is", "nil", "returns", "an", "empty", "CiliumNetworkPolicyNodeStatus", "." ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "SetPolicyStatus", "(", "nodeName", "string", ",", "cnpns", "CiliumNetworkPolicyNodeStatus", ")", "{", "if", "r", ".", "Status", ".", "Nodes", "==", "nil", "{", "r", ".", "Status", ".", "Nodes", "=", "map", "[", "string", "]", "CiliumNetworkPolicyNodeStatus", "{", "}", "\n", "}", "\n", "r", ".", "Status", ".", "Nodes", "[", "nodeName", "]", "=", "cnpns", "\n", "}" ]

[ "SetPolicyStatus", "sets", "the", "given", "policy", "status", "for", "the", "given", "nodes", "map" ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "SetDerivedPolicyStatus", "(", "derivativePolicyName", "string", ",", "status", "CiliumNetworkPolicyNodeStatus", ")", "{", "if", "r", ".", "Status", ".", "DerivativePolicies", "==", "nil", "{", "r", ".", "Status", ".", "DerivativePolicies", "=", "map", "[", "string", "]", "CiliumNetworkPolicyNodeStatus", "{", "}", "\n", "}", "\n", "r", ".", "Status", ".", "DerivativePolicies", "[", "derivativePolicyName", "]", "=", "status", "\n", "}" ]

[ "SetDerivedPolicyStatus", "set", "the", "derivative", "policy", "status", "for", "the", "given", "derivative", "policy", "name", "." ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "SpecEquals", "(", "o", "*", "CiliumNetworkPolicy", ")", "bool", "{", "if", "o", "==", "nil", "{", "return", "r", "==", "nil", "\n", "}", "\n", "return", "reflect", ".", "DeepEqual", "(", "r", ".", "Spec", ",", "o", ".", "Spec", ")", "&&", "reflect", ".", "DeepEqual", "(", "r", ".", "Specs", ",", "o", ".", "Specs", ")", "\n", "}" ]

[ "SpecEquals", "returns", "true", "if", "the", "spec", "and", "specs", "metadata", "is", "the", "sa" ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "Parse", "(", ")", "(", "api", ".", "Rules", ",", "error", ")", "{", "if", "r", ".", "ObjectMeta", ".", "Name", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "namespace", ":=", "k8sUtils", ".", "ExtractNamespace", "(", "&", "r", ".", "ObjectMeta", ")", "\n", "name", ":=", "r", ".", "ObjectMeta", ".", "Name", "\n", "uid", ":=", "r", ".", "ObjectMeta", ".", "UID", "\n\n", "retRules", ":=", "api", ".", "Rules", "{", "}", "\n\n", "if", "r", ".", "Spec", "!=", "nil", "{", "if", "err", ":=", "r", ".", "Spec", ".", "Sanitize", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n\n", "}", "\n", "cr", ":=", "k8sCiliumUtils", ".", "ParseToCiliumRule", "(", "namespace", ",", "name", ",", "uid", ",", "r", ".", "Spec", ")", "\n", "retRules", "=", "append", "(", "retRules", ",", "cr", ")", "\n", "}", "\n", "if", "r", ".", "Specs", "!=", "nil", "{", "for", "_", ",", "rule", ":=", "range", "r", ".", "Specs", "{", "if", "err", ":=", "rule", ".", "Sanitize", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n\n", "}", "\n", "cr", ":=", "k8sCiliumUtils", ".", "ParseToCiliumRule", "(", "namespace", ",", "name", ",", "uid", ",", "rule", ")", "\n", "retRules", "=", "append", "(", "retRules", ",", "cr", ")", "\n", "}", "\n", "}", "\n\n", "return", "retRules", ",", "nil", "\n", "}" ]

[ "Parse", "parses", "a", "CiliumNetworkPolicy", "and", "returns", "a", "list", "of", "cilium", "policy", "rules", "." ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "GetControllerName", "(", ")", "string", "{", "name", ":=", "k8sUtils", ".", "GetObjNamespaceName", "(", "&", "r", ".", "ObjectMeta", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k8sConst", ".", "CtrlPrefixPolicyStatus", ",", "name", ")", "\n", "}" ]

[ "GetControllerName", "returns", "the", "unique", "name", "for", "the", "controller", "manager", "." ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "GetIdentityLabels", "(", ")", "labels", ".", "LabelArray", "{", "namespace", ":=", "k8sUtils", ".", "ExtractNamespace", "(", "&", "r", ".", "ObjectMeta", ")", "\n", "name", ":=", "r", ".", "ObjectMeta", ".", "Name", "\n", "uid", ":=", "r", ".", "ObjectMeta", ".", "UID", "\n", "return", "k8sCiliumUtils", ".", "GetPolicyLabels", "(", "namespace", ",", "name", ",", "uid", ",", "k8sCiliumUtils", ".", "ResourceTypeCiliumNetworkPolicy", ")", "\n", "}" ]

[ "GetIdentityLabels", "returns", "all", "rule", "labels", "in", "the", "CiliumNetworkPolicy", "." ]

[ "func", "(", "r", "*", "CiliumNetworkPolicy", ")", "RequiresDerivative", "(", ")", "bool", "{", "if", "r", ".", "Spec", "!=", "nil", "{", "if", "r", ".", "Spec", ".", "RequiresDerivative", "(", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "if", "r", ".", "Specs", "!=", "nil", "{", "for", "_", ",", "rule", ":=", "range", "r", ".", "Specs", "{", "if", "rule", ".", "RequiresDerivative", "(", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "RequiresDerivative", "return", "true", "if", "the", "CNP", "has", "any", "rule", "that", "will", "create", "a", "new", "derivative", "rule", "." ]

[ "func", "(", "c", "ControllerList", ")", "Sort", "(", ")", "{", "sort", ".", "Slice", "(", "c", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "c", "[", "i", "]", ".", "Name", "<", "c", "[", "j", "]", ".", "Name", "}", ")", "\n", "}" ]

[ "Sort", "sorts", "the", "ControllerList", "by", "controller", "name" ]

[ "func", "(", "a", "AllowedIdentityList", ")", "Sort", "(", ")", "{", "sort", ".", "Slice", "(", "a", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "if", "a", "[", "i", "]", ".", "Identity", "<", "a", "[", "j", "]", ".", "Identity", "{", "return", "true", "\n", "}", "else", "if", "a", "[", "i", "]", ".", "Identity", "==", "a", "[", "j", "]", ".", "Identity", "{", "if", "a", "[", "i", "]", ".", "DestPort", "<", "a", "[", "j", "]", ".", "DestPort", "{", "return", "true", "\n", "}", "else", "if", "a", "[", "i", "]", ".", "DestPort", "==", "a", "[", "j", "]", ".", "DestPort", "{", "return", "a", "[", "i", "]", ".", "Protocol", "<", "a", "[", "j", "]", ".", "Protocol", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "}" ]

[ "Sort", "sorts", "a", "list", "AllowedIdentityTuple", "by", "numeric", "identity", "port", "and", "protocol" ]

[ "func", "(", "a", "AddressPairList", ")", "Sort", "(", ")", "{", "sort", ".", "Slice", "(", "a", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "if", "a", "[", "i", "]", ".", "IPV4", "<", "a", "[", "j", "]", ".", "IPV4", "{", "return", "true", "\n", "}", "else", "if", "a", "[", "i", "]", ".", "IPV4", "==", "a", "[", "j", "]", ".", "IPV4", "{", "return", "a", "[", "i", "]", ".", "IPV6", "<", "a", "[", "j", "]", ".", "IPV6", "\n", "}", "\n", "return", "false", "\n", "}", ")", "\n", "}" ]

[ "Sort", "sorts", "an", "AddressPairList", "by", "IPv4", "and", "IPv6", "address" ]

[ "func", "(", "m", "*", "EndpointStatus", ")", "DeepCopyInto", "(", "out", "*", "EndpointStatus", ")", "{", "*", "out", "=", "*", "m", "\n", "b", ",", "err", ":=", "(", "*", "EndpointStatus", ")", "(", "m", ")", ".", "MarshalBinary", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "err", "=", "(", "*", "EndpointStatus", ")", "(", "out", ")", ".", "UnmarshalBinary", "(", "b", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}" ]

[ "DeepCopyInto", "is", "an", "inefficient", "hack", "to", "allow", "reusing", "models", ".", "Endpoint", "in", "the", "CiliumEndpoint", "CRD", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "createEpInfoCache", "(", "epdir", "string", ")", "*", "epInfoCache", "{", "cidr6", ",", "cidr4", ":=", "e", ".", "GetCIDRPrefixLengths", "(", ")", "\n\n", "ep", ":=", "&", "epInfoCache", "{", "revision", ":", "e", ".", "nextPolicyRevision", ",", "keys", ":", "e", ".", "GetBPFKeys", "(", ")", ",", "epdir", ":", "epdir", ",", "id", ":", "e", ".", "GetID", "(", ")", ",", "ifName", ":", "e", ".", "IfName", ",", "ipvlan", ":", "e", ".", "HasIpvlanDataPath", "(", ")", ",", "identity", ":", "e", ".", "GetIdentity", "(", ")", ",", "mac", ":", "e", ".", "GetNodeMAC", "(", ")", ",", "ipv4", ":", "e", ".", "IPv4Address", "(", ")", ",", "ipv6", ":", "e", ".", "IPv6Address", "(", ")", ",", "conntrackLocal", ":", "e", ".", "ConntrackLocalLocked", "(", ")", ",", "cidr4PrefixLengths", ":", "cidr4", ",", "cidr6PrefixLengths", ":", "cidr6", ",", "options", ":", "e", ".", "Options", ".", "DeepCopy", "(", ")", ",", "endpoint", ":", "e", ",", "}", "\n\n", "var", "err", "error", "\n", "ep", ".", "value", ",", "err", "=", "e", ".", "GetBPFValue", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithField", "(", "logfields", ".", "EndpointID", ",", "e", ".", "ID", ")", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "ep", "\n", "}" ]

[ "Must", "be", "called", "when", "endpoint", "is", "still", "locked", "." ]

[ "func", "(", "ep", "*", "epInfoCache", ")", "Logger", "(", "subsystem", "string", ")", "*", "logrus", ".", "Entry", "{", "return", "ep", ".", "endpoint", ".", "Logger", "(", "subsystem", ")", "\n", "}" ]

[ "Logger", "returns", "the", "logger", "for", "the", "endpoint", "that", "is", "being", "cached", "." ]

[ "func", "OpenInstance", "(", "nodeID", "string", ",", "xdsPath", "string", ",", "newPolicyClient", "func", "(", "path", ",", "nodeID", "string", ",", "updater", "PolicyUpdater", ")", "PolicyClient", ",", "accessLogPath", "string", ",", "newAccessLogger", "func", "(", "accessLogPath", "string", ")", "AccessLogger", ")", "uint64", "{", "mutex", ".", "Lock", "(", ")", "\n", "defer", "mutex", ".", "Unlock", "(", ")", "\n\n", "// Check if have an instance with these params already", "for", "id", ",", "old", ":=", "range", "instances", "{", "oldXdsPath", ":=", "\"", "\"", "\n", "if", "old", ".", "policyClient", "!=", "nil", "{", "oldXdsPath", "=", "old", ".", "policyClient", ".", "Path", "(", ")", "\n", "}", "\n", "oldAccessLogPath", ":=", "\"", "\"", "\n", "if", "old", ".", "accessLogger", "!=", "nil", "{", "oldAccessLogPath", "=", "old", ".", "accessLogger", ".", "Path", "(", ")", "\n", "}", "\n", "if", "(", "nodeID", "==", "\"", "\"", "||", "old", ".", "nodeID", "==", "nodeID", ")", "&&", "xdsPath", "==", "oldXdsPath", "&&", "accessLogPath", "==", "oldAccessLogPath", "{", "old", ".", "openCount", "++", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "id", ",", "old", ".", "openCount", ")", "\n", "return", "id", "\n", "}", "\n", "}", "\n\n", "ins", ":=", "NewInstance", "(", "nodeID", ",", "newAccessLogger", "(", "accessLogPath", ")", ")", "\n", "// policy client needs the instance so we set it after instance has been created", "ins", ".", "policyClient", "=", "newPolicyClient", "(", "xdsPath", ",", "ins", ".", "nodeID", ",", "ins", ")", "\n\n", "instances", "[", "instanceId", "]", "=", "ins", "\n\n", "log", ".", "Infof", "(", "\"", "\"", ",", "instanceId", ")", "\n\n", "return", "instanceId", "\n", "}" ]

[ "OpenInstance", "creates", "a", "new", "instance", "or", "finds", "an", "existing", "one", "with", "equivalent", "parameters", ".", "returns", "the", "instance", "id", "." ]

[ "func", "CloseInstance", "(", "id", "uint64", ")", "uint64", "{", "mutex", ".", "Lock", "(", ")", "\n", "defer", "mutex", ".", "Unlock", "(", ")", "\n\n", "count", ":=", "uint64", "(", "0", ")", "\n", "if", "ins", ",", "ok", ":=", "instances", "[", "id", "]", ";", "ok", "{", "ins", ".", "openCount", "--", "\n", "count", "=", "ins", ".", "openCount", "\n", "if", "count", "<=", "0", "{", "if", "ins", ".", "policyClient", "!=", "nil", "{", "ins", ".", "policyClient", ".", "Close", "(", ")", "\n", "}", "\n", "if", "ins", ".", "accessLogger", "!=", "nil", "{", "ins", ".", "accessLogger", ".", "Close", "(", ")", "\n", "}", "\n", "delete", "(", "instances", ",", "id", ")", "\n", "}", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "id", ",", "count", ")", "\n", "}", "else", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "id", ")", "\n", "}", "\n", "return", "count", "\n", "}" ]

[ "Close", "returns", "the", "new", "open", "count" ]

[ "func", "(", "ins", "*", "Instance", ")", "PolicyUpdate", "(", "resp", "*", "envoy_api_v2", ".", "DiscoveryResponse", ")", "(", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "var", "ok", "bool", "\n", "if", "err", ",", "ok", "=", "r", ".", "(", "error", ")", ";", "!", "ok", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "resp", ")", "\n\n", "oldMap", ":=", "ins", ".", "getPolicyMap", "(", ")", "\n", "newMap", ":=", "newPolicyMap", "(", ")", "\n\n", "for", "_", ",", "any", ":=", "range", "resp", ".", "Resources", "{", "if", "any", ".", "TypeUrl", "!=", "resp", ".", "TypeUrl", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "any", ".", "TypeUrl", ",", "resp", ".", "TypeUrl", ")", "\n", "}", "\n", "var", "config", "cilium", ".", "NetworkPolicy", "\n", "if", "err", "=", "proto", ".", "Unmarshal", "(", "any", ".", "Value", ",", "&", "config", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "policyName", ":=", "config", ".", "GetName", "(", ")", "\n\n", "// Locate the old version, if any", "oldPolicy", ",", "found", ":=", "oldMap", "[", "policyName", "]", "\n", "if", "found", "{", "// Check if the new policy is the same as the old one", "if", "proto", ".", "Equal", "(", "&", "config", ",", "&", "oldPolicy", ".", "protobuf", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "policyName", ")", "\n", "newMap", "[", "policyName", "]", "=", "oldPolicy", "\n", "continue", "\n", "}", "\n", "}", "\n\n", "// Validate new config", "if", "err", "=", "config", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "policyName", ",", "err", ")", "\n", "}", "\n\n", "// Create new PolicyInstance, may panic", "newMap", "[", "policyName", "]", "=", "newPolicyInstance", "(", "&", "config", ")", "\n", "}", "\n\n", "// Store the new policy map", "ins", ".", "setPolicyMap", "(", "newMap", ")", "\n\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "ins", ".", "id", ",", "newMap", ")", "\n", "return", "\n", "}" ]

[ "Update", "the", "PolicyMap", "from", "a", "protobuf", ".", "PolicyMap", "is", "only", "ever", "changed", "if", "the", "whole", "update", "is", "successful", "." ]

[ "func", "GetHostPrimaryAddress", "(", "node", "*", "models", ".", "NodeStatus", ")", "*", "models", ".", "PathStatus", "{", "if", "node", ".", "Host", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "node", ".", "Host", ".", "PrimaryAddress", "\n", "}" ]

[ "GetHostPrimaryAddress", "returns", "the", "PrimaryAddress", "for", "the", "Host", "within", "node", ".", "If", "node", ".", "Host", "is", "nil", "returns", "nil", "." ]

[ "func", "FormatHealthStatusResponse", "(", "w", "io", ".", "Writer", ",", "sr", "*", "models", ".", "HealthStatusResponse", ",", "printAll", ",", "succinct", ",", "verbose", "bool", ",", "maxLines", "int", ")", "{", "var", "(", "healthy", "int", "\n", "localhost", "*", "models", ".", "NodeStatus", "\n", ")", "\n", "for", "_", ",", "node", ":=", "range", "sr", ".", "Nodes", "{", "if", "nodeIsHealthy", "(", "node", ")", "{", "healthy", "++", "\n", "}", "\n", "if", "nodeIsLocalhost", "(", "node", ",", "sr", ".", "Local", ")", "{", "localhost", "=", "node", "\n", "}", "\n", "}", "\n", "if", "succinct", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\\t", "\\n", "\"", ",", "healthy", ",", "len", "(", "sr", ".", "Nodes", ")", ",", "sr", ".", "Timestamp", ")", "\n", "if", "printAll", "||", "healthy", "<", "len", "(", "sr", ".", "Nodes", ")", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\\t", "\\t", "\\n", "\"", ")", "\n", "}", "\n", "}", "else", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\\n", "\"", ",", "sr", ".", "Timestamp", ")", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\n", "\"", ")", "\n", "}", "\n\n", "if", "localhost", "!=", "nil", "{", "formatNodeStatus", "(", "w", ",", "localhost", ",", "printAll", ",", "succinct", ",", "verbose", ",", "true", ")", "\n", "maxLines", "--", "\n", "}", "\n\n", "nodes", ":=", "sr", ".", "Nodes", "\n", "sort", ".", "Slice", "(", "nodes", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "strings", ".", "Compare", "(", "nodes", "[", "i", "]", ".", "Name", ",", "nodes", "[", "j", "]", ".", "Name", ")", "<", "0", "\n", "}", ")", "\n", "for", "n", ",", "node", ":=", "range", "nodes", "{", "if", "maxLines", ">", "0", "&&", "n", ">", "maxLines", "{", "break", "\n", "}", "\n", "if", "node", "==", "localhost", "{", "continue", "\n", "}", "\n", "formatNodeStatus", "(", "w", ",", "node", ",", "printAll", ",", "succinct", ",", "verbose", ",", "false", ")", "\n", "}", "\n", "if", "maxLines", ">", "0", "&&", "len", "(", "sr", ".", "Nodes", ")", "-", "healthy", ">", "maxLines", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "FormatHealthStatusResponse", "writes", "a", "HealthStatusResponse", "as", "a", "string", "to", "the", "writer", ".", "printAll", "if", "true", "causes", "all", "nodes", "to", "be", "printed", "regardless", "of", "status", "succinct", "if", "true", "causes", "node", "health", "to", "be", "output", "as", "one", "line", "per", "node", "verbose", "if", "true", "overrides", "succinct", "and", "prints", "all", "information", "maxLines", "if", "nonzero", "determines", "the", "maximum", "number", "of", "lines", "to", "print" ]

[ "func", "Execute", "(", ")", "{", "if", "err", ":=", "rootCmd", ".", "Execute", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "os", ".", "Exit", "(", "-", "1", ")", "\n", "}", "\n", "}" ]

[ "Execute", "is", "an", "entry", "point", "for", "node", "monitor" ]

[ "func", "buildServerOrExit", "(", "path", "string", ")", "net", ".", "Listener", "{", "scopedLog", ":=", "log", ".", "WithField", "(", "logfields", ".", "Path", ",", "path", ")", "\n\n", "os", ".", "Remove", "(", "path", ")", "\n", "server", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "path", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "os", ".", "Getuid", "(", ")", "==", "0", "{", "err", ":=", "api", ".", "SetDefaultPermissions", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "server", "\n", "}" ]

[ "buildServerOrExit", "opens", "a", "listener", "socket", "at", "path", ".", "It", "exits", "with", "logging", "on", "all", "errors", "." ]

[ "func", "(", "m", "*", "EndpointChangeRequest", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateAddressing", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateLabels", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateState", "(", "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", "change", "request" ]

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

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

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

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

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

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

[ "func", "(", "o", "*", "PutPolicyParams", ")", "WithPolicy", "(", "policy", "string", ")", "*", "PutPolicyParams", "{", "o", ".", "SetPolicy", "(", "policy", ")", "\n", "return", "o", "\n", "}" ]

[ "WithPolicy", "adds", "the", "policy", "to", "the", "put", "policy", "params" ]

[ "func", "MapUpdateContext", "(", "ctxID", "uint32", ",", "keyID", "uint8", ")", "error", "{", "k", ":=", "newEncryptKey", "(", "ctxID", ")", "\n", "v", ":=", "&", "EncryptValue", "{", "encryptKeyID", ":", "keyID", ",", "}", "\n", "return", "encryptMap", ".", "Update", "(", "k", ",", "v", ")", "\n", "}" ]

[ "MapUpdateContext", "updates", "the", "encrypt", "state", "with", "ctxID", "to", "use", "the", "new", "keyID" ]

[ "func", "(", "res", "*", "ResponseMessage", ")", "String", "(", ")", "string", "{", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "res", ".", "response", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", ".", "Error", "(", ")", "\n", "}", "\n", "return", "string", "(", "b", ")", "\n", "}" ]

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

[ "func", "ReadResponse", "(", "reader", "io", ".", "Reader", ")", "(", "*", "ResponseMessage", ",", "error", ")", "{", "rsp", ":=", "&", "ResponseMessage", "{", "}", "\n", "var", "err", "error", "\n\n", "_", ",", "rsp", ".", "rawMsg", ",", "err", "=", "proto", ".", "ReadResp", "(", "reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "rsp", ".", "rawMsg", ")", "<", "6", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "rsp", ",", "nil", "\n", "}" ]

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

[ "func", "(", "v", "*", "version", ")", "CiliumEndpoints", "(", ")", "CiliumEndpointInformer", "{", "return", "&", "ciliumEndpointInformer", "{", "factory", ":", "v", ".", "factory", ",", "namespace", ":", "v", ".", "namespace", ",", "tweakListOptions", ":", "v", ".", "tweakListOptions", "}", "\n", "}" ]

[ "CiliumEndpoints", "returns", "a", "CiliumEndpointInformer", "." ]

[ "func", "(", "v", "*", "version", ")", "CiliumNetworkPolicies", "(", ")", "CiliumNetworkPolicyInformer", "{", "return", "&", "ciliumNetworkPolicyInformer", "{", "factory", ":", "v", ".", "factory", ",", "namespace", ":", "v", ".", "namespace", ",", "tweakListOptions", ":", "v", ".", "tweakListOptions", "}", "\n", "}" ]

[ "CiliumNetworkPolicies", "returns", "a", "CiliumNetworkPolicyInformer", "." ]

[ "func", "(", "e", "*", "EndpointSet", ")", "ForEach", "(", "wg", "*", "sync", ".", "WaitGroup", ",", "epFunc", "func", "(", "epp", "Endpoint", ")", ")", "{", "e", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "e", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "wg", ".", "Add", "(", "len", "(", "e", ".", "endpoints", ")", ")", "\n\n", "for", "ep", ":=", "range", "e", ".", "endpoints", "{", "go", "func", "(", "eppp", "Endpoint", ")", "{", "epFunc", "(", "eppp", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", "ep", ")", "\n", "}", "\n", "}" ]

[ "ForEach", "runs", "epFunc", "asynchronously", "for", "all", "endpoints", "in", "the", "EndpointSet", ".", "It", "signals", "to", "the", "provided", "WaitGroup", "when", "epFunc", "has", "been", "executed", "for", "each", "endpoint", "." ]

[ "func", "(", "e", "*", "EndpointSet", ")", "Delete", "(", "ep", "Endpoint", ")", "{", "e", ".", "mutex", ".", "Lock", "(", ")", "\n", "delete", "(", "e", ".", "endpoints", ",", "ep", ")", "\n", "e", ".", "mutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Delete", "removes", "ep", "from", "the", "EndpointSet", "." ]

[ "func", "(", "e", "*", "EndpointSet", ")", "Insert", "(", "ep", "Endpoint", ")", "{", "e", ".", "mutex", ".", "Lock", "(", ")", "\n", "e", ".", "endpoints", "[", "ep", "]", "=", "struct", "{", "}", "{", "}", "\n", "e", ".", "mutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Insert", "adds", "ep", "to", "the", "EndpointSet", "." ]

[ "func", "(", "e", "*", "EndpointSet", ")", "Len", "(", ")", "int", "{", "e", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "e", ".", "mutex", ".", "RUnlock", "(", ")", "\n", "return", "len", "(", "e", ".", "endpoints", ")", "\n", "}" ]

[ "Len", "returns", "the", "number", "of", "elements", "in", "the", "EndpointSet", "." ]

[ "func", "SetupVethRemoteNs", "(", "netNs", "ns", ".", "NetNS", ",", "srcIfName", ",", "dstIfName", "string", ")", "(", "int", ",", "int", ",", "error", ")", "{", "return", "0", ",", "0", ",", "netNs", ".", "Do", "(", "func", "(", "_", "ns", ".", "NetNS", ")", "error", "{", "err", ":=", "link", ".", "Rename", "(", "srcIfName", ",", "dstIfName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "srcIfName", ",", "dstIfName", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "SetupVethRemoteNs", "renames", "the", "netdevice", "in", "the", "target", "namespace", "to", "the", "provided", "dstIfName", "." ]

[ "func", "SetupVeth", "(", "id", "string", ",", "mtu", "int", ",", "ep", "*", "models", ".", "EndpointChangeRequest", ")", "(", "*", "netlink", ".", "Veth", ",", "*", "netlink", ".", "Link", ",", "string", ",", "error", ")", "{", "if", "id", "==", "\"", "\"", "{", "return", "nil", ",", "nil", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "lxcIfName", ":=", "Endpoint2IfName", "(", "id", ")", "\n", "tmpIfName", ":=", "Endpoint2TempIfName", "(", "id", ")", "\n\n", "veth", ",", "link", ",", "err", ":=", "SetupVethWithNames", "(", "lxcIfName", ",", "tmpIfName", ",", "mtu", ",", "ep", ")", "\n", "return", "veth", ",", "link", ",", "tmpIfName", ",", "err", "\n", "}" ]

[ "SetupVeth", "sets", "up", "the", "net", "interface", "the", "temporary", "interface", "and", "fills", "up", "some", "endpoint", "fields", "such", "as", "LXCMAC", "NodeMac", "IfIndex", "and", "IfName", ".", "Returns", "a", "pointer", "for", "the", "created", "veth", "a", "pointer", "for", "the", "temporary", "link", "the", "name", "of", "the", "temporary", "link", "and", "error", "if", "something", "fails", "." ]

[ "func", "SetupVethWithNames", "(", "lxcIfName", ",", "tmpIfName", "string", ",", "mtu", "int", ",", "ep", "*", "models", ".", "EndpointChangeRequest", ")", "(", "*", "netlink", ".", "Veth", ",", "*", "netlink", ".", "Link", ",", "error", ")", "{", "veth", ":=", "&", "netlink", ".", "Veth", "{", "LinkAttrs", ":", "netlink", ".", "LinkAttrs", "{", "Name", ":", "lxcIfName", "}", ",", "PeerName", ":", "tmpIfName", ",", "}", "\n\n", "if", "err", ":=", "netlink", ".", "LinkAdd", "(", "veth", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "var", "err", "error", "\n", "defer", "func", "(", ")", "{", "if", "err", "!=", "nil", "{", "if", "err", "=", "netlink", ".", "LinkDel", "(", "veth", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "WithField", "(", "logfields", ".", "Veth", ",", "veth", ".", "Name", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "log", ".", "WithField", "(", "logfields", ".", "VethPair", ",", "[", "]", "string", "{", "veth", ".", "PeerName", ",", "lxcIfName", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "// Disable reverse path filter on the host side veth peer to allow", "// container addresses to be used as source address when the linux", "// stack performs routing.", "rpFilterPath", ":=", "filepath", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "lxcIfName", ",", "\"", "\"", ")", "\n", "err", "=", "WriteSysConfig", "(", "rpFilterPath", ",", "\"", "\\n", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "rpFilterPath", ",", "err", ")", "\n", "}", "\n\n", "peer", ",", "err", ":=", "netlink", ".", "LinkByName", "(", "tmpIfName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "netlink", ".", "LinkSetMTU", "(", "peer", ",", "mtu", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "tmpIfName", ",", "err", ")", "\n", "}", "\n\n", "hostVeth", ",", "err", ":=", "netlink", ".", "LinkByName", "(", "lxcIfName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "netlink", ".", "LinkSetMTU", "(", "hostVeth", ",", "mtu", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "lxcIfName", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "netlink", ".", "LinkSetUp", "(", "veth", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "ep", ".", "Mac", "=", "peer", ".", "Attrs", "(", ")", ".", "HardwareAddr", ".", "String", "(", ")", "\n", "ep", ".", "HostMac", "=", "hostVeth", ".", "Attrs", "(", ")", ".", "HardwareAddr", ".", "String", "(", ")", "\n", "ep", ".", "InterfaceIndex", "=", "int64", "(", "hostVeth", ".", "Attrs", "(", ")", ".", "Index", ")", "\n", "ep", ".", "InterfaceName", "=", "lxcIfName", "\n\n", "return", "veth", ",", "&", "peer", ",", "nil", "\n", "}" ]

[ "SetupVethWithNames", "sets", "up", "the", "net", "interface", "the", "temporary", "interface", "and", "fills", "up", "some", "endpoint", "fields", "such", "as", "LXCMAC", "NodeMac", "IfIndex", "and", "IfName", ".", "Returns", "a", "pointer", "for", "the", "created", "veth", "a", "pointer", "for", "the", "temporary", "link", "the", "name", "of", "the", "temporary", "link", "and", "error", "if", "something", "fails", "." ]

[ "func", "GetNetHttpHeaders", "(", "httpHeaders", "[", "]", "*", "cilium", ".", "KeyValue", ")", "http", ".", "Header", "{", "headers", ":=", "make", "(", "http", ".", "Header", ")", "\n\n", "for", "_", ",", "header", ":=", "range", "httpHeaders", "{", "headers", ".", "Add", "(", "header", ".", "Key", ",", "header", ".", "Value", ")", "\n", "}", "\n\n", "return", "headers", "\n", "}" ]

[ "getNetHttpHeaders", "returns", "the", "Headers", "as", "net", ".", "http", ".", "Header" ]

[ "func", "GetProtocol", "(", "httpProtocol", "cilium", ".", "HttpProtocol", ")", "string", "{", "switch", "httpProtocol", "{", "case", "cilium", ".", "HttpProtocol_HTTP10", ":", "return", "\"", "\"", "\n", "case", "cilium", ".", "HttpProtocol_HTTP11", ":", "return", "\"", "\"", "\n", "case", "cilium", ".", "HttpProtocol_HTTP2", ":", "return", "\"", "\"", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "getProtocol", "returns", "the", "HTTP", "protocol", "in", "the", "format", "that", "Cilium", "understands" ]

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

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

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

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

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

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

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

[ "GetServices", "returns", "a", "list", "of", "all", "services", "." ]

[ "func", "(", "c", "*", "Client", ")", "GetServiceID", "(", "id", "int64", ")", "(", "*", "models", ".", "Service", ",", "error", ")", "{", "params", ":=", "service", ".", "NewGetServiceIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Service", ".", "GetServiceID", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "GetServiceID", "returns", "a", "service", "by", "ID", "." ]

[ "func", "(", "c", "*", "Client", ")", "PutServiceID", "(", "id", "int64", ",", "svc", "*", "models", ".", "ServiceSpec", ")", "(", "bool", ",", "error", ")", "{", "svc", ".", "ID", "=", "id", "\n", "params", ":=", "service", ".", "NewPutServiceIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithConfig", "(", "svc", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "created", ",", "err", ":=", "c", ".", "Service", ".", "PutServiceID", "(", "params", ")", "\n", "return", "created", "!=", "nil", ",", "Hint", "(", "err", ")", "\n", "}" ]

[ "PutServiceID", "creates", "or", "updates", "a", "service", ".", "Returns", "true", "if", "service", "was", "created", "." ]

[ "func", "(", "c", "*", "Client", ")", "DeleteServiceID", "(", "id", "int64", ")", "error", "{", "params", ":=", "service", ".", "NewDeleteServiceIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "err", ":=", "c", ".", "Service", ".", "DeleteServiceID", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "DeleteServiceID", "deletes", "a", "service", "by", "ID", "." ]

[ "func", "(", "m", "*", "IPAMResponse", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateAddress", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateHostAddressing", "(", "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", "IP", "a", "m", "response" ]

[ "func", "CalculateDuration", "(", "min", ",", "max", "time", ".", "Duration", ",", "factor", "float64", ",", "jitter", "bool", ",", "failures", "int", ")", "time", ".", "Duration", "{", "minFloat", ":=", "float64", "(", "min", ")", "\n", "maxFloat", ":=", "float64", "(", "max", ")", "\n\n", "t", ":=", "minFloat", "*", "math", ".", "Pow", "(", "factor", ",", "float64", "(", "failures", ")", ")", "\n", "if", "max", "!=", "time", ".", "Duration", "(", "0", ")", "&&", "t", ">", "maxFloat", "{", "t", "=", "maxFloat", "\n", "}", "\n\n", "if", "jitter", "{", "t", "=", "rand", ".", "Float64", "(", ")", "*", "(", "t", "-", "minFloat", ")", "+", "minFloat", "\n", "}", "\n\n", "return", "time", ".", "Duration", "(", "t", ")", "\n", "}" ]

[ "CalculateDuration", "calculates", "the", "backoff", "duration", "based", "on", "minimum", "base", "interval", "exponential", "factor", "jitter", "and", "number", "of", "failures", "." ]

[ "func", "(", "b", "*", "Exponential", ")", "Wait", "(", "ctx", "context", ".", "Context", ")", "error", "{", "b", ".", "attempt", "++", "\n", "t", ":=", "b", ".", "Duration", "(", "b", ".", "attempt", ")", "\n\n", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "t", ",", "\"", "\"", ":", "b", ".", "attempt", ",", "\"", "\"", ":", "b", ".", "Name", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "case", "<-", "time", ".", "After", "(", "t", ")", ":", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Wait", "waits", "for", "the", "required", "time", "using", "an", "exponential", "backoff" ]

[ "func", "(", "b", "*", "Exponential", ")", "Duration", "(", "attempt", "int", ")", "time", ".", "Duration", "{", "if", "b", ".", "Name", "==", "\"", "\"", "{", "b", ".", "Name", "=", "uuid", ".", "NewUUID", "(", ")", ".", "String", "(", ")", "\n", "}", "\n\n", "min", ":=", "time", ".", "Duration", "(", "1", ")", "*", "time", ".", "Second", "\n", "if", "b", ".", "Min", "!=", "time", ".", "Duration", "(", "0", ")", "{", "min", "=", "b", ".", "Min", "\n", "}", "\n\n", "factor", ":=", "float64", "(", "2", ")", "\n", "if", "b", ".", "Factor", "!=", "float64", "(", "0", ")", "{", "factor", "=", "b", ".", "Factor", "\n", "}", "\n\n", "t", ":=", "CalculateDuration", "(", "min", ",", "b", ".", "Max", ",", "factor", ",", "b", ".", "Jitter", ",", "attempt", ")", "\n\n", "if", "b", ".", "NodeManager", "!=", "nil", "{", "t", "=", "b", ".", "NodeManager", ".", "ClusterSizeDependantInterval", "(", "t", ")", "\n", "}", "\n\n", "if", "b", ".", "Max", "!=", "time", ".", "Duration", "(", "0", ")", "&&", "t", ">", "b", ".", "Max", "{", "t", "=", "b", ".", "Max", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "Duration", "returns", "the", "wait", "duration", "for", "the", "nth", "attempt" ]

[ "func", "wrap", "(", "cfg", "datapath", ".", "EndpointConfiguration", ",", "stats", "*", "SpanStat", ")", "*", "templateCfg", "{", "if", "stats", "==", "nil", "{", "stats", "=", "&", "SpanStat", "{", "}", "\n", "}", "\n", "return", "&", "templateCfg", "{", "EndpointConfiguration", ":", "cfg", ",", "stats", ":", "stats", ",", "}", "\n", "}" ]

[ "wrap", "takes", "an", "endpoint", "configuration", "and", "optional", "stats", "tracker", "and", "wraps", "it", "inside", "a", "templateCfg", "which", "hides", "static", "data", "from", "callers", "that", "wish", "to", "generate", "header", "files", "based", "on", "the", "configuration", "substituting", "it", "for", "template", "data", "." ]

[ "func", "elfMapSubstitutions", "(", "ep", "endpoint", ")", "map", "[", "string", "]", "string", "{", "result", ":=", "make", "(", "map", "[", "string", "]", "string", ")", "\n\n", "epID", ":=", "uint16", "(", "ep", ".", "GetID", "(", ")", ")", "\n", "for", "_", ",", "name", ":=", "range", "elfMapPrefixes", "{", "templateStr", ":=", "bpf", ".", "LocalMapName", "(", "name", ",", "TemplateLxcID", ")", "\n", "desiredStr", ":=", "bpf", ".", "LocalMapName", "(", "name", ",", "epID", ")", "\n", "result", "[", "templateStr", "]", "=", "desiredStr", "\n", "}", "\n", "if", "ep", ".", "ConntrackLocalLocked", "(", ")", "{", "for", "_", ",", "name", ":=", "range", "elfCtMapPrefixes", "{", "templateStr", ":=", "bpf", ".", "LocalMapName", "(", "name", ",", "TemplateLxcID", ")", "\n", "desiredStr", ":=", "bpf", ".", "LocalMapName", "(", "name", ",", "epID", ")", "\n", "result", "[", "templateStr", "]", "=", "desiredStr", "\n", "}", "\n", "}", "\n\n", "result", "[", "policymap", ".", "CallString", "(", "TemplateLxcID", ")", "]", "=", "policymap", ".", "CallString", "(", "epID", ")", "\n", "return", "result", "\n", "}" ]

[ "elfMapSubstitutions", "returns", "the", "set", "of", "map", "substitutions", "that", "must", "occur", "in", "an", "ELF", "template", "object", "file", "to", "update", "map", "references", "for", "the", "specified", "endpoint", "." ]

[ "func", "sliceToU16", "(", "input", "[", "]", "byte", ")", "uint16", "{", "result", ":=", "uint16", "(", "input", "[", "0", "]", ")", "<<", "8", "\n", "result", "|=", "uint16", "(", "input", "[", "1", "]", ")", "\n", "return", "result", "\n", "}" ]

[ "sliceToU16", "converts", "the", "input", "slice", "of", "two", "bytes", "to", "a", "uint16", "." ]

[ "func", "sliceToU32", "(", "input", "[", "]", "byte", ")", "uint32", "{", "result", ":=", "uint32", "(", "input", "[", "0", "]", ")", "<<", "24", "\n", "result", "|=", "uint32", "(", "input", "[", "1", "]", ")", "<<", "16", "\n", "result", "|=", "uint32", "(", "input", "[", "2", "]", ")", "<<", "8", "\n", "result", "|=", "uint32", "(", "input", "[", "3", "]", ")", "\n", "return", "result", "\n", "}" ]

[ "sliceToU32", "converts", "the", "input", "slice", "of", "four", "bytes", "to", "a", "uint32", "." ]

[ "func", "elfVariableSubstitutions", "(", "ep", "endpoint", ")", "map", "[", "string", "]", "uint32", "{", "result", ":=", "make", "(", "map", "[", "string", "]", "uint32", ")", "\n\n", "if", "ipv6", ":=", "ep", ".", "IPv6Address", "(", ")", ";", "ipv6", "!=", "nil", "{", "// Corresponds to DEFINE_IPV6() in bpf/lib/utils.h", "result", "[", "\"", "\"", "]", "=", "sliceToBe32", "(", "ipv6", "[", "0", ":", "4", "]", ")", "\n", "result", "[", "\"", "\"", "]", "=", "sliceToBe32", "(", "ipv6", "[", "4", ":", "8", "]", ")", "\n", "result", "[", "\"", "\"", "]", "=", "sliceToBe32", "(", "ipv6", "[", "8", ":", "12", "]", ")", "\n", "result", "[", "\"", "\"", "]", "=", "sliceToBe32", "(", "ipv6", "[", "12", ":", "16", "]", ")", "\n", "}", "\n", "if", "ipv4", ":=", "ep", ".", "IPv4Address", "(", ")", ";", "ipv4", "!=", "nil", "{", "result", "[", "\"", "\"", "]", "=", "byteorder", ".", "HostSliceToNetwork", "(", "ipv4", ",", "reflect", ".", "Uint32", ")", ".", "(", "uint32", ")", "\n", "}", "\n\n", "mac", ":=", "ep", ".", "GetNodeMAC", "(", ")", "\n", "result", "[", "\"", "\"", "]", "=", "sliceToBe32", "(", "mac", "[", "0", ":", "4", "]", ")", "\n", "result", "[", "\"", "\"", "]", "=", "uint32", "(", "sliceToBe16", "(", "mac", "[", "4", ":", "6", "]", ")", ")", "\n", "result", "[", "\"", "\"", "]", "=", "uint32", "(", "ep", ".", "GetID", "(", ")", ")", "\n", "identity", ":=", "ep", ".", "GetIdentity", "(", ")", ".", "Uint32", "(", ")", "\n", "result", "[", "\"", "\"", "]", "=", "identity", "\n", "result", "[", "\"", "\"", "]", "=", "byteorder", ".", "HostToNetwork", "(", "identity", ")", ".", "(", "uint32", ")", "\n\n", "return", "result", "\n\n", "}" ]

[ "elfVariableSubstitutions", "returns", "the", "set", "of", "data", "substitutions", "that", "must", "occur", "in", "an", "ELF", "template", "object", "file", "to", "update", "static", "data", "for", "the", "specified", "endpoint", "." ]

[ "func", "ELFSubstitutions", "(", "ep", "endpoint", ")", "(", "map", "[", "string", "]", "uint32", ",", "map", "[", "string", "]", "string", ")", "{", "return", "elfVariableSubstitutions", "(", "ep", ")", ",", "elfMapSubstitutions", "(", "ep", ")", "\n", "}" ]

[ "ELFSubstitutions", "fetches", "the", "set", "of", "variable", "and", "map", "substitutions", "that", "must", "be", "implemented", "against", "an", "ELF", "template", "to", "configure", "the", "datapath", "for", "the", "specified", "endpoint", "." ]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[ "func", "NewCiliumEndpointInformer", "(", "client", "versioned", ".", "Interface", ",", "namespace", "string", ",", "resyncPeriod", "time", ".", "Duration", ",", "indexers", "cache", ".", "Indexers", ")", "cache", ".", "SharedIndexInformer", "{", "return", "NewFilteredCiliumEndpointInformer", "(", "client", ",", "namespace", ",", "resyncPeriod", ",", "indexers", ",", "nil", ")", "\n", "}" ]

[ "NewCiliumEndpointInformer", "constructs", "a", "new", "informer", "for", "CiliumEndpoint", "type", ".", "Always", "prefer", "using", "an", "informer", "factory", "to", "get", "a", "shared", "informer", "instead", "of", "getting", "an", "independent", "one", ".", "This", "reduces", "memory", "footprint", "and", "number", "of", "connections", "to", "the", "server", "." ]

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

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

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

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

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

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

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

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

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

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

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

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

[ "func", "createEnvoyRedirect", "(", "r", "*", "Redirect", ",", "stateDir", "string", ",", "xdsServer", "*", "envoy", ".", "XDSServer", ",", "wg", "*", "completion", ".", "WaitGroup", ")", "(", "RedirectImplementation", ",", "error", ")", "{", "envoyOnce", ".", "Do", "(", "func", "(", ")", "{", "// Start Envoy on first invocation", "envoyProxy", "=", "envoy", ".", "StartEnvoy", "(", "stateDir", ",", "option", ".", "Config", ".", "EnvoyLogPath", ",", "0", ")", "\n", "}", ")", "\n\n", "l", ":=", "r", ".", "listener", "\n", "if", "envoyProxy", "!=", "nil", "{", "redir", ":=", "&", "envoyRedirect", "{", "listenerName", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "l", ".", "name", ",", "l", ".", "proxyPort", ")", ",", "xdsServer", ":", "xdsServer", ",", "}", "\n\n", "xdsServer", ".", "AddListener", "(", "redir", ".", "listenerName", ",", "l", ".", "parserType", ",", "l", ".", "proxyPort", ",", "l", ".", "ingress", ",", "wg", ")", "\n\n", "return", "redir", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "l", ".", "name", ")", "\n", "}" ]

[ "createEnvoyRedirect", "creates", "a", "redirect", "with", "corresponding", "proxy", "configuration", ".", "This", "will", "launch", "a", "proxy", "instance", "." ]

[ "func", "(", "k", "*", "envoyRedirect", ")", "UpdateRules", "(", "wg", "*", "completion", ".", "WaitGroup", ",", "l4", "*", "policy", ".", "L4Filter", ")", "(", "revert", ".", "RevertFunc", ",", "error", ")", "{", "return", "func", "(", ")", "error", "{", "return", "nil", "}", ",", "nil", "\n", "}" ]

[ "UpdateRules", "is", "a", "no", "-", "op", "for", "envoy", "as", "redirect", "data", "is", "synchronized", "via", "the", "xDS", "cache", "." ]

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

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

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

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

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

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

[ "func", "(", "o", "*", "PatchPrefilterParams", ")", "WithPrefilterSpec", "(", "prefilterSpec", "*", "models", ".", "PrefilterSpec", ")", "*", "PatchPrefilterParams", "{", "o", ".", "SetPrefilterSpec", "(", "prefilterSpec", ")", "\n", "return", "o", "\n", "}" ]

[ "WithPrefilterSpec", "adds", "the", "prefilterSpec", "to", "the", "patch", "prefilter", "params" ]

[ "func", "(", "e", "Error", ")", "String", "(", ")", "string", "{", "var", "errstr", "string", "\n", "if", "len", "(", "e", ".", "str", ")", ">", "0", "{", "errstr", "=", "e", ".", "str", "\n", "}", "else", "{", "errstr", "=", "e", ".", "code", ".", "String", "(", ")", "\n", "}", "\n\n", "if", "e", ".", "IsFatal", "(", ")", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "errstr", ")", "\n", "}", "\n\n", "return", "errstr", "\n", "}" ]

[ "String", "returns", "a", "human", "readable", "representation", "of", "an", "Error" ]

[ "func", "getFatalError", "(", "H", "Handle", ")", "error", "{", "cErrstr", ":=", "(", "*", "C", ".", "char", ")", "(", "C", ".", "malloc", "(", "C", ".", "size_t", "(", "512", ")", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cErrstr", ")", ")", "\n\n", "cErr", ":=", "C", ".", "rd_kafka_fatal_error", "(", "H", ".", "gethandle", "(", ")", ".", "rk", ",", "cErrstr", ",", "512", ")", "\n", "if", "int", "(", "cErr", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "err", ":=", "newErrorFromCString", "(", "cErr", ",", "cErrstr", ")", "\n", "err", ".", "fatal", "=", "true", "\n\n", "return", "err", "\n", "}" ]

[ "getFatalError", "returns", "an", "Error", "object", "if", "the", "client", "instance", "has", "raised", "a", "fatal", "error", "else", "nil", "." ]

[ "func", "newCPartsFromTopicPartitions", "(", "partitions", "[", "]", "TopicPartition", ")", "(", "cparts", "*", "C", ".", "rd_kafka_topic_partition_list_t", ")", "{", "cparts", "=", "C", ".", "rd_kafka_topic_partition_list_new", "(", "C", ".", "int", "(", "len", "(", "partitions", ")", ")", ")", "\n", "for", "_", ",", "part", ":=", "range", "partitions", "{", "ctopic", ":=", "C", ".", "CString", "(", "*", "part", ".", "Topic", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "ctopic", ")", ")", "\n", "rktpar", ":=", "C", ".", "rd_kafka_topic_partition_list_add", "(", "cparts", ",", "ctopic", ",", "C", ".", "int32_t", "(", "part", ".", "Partition", ")", ")", "\n", "rktpar", ".", "offset", "=", "C", ".", "int64_t", "(", "part", ".", "Offset", ")", "\n", "}", "\n\n", "return", "cparts", "\n", "}" ]

[ "new_cparts_from_TopicPartitions", "creates", "a", "new", "C", "rd_kafka_topic_partition_list_t", "from", "a", "TopicPartition", "array", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "Subscribe", "(", "topic", "string", ",", "rebalanceCb", "RebalanceCb", ")", "error", "{", "return", "c", ".", "SubscribeTopics", "(", "[", "]", "string", "{", "topic", "}", ",", "rebalanceCb", ")", "\n", "}" ]

[ "Subscribe", "to", "a", "single", "topic", "This", "replaces", "the", "current", "subscription" ]

[ "func", "(", "c", "*", "Consumer", ")", "SubscribeTopics", "(", "topics", "[", "]", "string", ",", "rebalanceCb", "RebalanceCb", ")", "(", "err", "error", ")", "{", "ctopics", ":=", "C", ".", "rd_kafka_topic_partition_list_new", "(", "C", ".", "int", "(", "len", "(", "topics", ")", ")", ")", "\n", "defer", "C", ".", "rd_kafka_topic_partition_list_destroy", "(", "ctopics", ")", "\n\n", "for", "_", ",", "topic", ":=", "range", "topics", "{", "ctopic", ":=", "C", ".", "CString", "(", "topic", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "ctopic", ")", ")", "\n", "C", ".", "rd_kafka_topic_partition_list_add", "(", "ctopics", ",", "ctopic", ",", "C", ".", "RD_KAFKA_PARTITION_UA", ")", "\n", "}", "\n\n", "e", ":=", "C", ".", "rd_kafka_subscribe", "(", "c", ".", "handle", ".", "rk", ",", "ctopics", ")", "\n", "if", "e", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "newError", "(", "e", ")", "\n", "}", "\n\n", "c", ".", "rebalanceCb", "=", "rebalanceCb", "\n", "c", ".", "handle", ".", "currAppRebalanceEnable", "=", "c", ".", "rebalanceCb", "!=", "nil", "||", "c", ".", "appRebalanceEnable", "\n\n", "return", "nil", "\n", "}" ]

[ "SubscribeTopics", "subscribes", "to", "the", "provided", "list", "of", "topics", ".", "This", "replaces", "the", "current", "subscription", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "Unsubscribe", "(", ")", "(", "err", "error", ")", "{", "C", ".", "rd_kafka_unsubscribe", "(", "c", ".", "handle", ".", "rk", ")", "\n", "return", "nil", "\n", "}" ]

[ "Unsubscribe", "from", "the", "current", "subscription", "if", "any", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "Assign", "(", "partitions", "[", "]", "TopicPartition", ")", "(", "err", "error", ")", "{", "c", ".", "appReassigned", "=", "true", "\n\n", "cparts", ":=", "newCPartsFromTopicPartitions", "(", "partitions", ")", "\n", "defer", "C", ".", "rd_kafka_topic_partition_list_destroy", "(", "cparts", ")", "\n\n", "e", ":=", "C", ".", "rd_kafka_assign", "(", "c", ".", "handle", ".", "rk", ",", "cparts", ")", "\n", "if", "e", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "newError", "(", "e", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Assign", "an", "atomic", "set", "of", "partitions", "to", "consume", ".", "This", "replaces", "the", "current", "assignment", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "Unassign", "(", ")", "(", "err", "error", ")", "{", "c", ".", "appReassigned", "=", "true", "\n\n", "e", ":=", "C", ".", "rd_kafka_assign", "(", "c", ".", "handle", ".", "rk", ",", "nil", ")", "\n", "if", "e", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "newError", "(", "e", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Unassign", "the", "current", "set", "of", "partitions", "to", "consume", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "commit", "(", "offsets", "[", "]", "TopicPartition", ")", "(", "committedOffsets", "[", "]", "TopicPartition", ",", "err", "error", ")", "{", "var", "rkqu", "*", "C", ".", "rd_kafka_queue_t", "\n\n", "rkqu", "=", "C", ".", "rd_kafka_queue_new", "(", "c", ".", "handle", ".", "rk", ")", "\n", "defer", "C", ".", "rd_kafka_queue_destroy", "(", "rkqu", ")", "\n\n", "var", "coffsets", "*", "C", ".", "rd_kafka_topic_partition_list_t", "\n", "if", "offsets", "!=", "nil", "{", "coffsets", "=", "newCPartsFromTopicPartitions", "(", "offsets", ")", "\n", "defer", "C", ".", "rd_kafka_topic_partition_list_destroy", "(", "coffsets", ")", "\n", "}", "\n\n", "cErr", ":=", "C", ".", "rd_kafka_commit_queue", "(", "c", ".", "handle", ".", "rk", ",", "coffsets", ",", "rkqu", ",", "nil", ",", "nil", ")", "\n", "if", "cErr", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "nil", ",", "newError", "(", "cErr", ")", "\n", "}", "\n\n", "rkev", ":=", "C", ".", "rd_kafka_queue_poll", "(", "rkqu", ",", "C", ".", "int", "(", "-", "1", ")", ")", "\n", "if", "rkev", "==", "nil", "{", "// shouldn't happen", "return", "nil", ",", "newError", "(", "C", ".", "RD_KAFKA_RESP_ERR__DESTROY", ")", "\n", "}", "\n", "defer", "C", ".", "rd_kafka_event_destroy", "(", "rkev", ")", "\n\n", "if", "C", ".", "rd_kafka_event_type", "(", "rkev", ")", "!=", "C", ".", "RD_KAFKA_EVENT_OFFSET_COMMIT", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "C", ".", "GoString", "(", "C", ".", "rd_kafka_event_name", "(", "rkev", ")", ")", ")", ")", "\n", "}", "\n\n", "cErr", "=", "C", ".", "rd_kafka_event_error", "(", "rkev", ")", "\n", "if", "cErr", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "nil", ",", "newErrorFromCString", "(", "cErr", ",", "C", ".", "rd_kafka_event_error_string", "(", "rkev", ")", ")", "\n", "}", "\n\n", "cRetoffsets", ":=", "C", ".", "rd_kafka_event_topic_partition_list", "(", "rkev", ")", "\n", "if", "cRetoffsets", "==", "nil", "{", "// no offsets, no error", "return", "nil", ",", "nil", "\n", "}", "\n", "committedOffsets", "=", "newTopicPartitionsFromCparts", "(", "cRetoffsets", ")", "\n\n", "return", "committedOffsets", ",", "nil", "\n", "}" ]

[ "commit", "offsets", "for", "specified", "offsets", ".", "If", "offsets", "is", "nil", "the", "currently", "assigned", "partitions", "offsets", "are", "committed", ".", "This", "is", "a", "blocking", "call", "caller", "will", "need", "to", "wrap", "in", "go", "-", "routine", "to", "get", "async", "or", "throw", "-", "away", "behaviour", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "CommitMessage", "(", "m", "*", "Message", ")", "(", "[", "]", "TopicPartition", ",", "error", ")", "{", "if", "m", ".", "TopicPartition", ".", "Error", "!=", "nil", "{", "return", "nil", ",", "newErrorFromString", "(", "ErrInvalidArg", ",", "\"", "\"", ")", "\n", "}", "\n", "offsets", ":=", "[", "]", "TopicPartition", "{", "m", ".", "TopicPartition", "}", "\n", "offsets", "[", "0", "]", ".", "Offset", "++", "\n", "return", "c", ".", "commit", "(", "offsets", ")", "\n", "}" ]

[ "CommitMessage", "commits", "offset", "based", "on", "the", "provided", "message", ".", "This", "is", "a", "blocking", "call", ".", "Returns", "the", "committed", "offsets", "on", "success", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "CommitOffsets", "(", "offsets", "[", "]", "TopicPartition", ")", "(", "[", "]", "TopicPartition", ",", "error", ")", "{", "return", "c", ".", "commit", "(", "offsets", ")", "\n", "}" ]

[ "CommitOffsets", "commits", "the", "provided", "list", "of", "offsets", "This", "is", "a", "blocking", "call", ".", "Returns", "the", "committed", "offsets", "on", "success", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "Close", "(", ")", "(", "err", "error", ")", "{", "if", "c", ".", "eventsChanEnable", "{", "// Wait for consumerReader() to terminate (by closing readerTermChan)", "close", "(", "c", ".", "readerTermChan", ")", "\n", "c", ".", "handle", ".", "waitTerminated", "(", "1", ")", "\n", "close", "(", "c", ".", "events", ")", "\n", "}", "\n\n", "C", ".", "rd_kafka_queue_destroy", "(", "c", ".", "handle", ".", "rkq", ")", "\n", "c", ".", "handle", ".", "rkq", "=", "nil", "\n\n", "e", ":=", "C", ".", "rd_kafka_consumer_close", "(", "c", ".", "handle", ".", "rk", ")", "\n", "if", "e", "!=", "C", ".", "RD_KAFKA_RESP_ERR_NO_ERROR", "{", "return", "newError", "(", "e", ")", "\n", "}", "\n\n", "c", ".", "handle", ".", "cleanup", "(", ")", "\n\n", "C", ".", "rd_kafka_destroy", "(", "c", ".", "handle", ".", "rk", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Close", "Consumer", "instance", ".", "The", "object", "is", "no", "longer", "usable", "after", "this", "call", "." ]

[ "func", "(", "c", "*", "Consumer", ")", "rebalance", "(", "ev", "Event", ")", "bool", "{", "c", ".", "appReassigned", "=", "false", "\n\n", "if", "c", ".", "rebalanceCb", "!=", "nil", "{", "c", ".", "rebalanceCb", "(", "c", ",", "ev", ")", "\n", "}", "\n\n", "return", "c", ".", "appReassigned", "\n", "}" ]

[ "rebalance", "calls", "the", "application", "s", "rebalance", "callback", "if", "any", ".", "Returns", "true", "if", "the", "underlying", "assignment", "was", "updated", "else", "false", "." ]

[ "func", "consumerReader", "(", "c", "*", "Consumer", ",", "termChan", "chan", "bool", ")", "{", "out", ":", "for", "true", "{", "select", "{", "case", "_", "=", "<-", "termChan", ":", "break", "out", "\n", "default", ":", "_", ",", "term", ":=", "c", ".", "handle", ".", "eventPoll", "(", "c", ".", "events", ",", "100", ",", "1000", ",", "termChan", ")", "\n", "if", "term", "{", "break", "out", "\n", "}", "\n\n", "}", "\n", "}", "\n\n", "c", ".", "handle", ".", "terminatedChan", "<-", "\"", "\"", "\n", "return", "\n\n", "}" ]

[ "consumerReader", "reads", "messages", "and", "events", "from", "the", "librdkafka", "consumer", "queue", "and", "posts", "them", "on", "the", "consumer", "channel", ".", "Runs", "until", "termChan", "closes" ]