Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.5k

[ "func", "OpenMapElems", "(", "path", "string", ",", "prefixlen", "int", ",", "prefixdyn", "bool", ",", "maxelem", "uint32", ")", "(", "*", "CIDRMap", ",", "bool", ",", "error", ")", "{", "var", "typeMap", "=", "bpf", ".", "BPF_MAP_TYPE_LPM_TRIE", "\n", "var", "prefix", "=", "0", "\n\n", "if", "prefixdyn", "==", "false", "{", "typeMap", "=", "bpf", ".", "BPF_MAP_TYPE_HASH", "\n", "prefix", "=", "prefixlen", "\n", "}", "\n", "if", "prefixlen", "<=", "0", "{", "return", "nil", ",", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "bytes", ":=", "(", "prefixlen", "-", "1", ")", "/", "8", "+", "1", "\n", "fd", ",", "isNewMap", ",", "err", ":=", "bpf", ".", "OpenOrCreateMap", "(", "path", ",", "typeMap", ",", "uint32", "(", "unsafe", ".", "Sizeof", "(", "uint32", "(", "0", ")", ")", "+", "uintptr", "(", "bytes", ")", ")", ",", "uint32", "(", "LPM_MAP_VALUE_SIZE", ")", ",", "maxelem", ",", "bpf", ".", "BPF_F_NO_PREALLOC", ",", "0", ",", ")", "\n\n", "if", "err", "!=", "nil", "{", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "typeMap", "=", "bpf", ".", "BPF_MAP_TYPE_HASH", "\n", "fd", ",", "isNewMap", ",", "err", "=", "bpf", ".", "OpenOrCreateMap", "(", "path", ",", "typeMap", ",", "uint32", "(", "unsafe", ".", "Sizeof", "(", "uint32", "(", "0", ")", ")", "+", "uintptr", "(", "bytes", ")", ")", ",", "uint32", "(", "LPM_MAP_VALUE_SIZE", ")", ",", "maxelem", ",", "bpf", ".", "BPF_F_NO_PREALLOC", ",", "0", ",", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ":=", "log", ".", "WithError", "(", "err", ")", ".", "WithField", "(", "logfields", ".", "Path", ",", "path", ")", "\n", "scopedLog", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "false", ",", "err", "\n", "}", "\n", "}", "\n\n", "m", ":=", "&", "CIDRMap", "{", "path", ":", "path", ",", "Fd", ":", "fd", ",", "AddrSize", ":", "bytes", ",", "Prefixlen", ":", "uint32", "(", "prefix", ")", ",", "PrefixIsDynamic", ":", "prefixdyn", ",", "}", "\n\n", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Path", ":", "path", ",", "\"", "\"", ":", "fd", ",", "\"", "\"", ":", "typeMap", "==", "bpf", ".", "BPF_MAP_TYPE_LPM_TRIE", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "m", ",", "isNewMap", ",", "nil", "\n", "}" ]

[ "OpenMapElems", "is", "the", "same", "as", "OpenMap", "only", "with", "defined", "maxelem", "as", "argument", "." ]

[ "func", "(", "s", "*", "proxySocket", ")", "Close", "(", ")", "{", "s", ".", "locker", ".", "Lock", "(", ")", "\n\n", "select", "{", "case", "<-", "s", ".", "closing", ":", "s", ".", "locker", ".", "Unlock", "(", ")", "\n", "return", "\n", "default", ":", "}", "\n\n", "close", "(", "s", ".", "closing", ")", "\n", "s", ".", "listener", ".", "Close", "(", ")", "\n\n", "pairs", ":=", "s", ".", "pairs", "\n", "s", ".", "pairs", "=", "nil", "\n\n", "s", ".", "locker", ".", "Unlock", "(", ")", "\n\n", "// Immediately close all connection pairs for which cascading close was", "// requested in Accept.", "for", "_", ",", "pair", ":=", "range", "pairs", "{", "pair", ".", "Rx", ".", "Close", "(", ")", "\n", "}", "\n", "}" ]

[ "Close", "closes", "the", "proxy", "socket", "and", "stops", "accepting", "new", "connections", "." ]

[ "func", "(", "c", "*", "proxyConnection", ")", "Enqueue", "(", "msg", "[", "]", "byte", ")", "{", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "fieldConn", ":", "c", ",", "fieldSize", ":", "len", "(", "msg", ")", ",", "}", ")", "\n\n", "flowdebug", ".", "Log", "(", "scopedLog", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "direction", "(", ")", ")", ")", "\n\n", "select", "{", "case", "<-", "c", ".", "close", ":", "flowdebug", ".", "Log", "(", "scopedLog", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "direction", "(", ")", ")", ")", "\n", "case", "c", ".", "queue", "<-", "msg", ":", "flowdebug", ".", "Log", "(", "scopedLog", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "direction", "(", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "Enqueue", "queues", "a", "message", "to", "be", "written", "into", "the", "connection", "." ]

[ "func", "(", "c", "*", "proxyConnection", ")", "Close", "(", ")", "{", "scopedLog", ":=", "log", ".", "WithField", "(", "fieldConn", ",", "c", ")", "\n\n", "c", ".", "closeLocker", ".", "Lock", "(", ")", "\n", "select", "{", "case", "<-", "c", ".", "close", ":", "// Already closed. Nothing to do.", "c", ".", "closeLocker", ".", "Unlock", "(", ")", "\n", "return", "\n", "default", ":", "}", "\n", "// Cause writeQueuedMessages to terminate.", "close", "(", "c", ".", "close", ")", "\n", "c", ".", "closeLocker", ".", "Unlock", "(", ")", "\n\n", "// Actually close the TCP connection. This will unblock any eventually", "// blocking c.conn.Write call in writeQueuedMessages.", "if", "!", "c", ".", "Closed", "(", ")", "{", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "c", ".", "conn", ".", "Close", "(", ")", "\n", "}", "\n\n", "// Call connectionPair.close() concurrently so that this call doesn't block", "// while waiting for the other connection in the pair to close.", "go", "c", ".", "afterClose", "(", ")", "\n", "}" ]

[ "Close", "closes", "this", "connection", ".", "The", "connection", "on", "the", "other", "side", "of", "the", "proxy", "is", "closed", "after", "it", "is", "queued", "for", "closing", "or", "after", "proxyConnectionCloseTimeout", "." ]

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

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

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

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

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

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

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

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

[ "func", "newCiliumEndpoints", "(", "c", "*", "CiliumV2Client", ",", "namespace", "string", ")", "*", "ciliumEndpoints", "{", "return", "&", "ciliumEndpoints", "{", "client", ":", "c", ".", "RESTClient", "(", ")", ",", "ns", ":", "namespace", ",", "}", "\n", "}" ]

[ "newCiliumEndpoints", "returns", "a", "CiliumEndpoints" ]

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

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

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

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

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

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

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

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

[ "func", "(", "n", "*", "NatEntry6", ")", "Dump", "(", "key", "tuple", ".", "TupleKey", ",", "start", "uint64", ")", "string", "{", "var", "which", "string", "\n\n", "if", "key", ".", "GetFlags", "(", ")", "&", "tuple", ".", "TUPLE_F_IN", "!=", "0", "{", "which", "=", "\"", "\"", "\n", "}", "else", "{", "which", "=", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "which", ",", "n", ".", "Addr", ",", "n", ".", "Port", ",", "NatDumpCreated", "(", "start", ",", "n", ".", "Created", ")", ",", "n", ".", "HostLocal", ")", "\n", "}" ]

[ "Dump", "dumps", "NAT", "entry", "to", "string", "." ]

[ "func", "(", "n", "*", "NatEntry6", ")", "ToHost", "(", ")", "NatEntry", "{", "x", ":=", "*", "n", "\n", "x", ".", "Port", "=", "byteorder", ".", "NetworkToHost", "(", "n", ".", "Port", ")", ".", "(", "uint16", ")", "\n", "return", "&", "x", "\n", "}" ]

[ "ToHost", "converts", "NatEntry4", "ports", "to", "host", "byte", "order", "." ]

[ "func", "(", "n", "*", "healthNode", ")", "PrimaryIP", "(", ")", "string", "{", "if", "n", ".", "NodeElement", ".", "PrimaryAddress", ".", "IPV4", ".", "Enabled", "{", "return", "n", ".", "NodeElement", ".", "PrimaryAddress", ".", "IPV4", ".", "IP", "\n", "}", "\n", "return", "n", ".", "NodeElement", ".", "PrimaryAddress", ".", "IPV6", ".", "IP", "\n", "}" ]

[ "PrimaryIP", "returns", "the", "primary", "IP", "address", "of", "the", "node", "." ]

[ "func", "(", "n", "*", "healthNode", ")", "HealthIP", "(", ")", "string", "{", "if", "n", ".", "NodeElement", ".", "HealthEndpointAddress", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "if", "n", ".", "NodeElement", ".", "HealthEndpointAddress", ".", "IPV4", ".", "Enabled", "{", "return", "n", ".", "NodeElement", ".", "HealthEndpointAddress", ".", "IPV4", ".", "IP", "\n", "}", "\n", "return", "n", ".", "NodeElement", ".", "HealthEndpointAddress", ".", "IPV6", ".", "IP", "\n", "}" ]

[ "HealthIP", "returns", "the", "IP", "address", "of", "the", "health", "endpoint", "for", "the", "node", "." ]

[ "func", "(", "n", "*", "healthNode", ")", "Addresses", "(", ")", "map", "[", "*", "models", ".", "NodeAddressingElement", "]", "bool", "{", "addresses", ":=", "map", "[", "*", "models", ".", "NodeAddressingElement", "]", "bool", "{", "}", "\n", "if", "n", ".", "NodeElement", ".", "PrimaryAddress", "!=", "nil", "{", "addr", ":=", "n", ".", "NodeElement", ".", "PrimaryAddress", "\n", "addresses", "[", "addr", ".", "IPV4", "]", "=", "addr", ".", "IPV4", ".", "Enabled", "\n", "addresses", "[", "addr", ".", "IPV6", "]", "=", "addr", ".", "IPV6", ".", "Enabled", "\n", "}", "\n", "if", "n", ".", "NodeElement", ".", "HealthEndpointAddress", "!=", "nil", "{", "addresses", "[", "n", ".", "NodeElement", ".", "HealthEndpointAddress", ".", "IPV4", "]", "=", "false", "\n", "addresses", "[", "n", ".", "NodeElement", ".", "HealthEndpointAddress", ".", "IPV6", "]", "=", "false", "\n", "}", "\n", "for", "_", ",", "elem", ":=", "range", "n", ".", "NodeElement", ".", "SecondaryAddresses", "{", "addresses", "[", "elem", "]", "=", "false", "\n", "}", "\n", "return", "addresses", "\n", "}" ]

[ "Addresses", "returns", "a", "map", "of", "the", "node", "s", "addresses", "-", ">", "primary", "bool" ]

[ "func", "transformEndpointForDowngrade", "(", "ep", "*", "Endpoint", ")", "{", "ep", ".", "DeprecatedOpts", ".", "Opts", "=", "convertOptions", "(", "ep", ".", "Options", ".", "Opts", ")", "\n", "}" ]

[ "transformEndpointForDowngrade", "modifies", "the", "specified", "endpoint", "to", "populate", "deprecated", "fields", "so", "that", "when", "the", "endpoint", "is", "serialized", "an", "older", "version", "of", "Cilium", "will", "understand", "the", "format", ".", "This", "allows", "safe", "downgrade", "from", "this", "version", "to", "an", "older", "version", "." ]

[ "func", "ReadEPsFromDirNames", "(", "basePath", "string", ",", "eptsDirNames", "[", "]", "string", ")", "map", "[", "uint16", "]", "*", "Endpoint", "{", "possibleEPs", ":=", "map", "[", "uint16", "]", "*", "Endpoint", "{", "}", "\n", "for", "_", ",", "epDirName", ":=", "range", "eptsDirNames", "{", "epDir", ":=", "filepath", ".", "Join", "(", "basePath", ",", "epDirName", ")", "\n", "readDir", ":=", "func", "(", ")", "string", "{", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "EndpointID", ":", "epDirName", ",", "logfields", ".", "Path", ":", "filepath", ".", "Join", "(", "epDir", ",", "common", ".", "CHeaderFileName", ")", ",", "}", ")", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "epFiles", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "epDir", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "\"", "\"", "\n", "}", "\n", "cHeaderFile", ":=", "common", ".", "FindEPConfigCHeader", "(", "epDir", ",", "epFiles", ")", "\n", "if", "cHeaderFile", "==", "\"", "\"", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "cHeaderFile", "\n", "}", "\n", "// There's an odd issue where the first read dir doesn't work.", "cHeaderFile", ":=", "readDir", "(", ")", "\n", "if", "cHeaderFile", "==", "\"", "\"", "{", "cHeaderFile", "=", "readDir", "(", ")", "\n", "}", "\n\n", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "EndpointID", ":", "epDirName", ",", "logfields", ".", "Path", ":", "cHeaderFile", ",", "}", ")", "\n\n", "if", "cHeaderFile", "==", "\"", "\"", "{", "scopedLog", ".", "Warning", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "strEp", ",", "err", ":=", "common", ".", "GetCiliumVersionString", "(", "cHeaderFile", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n", "ep", ",", "err", ":=", "ParseEndpoint", "(", "strEp", ")", "\n", "if", "err", "!=", "nil", "{", "scopedLog", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "possibleEPs", "[", "ep", ".", "ID", "]", ";", "ok", "{", "// If the endpoint already exists then give priority to the directory", "// that contains an endpoint that didn't fail to be build.", "if", "strings", ".", "HasSuffix", "(", "ep", ".", "DirectoryPath", "(", ")", ",", "epDirName", ")", "{", "possibleEPs", "[", "ep", ".", "ID", "]", "=", "ep", "\n", "}", "\n", "}", "else", "{", "possibleEPs", "[", "ep", ".", "ID", "]", "=", "ep", "\n", "}", "\n", "}", "\n", "return", "possibleEPs", "\n", "}" ]

[ "ReadEPsFromDirNames", "returns", "a", "mapping", "of", "endpoint", "ID", "to", "endpoint", "of", "endpoints", "from", "a", "list", "of", "directory", "names", "that", "can", "possible", "contain", "an", "endpoint", "." ]

[ "func", "(", "m", "*", "ModulesManager", ")", "Init", "(", ")", "error", "{", "modulesList", ",", "err", ":=", "listModules", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "m", ".", "modulesList", "=", "modulesList", "\n", "return", "nil", "\n", "}" ]

[ "Init", "initializes", "the", "internal", "modules", "information", "store", "of", "modules", "manager", "." ]

[ "func", "(", "m", "*", "ModulesManager", ")", "findModules", "(", "expectedNames", "...", "string", ")", "(", "bool", ",", "[", "]", "string", ")", "{", "return", "set", ".", "SliceSubsetOf", "(", "expectedNames", ",", "m", ".", "modulesList", ")", "\n", "}" ]

[ "findModules", "checks", "whether", "the", "given", "kernel", "modules", "are", "loaded", "and", "also", "returns", "a", "slice", "with", "names", "of", "modules", "which", "are", "not", "loaded", "." ]

[ "func", "(", "m", "*", "ModulesManager", ")", "FindOrLoadModules", "(", "expectedNames", "...", "string", ")", "error", "{", "found", ",", "diff", ":=", "m", ".", "findModules", "(", "expectedNames", "...", ")", "\n", "if", "found", "{", "return", "nil", "\n", "}", "\n", "for", "_", ",", "unloadedModule", ":=", "range", "diff", "{", "if", "_", ",", "err", ":=", "exec", ".", "WithTimeout", "(", "defaults", ".", "ExecTimeout", ",", "moduleLoader", "(", ")", ",", "unloadedModule", ")", ".", "CombinedOutput", "(", "nil", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "unloadedModule", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "FindOrLoadModules", "checks", "whether", "the", "given", "kernel", "modules", "are", "loaded", "and", "tries", "to", "load", "those", "which", "are", "not", "." ]

[ "func", "DeferTerminationCleanupFunction", "(", "wg", "*", "sync", ".", "WaitGroup", ",", "ch", "<-", "chan", "struct", "{", "}", ",", "f", "func", "(", ")", ")", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "<-", "ch", "\n", "f", "(", ")", "\n", "}", "(", ")", "\n", "}" ]

[ "DeferTerminationCleanupFunction", "will", "execute", "the", "given", "function", "f", "when", "the", "channel", "ch", "is", "closed", ".", "The", "given", "waitGroup", "will", "be", "added", "with", "a", "delta", "+", "1", "and", "once", "the", "function", "f", "returns", "from", "its", "execution", "that", "same", "waitGroup", "will", "signalize", "function", "f", "is", "completed", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "UpdateIdentities", "(", "added", ",", "deleted", "cache", ".", "IdentityCache", ")", "{", "policy", ".", "UpdateIdentities", "(", "added", ",", "deleted", ")", "\n", "d", ".", "TriggerPolicyUpdates", "(", "true", ",", "\"", "\"", ")", "\n", "}" ]

[ "UpdateIdentities", "informs", "the", "policy", "package", "of", "all", "identity", "changes", "and", "also", "triggers", "policy", "updates", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "PolicyAdd", "(", "rules", "policyAPI", ".", "Rules", ",", "opts", "*", "AddOptions", ")", "(", "newRev", "uint64", ",", "err", "error", ")", "{", "p", ":=", "&", "PolicyAddEvent", "{", "rules", ":", "rules", ",", "opts", ":", "opts", ",", "d", ":", "d", ",", "}", "\n", "polAddEvent", ":=", "eventqueue", ".", "NewEvent", "(", "p", ")", "\n", "resChan", ":=", "d", ".", "policy", ".", "RepositoryChangeQueue", ".", "Enqueue", "(", "polAddEvent", ")", "\n\n", "res", ",", "ok", ":=", "<-", "resChan", "\n", "if", "ok", "{", "pRes", ":=", "res", ".", "(", "*", "PolicyAddResult", ")", "\n", "return", "pRes", ".", "newRev", ",", "pRes", ".", "err", "\n", "}", "\n", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "PolicyAdd", "adds", "a", "slice", "of", "rules", "to", "the", "policy", "repository", "owned", "by", "the", "daemon", ".", "Eventual", "changes", "in", "policy", "rules", "are", "propagated", "to", "all", "locally", "managed", "endpoints", ".", "Returns", "the", "policy", "revision", "number", "of", "the", "repository", "after", "adding", "the", "rules", "into", "the", "repository", "or", "an", "error", "if", "the", "updated", "policy", "was", "not", "able", "to", "be", "imported", "." ]

[ "func", "(", "d", "*", "Daemon", ")", "PolicyDelete", "(", "labels", "labels", ".", "LabelArray", ")", "(", "newRev", "uint64", ",", "err", "error", ")", "{", "p", ":=", "&", "PolicyDeleteEvent", "{", "labels", ":", "labels", ",", "d", ":", "d", ",", "}", "\n", "policyDeleteEvent", ":=", "eventqueue", ".", "NewEvent", "(", "p", ")", "\n", "resChan", ":=", "d", ".", "policy", ".", "RepositoryChangeQueue", ".", "Enqueue", "(", "policyDeleteEvent", ")", "\n\n", "res", ",", "ok", ":=", "<-", "resChan", "\n", "if", "ok", "{", "ress", ":=", "res", ".", "(", "*", "PolicyDeleteResult", ")", "\n", "return", "ress", ".", "newRev", ",", "ress", ".", "err", "\n", "}", "\n", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}" ]

[ "PolicyDelete", "deletes", "the", "policy", "rules", "with", "the", "provided", "set", "of", "labels", "from", "the", "policy", "repository", "of", "the", "daemon", ".", "Returns", "the", "revision", "number", "and", "an", "error", "in", "case", "it", "was", "not", "possible", "to", "delete", "the", "policy", "." ]

[ "func", "initParser", "(", ")", "{", "if", "cache", "==", "nil", "{", "log", ".", "Info", "(", "\"", "\"", ")", "\n\n", "cache", "=", "&", "parserCache", "{", "decoded", ":", "[", "]", "gopacket", ".", "LayerType", "{", "}", ",", "}", "\n\n", "parser", "=", "gopacket", ".", "NewDecodingLayerParser", "(", "layers", ".", "LayerTypeEthernet", ",", "&", "cache", ".", "eth", ",", "&", "cache", ".", "ip4", ",", "&", "cache", ".", "ip6", ",", "&", "cache", ".", "icmp4", ",", "&", "cache", ".", "icmp6", ",", "&", "cache", ".", "tcp", ",", "&", "cache", ".", "udp", ")", "\n", "}", "\n", "}" ]

[ "getParser", "must", "be", "called", "with", "dissectLock", "held" ]

[ "func", "Dissect", "(", "dissect", "bool", ",", "data", "[", "]", "byte", ")", "{", "if", "dissect", "{", "dissectLock", ".", "Lock", "(", ")", "\n", "defer", "dissectLock", ".", "Unlock", "(", ")", "\n\n", "initParser", "(", ")", "\n", "parser", ".", "DecodeLayers", "(", "data", ",", "&", "cache", ".", "decoded", ")", "\n\n", "for", "_", ",", "typ", ":=", "range", "cache", ".", "decoded", "{", "switch", "typ", "{", "case", "layers", ".", "LayerTypeEthernet", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "eth", ")", ")", "\n", "case", "layers", ".", "LayerTypeIPv4", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "ip4", ")", ")", "\n", "case", "layers", ".", "LayerTypeIPv6", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "ip6", ")", ")", "\n", "case", "layers", ".", "LayerTypeTCP", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "tcp", ")", ")", "\n", "case", "layers", ".", "LayerTypeUDP", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "udp", ")", ")", "\n", "case", "layers", ".", "LayerTypeICMPv4", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "icmp4", ")", ")", "\n", "case", "layers", ".", "LayerTypeICMPv6", ":", "fmt", ".", "Println", "(", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "icmp6", ")", ")", "\n", "default", ":", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "parser", ".", "Truncated", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "\n\n", "}", "else", "{", "fmt", ".", "Print", "(", "hex", ".", "Dump", "(", "data", ")", ")", "\n", "}", "\n", "}" ]

[ "Dissect", "parses", "and", "prints", "the", "provided", "data", "if", "dissect", "is", "set", "to", "true", "otherwise", "the", "data", "is", "printed", "as", "HEX", "output" ]

[ "func", "GetDissectSummary", "(", "data", "[", "]", "byte", ")", "*", "DissectSummary", "{", "dissectLock", ".", "Lock", "(", ")", "\n", "defer", "dissectLock", ".", "Unlock", "(", ")", "\n\n", "initParser", "(", ")", "\n", "parser", ".", "DecodeLayers", "(", "data", ",", "&", "cache", ".", "decoded", ")", "\n\n", "ret", ":=", "&", "DissectSummary", "{", "}", "\n\n", "for", "_", ",", "typ", ":=", "range", "cache", ".", "decoded", "{", "switch", "typ", "{", "case", "layers", ".", "LayerTypeEthernet", ":", "ret", ".", "Ethernet", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "eth", ")", "\n", "src", ",", "dst", ":=", "cache", ".", "eth", ".", "LinkFlow", "(", ")", ".", "Endpoints", "(", ")", "\n", "ret", ".", "L2", "=", "&", "Flow", "{", "Src", ":", "src", ".", "String", "(", ")", ",", "Dst", ":", "dst", ".", "String", "(", ")", "}", "\n", "case", "layers", ".", "LayerTypeIPv4", ":", "ret", ".", "IPv4", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "ip4", ")", "\n", "src", ",", "dst", ":=", "cache", ".", "ip4", ".", "NetworkFlow", "(", ")", ".", "Endpoints", "(", ")", "\n", "ret", ".", "L3", "=", "&", "Flow", "{", "Src", ":", "src", ".", "String", "(", ")", ",", "Dst", ":", "dst", ".", "String", "(", ")", "}", "\n", "case", "layers", ".", "LayerTypeIPv6", ":", "ret", ".", "IPv6", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "ip6", ")", "\n", "src", ",", "dst", ":=", "cache", ".", "ip6", ".", "NetworkFlow", "(", ")", ".", "Endpoints", "(", ")", "\n", "ret", ".", "L3", "=", "&", "Flow", "{", "Src", ":", "src", ".", "String", "(", ")", ",", "Dst", ":", "dst", ".", "String", "(", ")", "}", "\n", "case", "layers", ".", "LayerTypeTCP", ":", "ret", ".", "TCP", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "tcp", ")", "\n", "src", ",", "dst", ":=", "cache", ".", "tcp", ".", "TransportFlow", "(", ")", ".", "Endpoints", "(", ")", "\n", "ret", ".", "L4", "=", "&", "Flow", "{", "Src", ":", "src", ".", "String", "(", ")", ",", "Dst", ":", "dst", ".", "String", "(", ")", "}", "\n", "case", "layers", ".", "LayerTypeUDP", ":", "ret", ".", "UDP", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "udp", ")", "\n", "src", ",", "dst", ":=", "cache", ".", "udp", ".", "TransportFlow", "(", ")", ".", "Endpoints", "(", ")", "\n", "ret", ".", "L4", "=", "&", "Flow", "{", "Src", ":", "src", ".", "String", "(", ")", ",", "Dst", ":", "dst", ".", "String", "(", ")", "}", "\n", "case", "layers", ".", "LayerTypeICMPv4", ":", "ret", ".", "ICMPv4", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "icmp4", ")", "\n", "case", "layers", ".", "LayerTypeICMPv6", ":", "ret", ".", "ICMPv6", "=", "gopacket", ".", "LayerString", "(", "&", "cache", ".", "icmp6", ")", "\n", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "GetDissectSummary", "returns", "DissectSummary", "created", "from", "data" ]

[ "func", "ipNetToLabel", "(", "cidr", "*", "net", ".", "IPNet", ")", "labels", ".", "Label", "{", "ones", ",", "_", ":=", "cidr", ".", "Mask", ".", "Size", "(", ")", "\n", "lblStr", ":=", "maskedIPToLabelString", "(", "&", "cidr", ".", "IP", ",", "ones", ")", "\n", "return", "labels", ".", "ParseLabel", "(", "lblStr", ")", "\n", "}" ]

[ "ipNetToLabel", "turns", "a", "CIDR", "into", "a", "Label", "object", "which", "can", "be", "used", "to", "create", "EndpointSelector", "objects", "." ]

[ "func", "IPStringToLabel", "(", "IP", "string", ")", "(", "labels", ".", "Label", ",", "error", ")", "{", "_", ",", "parsedPrefix", ",", "err", ":=", "net", ".", "ParseCIDR", "(", "IP", ")", "\n", "if", "err", "!=", "nil", "{", "parsedIP", ":=", "net", ".", "ParseIP", "(", "IP", ")", "\n", "if", "parsedIP", "==", "nil", "{", "return", "labels", ".", "Label", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "IP", ")", "\n", "}", "\n", "bits", ":=", "net", ".", "IPv6len", "*", "8", "\n", "if", "parsedIP", ".", "To4", "(", ")", "!=", "nil", "{", "bits", "=", "net", ".", "IPv4len", "*", "8", "\n", "}", "\n", "parsedPrefix", "=", "&", "net", ".", "IPNet", "{", "IP", ":", "parsedIP", ",", "Mask", ":", "net", ".", "CIDRMask", "(", "bits", ",", "bits", ")", "}", "\n", "}", "\n\n", "return", "ipNetToLabel", "(", "parsedPrefix", ")", ",", "nil", "\n", "}" ]

[ "IPStringToLabel", "parses", "a", "string", "and", "returns", "it", "as", "a", "CIDR", "label", ".", "If", "IP", "is", "not", "a", "valid", "IP", "address", "or", "CIDR", "Prefix", "returns", "an", "error", "." ]

[ "func", "isInjectedWithIstioSidecarProxy", "(", "scopedLog", "*", "logrus", ".", "Entry", ",", "pod", "*", "corev1", ".", "Pod", ")", "bool", "{", "istioStatusString", ",", "ok", ":=", "pod", ".", "GetAnnotations", "(", ")", "[", "AnnotationIstioSidecarStatus", "]", "\n", "if", "!", "ok", "{", "// Istio's injection annotation was not found.", "scopedLog", ".", "Debugf", "(", "\"", "\"", ",", "AnnotationIstioSidecarStatus", ")", "\n", "return", "false", "\n", "}", "\n\n", "scopedLog", ".", "Debugf", "(", "\"", "\"", ",", "AnnotationIstioSidecarStatus", ",", "istioStatusString", ")", "\n\n", "// Check that there's an \"istio-proxy\" container that uses an image", "// compatible with Cilium.", "for", "_", ",", "container", ":=", "range", "pod", ".", "Spec", ".", "Containers", "{", "if", "container", ".", "Name", "!=", "\"", "\"", "{", "continue", "\n", "}", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "if", "!", "SidecarIstioProxyImageRegexp", ".", "MatchString", "(", "container", ".", "Image", ")", "{", "continue", "\n", "}", "\n", "scopedLog", ".", "Debugf", "(", "\"", "\"", ",", "container", ".", "Image", ")", "\n\n", "for", "_", ",", "mount", ":=", "range", "container", ".", "VolumeMounts", "{", "if", "mount", ".", "MountPath", "!=", "\"", "\"", "{", "continue", "\n", "}", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "return", "true", "\n", "}", "\n", "}", "\n\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "false", "\n", "}" ]

[ "isInjectedWithIstioSidecarProxy", "returns", "whether", "the", "given", "pod", "has", "been", "injected", "by", "Istio", "with", "a", "sidecar", "proxy", "that", "is", "compatible", "with", "Cilium", "." ]

[ "func", "GetPodLabels", "(", "namespace", ",", "podName", "string", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "scopedLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "K8sNamespace", ":", "namespace", ",", "logfields", ".", "K8sPodName", ":", "podName", ",", "}", ")", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "result", ",", "err", ":=", "Client", "(", ")", ".", "CoreV1", "(", ")", ".", "Pods", "(", "namespace", ")", ".", "Get", "(", "podName", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Also get all labels from the namespace where the pod is running", "k8sNs", ",", "err", ":=", "Client", "(", ")", ".", "CoreV1", "(", ")", ".", "Namespaces", "(", ")", ".", "Get", "(", "namespace", ",", "metav1", ".", "GetOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "k8sLabels", ":=", "result", ".", "GetLabels", "(", ")", "\n", "if", "k8sLabels", "==", "nil", "{", "k8sLabels", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "k8sNs", ".", "GetLabels", "(", ")", "{", "k8sLabels", "[", "policy", ".", "JoinPath", "(", "k8sConst", ".", "PodNamespaceMetaLabels", ",", "k", ")", "]", "=", "v", "\n", "}", "\n", "k8sLabels", "[", "k8sConst", ".", "PodNamespaceLabel", "]", "=", "namespace", "\n\n", "if", "result", ".", "Spec", ".", "ServiceAccountName", "!=", "\"", "\"", "{", "k8sLabels", "[", "k8sConst", ".", "PolicyLabelServiceAccount", "]", "=", "result", ".", "Spec", ".", "ServiceAccountName", "\n", "}", "else", "{", "delete", "(", "k8sLabels", ",", "k8sConst", ".", "PolicyLabelServiceAccount", ")", "\n", "}", "\n\n", "// If the pod has been injected with an Istio sidecar proxy compatible with", "// Cilium, add a label to notify that.", "// If the pod already contains that label to explicitly enable or disable", "// the sidecar proxy mode, keep it as is.", "if", "_", ",", "ok", ":=", "k8sLabels", "[", "k8sConst", ".", "PolicyLabelIstioSidecarProxy", "]", ";", "!", "ok", "&&", "isInjectedWithIstioSidecarProxy", "(", "scopedLog", ",", "result", ")", "{", "k8sLabels", "[", "k8sConst", ".", "PolicyLabelIstioSidecarProxy", "]", "=", "\"", "\"", "\n", "}", "\n\n", "k8sLabels", "[", "k8sConst", ".", "PolicyLabelCluster", "]", "=", "option", ".", "Config", ".", "ClusterName", "\n\n", "return", "k8sLabels", ",", "nil", "\n", "}" ]

[ "GetPodLabels", "returns", "the", "labels", "of", "a", "pod" ]

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

[ "func", "(", "d", "*", "datapathHash", ")", "sumEndpoint", "(", "dp", "datapath", ".", "Datapath", ",", "epCfg", "datapath", ".", "EndpointConfiguration", ",", "staticData", "bool", ")", "(", "string", ",", "error", ")", "{", "result", ",", "err", ":=", "d", ".", "Copy", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "staticData", "{", "dp", ".", "WriteEndpointConfig", "(", "result", ",", "epCfg", ")", "\n", "}", "else", "{", "dp", ".", "WriteTemplateConfig", "(", "result", ",", "epCfg", ")", "\n", "}", "\n", "return", "result", ".", "String", "(", ")", ",", "nil", "\n", "}" ]

[ "sumEndpoint", "returns", "the", "hash", "of", "the", "complete", "datapath", "for", "an", "endpoint", ".", "It", "does", "not", "change", "the", "underlying", "hash", "state", "." ]

[ "func", "(", "o", "Option", ")", "RequiresOption", "(", "name", "string", ")", "bool", "{", "for", "_", ",", "o", ":=", "range", "o", ".", "Requires", "{", "if", "o", "==", "name", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "RequiresOption", "returns", "true", "if", "the", "option", "requires", "the", "specified", "option", "name", "." ]

[ "func", "(", "l", "*", "OptionLibrary", ")", "ValidateConfigurationMap", "(", "n", "models", ".", "ConfigurationMap", ")", "(", "OptionMap", ",", "error", ")", "{", "o", ":=", "make", "(", "OptionMap", ")", "\n", "for", "k", ",", "v", ":=", "range", "n", "{", "_", ",", "newVal", ",", "err", ":=", "ParseKeyValue", "(", "l", ",", "k", ",", "v", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "l", ".", "Validate", "(", "k", ",", "v", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "o", "[", "k", "]", "=", "newVal", "\n", "}", "\n\n", "return", "o", ",", "nil", "\n", "}" ]

[ "ValidateConfigurationMap", "validates", "a", "given", "configuration", "map", "based", "on", "the", "option", "library" ]

[ "func", "(", "o", "*", "IntOptions", ")", "GetImmutableModel", "(", ")", "*", "models", ".", "ConfigurationMap", "{", "immutableCfg", ":=", "make", "(", "models", ".", "ConfigurationMap", ")", "\n", "return", "&", "immutableCfg", "\n", "}" ]

[ "GetImmutableModel", "returns", "the", "set", "of", "immutable", "options", "as", "a", "ConfigurationMap", "API", "model", "." ]

[ "func", "(", "o", "*", "IntOptions", ")", "GetMutableModel", "(", ")", "*", "models", ".", "ConfigurationMap", "{", "mutableCfg", ":=", "make", "(", "models", ".", "ConfigurationMap", ")", "\n", "o", ".", "optsMU", ".", "RLock", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "o", ".", "Opts", "{", "_", ",", "config", ":=", "o", ".", "Library", ".", "Lookup", "(", "k", ")", "\n\n", "// It's possible that an option has since been removed and thus has", "// no corresponding configuration; need to check if configuration is", "// nil accordingly.", "if", "config", "!=", "nil", "{", "if", "config", ".", "Format", "==", "nil", "{", "if", "v", "==", "OptionDisabled", "{", "mutableCfg", "[", "k", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", "\n", "}", "else", "{", "mutableCfg", "[", "k", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "{", "mutableCfg", "[", "k", "]", "=", "config", ".", "Format", "(", "v", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "o", ".", "optsMU", ".", "RUnlock", "(", ")", "\n\n", "return", "&", "mutableCfg", "\n", "}" ]

[ "GetMutableModel", "returns", "the", "set", "of", "mutable", "options", "as", "a", "ConfigurationMap", "API", "model", "." ]

[ "func", "(", "o", "*", "IntOptions", ")", "SetValidated", "(", "key", "string", ",", "value", "OptionSetting", ")", "{", "o", ".", "optsMU", ".", "Lock", "(", ")", "\n", "o", ".", "Opts", "[", "key", "]", "=", "value", "\n", "o", ".", "optsMU", ".", "Unlock", "(", ")", "\n", "}" ]

[ "SetValidated", "sets", "the", "option", "key", "to", "the", "specified", "value", ".", "The", "caller", "is", "expected", "to", "have", "validated", "the", "input", "to", "this", "function", "." ]

[ "func", "(", "o", "*", "IntOptions", ")", "SetBool", "(", "key", "string", ",", "value", "bool", ")", "{", "intValue", ":=", "OptionDisabled", "\n", "if", "value", "{", "intValue", "=", "OptionEnabled", "\n", "}", "\n", "o", ".", "optsMU", ".", "Lock", "(", ")", "\n", "o", ".", "Opts", "[", "key", "]", "=", "intValue", "\n", "o", ".", "optsMU", ".", "Unlock", "(", ")", "\n", "}" ]

[ "SetBool", "sets", "the", "specified", "option", "to", "Enabled", "." ]

[ "func", "(", "o", "*", "IntOptions", ")", "Validate", "(", "n", "models", ".", "ConfigurationMap", ")", "error", "{", "o", ".", "optsMU", ".", "RLock", "(", ")", "\n", "defer", "o", ".", "optsMU", ".", "RUnlock", "(", ")", "\n", "for", "k", ",", "v", ":=", "range", "n", "{", "_", ",", "newVal", ",", "err", ":=", "ParseKeyValue", "(", "o", ".", "Library", ",", "k", ",", "v", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Ignore validation if value is identical", "if", "oldVal", ",", "ok", ":=", "o", ".", "Opts", "[", "k", "]", ";", "ok", "&&", "oldVal", "==", "newVal", "{", "continue", "\n", "}", "\n\n", "if", "err", ":=", "o", ".", "Library", ".", "Validate", "(", "k", ",", "v", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "a", "given", "configuration", "map", "based", "on", "the", "option", "library" ]

[ "func", "(", "o", "*", "IntOptions", ")", "enable", "(", "name", "string", ")", "{", "if", "o", ".", "Library", "!=", "nil", "{", "if", "_", ",", "opt", ":=", "o", ".", "Library", ".", "Lookup", "(", "name", ")", ";", "opt", "!=", "nil", "{", "for", "_", ",", "dependency", ":=", "range", "opt", ".", "Requires", "{", "o", ".", "enable", "(", "dependency", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "o", ".", "Opts", "[", "name", "]", "=", "OptionEnabled", "\n", "}" ]

[ "enable", "enables", "the", "option", "name", "with", "all", "its", "dependencies" ]

[ "func", "(", "o", "*", "IntOptions", ")", "set", "(", "name", "string", ",", "value", "OptionSetting", ")", "{", "o", ".", "enable", "(", "name", ")", "\n", "o", ".", "Opts", "[", "name", "]", "=", "value", "\n", "}" ]

[ "set", "enables", "the", "option", "name", "with", "all", "its", "dependencies", "and", "sets", "the", "integer", "level", "of", "the", "option", "to", "value", "." ]

[ "func", "(", "o", "*", "IntOptions", ")", "disable", "(", "name", "string", ")", "{", "o", ".", "Opts", "[", "name", "]", "=", "OptionDisabled", "\n\n", "if", "o", ".", "Library", "!=", "nil", "{", "// Disable all options which have a dependency on the option", "// that was just disabled", "for", "key", ",", "opt", ":=", "range", "*", "o", ".", "Library", "{", "if", "opt", ".", "RequiresOption", "(", "name", ")", "&&", "o", ".", "Opts", "[", "key", "]", "!=", "OptionDisabled", "{", "o", ".", "disable", "(", "key", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "disable", "disables", "the", "option", "name", ".", "All", "options", "which", "depend", "on", "the", "option", "to", "be", "disabled", "will", "be", "disabled", ".", "Options", "which", "have", "previously", "been", "enabled", "as", "a", "dependency", "will", "not", "be", "automatically", "disabled", "." ]

[ "func", "(", "o", "*", "IntOptions", ")", "ApplyValidated", "(", "n", "OptionMap", ",", "changed", "ChangedFunc", ",", "data", "interface", "{", "}", ")", "int", "{", "changes", ":=", "make", "(", "[", "]", "changedOptions", ",", "0", ",", "len", "(", "n", ")", ")", "\n\n", "o", ".", "optsMU", ".", "Lock", "(", ")", "\n", "for", "k", ",", "optVal", ":=", "range", "n", "{", "val", ",", "ok", ":=", "o", ".", "Opts", "[", "k", "]", "\n\n", "if", "optVal", "==", "OptionDisabled", "{", "/* Only disable if enabled already */", "if", "ok", "&&", "val", "!=", "OptionDisabled", "{", "o", ".", "disable", "(", "k", ")", "\n", "changes", "=", "append", "(", "changes", ",", "changedOptions", "{", "key", ":", "k", ",", "value", ":", "optVal", "}", ")", "\n", "}", "\n", "}", "else", "{", "/* Only enable if not enabled already */", "if", "!", "ok", "||", "val", "==", "OptionDisabled", "{", "o", ".", "set", "(", "k", ",", "optVal", ")", "\n", "changes", "=", "append", "(", "changes", ",", "changedOptions", "{", "key", ":", "k", ",", "value", ":", "optVal", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "o", ".", "optsMU", ".", "Unlock", "(", ")", "\n\n", "for", "_", ",", "change", ":=", "range", "changes", "{", "changed", "(", "change", ".", "key", ",", "change", ".", "value", ",", "data", ")", "\n", "}", "\n\n", "return", "len", "(", "changes", ")", "\n", "}" ]

[ "ApplyValidated", "takes", "a", "configuration", "map", "and", "applies", "the", "changes", ".", "For", "an", "option", "which", "is", "changed", "the", "ChangedFunc", "function", "is", "called", "with", "the", "data", "argument", "passed", "in", "as", "well", ".", "Returns", "the", "number", "of", "options", "changed", "if", "any", ".", "The", "caller", "is", "expected", "to", "have", "validated", "the", "configuration", "options", "prior", "to", "calling", "this", "function", "." ]

[ "func", "(", "l", "Labels", ")", "AppendPrefixInKey", "(", "prefix", "string", ")", "Labels", "{", "newLabels", ":=", "Labels", "{", "}", "\n", "for", "k", ",", "v", ":=", "range", "l", "{", "newLabels", "[", "prefix", "+", "k", "]", "=", "Label", "{", "Key", ":", "prefix", "+", "v", ".", "Key", ",", "Value", ":", "v", ".", "Value", ",", "Source", ":", "v", ".", "Source", ",", "}", "\n", "}", "\n", "return", "newLabels", "\n", "}" ]

[ "AppendPrefixInKey", "appends", "the", "given", "prefix", "to", "all", "the", "Key", "s", "of", "the", "map", "and", "the", "respective", "Labels", "Key", "." ]

[ "func", "(", "l", "Labels", ")", "Equals", "(", "other", "Labels", ")", "bool", "{", "if", "len", "(", "l", ")", "!=", "len", "(", "other", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "k", ",", "lbl1", ":=", "range", "l", "{", "if", "lbl2", ",", "ok", ":=", "other", "[", "k", "]", ";", "ok", "{", "if", "lbl1", ".", "Source", "==", "lbl2", ".", "Source", "&&", "lbl1", ".", "Key", "==", "lbl2", ".", "Key", "&&", "lbl1", ".", "Value", "==", "lbl2", ".", "Value", "{", "continue", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Equals", "returns", "true", "if", "the", "two", "Labels", "contain", "the", "same", "set", "of", "labels", "." ]

[ "func", "(", "l", "Labels", ")", "GetFromSource", "(", "source", "string", ")", "Labels", "{", "lbls", ":=", "Labels", "{", "}", "\n", "for", "k", ",", "v", ":=", "range", "l", "{", "if", "v", ".", "Source", "==", "source", "{", "lbls", "[", "k", "]", "=", "v", "\n", "}", "\n", "}", "\n", "return", "lbls", "\n", "}" ]

[ "GetFromSource", "returns", "all", "labels", "that", "are", "from", "the", "given", "source", "." ]

[ "func", "(", "l", "*", "Label", ")", "Matches", "(", "target", "*", "Label", ")", "bool", "{", "return", "l", ".", "IsAllLabel", "(", ")", "||", "l", ".", "Equals", "(", "target", ")", "\n", "}" ]

[ "Matches", "returns", "true", "if", "l", "matches", "the", "target" ]

[ "func", "NewLabelsFromModel", "(", "base", "[", "]", "string", ")", "Labels", "{", "lbls", ":=", "make", "(", "Labels", ",", "len", "(", "base", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "base", "{", "if", "lbl", ":=", "ParseLabel", "(", "v", ")", ";", "lbl", ".", "Key", "!=", "\"", "\"", "{", "lbls", "[", "lbl", ".", "Key", "]", "=", "lbl", "\n", "}", "\n", "}", "\n\n", "return", "lbls", "\n", "}" ]

[ "NewLabelsFromModel", "creates", "labels", "from", "string", "array", "." ]

[ "func", "NewSelectLabelArrayFromModel", "(", "base", "[", "]", "string", ")", "LabelArray", "{", "lbls", ":=", "make", "(", "LabelArray", ",", "0", ",", "len", "(", "base", ")", ")", "\n", "for", "i", ":=", "range", "base", "{", "lbls", "=", "append", "(", "lbls", ",", "ParseSelectLabel", "(", "base", "[", "i", "]", ")", ")", "\n", "}", "\n\n", "return", "lbls", ".", "Sort", "(", ")", "\n", "}" ]

[ "NewSelectLabelArrayFromModel", "parses", "a", "slice", "of", "strings", "and", "converts", "them", "into", "an", "array", "of", "selecting", "labels", "sorted", "by", "the", "key", "." ]

[ "func", "(", "l", "Labels", ")", "GetModel", "(", ")", "[", "]", "string", "{", "res", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "l", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "l", "{", "res", "=", "append", "(", "res", ",", "v", ".", "String", "(", ")", ")", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "GetModel", "returns", "model", "with", "all", "the", "values", "of", "the", "labels", "." ]

[ "func", "(", "l", "Labels", ")", "SHA256Sum", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sha512", ".", "Sum512_256", "(", "l", ".", "SortedList", "(", ")", ")", ")", "\n", "}" ]

[ "SHA256Sum", "calculates", "l", "internal", "SHA256Sum", ".", "For", "a", "particular", "set", "of", "labels", "is", "guarantee", "that", "it", "will", "always", "have", "the", "same", "SHA256Sum", "." ]

[ "func", "(", "l", "Label", ")", "FormatForKVStore", "(", ")", "string", "{", "// We don't care if the values already have a '=' since this method is", "// only used to calculate a SHA256Sum", "//", "// We absolutely care that the final character is a semi-colon.", "// Identity allocation in the kvstore depends on this (see", "// kvstore.prefixMatchesKey())", "return", "fmt", ".", "Sprintf", "(", "`%s:%s=%s;`", ",", "l", ".", "Source", ",", "l", ".", "Key", ",", "l", ".", "Value", ")", "\n", "}" ]

[ "FormatForKVStore", "returns", "the", "label", "as", "a", "formatted", "string", "ending", "in", "a", "semicolon", "DO", "NOT", "BREAK", "THE", "FORMAT", "OF", "THIS", ".", "THE", "RETURNED", "STRING", "IS", "USED", "AS", "PART", "OF", "THE", "KEY", "IN", "THE", "KEY", "-", "VALUE", "STORE", ".", "Non", "-", "pointer", "receiver", "allows", "this", "to", "be", "called", "on", "a", "value", "in", "a", "map", "." ]

[ "func", "(", "l", "Labels", ")", "SortedList", "(", ")", "[", "]", "byte", "{", "var", "keys", "[", "]", "string", "\n", "for", "k", ":=", "range", "l", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n\n", "result", ":=", "\"", "\"", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "result", "+=", "l", "[", "k", "]", ".", "FormatForKVStore", "(", ")", "\n", "}", "\n\n", "return", "[", "]", "byte", "(", "result", ")", "\n", "}" ]

[ "SortedList", "returns", "the", "labels", "as", "a", "sorted", "list", "separated", "by", "semicolon", "DO", "NOT", "BREAK", "THE", "FORMAT", "OF", "THIS", ".", "THE", "RETURNED", "STRING", "IS", "USED", "AS", "KEY", "IN", "THE", "KEY", "-", "VALUE", "STORE", "." ]

[ "func", "(", "l", "Labels", ")", "LabelArray", "(", ")", "LabelArray", "{", "labels", ":=", "make", "(", "LabelArray", ",", "0", ",", "len", "(", "l", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "l", "{", "labels", "=", "append", "(", "labels", ",", "v", ")", "\n", "}", "\n", "return", "labels", ".", "Sort", "(", ")", "\n", "}" ]

[ "LabelArray", "returns", "the", "labels", "as", "label", "array", "sorted", "by", "the", "key", "." ]

[ "func", "(", "l", "Labels", ")", "IsReserved", "(", ")", "bool", "{", "for", "_", ",", "lbl", ":=", "range", "l", "{", "if", "lbl", ".", "Source", "==", "LabelSourceReserved", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsReserved", "returns", "true", "if", "any", "of", "the", "labels", "has", "a", "reserved", "source", "." ]

[ "func", "NewFunctionQueue", "(", "queueSize", "uint", ")", "*", "FunctionQueue", "{", "fq", ":=", "&", "FunctionQueue", "{", "queue", ":", "make", "(", "chan", "queuedFunction", ",", "queueSize", ")", ",", "stopCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "go", "fq", ".", "run", "(", ")", "\n", "return", "fq", "\n", "}" ]

[ "NewFunctionQueue", "returns", "a", "FunctionQueue", "that", "will", "be", "used", "to", "execute", "functions", "in", "the", "same", "order", "they", "are", "enqueued", "." ]

[ "func", "(", "fq", "*", "FunctionQueue", ")", "run", "(", ")", "{", "for", "{", "select", "{", "case", "<-", "fq", ".", "stopCh", ":", "return", "\n", "case", "f", ":=", "<-", "fq", ".", "queue", ":", "retries", ":=", "0", "\n", "for", "{", "select", "{", "case", "<-", "fq", ".", "stopCh", ":", "return", "\n", "default", ":", "}", "\n", "retries", "++", "\n", "if", "err", ":=", "f", ".", "f", "(", ")", ";", "err", "!=", "nil", "{", "if", "!", "f", ".", "waitFunc", "(", "retries", ")", "{", "break", "\n", "}", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "run", "starts", "the", "FunctionQueue", "internal", "worker", ".", "It", "will", "be", "stopped", "once", "stopCh", "is", "closed", "or", "receives", "a", "value", "." ]

[ "func", "(", "fq", "*", "FunctionQueue", ")", "Wait", "(", "ctx", "context", ".", "Context", ")", "error", "{", "select", "{", "case", "<-", "fq", ".", "stopCh", ":", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "}", "\n", "if", "err", ":=", "ctx", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Wait", "until", "the", "FunctionQueue", "is", "stopped", "or", "the", "specified", "context", "deadline", "expires", ".", "Returns", "the", "error", "from", "the", "context", "or", "nil", "if", "the", "FunctionQueue", "was", "completed", "before", "the", "context", "deadline", "." ]

[ "func", "(", "fq", "*", "FunctionQueue", ")", "Enqueue", "(", "f", "func", "(", ")", "error", ",", "waitFunc", "WaitFunc", ")", "{", "fq", ".", "queue", "<-", "queuedFunction", "{", "f", ":", "f", ",", "waitFunc", ":", "waitFunc", "}", "\n", "}" ]

[ "Enqueue", "enqueues", "the", "receiving", "function", "f", "to", "be", "executed", "by", "the", "function", "queue", ".", "Depending", "on", "the", "size", "of", "the", "function", "queue", "and", "the", "amount", "of", "functions", "queued", "this", "function", "can", "block", "until", "the", "function", "queue", "is", "ready", "to", "receive", "more", "requests", ".", "If", "f", "returns", "an", "error", "waitFunc", "will", "be", "executed", "and", "depending", "on", "the", "return", "value", "of", "waitFunc", "f", "will", "be", "executed", "again", "or", "not", ".", "The", "return", "value", "of", "f", "will", "not", "be", "logged", "and", "it", "s", "up", "to", "the", "caller", "to", "log", "it", "properly", "." ]

[ "func", "NewTrigger", "(", "p", "Parameters", ")", "(", "*", "Trigger", ",", "error", ")", "{", "if", "p", ".", "sleepInterval", "==", "0", "{", "p", ".", "sleepInterval", "=", "time", ".", "Second", "\n", "}", "\n\n", "if", "p", ".", "TriggerFunc", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "p", ".", "PrometheusMetrics", "&&", "p", ".", "Name", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "t", ":=", "&", "Trigger", "{", "params", ":", "p", ",", "wakeupChan", ":", "make", "(", "chan", "bool", ",", "1", ")", ",", "closeChan", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "foldedReasons", ":", "newReasonStack", "(", ")", ",", "}", "\n\n", "// Guarantee that initial trigger has no delay", "if", "p", ".", "MinInterval", ">", "time", ".", "Duration", "(", "0", ")", "{", "t", ".", "lastTrigger", "=", "time", ".", "Now", "(", ")", ".", "Add", "(", "-", "1", "*", "p", ".", "MinInterval", ")", "\n", "}", "\n\n", "if", "p", ".", "PrometheusMetrics", "{", "t", ".", "triggerReasons", "=", "prometheus", ".", "NewCounterVec", "(", "prometheus", ".", "CounterOpts", "{", "Namespace", ":", "metrics", ".", "Namespace", ",", "Subsystem", ":", "\"", "\"", ",", "Name", ":", "p", ".", "Name", "+", "\"", "\"", ",", "Help", ":", "\"", "\"", ",", "}", ",", "[", "]", "string", "{", "metricLabelReason", "}", ")", "\n\n", "if", "err", ":=", "metrics", ".", "Register", "(", "t", ".", "triggerReasons", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "t", ".", "triggerFolds", "=", "prometheus", ".", "NewGauge", "(", "prometheus", ".", "GaugeOpts", "{", "Namespace", ":", "metrics", ".", "Namespace", ",", "Subsystem", ":", "\"", "\"", ",", "Name", ":", "p", ".", "Name", "+", "\"", "\"", ",", "Help", ":", "\"", "\"", ",", "}", ")", "\n\n", "if", "err", ":=", "metrics", ".", "Register", "(", "t", ".", "triggerFolds", ")", ";", "err", "!=", "nil", "{", "metrics", ".", "Unregister", "(", "t", ".", "triggerReasons", ")", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "t", ".", "callDurations", "=", "prometheus", ".", "NewHistogramVec", "(", "prometheus", ".", "HistogramOpts", "{", "Namespace", ":", "metrics", ".", "Namespace", ",", "Subsystem", ":", "\"", "\"", ",", "Name", ":", "p", ".", "Name", "+", "\"", "\"", ",", "Help", ":", "\"", "\"", ",", "}", ",", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n\n", "if", "err", ":=", "metrics", ".", "Register", "(", "t", ".", "callDurations", ")", ";", "err", "!=", "nil", "{", "metrics", ".", "Unregister", "(", "t", ".", "triggerReasons", ")", "\n", "metrics", ".", "Unregister", "(", "t", ".", "triggerFolds", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "go", "t", ".", "waiter", "(", ")", "\n\n", "return", "t", ",", "nil", "\n", "}" ]

[ "NewTrigger", "returns", "a", "new", "trigger", "based", "on", "the", "provided", "parameters" ]

[ "func", "(", "t", "*", "Trigger", ")", "needsDelay", "(", ")", "(", "bool", ",", "time", ".", "Duration", ")", "{", "if", "t", ".", "params", ".", "MinInterval", "==", "time", ".", "Duration", "(", "0", ")", "{", "return", "false", ",", "0", "\n", "}", "\n\n", "sleepTime", ":=", "time", ".", "Since", "(", "t", ".", "lastTrigger", ".", "Add", "(", "t", ".", "params", ".", "MinInterval", ")", ")", "\n", "return", "sleepTime", "<", "0", ",", "sleepTime", "*", "-", "1", "\n", "}" ]

[ "needsDelay", "returns", "whether", "and", "how", "long", "of", "a", "delay", "is", "required", "to", "fullfil", "MinInterval" ]

[ "func", "(", "t", "*", "Trigger", ")", "Shutdown", "(", ")", "{", "close", "(", "t", ".", "closeChan", ")", "\n", "if", "t", ".", "params", ".", "PrometheusMetrics", "{", "metrics", ".", "Unregister", "(", "t", ".", "triggerReasons", ")", "\n", "metrics", ".", "Unregister", "(", "t", ".", "triggerFolds", ")", "\n", "metrics", ".", "Unregister", "(", "t", ".", "callDurations", ")", "\n", "}", "\n", "}" ]

[ "Shutdown", "stops", "the", "trigger", "mechanism" ]

[ "func", "(", "g", "*", "group", ")", "V2", "(", ")", "v2", ".", "Interface", "{", "return", "v2", ".", "New", "(", "g", ".", "factory", ",", "g", ".", "namespace", ",", "g", ".", "tweakListOptions", ")", "\n", "}" ]

[ "V2", "returns", "a", "new", "v2", ".", "Interface", "." ]

[ "func", "NewPutServiceID", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "PutServiceIDHandler", ")", "*", "PutServiceID", "{", "return", "&", "PutServiceID", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewPutServiceID", "creates", "a", "new", "http", ".", "Handler", "for", "the", "put", "service", "ID", "operation" ]

[ "func", "NewServer", "(", "resourceTypes", "map", "[", "string", "]", "*", "ResourceTypeConfiguration", ",", "resourceAccessTimeout", "time", ".", "Duration", ")", "*", "Server", "{", "watchers", ":=", "make", "(", "map", "[", "string", "]", "*", "ResourceWatcher", ",", "len", "(", "resourceTypes", ")", ")", "\n", "ackObservers", ":=", "make", "(", "map", "[", "string", "]", "ResourceVersionAckObserver", ",", "len", "(", "resourceTypes", ")", ")", "\n", "for", "typeURL", ",", "resType", ":=", "range", "resourceTypes", "{", "w", ":=", "NewResourceWatcher", "(", "typeURL", ",", "resType", ".", "Source", ",", "resourceAccessTimeout", ")", "\n", "resType", ".", "Source", ".", "AddResourceVersionObserver", "(", "w", ")", "\n", "watchers", "[", "typeURL", "]", "=", "w", "\n\n", "if", "resType", ".", "AckObserver", "!=", "nil", "{", "ackObservers", "[", "typeURL", "]", "=", "resType", ".", "AckObserver", "\n", "}", "\n", "}", "\n\n", "// TODO: Unregister the watchers when stopping the server.", "return", "&", "Server", "{", "watchers", ":", "watchers", ",", "ackObservers", ":", "ackObservers", "}", "\n", "}" ]

[ "NewServer", "creates", "an", "xDS", "gRPC", "stream", "handler", "using", "the", "given", "resource", "sources", ".", "types", "maps", "each", "supported", "resource", "type", "URL", "to", "its", "corresponding", "resource", "source", "and", "ACK", "observer", "." ]

[ "func", "(", "s", "*", "Server", ")", "HandleRequestStream", "(", "ctx", "context", ".", "Context", ",", "stream", "Stream", ",", "defaultTypeURL", "string", ")", "error", "{", "// increment stream count", "streamID", ":=", "atomic", ".", "AddUint64", "(", "&", "s", ".", "lastStreamID", ",", "1", ")", "\n\n", "streamLog", ":=", "log", ".", "WithField", "(", "logfields", ".", "XDSStreamID", ",", "streamID", ")", "\n\n", "reqCh", ":=", "make", "(", "chan", "*", "envoy_api_v2", ".", "DiscoveryRequest", ")", "\n\n", "stopRecv", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "defer", "close", "(", "stopRecv", ")", "\n\n", "go", "func", "(", ")", "{", "defer", "close", "(", "reqCh", ")", "\n", "for", "{", "req", ",", "err", ":=", "stream", ".", "Recv", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "streamLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "else", "{", "streamLog", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "if", "req", "==", "nil", "{", "streamLog", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "if", "req", ".", "GetTypeUrl", "(", ")", "==", "\"", "\"", "{", "req", ".", "TypeUrl", "=", "defaultTypeURL", "\n", "}", "\n", "streamLog", ".", "WithFields", "(", "getXDSRequestFields", "(", "req", ")", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "select", "{", "case", "<-", "stopRecv", ":", "streamLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "case", "reqCh", "<-", "req", ":", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "s", ".", "processRequestStream", "(", "ctx", ",", "streamLog", ",", "stream", ",", "reqCh", ",", "defaultTypeURL", ")", "\n", "}" ]

[ "HandleRequestStream", "receives", "and", "processes", "the", "requests", "from", "an", "xDS", "stream", "." ]

[ "func", "NewEventQueueBuffered", "(", "name", "string", ",", "numBufferedEvents", "int", ")", "*", "EventQueue", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "name", ",", "\"", "\"", ":", "numBufferedEvents", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "&", "EventQueue", "{", "name", ":", "name", ",", "// Up to numBufferedEvents can be Enqueued until Enqueueing blocks.", "events", ":", "make", "(", "chan", "*", "Event", ",", "numBufferedEvents", ")", ",", "close", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "drain", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n\n", "}" ]

[ "NewEventQueueBuffered", "returns", "an", "EventQueue", "with", "a", "capacity", "of", "numBufferedEvents", "at", "a", "time", "and", "all", "other", "needed", "fields", "initialized", "." ]

[ "func", "NewEvent", "(", "meta", "EventHandler", ")", "*", "Event", "{", "return", "&", "Event", "{", "Metadata", ":", "meta", ",", "eventResults", ":", "make", "(", "chan", "interface", "{", "}", ",", "1", ")", ",", "cancelled", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "stats", ":", "eventStatistics", "{", "}", ",", "}", "\n", "}" ]

[ "NewEvent", "returns", "an", "Event", "with", "all", "fields", "initialized", "." ]

[ "func", "(", "q", "*", "EventQueue", ")", "Enqueue", "(", "ev", "*", "Event", ")", "<-", "chan", "interface", "{", "}", "{", "if", "q", ".", "notSafeToAccess", "(", ")", "||", "ev", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// Track that event has been Enqueued.", "q", ".", "closeWaitGroup", ".", "Add", "(", "1", ")", "\n", "defer", "q", ".", "closeWaitGroup", ".", "Done", "(", ")", "\n\n", "select", "{", "// The event should be drained from the queue (e.g., it should not be", "// processed).", "case", "<-", "q", ".", "drain", ":", "// Closed eventResults channel signifies cancellation.", "close", "(", "ev", ".", "cancelled", ")", "\n", "close", "(", "ev", ".", "eventResults", ")", "\n\n", "return", "ev", ".", "eventResults", "\n", "default", ":", "// The events channel may be closed even if an event has been pushed", "// onto the events channel, as events are consumed off of the events", "// channel asynchronously! If the EventQueue is closed before this", "// event is processed, then it will be cancelled.", "ev", ".", "stats", ".", "waitEnqueue", ".", "Start", "(", ")", "\n", "q", ".", "events", "<-", "ev", "\n", "ev", ".", "stats", ".", "waitEnqueue", ".", "End", "(", "true", ")", "\n", "ev", ".", "stats", ".", "waitConsumeOffQueue", ".", "Start", "(", ")", "\n", "return", "ev", ".", "eventResults", "\n", "}", "\n", "}" ]

[ "Enqueue", "pushes", "the", "given", "event", "onto", "the", "EventQueue", ".", "If", "the", "queue", "has", "been", "stopped", "the", "Event", "will", "not", "be", "enqueued", "and", "its", "cancel", "channel", "will", "be", "closed", "indicating", "that", "the", "Event", "was", "not", "ran", ".", "This", "function", "may", "block", "if", "the", "queue", "is", "at", "its", "capacity", "for", "events", "." ]

[ "func", "(", "q", "*", "EventQueue", ")", "Stop", "(", ")", "{", "if", "q", ".", "notSafeToAccess", "(", ")", "{", "return", "\n", "}", "\n\n", "q", ".", "closeOnce", ".", "Do", "(", "func", "(", ")", "{", "q", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "// Any event that is sent to the queue at this point will be cancelled", "// immediately in Enqueue().", "close", "(", "q", ".", "drain", ")", "\n\n", "// Wait for all events which have been queued to be processed. If", "// a large amount of events are continuously enqueued at this point,", "// then this may block. But, in most scenarios, this should exit", "// fairly quickly.", "q", ".", "closeWaitGroup", ".", "Wait", "(", ")", "\n\n", "// Signal that the queue has been drained.", "close", "(", "q", ".", "close", ")", "\n\n", "// This will cause Run() to receive a nil event.", "close", "(", "q", ".", "events", ")", "\n\n", "}", ")", "\n", "}" ]

[ "Stop", "stops", "any", "further", "events", "from", "being", "processed", "by", "the", "EventQueue", ".", "Any", "event", "which", "is", "currently", "being", "processed", "by", "the", "EventQueue", "will", "continue", "to", "run", ".", "All", "other", "events", "waiting", "to", "be", "processed", "and", "all", "events", "that", "may", "be", "enqueued", "will", "not", "be", "processed", "by", "the", "event", "queue", ";", "they", "will", "be", "cancelled", ".", "If", "the", "queue", "has", "already", "been", "stopped", "this", "is", "a", "no", "-", "op", "." ]

[ "func", "newSelectorCache", "(", ")", "*", "SelectorCache", "{", "return", "&", "SelectorCache", "{", "idCache", ":", "cache", ".", "GetIdentityCache", "(", ")", ",", "selectors", ":", "make", "(", "map", "[", "string", "]", "identitySelector", ")", ",", "}", "\n", "}" ]

[ "newSelectorCache", "creates", "a", "new", "SelectorCache", "." ]

[ "func", "(", "l", "*", "labelIdentitySelector", ")", "updateSelections", "(", ")", "{", "selections", ":=", "make", "(", "[", "]", "identity", ".", "NumericIdentity", ",", "len", "(", "l", ".", "cachedSelections", ")", ")", "\n", "i", ":=", "0", "\n", "for", "nid", ":=", "range", "l", ".", "cachedSelections", "{", "selections", "[", "i", "]", "=", "nid", "\n", "i", "++", "\n", "}", "\n", "// Sort the numeric identities so that the map iteration order", "// does not matter. This makes testing easier, but may help", "// identifying changes easier also otherwise.", "sort", ".", "Slice", "(", "selections", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "selections", "[", "i", "]", "<", "selections", "[", "j", "]", "\n", "}", ")", "\n", "l", ".", "setSelections", "(", "&", "selections", ")", "\n", "}" ]

[ "updateSelections", "updates", "the", "immutable", "slice", "representation", "of", "the", "cached", "selections", "after", "the", "cached", "selections", "have", "been", "changed", ".", "lock", "must", "be", "held" ]

[ "func", "(", "sc", "*", "SelectorCache", ")", "AddIdentitySelector", "(", "user", "CachedSelectionUser", ",", "selector", "api", ".", "EndpointSelector", ")", "(", "cachedSelector", "CachedSelector", ",", "added", "bool", ")", "{", "// The key returned here may be different for equivalent", "// labelselectors, if the selector's requirements are stored", "// in different orders. When this happens we'll be tracking", "// essentially two copies of the same selector.", "key", ":=", "selector", ".", "LabelSelector", ".", "String", "(", ")", "\n", "sc", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "sc", ".", "mutex", ".", "Unlock", "(", ")", "\n", "idSel", ",", "exists", ":=", "sc", ".", "selectors", "[", "key", "]", "\n", "if", "exists", "{", "return", "idSel", ",", "idSel", ".", "addUser", "(", "user", ")", "\n", "}", "\n\n", "// Selectors are never modified once a rule is placed in the policy repository,", "// so no need to copy.", "// TODO: FQDNSelector", "newIDSel", ":=", "&", "labelIdentitySelector", "{", "key", ":", "key", ",", "users", ":", "make", "(", "map", "[", "CachedSelectionUser", "]", "struct", "{", "}", ")", ",", "selector", ":", "selector", ",", "cachedSelections", ":", "make", "(", "map", "[", "identity", ".", "NumericIdentity", "]", "struct", "{", "}", ")", ",", "}", "\n\n", "// Add the initial user", "newIDSel", ".", "users", "[", "user", "]", "=", "struct", "{", "}", "{", "}", "\n\n", "// Find all matching identities from the identity cache.", "for", "numericID", ",", "lbls", ":=", "range", "sc", ".", "idCache", "{", "if", "selector", ".", "Matches", "(", "lbls", ")", "{", "newIDSel", ".", "cachedSelections", "[", "numericID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "// Create the immutable slice representation of the selected", "// numeric identities", "newIDSel", ".", "updateSelections", "(", ")", "\n\n", "// Note: No notifications are sent for the existing", "// identities. Caller must use GetSelections() to get the", "// current selections after adding a selector. This way the", "// behavior is the same between the two cases here (selector", "// is already cached, or is a new one).", "sc", ".", "selectors", "[", "key", "]", "=", "newIDSel", "\n", "return", "newIDSel", ",", "true", "\n", "}" ]

[ "AddIdentitySelector", "adds", "the", "given", "api", ".", "EndpointSelector", "in", "to", "the", "selector", "cache", ".", "If", "an", "identical", "EndpointSelector", "has", "already", "been", "cached", "the", "corresponding", "CachedSelector", "is", "returned", "otherwise", "one", "is", "created", "and", "added", "to", "the", "cache", "." ]

[ "func", "(", "sc", "*", "SelectorCache", ")", "RemoveIdentitySelector", "(", "user", "CachedSelectionUser", ",", "selector", "CachedSelector", ")", "{", "key", ":=", "selector", ".", "String", "(", ")", "\n", "sc", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "sc", ".", "mutex", ".", "Unlock", "(", ")", "\n", "idSel", ",", "exists", ":=", "sc", ".", "selectors", "[", "key", "]", "\n", "if", "exists", "{", "if", "idSel", ".", "removeUser", "(", "user", ")", "{", "delete", "(", "sc", ".", "selectors", ",", "key", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "RemoveIdentitySelector", "removes", "CachedSelector", "for", "the", "user", "." ]

[ "func", "(", "sc", "*", "SelectorCache", ")", "UpdateIdentities", "(", "added", ",", "deleted", "cache", ".", "IdentityCache", ")", "{", "sc", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "sc", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// Update idCache so that newly added selectors get", "// prepopulated with all matching numeric identities.", "for", "numericID", ":=", "range", "deleted", "{", "if", "_", ",", "exists", ":=", "sc", ".", "idCache", "[", "numericID", "]", ";", "exists", "{", "delete", "(", "sc", ".", "idCache", ",", "numericID", ")", "\n", "}", "else", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Identity", ":", "numericID", "}", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "for", "numericID", ",", "lbls", ":=", "range", "added", "{", "if", "_", ",", "exists", ":=", "sc", ".", "idCache", "[", "numericID", "]", ";", "exists", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Identity", ":", "numericID", "}", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "}", "\n", "sc", ".", "idCache", "[", "numericID", "]", "=", "lbls", "\n", "}", "\n\n", "// Iterate through all locally used identity selectors and", "// update the cached numeric identities as required.", "for", "_", ",", "sel", ":=", "range", "sc", ".", "selectors", "{", "var", "adds", ",", "dels", "[", "]", "identity", ".", "NumericIdentity", "\n", "switch", "idSel", ":=", "sel", ".", "(", "type", ")", "{", "case", "*", "labelIdentitySelector", ":", "for", "numericID", ":=", "range", "deleted", "{", "if", "_", ",", "exists", ":=", "idSel", ".", "cachedSelections", "[", "numericID", "]", ";", "exists", "{", "dels", "=", "append", "(", "dels", ",", "numericID", ")", "\n", "delete", "(", "idSel", ".", "cachedSelections", ",", "numericID", ")", "\n", "}", "\n", "}", "\n", "for", "numericID", ",", "lbls", ":=", "range", "added", "{", "if", "_", ",", "exists", ":=", "idSel", ".", "cachedSelections", "[", "numericID", "]", ";", "!", "exists", "{", "if", "idSel", ".", "selector", ".", "Matches", "(", "lbls", ")", "{", "adds", "=", "append", "(", "adds", ",", "numericID", ")", "\n", "idSel", ".", "cachedSelections", "[", "numericID", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "len", "(", "dels", ")", "+", "len", "(", "adds", ")", ">", "0", "{", "idSel", ".", "updateSelections", "(", ")", "\n", "idSel", ".", "notifyUsers", "(", "adds", ",", "dels", ")", "\n", "}", "\n", "case", "*", "fqdnSelector", ":", "// TODO", "}", "\n", "}", "\n", "}" ]

[ "UpdateIdentities", "propagates", "identity", "updates", "to", "selectors" ]

[ "func", "AddIdentitySelector", "(", "user", "CachedSelectionUser", ",", "selector", "api", ".", "EndpointSelector", ")", "(", "cachedSelector", "CachedSelector", ",", "added", "bool", ")", "{", "return", "selectorCache", ".", "AddIdentitySelector", "(", "user", ",", "selector", ")", "\n", "}" ]

[ "Export", "global", "functions", "to", "interface", "with", "the", "global", "selector", "cache", "AddIdentitySelector", "adds", "the", "given", "api", ".", "EndpointSelector", "in", "to", "the", "selector", "cache", ".", "If", "an", "identical", "EndpointSelector", "has", "already", "been", "cached", "the", "corresponding", "CachedSelector", "is", "returned", "otherwise", "one", "is", "created", "and", "added", "to", "the", "cache", "." ]

[ "func", "NewDeleteIPAMIP", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "DeleteIPAMIPHandler", ")", "*", "DeleteIPAMIP", "{", "return", "&", "DeleteIPAMIP", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewDeleteIPAMIP", "creates", "a", "new", "http", ".", "Handler", "for", "the", "delete", "IP", "a", "m", "IP", "operation" ]

[ "func", "(", "n", "*", "NatEntry4", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "n", ".", "Addr", ",", "n", ".", "Port", ",", "n", ".", "Created", ",", "n", ".", "HostLocal", ")", "\n", "}" ]

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

[ "func", "NewPutPolicy", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "PutPolicyHandler", ")", "*", "PutPolicy", "{", "return", "&", "PutPolicy", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewPutPolicy", "creates", "a", "new", "http", ".", "Handler", "for", "the", "put", "policy", "operation" ]

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

[ "Validate", "validates", "this", "b", "p", "f", "map", "list" ]

[ "func", "(", "ls", "LabelArrayList", ")", "DeepCopy", "(", ")", "LabelArrayList", "{", "if", "ls", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "o", ":=", "make", "(", "LabelArrayList", ",", "0", ",", "len", "(", "ls", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "ls", "{", "o", "=", "append", "(", "o", ",", "v", ".", "DeepCopy", "(", ")", ")", "\n", "}", "\n", "return", "o", "\n", "}" ]

[ "DeepCopy", "returns", "a", "deep", "copy", "of", "the", "LabelArray", "with", "each", "element", "also", "copied", "." ]

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

[ "Validate", "validates", "this", "endpoint", "state" ]

[ "func", "(", "ws", "*", "watcherState", ")", "handlingContainerID", "(", "id", "string", ")", "bool", "{", "ws", ".", "Lock", "(", ")", "\n", "defer", "ws", ".", "Unlock", "(", ")", "\n\n", "_", ",", "handled", ":=", "ws", ".", "events", "[", "id", "]", "\n", "return", "handled", "\n", "}" ]

[ "handlingContainerID", "returns", "whether", "there", "is", "a", "goroutine", "already", "consuming", "events", "for", "this", "id" ]

[ "func", "(", "ws", "*", "watcherState", ")", "reapEmpty", "(", ")", "{", "ws", ".", "Lock", "(", ")", "\n", "defer", "ws", ".", "Unlock", "(", ")", "\n\n", "for", "id", ",", "q", ":=", "range", "ws", ".", "events", "{", "if", "len", "(", "q", ")", "==", "0", "{", "close", "(", "q", ")", "\n", "delete", "(", "ws", ".", "events", ",", "id", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "reapEmpty", "deletes", "empty", "queues", "from", "the", "map", ".", "This", "also", "causes", "the", "handler", "goroutines", "to", "exit", ".", "It", "is", "expected", "to", "be", "called", "periodically", "to", "avoid", "the", "map", "growing", "over", "time", "." ]

[ "func", "(", "ws", "*", "watcherState", ")", "syncWithRuntime", "(", ")", "{", "var", "wg", "sync", ".", "WaitGroup", "\n\n", "timeoutCtx", ",", "cancel", ":=", "ctx", ".", "WithTimeout", "(", "ctx", ".", "Background", "(", ")", ",", "10", "*", "time", ".", "Second", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "cList", ",", "err", ":=", "Client", "(", ")", ".", "workloadIDsList", "(", "timeoutCtx", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "for", "_", ",", "contID", ":=", "range", "cList", "{", "if", "ignoredContainer", "(", "contID", ")", "{", "continue", "\n", "}", "\n\n", "if", "alreadyHandled", ":=", "ws", ".", "handlingContainerID", "(", "contID", ")", ";", "!", "alreadyHandled", "{", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "ContainerID", ":", "shortContainerID", "(", "contID", ")", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "wg", "*", "sync", ".", "WaitGroup", ",", "id", "string", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "Client", "(", ")", ".", "handleCreateWorkload", "(", "id", ",", "false", ")", "\n", "}", "(", "&", "wg", ",", "contID", ")", "\n", "}", "\n", "}", "\n\n", "// Wait for all spawned go routines handling container creations to exit", "wg", ".", "Wait", "(", ")", "\n", "}" ]

[ "syncWithRuntime", "is", "used", "by", "the", "daemon", "to", "synchronize", "changes", "between", "Docker", "and", "Cilium", ".", "This", "includes", "identities", "labels", "etc", "." ]

[ "func", "NewIPAM", "(", "nodeAddressing", "datapath", ".", "NodeAddressing", ",", "c", "Configuration", ")", "*", "IPAM", "{", "ipam", ":=", "&", "IPAM", "{", "nodeAddressing", ":", "nodeAddressing", ",", "config", ":", "c", ",", "owner", ":", "map", "[", "string", "]", "string", "{", "}", ",", "}", "\n\n", "if", "c", ".", "EnableIPv6", "{", "ipam", ".", "IPv6Allocator", "=", "ipallocator", ".", "NewCIDRRange", "(", "nodeAddressing", ".", "IPv6", "(", ")", ".", "AllocationCIDR", "(", ")", ".", "IPNet", ")", "\n", "}", "\n\n", "if", "c", ".", "EnableIPv4", "{", "ipam", ".", "IPv4Allocator", "=", "ipallocator", ".", "NewCIDRRange", "(", "nodeAddressing", ".", "IPv4", "(", ")", ".", "AllocationCIDR", "(", ")", ".", "IPNet", ")", "\n", "}", "\n\n", "return", "ipam", "\n", "}" ]

[ "NewIPAM", "returns", "a", "new", "IP", "address", "manager" ]

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

[ "EndpointList", "returns", "a", "list", "of", "all", "endpoints" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointGet", "(", "id", "string", ")", "(", "*", "models", ".", "Endpoint", ",", "error", ")", "{", "params", ":=", "endpoint", ".", "NewGetEndpointIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Endpoint", ".", "GetEndpointID", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "/* Since plugins rely on checking the error type, we don't wrap this\n\t\t * with Hint(...)\n\t\t */", "return", "nil", ",", "err", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "EndpointGet", "returns", "endpoint", "by", "ID" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointCreate", "(", "ep", "*", "models", ".", "EndpointChangeRequest", ")", "error", "{", "id", ":=", "pkgEndpointID", ".", "NewCiliumID", "(", "ep", ".", "ID", ")", "\n", "params", ":=", "endpoint", ".", "NewPutEndpointIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithEndpoint", "(", "ep", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "err", ":=", "c", ".", "Endpoint", ".", "PutEndpointID", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "EndpointCreate", "creates", "a", "new", "endpoint" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointPatch", "(", "id", "string", ",", "ep", "*", "models", ".", "EndpointChangeRequest", ")", "error", "{", "params", ":=", "endpoint", ".", "NewPatchEndpointIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithEndpoint", "(", "ep", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "err", ":=", "c", ".", "Endpoint", ".", "PatchEndpointID", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "EndpointPatch", "modifies", "the", "endpoint" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointDelete", "(", "id", "string", ")", "error", "{", "params", ":=", "endpoint", ".", "NewDeleteEndpointIDParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "_", ",", "err", ":=", "c", ".", "Endpoint", ".", "DeleteEndpointID", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "EndpointDelete", "deletes", "endpoint" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointLogGet", "(", "id", "string", ")", "(", "models", ".", "EndpointStatusLog", ",", "error", ")", "{", "params", ":=", "endpoint", ".", "NewGetEndpointIDLogParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Endpoint", ".", "GetEndpointIDLog", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "EndpointLogGet", "returns", "endpoint", "log" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointHealthGet", "(", "id", "string", ")", "(", "*", "models", ".", "EndpointHealth", ",", "error", ")", "{", "params", ":=", "endpoint", ".", "NewGetEndpointIDHealthzParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Endpoint", ".", "GetEndpointIDHealthz", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "EndpointHealthGet", "returns", "endpoint", "healthz" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointConfigGet", "(", "id", "string", ")", "(", "*", "models", ".", "EndpointConfigurationStatus", ",", "error", ")", "{", "params", ":=", "endpoint", ".", "NewGetEndpointIDConfigParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Endpoint", ".", "GetEndpointIDConfig", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "EndpointConfigGet", "returns", "endpoint", "configuration" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointConfigPatch", "(", "id", "string", ",", "cfg", "*", "models", ".", "EndpointConfigurationSpec", ")", "error", "{", "params", ":=", "endpoint", ".", "NewPatchEndpointIDConfigParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "if", "cfg", "!=", "nil", "{", "params", ".", "SetEndpointConfiguration", "(", "cfg", ")", "\n", "}", "\n\n", "_", ",", "err", ":=", "c", ".", "Endpoint", ".", "PatchEndpointIDConfig", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "EndpointConfigPatch", "modifies", "endpoint", "configuration" ]

[ "func", "(", "c", "*", "Client", ")", "EndpointLabelsGet", "(", "id", "string", ")", "(", "*", "models", ".", "LabelConfiguration", ",", "error", ")", "{", "params", ":=", "endpoint", ".", "NewGetEndpointIDLabelsParams", "(", ")", ".", "WithID", "(", "id", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "resp", ",", "err", ":=", "c", ".", "Endpoint", ".", "GetEndpointIDLabels", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "EndpointLabelsGet", "returns", "endpoint", "label", "configuration" ]