Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 12.6k

[ "func", "CollectStaleMapGarbage", "(", ")", "{", "if", "err", ":=", "filepath", ".", "Walk", "(", "bpf", ".", "MapPrefixPath", "(", ")", ",", "globalSweeper", ".", "walk", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "CollectStaleMapGarbage", "cleans", "up", "stale", "content", "in", "the", "BPF", "maps", "from", "the", "datapath", "." ]

[ "func", "RemoveDisabledMaps", "(", ")", "{", "maps", ":=", "[", "]", "string", "{", "}", "\n\n", "if", "!", "option", ".", "Config", ".", "EnableIPv6", "{", "maps", "=", "append", "(", "maps", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "...", ")", "\n", "}", "\n\n", "if", "!", "option", ".", "Config", ".", "EnableIPv4", "{", "maps", "=", "append", "(", "maps", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "...", ")", "\n", "}", "\n\n", "for", "_", ",", "m", ":=", "range", "maps", "{", "p", ":=", "path", ".", "Join", "(", "bpf", ".", "MapPrefixPath", "(", ")", ",", "m", ")", "\n", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "p", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "globalSweeper", ".", "removeMapPath", "(", "p", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "RemoveDisabledMaps", "removes", "BPF", "maps", "in", "the", "filesystem", "for", "features", "that", "have", "been", "disabled", ".", "The", "maps", "may", "still", "be", "in", "use", "in", "which", "case", "they", "will", "continue", "to", "live", "until", "the", "BPF", "program", "using", "them", "is", "being", "replaced", "." ]

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

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

[ "func", "GetMagicProxyMark", "(", "isIngress", "bool", ",", "identity", "int", ")", "int", "{", "var", "mark", "int", "\n\n", "if", "isIngress", "{", "mark", "=", "MagicMarkIngress", "\n", "}", "else", "{", "mark", "=", "MagicMarkEgress", "\n", "}", "\n\n", "if", "identity", "!=", "0", "{", "mark", "|=", "(", "identity", ">>", "16", ")", "&", "0xFF", "\n", "mark", "|=", "(", "identity", "&", "0xFFFF", ")", "<<", "16", "\n", "}", "\n\n", "return", "mark", "\n", "}" ]

[ "getMagicMark", "returns", "the", "magic", "marker", "with", "which", "each", "packet", "must", "be", "marked", ".", "The", "mark", "is", "different", "depending", "on", "whether", "the", "proxy", "is", "injected", "at", "ingress", "or", "egress", "." ]

[ "func", "(", "m", "*", "ControllerStatus", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateConfiguration", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateStatus", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateUUID", "(", "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", "controller", "status" ]

[ "func", "(", "r", "*", "Route", ")", "LogFields", "(", ")", "logrus", ".", "Fields", "{", "return", "logrus", ".", "Fields", "{", "\"", "\"", ":", "r", ".", "Prefix", ",", "\"", "\"", ":", "r", ".", "Nexthop", ",", "\"", "\"", ":", "r", ".", "Local", ",", "logfields", ".", "Interface", ":", "r", ".", "Device", ",", "}", "\n", "}" ]

[ "LogFields", "returns", "the", "route", "attributes", "as", "logrus", ".", "Fields", "map" ]

[ "func", "progLDFlags", "(", "prog", "*", "progInfo", ",", "dir", "*", "directoryInfo", ")", "[", "]", "string", "{", "return", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "prog", ".", "OutputType", ")", ",", "\"", "\"", ",", "path", ".", "Join", "(", "dir", ".", "Output", ",", "prog", ".", "Output", ")", ",", "}", "\n", "}" ]

[ "progLDFlags", "determines", "the", "loader", "flags", "for", "the", "specified", "prog", "and", "paths", "." ]

[ "func", "prepareCmdPipes", "(", "cmd", "*", "exec", ".", "Cmd", ")", "(", "io", ".", "ReadCloser", ",", "io", ".", "ReadCloser", ",", "error", ")", "{", "stdout", ",", "err", ":=", "cmd", ".", "StdoutPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "stderr", ",", "err", ":=", "cmd", ".", "StderrPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "stdout", ".", "Close", "(", ")", "\n", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "stdout", ",", "stderr", ",", "nil", "\n", "}" ]

[ "prepareCmdPipes", "attaches", "pipes", "to", "the", "stdout", "and", "stderr", "of", "the", "specified", "command", "and", "returns", "the", "stdout", "stderr", "and", "any", "error", "that", "may", "have", "occurred", "while", "creating", "the", "pipes", "." ]

[ "func", "compileAndLink", "(", "ctx", "context", ".", "Context", ",", "prog", "*", "progInfo", ",", "dir", "*", "directoryInfo", ",", "debug", "bool", ",", "compileArgs", "...", "string", ")", "error", "{", "compileCmd", ",", "cancelCompile", ":=", "exec", ".", "WithCancel", "(", "ctx", ",", "compiler", ",", "compileArgs", "...", ")", "\n", "defer", "cancelCompile", "(", ")", "\n", "compilerStdout", ",", "compilerStderr", ",", "err", ":=", "prepareCmdPipes", "(", "compileCmd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "linkArgs", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "8", ")", "\n", "if", "debug", "{", "linkArgs", "=", "append", "(", "linkArgs", ",", "\"", "\"", ")", "\n", "}", "\n", "linkArgs", "=", "append", "(", "linkArgs", ",", "standardLDFlags", "...", ")", "\n", "linkArgs", "=", "append", "(", "linkArgs", ",", "progLDFlags", "(", "prog", ",", "dir", ")", "...", ")", "\n\n", "linkCmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "linker", ",", "linkArgs", "...", ")", "\n", "linkCmd", ".", "Stdin", "=", "compilerStdout", "\n", "if", "err", ":=", "compileCmd", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "compileCmd", ".", "Args", ",", "err", ")", "\n", "}", "\n\n", "var", "compileOut", "[", "]", "byte", "\n", "/* Ignoring the output here because pkg/command/exec will log it. */", "_", ",", "err", "=", "linkCmd", ".", "CombinedOutput", "(", "log", ",", "true", ")", "\n", "if", "err", "==", "nil", "{", "compileOut", ",", "_", "=", "ioutil", ".", "ReadAll", "(", "compilerStderr", ")", "\n", "err", "=", "compileCmd", ".", "Wait", "(", ")", "\n", "}", "else", "{", "cancelCompile", "(", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "prog", ".", "Output", ",", "err", ")", "\n", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "pidFromProcess", "(", "compileCmd", ".", "Process", ")", ",", "\"", "\"", ":", "pidFromProcess", "(", "linkCmd", ".", "Process", ")", ",", "}", ")", ".", "Error", "(", "err", ")", "\n", "if", "compileOut", "!=", "nil", "{", "scopedLog", ":=", "log", ".", "Warn", "\n", "if", "debug", "{", "scopedLog", "=", "log", ".", "Debug", "\n", "}", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "bytes", ".", "NewReader", "(", "compileOut", ")", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "scopedLog", "(", "scanner", ".", "Text", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "compileAndLink", "links", "the", "specified", "program", "from", "the", "specified", "path", "to", "the", "intermediate", "representation", "to", "the", "output", "specified", "in", "the", "prog", "s", "info", "." ]

[ "func", "progCFlags", "(", "prog", "*", "progInfo", ",", "dir", "*", "directoryInfo", ")", "[", "]", "string", "{", "var", "output", "string", "\n\n", "if", "prog", ".", "OutputType", "==", "outputSource", "{", "output", "=", "path", ".", "Join", "(", "dir", ".", "Output", ",", "prog", ".", "Output", ")", "\n", "}", "else", "{", "output", "=", "\"", "\"", "// stdout", "\n", "}", "\n\n", "return", "append", "(", "testIncludes", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ".", "Join", "(", "dir", ".", "Runtime", ",", "\"", "\"", ")", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dir", ".", "State", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dir", ".", "Library", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "path", ".", "Join", "(", "dir", ".", "Library", ",", "\"", "\"", ")", ")", ",", "\"", "\"", ",", "path", ".", "Join", "(", "dir", ".", "Library", ",", "prog", ".", "Source", ")", ",", "\"", "\"", ",", "output", ",", ")", "\n", "}" ]

[ "progLDFlags", "determines", "the", "compiler", "flags", "for", "the", "specified", "prog", "and", "paths", "." ]

[ "func", "compile", "(", "ctx", "context", ".", "Context", ",", "prog", "*", "progInfo", ",", "dir", "*", "directoryInfo", ",", "debug", "bool", ")", "(", "err", "error", ")", "{", "args", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "16", ")", "\n", "if", "prog", ".", "OutputType", "==", "outputSource", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "// Preprocessor", "\n", "}", "else", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "\n", "if", "debug", "{", "args", "=", "append", "(", "args", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "args", "=", "append", "(", "args", ",", "standardCFlags", "...", ")", "\n", "args", "=", "append", "(", "args", ",", "progCFlags", "(", "prog", ",", "dir", ")", "...", ")", "\n\n", "// Compilation is split between two exec calls. First clang generates", "// LLVM bitcode and then later llc compiles it to byte-code.", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "compiler", ",", "\"", "\"", ":", "args", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "prog", ".", "OutputType", "==", "outputSource", "{", "compileCmd", ":=", "exec", ".", "CommandContext", "(", "ctx", ",", "compiler", ",", "args", "...", ")", "\n", "_", ",", "err", "=", "compileCmd", ".", "CombinedOutput", "(", "log", ",", "debug", ")", "\n", "}", "else", "{", "switch", "prog", ".", "OutputType", "{", "case", "outputObject", ":", "err", "=", "compileAndLink", "(", "ctx", ",", "prog", ",", "dir", ",", "debug", ",", "args", "...", ")", "\n", "case", "outputAssembly", ":", "err", "=", "compileAndLink", "(", "ctx", ",", "prog", ",", "dir", ",", "false", ",", "args", "...", ")", "\n", "default", ":", "log", ".", "Fatalf", "(", "\"", "\"", ",", "prog", ".", "OutputType", ")", "\n", "}", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "compile", "and", "link", "a", "program", "." ]

[ "func", "Compile", "(", "ctx", "context", ".", "Context", ",", "src", "string", ",", "out", "string", ")", "error", "{", "debug", ":=", "option", ".", "Config", ".", "BPFCompilationDebug", "\n", "prog", ":=", "progInfo", "{", "Source", ":", "src", ",", "Output", ":", "out", ",", "OutputType", ":", "outputObject", ",", "}", "\n", "dirs", ":=", "directoryInfo", "{", "Library", ":", "option", ".", "Config", ".", "BpfDir", ",", "Runtime", ":", "option", ".", "Config", ".", "StateDir", ",", "Output", ":", "option", ".", "Config", ".", "StateDir", ",", "State", ":", "option", ".", "Config", ".", "StateDir", ",", "}", "\n", "return", "compile", "(", "ctx", ",", "&", "prog", ",", "&", "dirs", ",", "debug", ")", "\n", "}" ]

[ "Compile", "compiles", "a", "BPF", "program", "generating", "an", "object", "file", "." ]

[ "func", "compileTemplate", "(", "ctx", "context", ".", "Context", ",", "out", "string", ")", "error", "{", "dirs", ":=", "directoryInfo", "{", "Library", ":", "option", ".", "Config", ".", "BpfDir", ",", "Runtime", ":", "option", ".", "Config", ".", "StateDir", ",", "Output", ":", "out", ",", "State", ":", "out", ",", "}", "\n", "return", "compileDatapath", "(", "ctx", ",", "&", "dirs", ",", "option", ".", "Config", ".", "BPFCompilationDebug", ",", "log", ")", "\n", "}" ]

[ "compileTemplate", "compiles", "a", "BPF", "program", "generating", "a", "template", "object", "file", "." ]

[ "func", "(", "s", "*", "BaseObservableResourceSource", ")", "AddResourceVersionObserver", "(", "observer", "ResourceVersionObserver", ")", "{", "s", ".", "locker", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "locker", ".", "Unlock", "(", ")", "\n\n", "s", ".", "observers", "[", "observer", "]", "=", "struct", "{", "}", "{", "}", "\n", "}" ]

[ "AddResourceVersionObserver", "registers", "an", "observer", "to", "be", "notified", "of", "new", "resource", "version", "." ]

[ "func", "(", "s", "*", "BaseObservableResourceSource", ")", "RemoveResourceVersionObserver", "(", "observer", "ResourceVersionObserver", ")", "{", "s", ".", "locker", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "locker", ".", "Unlock", "(", ")", "\n\n", "delete", "(", "s", ".", "observers", ",", "observer", ")", "\n", "}" ]

[ "RemoveResourceVersionObserver", "unregisters", "an", "observer", "that", "was", "previously", "registered", "by", "calling", "AddResourceVersionObserver", "." ]

[ "func", "(", "s", "*", "BaseObservableResourceSource", ")", "NotifyNewResourceVersionRLocked", "(", "typeURL", "string", ",", "version", "uint64", ")", "{", "for", "o", ":=", "range", "s", ".", "observers", "{", "o", ".", "HandleNewResourceVersion", "(", "typeURL", ",", "version", ")", "\n", "}", "\n", "}" ]

[ "NotifyNewResourceVersionRLocked", "notifies", "registered", "observers", "that", "a", "new", "version", "of", "the", "resources", "of", "the", "given", "type", "is", "available", ".", "This", "function", "MUST", "be", "called", "with", "locker", "s", "lock", "acquired", "." ]

[ "func", "(", "m", "*", "TraceTo", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateDports", "(", "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", "len", "(", "res", ")", ">", "0", "{", "return", "errors", ".", "CompositeValidationError", "(", "res", "...", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

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

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

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

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

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

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

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

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

[ "func", "(", "m", "*", "Manager", ")", "UpdateController", "(", "name", "string", ",", "params", "ControllerParams", ")", "*", "Controller", "{", "start", ":=", "time", ".", "Now", "(", ")", "\n\n", "// ensure the callbacks are valid", "if", "params", ".", "DoFunc", "==", "nil", "{", "params", ".", "DoFunc", "=", "func", "(", "ctx", "context", ".", "Context", ")", "error", "{", "return", "undefinedDoFunc", "(", "name", ")", "\n", "}", "\n", "}", "\n", "if", "params", ".", "StopFunc", "==", "nil", "{", "params", ".", "StopFunc", "=", "NoopFunc", "\n", "}", "\n\n", "m", ".", "mutex", ".", "Lock", "(", ")", "\n\n", "if", "m", ".", "controllers", "==", "nil", "{", "m", ".", "controllers", "=", "controllerMap", "{", "}", "\n", "}", "\n\n", "ctrl", ",", "exists", ":=", "m", ".", "controllers", "[", "name", "]", "\n", "if", "exists", "{", "m", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "ctrl", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "ctrl", ".", "mutex", ".", "Lock", "(", ")", "\n", "ctrl", ".", "updateParamsLocked", "(", "params", ")", "\n", "ctrl", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// Notify the goroutine of the params update.", "select", "{", "case", "ctrl", ".", "update", "<-", "struct", "{", "}", "{", "}", ":", "default", ":", "}", "\n\n", "ctrl", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ",", "time", ".", "Since", "(", "start", ")", ")", "\n", "}", "else", "{", "ctrl", "=", "&", "Controller", "{", "name", ":", "name", ",", "uuid", ":", "uuid", ".", "NewUUID", "(", ")", ".", "String", "(", ")", ",", "stop", ":", "make", "(", "chan", "struct", "{", "}", ",", "0", ")", ",", "update", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "terminated", ":", "make", "(", "chan", "struct", "{", "}", ",", "0", ")", ",", "}", "\n", "ctrl", ".", "updateParamsLocked", "(", "params", ")", "\n", "ctrl", ".", "getLogger", "(", ")", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "ctrl", ".", "ctxDoFunc", ",", "ctrl", ".", "cancelDoFunc", "=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "m", ".", "controllers", "[", "ctrl", ".", "name", "]", "=", "ctrl", "\n", "m", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "globalStatus", ".", "mutex", ".", "Lock", "(", ")", "\n", "globalStatus", ".", "controllers", "[", "ctrl", ".", "uuid", "]", "=", "ctrl", "\n", "globalStatus", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "go", "ctrl", ".", "runController", "(", ")", "\n", "}", "\n\n", "return", "ctrl", "\n", "}" ]

[ "UpdateController", "installs", "or", "updates", "a", "controller", "in", "the", "manager", ".", "A", "controller", "is", "identified", "by", "its", "name", ".", "If", "a", "controller", "with", "the", "name", "already", "exists", "the", "controller", "will", "be", "shut", "down", "and", "replaced", "with", "the", "provided", "controller", ".", "Updating", "a", "controller", "will", "cause", "the", "DoFunc", "to", "be", "run", "immediately", "regardless", "of", "any", "previous", "conditions", ".", "It", "will", "also", "cause", "any", "statistics", "to", "be", "reset", "." ]

[ "func", "(", "m", "*", "Manager", ")", "RemoveController", "(", "name", "string", ")", "error", "{", "_", ",", "err", ":=", "m", ".", "removeAndReturnController", "(", "name", ")", "\n", "return", "err", "\n", "}" ]

[ "RemoveController", "stops", "and", "removes", "a", "controller", "from", "the", "manager", ".", "If", "DoFunc", "is", "currently", "running", "DoFunc", "is", "allowed", "to", "complete", "in", "the", "background", "." ]

[ "func", "(", "m", "*", "Manager", ")", "TerminationChannel", "(", "name", "string", ")", "chan", "struct", "{", "}", "{", "if", "c", ":=", "m", ".", "lookup", "(", "name", ")", ";", "c", "!=", "nil", "{", "return", "c", ".", "terminated", "\n", "}", "\n\n", "c", ":=", "make", "(", "chan", "struct", "{", "}", ",", "0", ")", "\n", "close", "(", "c", ")", "\n", "return", "c", "\n", "}" ]

[ "TerminationChannel", "returns", "a", "channel", "that", "is", "closed", "after", "the", "controller", "has", "been", "terminated" ]

[ "func", "(", "m", "*", "Manager", ")", "RemoveAllAndWait", "(", ")", "{", "ctrls", ":=", "m", ".", "removeAll", "(", ")", "\n", "for", "_", ",", "ctrl", ":=", "range", "ctrls", "{", "<-", "ctrl", ".", "terminated", "\n", "}", "\n", "}" ]

[ "RemoveAllAndWait", "stops", "and", "removes", "all", "controllers", "of", "the", "manager", "and", "then", "waits", "for", "all", "controllers", "to", "exit" ]

[ "func", "(", "m", "*", "Manager", ")", "GetStatusModel", "(", ")", "models", ".", "ControllerStatuses", "{", "// Create a copy of pointers to current controller so we can unlock the", "// manager mutex quickly again", "controllers", ":=", "controllerMap", "{", "}", "\n", "m", ".", "mutex", ".", "RLock", "(", ")", "\n", "for", "key", ",", "c", ":=", "range", "m", ".", "controllers", "{", "controllers", "[", "key", "]", "=", "c", "\n", "}", "\n", "m", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "statuses", ":=", "models", ".", "ControllerStatuses", "{", "}", "\n", "for", "_", ",", "c", ":=", "range", "controllers", "{", "statuses", "=", "append", "(", "statuses", ",", "c", ".", "GetStatusModel", "(", ")", ")", "\n", "}", "\n\n", "return", "statuses", "\n", "}" ]

[ "GetStatusModel", "returns", "the", "status", "of", "all", "controllers", "as", "models", ".", "ControllerStatuses" ]

[ "func", "FakeManager", "(", "failingControllers", "int", ")", "*", "Manager", "{", "m", ":=", "&", "Manager", "{", "controllers", ":", "controllerMap", "{", "}", ",", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "failingControllers", ";", "i", "++", "{", "ctrl", ":=", "&", "Controller", "{", "name", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ",", "uuid", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ",", "stop", ":", "make", "(", "chan", "struct", "{", "}", ",", "0", ")", ",", "update", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "terminated", ":", "make", "(", "chan", "struct", "{", "}", ",", "0", ")", ",", "lastError", ":", "fmt", ".", "Errorf", "(", "\"", "\"", ")", ",", "failureCount", ":", "1", ",", "consecutiveErrors", ":", "1", ",", "}", "\n\n", "ctrl", ".", "ctxDoFunc", ",", "ctrl", ".", "cancelDoFunc", "=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "m", ".", "controllers", "[", "ctrl", ".", "name", "]", "=", "ctrl", "\n", "}", "\n\n", "return", "m", "\n", "}" ]

[ "FakeManager", "returns", "a", "fake", "controller", "manager", "with", "the", "specified", "number", "of", "failing", "controllers", ".", "The", "returned", "manager", "is", "identical", "in", "any", "regard", "except", "for", "internal", "pointers", "." ]

[ "func", "New", "(", "transport", "runtime", ".", "ClientTransport", ",", "formats", "strfmt", ".", "Registry", ")", "*", "CiliumHealth", "{", "// ensure nullable parameters have default", "if", "formats", "==", "nil", "{", "formats", "=", "strfmt", ".", "Default", "\n", "}", "\n\n", "cli", ":=", "new", "(", "CiliumHealth", ")", "\n", "cli", ".", "Transport", "=", "transport", "\n\n", "cli", ".", "Connectivity", "=", "connectivity", ".", "New", "(", "transport", ",", "formats", ")", "\n\n", "cli", ".", "Restapi", "=", "restapi", ".", "New", "(", "transport", ",", "formats", ")", "\n\n", "return", "cli", "\n", "}" ]

[ "New", "creates", "a", "new", "cilium", "health", "client" ]

[ "func", "StartServer", "(", "addr", "string", ",", "shutdownSignal", "<-", "chan", "struct", "{", "}", ")", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "addr", ")", "\n\n", "http", ".", "HandleFunc", "(", "\"", "\"", ",", "healthHandler", ")", "\n\n", "srv", ":=", "&", "http", ".", "Server", "{", "Addr", ":", "addr", "}", "\n\n", "go", "func", "(", ")", "{", "<-", "shutdownSignal", "\n", "if", "err", ":=", "srv", ".", "Shutdown", "(", "context", ".", "Background", "(", ")", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "if", "err", ":=", "srv", ".", "ListenAndServe", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Error", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "StartServer", "starts", "an", "api", "server", "listening", "on", "the", "given", "address", "." ]

[ "func", "checkStatus", "(", ")", "error", "{", "if", "client", ":=", "kvstore", ".", "Client", "(", ")", ";", "client", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "else", "if", "_", ",", "err", ":=", "client", ".", "Status", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "if", "_", ",", "err", ":=", "k8s", ".", "Client", "(", ")", ".", "Discovery", "(", ")", ".", "ServerVersion", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "checkStatus", "checks", "the", "connection", "status", "to", "the", "kvstore", "and", "k8s", "apiserver", "and", "returns", "an", "error", "if", "any", "of", "them", "is", "unhealthy" ]

[ "func", "(", "c", "*", "Client", ")", "IPAMAllocate", "(", "family", ",", "owner", "string", ")", "(", "*", "models", ".", "IPAMResponse", ",", "error", ")", "{", "params", ":=", "ipam", ".", "NewPostIPAMParams", "(", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n\n", "if", "family", "!=", "\"", "\"", "{", "params", ".", "SetFamily", "(", "&", "family", ")", "\n", "}", "\n\n", "if", "owner", "!=", "\"", "\"", "{", "params", ".", "SetOwner", "(", "&", "owner", ")", "\n", "}", "\n\n", "resp", ",", "err", ":=", "c", ".", "IPAM", ".", "PostIPAM", "(", "params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "Hint", "(", "err", ")", "\n", "}", "\n", "return", "resp", ".", "Payload", ",", "nil", "\n", "}" ]

[ "IPAMAllocate", "allocates", "an", "IP", "address", "out", "of", "address", "family", "specific", "pool", "." ]

[ "func", "(", "c", "*", "Client", ")", "IPAMAllocateIP", "(", "ip", ",", "owner", "string", ")", "error", "{", "params", ":=", "ipam", ".", "NewPostIPAMIPParams", "(", ")", ".", "WithIP", "(", "ip", ")", ".", "WithOwner", "(", "&", "owner", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "err", ":=", "c", ".", "IPAM", ".", "PostIPAMIP", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "IPAMAllocateIP", "tries", "to", "allocate", "a", "particular", "IP", "address", "." ]

[ "func", "(", "c", "*", "Client", ")", "IPAMReleaseIP", "(", "ip", "string", ")", "error", "{", "params", ":=", "ipam", ".", "NewDeleteIPAMIPParams", "(", ")", ".", "WithIP", "(", "ip", ")", ".", "WithTimeout", "(", "api", ".", "ClientTimeout", ")", "\n", "_", ",", "err", ":=", "c", ".", "IPAM", ".", "DeleteIPAMIP", "(", "params", ")", "\n", "return", "Hint", "(", "err", ")", "\n", "}" ]

[ "IPAMReleaseIP", "releases", "a", "IP", "address", "back", "to", "the", "pool", "." ]

[ "func", "(", "c", "*", "Controller", ")", "GetSuccessCount", "(", ")", "int", "{", "c", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "successCount", "\n", "}" ]

[ "GetSuccessCount", "returns", "the", "number", "of", "successful", "controller", "runs" ]

[ "func", "(", "c", "*", "Controller", ")", "GetFailureCount", "(", ")", "int", "{", "c", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "failureCount", "\n", "}" ]

[ "GetFailureCount", "returns", "the", "number", "of", "failed", "controller", "runs" ]

[ "func", "(", "c", "*", "Controller", ")", "GetLastError", "(", ")", "error", "{", "c", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "lastError", "\n", "}" ]

[ "GetLastError", "returns", "the", "last", "error", "returned" ]

[ "func", "(", "c", "*", "Controller", ")", "GetLastErrorTimestamp", "(", ")", "time", ".", "Time", "{", "c", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "lastErrorStamp", "\n", "}" ]

[ "GetLastErrorTimestamp", "returns", "the", "last", "error", "returned" ]

[ "func", "(", "c", "*", "Controller", ")", "updateParamsLocked", "(", "params", "ControllerParams", ")", "{", "c", ".", "params", "=", "params", "\n\n", "maxInterval", ":=", "time", ".", "Duration", "(", "option", ".", "Config", ".", "MaxControllerInterval", ")", "*", "time", ".", "Second", "\n", "if", "maxInterval", ">", "0", "&&", "params", ".", "RunInterval", ">", "maxInterval", "{", "c", ".", "getLogger", "(", ")", ".", "Infof", "(", "\"", "\"", ",", "maxInterval", ")", "\n", "c", ".", "params", ".", "RunInterval", "=", "maxInterval", "\n", "}", "\n", "}" ]

[ "updateParamsLocked", "sets", "the", "specified", "controller", "s", "parameters", ".", "If", "the", "RunInterval", "exceeds", "ControllerMaxInterval", "it", "will", "be", "capped", "." ]

[ "func", "(", "c", "*", "Controller", ")", "getLogger", "(", ")", "*", "logrus", ".", "Entry", "{", "return", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "fieldControllerName", ":", "c", ".", "name", ",", "fieldUUID", ":", "c", ".", "uuid", ",", "}", ")", "\n", "}" ]

[ "logger", "returns", "a", "logrus", "object", "with", "controllerName", "and", "UUID", "fields", "." ]

[ "func", "(", "c", "*", "Controller", ")", "GetStatusModel", "(", ")", "*", "models", ".", "ControllerStatus", "{", "c", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "status", ":=", "&", "models", ".", "ControllerStatus", "{", "Name", ":", "c", ".", "name", ",", "UUID", ":", "strfmt", ".", "UUID", "(", "c", ".", "uuid", ")", ",", "Configuration", ":", "&", "models", ".", "ControllerStatusConfiguration", "{", "ErrorRetry", ":", "!", "c", ".", "params", ".", "NoErrorRetry", ",", "ErrorRetryBase", ":", "strfmt", ".", "Duration", "(", "c", ".", "params", ".", "ErrorRetryBaseDuration", ")", ",", "Interval", ":", "strfmt", ".", "Duration", "(", "c", ".", "params", ".", "RunInterval", ")", ",", "}", ",", "Status", ":", "&", "models", ".", "ControllerStatusStatus", "{", "SuccessCount", ":", "int64", "(", "c", ".", "successCount", ")", ",", "LastSuccessTimestamp", ":", "strfmt", ".", "DateTime", "(", "c", ".", "lastSuccessStamp", ")", ",", "FailureCount", ":", "int64", "(", "c", ".", "failureCount", ")", ",", "LastFailureTimestamp", ":", "strfmt", ".", "DateTime", "(", "c", ".", "lastErrorStamp", ")", ",", "ConsecutiveFailureCount", ":", "int64", "(", "c", ".", "consecutiveErrors", ")", ",", "}", ",", "}", "\n\n", "if", "c", ".", "lastError", "!=", "nil", "{", "status", ".", "Status", ".", "LastFailureMsg", "=", "c", ".", "lastError", ".", "Error", "(", ")", "\n", "}", "\n\n", "return", "status", "\n", "}" ]

[ "GetStatusModel", "returns", "a", "models", ".", "ControllerStatus", "representing", "the", "controller", "s", "configuration", "&", "status" ]

[ "func", "(", "c", "*", "Controller", ")", "recordError", "(", "err", "error", ")", "{", "c", ".", "lastError", "=", "err", "\n", "c", ".", "lastErrorStamp", "=", "time", ".", "Now", "(", ")", "\n", "c", ".", "failureCount", "++", "\n", "c", ".", "consecutiveErrors", "++", "\n", "metrics", ".", "ControllerRuns", ".", "WithLabelValues", "(", "failure", ")", ".", "Inc", "(", ")", "\n", "metrics", ".", "ControllerRunsDuration", ".", "WithLabelValues", "(", "failure", ")", ".", "Observe", "(", "c", ".", "lastDuration", ".", "Seconds", "(", ")", ")", "\n", "}" ]

[ "recordError", "updates", "all", "statistic", "collection", "variables", "on", "error", "c", ".", "mutex", "must", "be", "held", "." ]

[ "func", "(", "c", "*", "Controller", ")", "recordSuccess", "(", ")", "{", "c", ".", "lastError", "=", "nil", "\n", "c", ".", "lastSuccessStamp", "=", "time", ".", "Now", "(", ")", "\n", "c", ".", "successCount", "++", "\n", "c", ".", "consecutiveErrors", "=", "0", "\n\n", "metrics", ".", "ControllerRuns", ".", "WithLabelValues", "(", "success", ")", ".", "Inc", "(", ")", "\n", "metrics", ".", "ControllerRunsDuration", ".", "WithLabelValues", "(", "success", ")", ".", "Observe", "(", "c", ".", "lastDuration", ".", "Seconds", "(", ")", ")", "\n", "}" ]

[ "recordSuccess", "updates", "all", "statistic", "collection", "variables", "on", "success", "c", ".", "mutex", "must", "be", "held", "." ]

[ "func", "(", "c", "*", "CIDR", ")", "MatchesAll", "(", ")", "bool", "{", "for", "_", ",", "wildcard", ":=", "range", "CIDRMatchAll", "{", "if", "*", "c", "==", "wildcard", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "MatchesAll", "determines", "whether", "the", "CIDR", "matches", "all", "traffic", "." ]

[ "func", "(", "s", "CIDRSlice", ")", "GetAsEndpointSelectors", "(", ")", "EndpointSelectorSlice", "{", "// If multiple CIDRs representing reserved:world are in this CIDRSlice,", "// we only have to add the EndpointSelector representing reserved:world", "// once.", "var", "hasWorldBeenAdded", "bool", "\n", "slice", ":=", "EndpointSelectorSlice", "{", "}", "\n", "for", "_", ",", "cidr", ":=", "range", "s", "{", "if", "cidr", ".", "MatchesAll", "(", ")", "&&", "!", "hasWorldBeenAdded", "{", "hasWorldBeenAdded", "=", "true", "\n", "slice", "=", "append", "(", "slice", ",", "ReservedEndpointSelectors", "[", "labels", ".", "IDNameWorld", "]", ")", "\n", "}", "\n", "lbl", ",", "err", ":=", "cidrpkg", ".", "IPStringToLabel", "(", "string", "(", "cidr", ")", ")", "\n", "if", "err", "==", "nil", "{", "slice", "=", "append", "(", "slice", ",", "NewESFromLabels", "(", "lbl", ")", ")", "\n", "}", "\n", "// TODO: Log the error?", "}", "\n\n", "return", "slice", "\n", "}" ]

[ "GetAsEndpointSelectors", "returns", "the", "provided", "CIDR", "slice", "as", "a", "slice", "of", "endpoint", "selectors" ]

[ "func", "(", "s", "CIDRSlice", ")", "StringSlice", "(", ")", "[", "]", "string", "{", "result", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "s", ")", ")", "\n", "for", "_", ",", "c", ":=", "range", "s", "{", "result", "=", "append", "(", "result", ",", "string", "(", "c", ")", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "StringSlice", "returns", "the", "CIDR", "slice", "as", "a", "slice", "of", "strings", "." ]

[ "func", "ComputeResultantCIDRSet", "(", "cidrs", "CIDRRuleSlice", ")", "CIDRSlice", "{", "var", "allResultantAllowedCIDRs", "CIDRSlice", "\n", "for", "_", ",", "s", ":=", "range", "cidrs", "{", "_", ",", "allowNet", ",", "_", ":=", "net", ".", "ParseCIDR", "(", "string", "(", "s", ".", "Cidr", ")", ")", "\n\n", "var", "removeSubnets", "[", "]", "*", "net", ".", "IPNet", "\n", "for", "_", ",", "t", ":=", "range", "s", ".", "ExceptCIDRs", "{", "_", ",", "removeSubnet", ",", "_", ":=", "net", ".", "ParseCIDR", "(", "string", "(", "t", ")", ")", "\n", "removeSubnets", "=", "append", "(", "removeSubnets", ",", "removeSubnet", ")", "\n", "}", "\n", "resultantAllowedCIDRs", ",", "_", ":=", "ip", ".", "RemoveCIDRs", "(", "[", "]", "*", "net", ".", "IPNet", "{", "allowNet", "}", ",", "removeSubnets", ")", "\n\n", "for", "_", ",", "u", ":=", "range", "resultantAllowedCIDRs", "{", "allResultantAllowedCIDRs", "=", "append", "(", "allResultantAllowedCIDRs", ",", "CIDR", "(", "u", ".", "String", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n", "return", "allResultantAllowedCIDRs", "\n", "}" ]

[ "ComputeResultantCIDRSet", "converts", "a", "slice", "of", "CIDRRules", "into", "a", "slice", "of", "individual", "CIDRs", ".", "This", "expands", "the", "cidr", "defined", "by", "each", "CIDRRule", "applies", "the", "CIDR", "exceptions", "defined", "in", "ExceptCIDRs", "and", "forms", "a", "minimal", "set", "of", "CIDRs", "that", "cover", "all", "of", "the", "CIDRRules", ".", "Assumes", "no", "error", "checking", "is", "necessary", "as", "CIDRRule", ".", "Sanitize", "already", "does", "this", "." ]

[ "func", "NewGetHealthz", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetHealthzHandler", ")", "*", "GetHealthz", "{", "return", "&", "GetHealthz", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetHealthz", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "healthz", "operation" ]

[ "func", "Lookup", "(", "name", "string", ")", "ChainingPlugin", "{", "mutex", ".", "RLock", "(", ")", "\n", "defer", "mutex", ".", "RUnlock", "(", ")", "\n\n", "return", "chainingPlugins", "[", "name", "]", "\n", "}" ]

[ "Lookup", "searches", "for", "a", "chaining", "plugin", "with", "a", "given", "name", "and", "returns", "it" ]

[ "func", "NewEndpointKey", "(", "ip", "net", ".", "IP", ")", "EndpointKey", "{", "result", ":=", "EndpointKey", "{", "}", "\n\n", "if", "ip4", ":=", "ip", ".", "To4", "(", ")", ";", "ip4", "!=", "nil", "{", "result", ".", "Family", "=", "EndpointKeyIPv4", "\n", "copy", "(", "result", ".", "IP", "[", ":", "]", ",", "ip4", ")", "\n", "}", "else", "{", "result", ".", "Family", "=", "EndpointKeyIPv6", "\n", "copy", "(", "result", ".", "IP", "[", ":", "]", ",", "ip", ")", "\n", "}", "\n", "result", ".", "Key", "=", "0", "\n\n", "return", "result", "\n", "}" ]

[ "NewEndpointKey", "returns", "an", "EndpointKey", "based", "on", "the", "provided", "IP", "address", ".", "The", "address", "family", "is", "automatically", "detected", "." ]

[ "func", "(", "k", "EndpointKey", ")", "ToIP", "(", ")", "net", ".", "IP", "{", "switch", "k", ".", "Family", "{", "case", "EndpointKeyIPv4", ":", "return", "k", ".", "IP", "[", ":", "4", "]", "\n", "case", "EndpointKeyIPv6", ":", "return", "k", ".", "IP", "[", ":", "]", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ToIP", "converts", "the", "EndpointKey", "into", "a", "net", ".", "IP", "structure", "." ]

[ "func", "(", "k", "EndpointKey", ")", "String", "(", ")", "string", "{", "if", "ip", ":=", "k", ".", "ToIP", "(", ")", ";", "ip", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ip", ".", "String", "(", ")", ",", "k", ".", "Key", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "String", "provides", "a", "string", "representation", "of", "the", "EndpointKey", "." ]

[ "func", "NewPatchEndpointID", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "PatchEndpointIDHandler", ")", "*", "PatchEndpointID", "{", "return", "&", "PatchEndpointID", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewPatchEndpointID", "creates", "a", "new", "http", ".", "Handler", "for", "the", "patch", "endpoint", "ID", "operation" ]

[ "func", "(", "ch", "*", "CiliumHealth", ")", "Run", "(", ")", "{", "ch", ".", "SetTarget", "(", "targetName", ")", "\n", "ch", ".", "SetArgs", "(", "[", "]", "string", "{", "\"", "\"", "}", ")", "\n\n", "// Wait until Cilium API is available", "for", "{", "cli", ",", "err", ":=", "ciliumPkg", ".", "NewDefaultClient", "(", ")", "\n", "if", "err", "==", "nil", "{", "if", "_", ",", "err", "=", "cli", ".", "Daemon", ".", "GetHealthz", "(", "nil", ")", ";", "err", "==", "nil", "{", "break", "\n", "}", "\n", "}", "\n", "log", ".", "WithError", "(", "err", ")", ".", "Debugf", "(", "\"", "\"", ")", "\n", "time", ".", "Sleep", "(", "connectRetryInterval", ")", "\n", "}", "\n\n", "for", "{", "var", "err", "error", "\n\n", "os", ".", "Remove", "(", "defaults", ".", "SockPath", ")", "\n", "ch", ".", "Launcher", ".", "Run", "(", ")", "\n", "ch", ".", "client", ",", "err", "=", "healthPkg", ".", "NewDefaultClient", "(", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Infof", "(", "\"", "\"", ",", "targetName", ")", "\n", "time", ".", "Sleep", "(", "connectRetryInterval", ")", "\n", "continue", "\n", "}", "\n\n", "for", "{", "status", ":=", "&", "models", ".", "Status", "{", "State", ":", "models", ".", "StatusStateOk", ",", "}", "\n", "if", "_", ",", "err", ":=", "ch", ".", "client", ".", "Restapi", ".", "GetHello", "(", "nil", ")", ";", "err", "!=", "nil", "{", "status", ".", "Msg", "=", "ciliumPkg", ".", "Hint", "(", "err", ")", ".", "Error", "(", ")", "\n", "status", ".", "State", "=", "models", ".", "StatusStateWarning", "\n", "}", "\n", "ch", ".", "setStatus", "(", "status", ")", "\n", "time", ".", "Sleep", "(", "statusProbeInterval", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Run", "launches", "the", "cilium", "-", "health", "daemon", "." ]

[ "func", "(", "ch", "*", "CiliumHealth", ")", "GetStatus", "(", ")", "*", "models", ".", "Status", "{", "ch", ".", "Mutex", ".", "RLock", "(", ")", "\n", "status", ":=", "ch", ".", "status", "\n", "ch", ".", "Mutex", ".", "RUnlock", "(", ")", "\n", "return", "status", "\n", "}" ]

[ "GetStatus", "returns", "the", "status", "of", "the", "cilium", "-", "health", "daemon", "." ]

[ "func", "(", "ch", "*", "CiliumHealth", ")", "setStatus", "(", "status", "*", "models", ".", "Status", ")", "{", "ch", ".", "Mutex", ".", "Lock", "(", ")", "\n", "ch", ".", "status", "=", "status", "\n", "ch", ".", "Mutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "setStatus", "updates", "the", "status", "of", "the", "cilium", "-", "health", "daemon", "." ]

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

[ "bindIP", "binds", "and", "validates", "parameter", "IP", "from", "path", "." ]

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

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

[ "func", "(", "e", "*", "Endpoint", ")", "DirectoryPath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "ID", ")", ")", "\n", "}" ]

[ "DirectoryPath", "returns", "the", "directory", "name", "for", "this", "endpoint", "bpf", "program", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "StateDirectoryPath", "(", ")", "string", "{", "return", "filepath", ".", "Join", "(", "option", ".", "Config", ".", "StateDir", ",", "e", ".", "StringID", "(", ")", ")", "\n", "}" ]

[ "StateDirectoryPath", "returns", "the", "directory", "name", "for", "this", "endpoint", "bpf", "program", "." ]

[ "func", "(", "e", "*", "Endpoint", ")", "synchronizeDirectories", "(", "origDir", "string", ",", "compilationExecuted", "bool", ")", "error", "{", "scopedLog", ":=", "e", ".", "getLogger", "(", ")", "\n", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n\n", "tmpDir", ":=", "e", ".", "NextDirectoryPath", "(", ")", "\n\n", "// Check if an existing endpoint directory exists, e.g.", "// /var/run/cilium/state/1111", "_", ",", "err", ":=", "os", ".", "Stat", "(", "origDir", ")", "\n", "switch", "{", "// An endpoint directory already exists. We need to back it up before attempting", "// to move the new directory in its place so we can attempt recovery.", "case", "!", "os", ".", "IsNotExist", "(", "err", ")", ":", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "backupDir", ":=", "e", ".", "backupDirectoryPath", "(", ")", "\n\n", "// Remove any eventual old backup directory. This may fail if", "// the directory does not exist. The error is deliberately", "// ignored.", "e", ".", "removeDirectory", "(", "backupDir", ")", "\n\n", "// Move the current endpoint directory to a backup location", "scopedLog", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "origDir", ",", "\"", "\"", ":", "backupDir", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "os", ".", "Rename", "(", "origDir", ",", "backupDir", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// Regarldess of whether the atomic replace succeeds or not,", "// ensure that the backup directory is removed when the", "// function returns.", "defer", "e", ".", "removeDirectory", "(", "backupDir", ")", "\n\n", "// Make temporary directory the new endpoint directory", "if", "err", ":=", "os", ".", "Rename", "(", "tmpDir", ",", "origDir", ")", ";", "err", "!=", "nil", "{", "if", "err2", ":=", "os", ".", "Rename", "(", "backupDir", ",", "origDir", ")", ";", "err2", "!=", "nil", "{", "scopedLog", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "Path", ":", "backupDir", ",", "}", ")", ".", "Warn", "(", "\"", "\"", "+", "\"", "\"", ")", "\n", "return", "err2", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// If the compilation was skipped then we need to copy the old", "// bpf objects into the new directory", "if", "!", "compilationExecuted", "{", "scopedLog", ".", "Debug", "(", "\"", "\"", ")", "\n", "err", ":=", "common", ".", "MoveNewFilesTo", "(", "backupDir", ",", "origDir", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Debugf", "(", "\"", "\"", "+", "\"", "\"", ",", "backupDir", ",", "origDir", ")", "\n", "}", "\n", "}", "\n\n", "// No existing endpoint directory, synchronizing the directory is a", "// simple move", "default", ":", "// Make temporary directory the new endpoint directory", "scopedLog", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "tmpDir", ",", "\"", "\"", ":", "origDir", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err", ":=", "os", ".", "Rename", "(", "tmpDir", ",", "origDir", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// The build succeeded and is in place, any eventual existing failure", "// directory can be removed.", "e", ".", "removeDirectory", "(", "e", ".", "FailedDirectoryPath", "(", ")", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "synchronizeDirectories", "moves", "the", "files", "related", "to", "endpoint", "BPF", "program", "compilation", "to", "their", "according", "directories", "if", "compilation", "of", "BPF", "was", "necessary", "for", "the", "endpoint", ".", "Returns", "the", "original", "regenerationError", "if", "regenerationError", "was", "non", "-", "nil", "or", "if", "any", "updates", "to", "directories", "for", "the", "endpoint", "s", "directories", "fails", ".", "Must", "be", "called", "with", "endpoint", ".", "Mutex", "held", "." ]

[ "func", "(", "nn", "Identity", ")", "String", "(", ")", "string", "{", "return", "path", ".", "Join", "(", "nn", ".", "Cluster", ",", "nn", ".", "Name", ")", "\n", "}" ]

[ "String", "returns", "the", "string", "representation", "on", "NodeIdentity", "." ]

[ "func", "(", "n", "*", "Node", ")", "Fullname", "(", ")", "string", "{", "if", "n", ".", "Cluster", "!=", "defaults", ".", "ClusterName", "{", "return", "path", ".", "Join", "(", "n", ".", "Cluster", ",", "n", ".", "Name", ")", "\n", "}", "\n\n", "return", "n", ".", "Name", "\n", "}" ]

[ "Fullname", "returns", "the", "node", "s", "full", "name", "including", "the", "cluster", "name", "if", "a", "cluster", "name", "value", "other", "than", "the", "default", "value", "has", "been", "specified" ]

[ "func", "(", "n", "*", "Node", ")", "GetModel", "(", ")", "*", "models", ".", "NodeElement", "{", "return", "&", "models", ".", "NodeElement", "{", "Name", ":", "n", ".", "Fullname", "(", ")", ",", "PrimaryAddress", ":", "n", ".", "getPrimaryAddress", "(", ")", ",", "SecondaryAddresses", ":", "n", ".", "getSecondaryAddresses", "(", ")", ",", "HealthEndpointAddress", ":", "n", ".", "getHealthAddresses", "(", ")", ",", "}", "\n", "}" ]

[ "GetModel", "returns", "the", "API", "model", "representation", "of", "a", "node", "." ]

[ "func", "(", "n", "*", "Node", ")", "Identity", "(", ")", "Identity", "{", "return", "Identity", "{", "Name", ":", "n", ".", "Name", ",", "Cluster", ":", "n", ".", "Cluster", ",", "}", "\n", "}" ]

[ "Identity", "returns", "the", "identity", "of", "the", "node" ]

[ "func", "(", "n", "*", "Node", ")", "PublicAttrEquals", "(", "o", "*", "Node", ")", "bool", "{", "if", "(", "n", "==", "nil", ")", "!=", "(", "o", "==", "nil", ")", "{", "return", "false", "\n", "}", "\n\n", "if", "n", ".", "Name", "==", "o", ".", "Name", "&&", "n", ".", "Cluster", "==", "o", ".", "Cluster", "&&", "n", ".", "IPv4HealthIP", ".", "Equal", "(", "o", ".", "IPv4HealthIP", ")", "&&", "n", ".", "IPv6HealthIP", ".", "Equal", "(", "o", ".", "IPv6HealthIP", ")", "&&", "n", ".", "ClusterID", "==", "o", ".", "ClusterID", "&&", "n", ".", "Source", "==", "o", ".", "Source", "{", "if", "len", "(", "n", ".", "IPAddresses", ")", "!=", "len", "(", "o", ".", "IPAddresses", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "i", ":=", "range", "n", ".", "IPAddresses", "{", "if", "(", "n", ".", "IPAddresses", "[", "i", "]", ".", "Type", "!=", "o", ".", "IPAddresses", "[", "i", "]", ".", "Type", ")", "||", "!", "n", ".", "IPAddresses", "[", "i", "]", ".", "IP", ".", "Equal", "(", "o", ".", "IPAddresses", "[", "i", "]", ".", "IP", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "if", "(", "n", ".", "IPv4AllocCIDR", "==", "nil", ")", "!=", "(", "o", ".", "IPv4AllocCIDR", "==", "nil", ")", "{", "return", "false", "\n", "}", "\n", "if", "n", ".", "IPv4AllocCIDR", ".", "String", "(", ")", "!=", "o", ".", "IPv4AllocCIDR", ".", "String", "(", ")", "{", "return", "false", "\n", "}", "\n\n", "if", "(", "n", ".", "IPv6AllocCIDR", "==", "nil", ")", "!=", "(", "o", ".", "IPv6AllocCIDR", "==", "nil", ")", "{", "return", "false", "\n", "}", "\n", "if", "n", ".", "IPv6AllocCIDR", ".", "String", "(", ")", "!=", "o", ".", "IPv6AllocCIDR", ".", "String", "(", ")", "{", "return", "false", "\n", "}", "\n\n", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "PublicAttrEquals", "returns", "true", "only", "if", "the", "public", "attributes", "of", "both", "nodes", "are", "the", "same", "otherwise", "returns", "false", "." ]

[ "func", "(", "n", "*", "Node", ")", "Unmarshal", "(", "data", "[", "]", "byte", ")", "error", "{", "newNode", ":=", "Node", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "newNode", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "*", "n", "=", "newNode", "\n\n", "return", "nil", "\n", "}" ]

[ "Unmarshal", "parses", "the", "JSON", "byte", "slice", "and", "updates", "the", "node", "receiver" ]

[ "func", "DeleteByName", "(", "ifName", "string", ")", "error", "{", "iface", ",", "err", ":=", "netlink", ".", "LinkByName", "(", "ifName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ifName", ",", "err", ")", "\n", "}", "\n\n", "if", "err", "=", "netlink", ".", "LinkDel", "(", "iface", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ifName", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteByName", "deletes", "the", "interface", "with", "the", "name", "ifName", "." ]

[ "func", "Rename", "(", "curName", ",", "newName", "string", ")", "error", "{", "link", ",", "err", ":=", "netlink", ".", "LinkByName", "(", "curName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "netlink", ".", "LinkSetName", "(", "link", ",", "newName", ")", "\n", "}" ]

[ "Rename", "renames", "a", "network", "link" ]

[ "func", "reverse", "(", "b", "[", "]", "byte", ")", "[", "]", "byte", "{", "size", ":=", "len", "(", "b", ")", "\n", "c", ":=", "make", "(", "[", "]", "byte", ",", "size", ")", "\n\n", "for", "i", ",", "j", ":=", "size", "-", "1", ",", "0", ";", "i", ">=", "0", ";", "i", ",", "j", "=", "i", "-", "1", ",", "j", "+", "1", "{", "c", "[", "j", "]", "=", "b", "[", "i", "]", "\n", "}", "\n\n", "return", "c", "\n", "}" ]

[ "reverse", "returns", "a", "reversed", "slice", "of", "b", "." ]

[ "func", "HostToNetwork", "(", "b", "interface", "{", "}", ")", "interface", "{", "}", "{", "switch", "b", ".", "(", "type", ")", "{", "case", "uint16", ":", "return", "swap16", "(", "b", ".", "(", "uint16", ")", ")", "\n", "case", "uint32", ":", "return", "swap32", "(", "b", ".", "(", "uint32", ")", ")", "\n", "default", ":", "panic", "(", "unsupported", "(", "b", ")", ")", "\n", "}", "\n", "}" ]

[ "HostToNetwork", "converts", "b", "to", "the", "networking", "byte", "order", "." ]

[ "func", "NetworkToHost", "(", "n", "interface", "{", "}", ")", "interface", "{", "}", "{", "switch", "n", ".", "(", "type", ")", "{", "case", "uint16", ":", "return", "swap16", "(", "n", ".", "(", "uint16", ")", ")", "\n", "case", "uint32", ":", "return", "swap32", "(", "n", ".", "(", "uint32", ")", ")", "\n", "default", ":", "panic", "(", "unsupported", "(", "n", ")", ")", "\n", "}", "\n", "}" ]

[ "NetworkToHost", "converts", "n", "to", "host", "byte", "order", "." ]

[ "func", "HostToNetworkSlice", "(", "b", "[", "]", "byte", ",", "t", "reflect", ".", "Kind", ")", "interface", "{", "}", "{", "switch", "t", "{", "case", "reflect", ".", "Uint32", ":", "return", "binary", ".", "BigEndian", ".", "Uint32", "(", "b", ")", "\n", "case", "reflect", ".", "Uint16", ":", "return", "binary", ".", "BigEndian", ".", "Uint16", "(", "b", ")", "\n", "default", ":", "panic", "(", "unsupported", "(", "b", ")", ")", "\n", "}", "\n", "}" ]

[ "HostToNetworkSlice", "converts", "b", "to", "the", "networking", "byte", "order", "." ]

[ "func", "HostToNetworkPut", "(", "b", "[", "]", "byte", ",", "v", "interface", "{", "}", ")", "{", "switch", "reflect", ".", "TypeOf", "(", "v", ")", ".", "Kind", "(", ")", "{", "case", "reflect", ".", "Uint32", ":", "binary", ".", "BigEndian", ".", "PutUint32", "(", "b", ",", "v", ".", "(", "uint32", ")", ")", "\n", "case", "reflect", ".", "Uint16", ":", "binary", ".", "BigEndian", ".", "PutUint16", "(", "b", ",", "v", ".", "(", "uint16", ")", ")", "\n", "default", ":", "panic", "(", "unsupported", "(", "v", ")", ")", "\n", "}", "\n", "}" ]

[ "HostToNetworkPut", "puts", "v", "into", "b", "with", "the", "networking", "byte", "order", "." ]

[ "func", "NetworkToHostPut", "(", "b", "[", "]", "byte", ",", "v", "interface", "{", "}", ")", "{", "switch", "reflect", ".", "TypeOf", "(", "v", ")", ".", "Kind", "(", ")", "{", "case", "reflect", ".", "Uint32", ":", "Native", ".", "PutUint32", "(", "b", ",", "v", ".", "(", "uint32", ")", ")", "\n", "case", "reflect", ".", "Uint16", ":", "Native", ".", "PutUint16", "(", "b", ",", "v", ".", "(", "uint16", ")", ")", "\n", "default", ":", "panic", "(", "unsupported", "(", "v", ")", ")", "\n", "}", "\n", "}" ]

[ "NetworkToHostPut", "puts", "v", "into", "b", "with", "the", "networking", "byte", "order", "." ]

[ "func", "HostSliceToNetwork", "(", "b", "[", "]", "byte", ",", "t", "reflect", ".", "Kind", ")", "interface", "{", "}", "{", "switch", "t", "{", "case", "reflect", ".", "Uint32", ":", "if", "Native", "!=", "binary", ".", "BigEndian", "{", "return", "binary", ".", "BigEndian", ".", "Uint32", "(", "reverse", "(", "b", ")", ")", "\n", "}", "\n", "return", "binary", ".", "BigEndian", ".", "Uint32", "(", "b", ")", "\n", "case", "reflect", ".", "Uint16", ":", "if", "Native", "!=", "binary", ".", "BigEndian", "{", "return", "binary", ".", "BigEndian", ".", "Uint16", "(", "reverse", "(", "b", ")", ")", "\n", "}", "\n", "return", "binary", ".", "BigEndian", ".", "Uint16", "(", "b", ")", "\n", "default", ":", "panic", "(", "unsupported", "(", "t", ")", ")", "\n", "}", "\n", "}" ]

[ "HostSliceToNetwork", "converts", "b", "to", "the", "networking", "byte", "order", "." ]

[ "func", "unsupported", "(", "field", "interface", "{", "}", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "field", ")", ".", "Kind", "(", ")", ",", "field", ")", "\n", "}" ]

[ "unsupported", "returns", "a", "string", "to", "used", "for", "debugging", "unhandled", "types", "." ]

[ "func", "(", "m", "*", "HealthStatusResponse", ")", "Validate", "(", "formats", "strfmt", ".", "Registry", ")", "error", "{", "var", "res", "[", "]", "error", "\n\n", "if", "err", ":=", "m", ".", "validateLocal", "(", "formats", ")", ";", "err", "!=", "nil", "{", "res", "=", "append", "(", "res", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "m", ".", "validateNodes", "(", "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", "health", "status", "response" ]

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

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

[ "func", "NewServiceCache", "(", ")", "ServiceCache", "{", "return", "ServiceCache", "{", "services", ":", "map", "[", "ServiceID", "]", "*", "Service", "{", "}", ",", "endpoints", ":", "map", "[", "ServiceID", "]", "*", "Endpoints", "{", "}", ",", "ingresses", ":", "map", "[", "ServiceID", "]", "*", "Service", "{", "}", ",", "externalEndpoints", ":", "map", "[", "ServiceID", "]", "externalEndpoints", "{", "}", ",", "Events", ":", "make", "(", "chan", "ServiceEvent", ",", "128", ")", ",", "}", "\n", "}" ]

[ "NewServiceCache", "returns", "a", "new", "ServiceCache" ]

[ "func", "(", "s", "*", "ServiceCache", ")", "GetRandomBackendIP", "(", "svcID", "ServiceID", ")", "*", "loadbalancer", ".", "L3n4Addr", "{", "s", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "s", ".", "mutex", ".", "RUnlock", "(", ")", "\n", "svc", ":=", "s", ".", "services", "[", "svcID", "]", "\n", "if", "svc", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "for", "_", ",", "port", ":=", "range", "svc", ".", "Ports", "{", "return", "loadbalancer", ".", "NewL3n4Addr", "(", "port", ".", "Protocol", ",", "svc", ".", "FrontendIP", ",", "port", ".", "Port", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetRandomBackendIP", "returns", "a", "random", "L3n4Addr", "that", "is", "backing", "the", "given", "Service", "ID", "." ]

[ "func", "(", "s", "*", "ServiceCache", ")", "UpdateService", "(", "k8sSvc", "*", "types", ".", "Service", ")", "ServiceID", "{", "svcID", ",", "newService", ":=", "ParseService", "(", "k8sSvc", ")", "\n", "if", "newService", "==", "nil", "{", "return", "svcID", "\n", "}", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "oldService", ",", "ok", ":=", "s", ".", "services", "[", "svcID", "]", ";", "ok", "{", "if", "oldService", ".", "DeepEquals", "(", "newService", ")", "{", "return", "svcID", "\n", "}", "\n", "}", "\n\n", "s", ".", "services", "[", "svcID", "]", "=", "newService", "\n\n", "// Check if the corresponding Endpoints resource is already available", "endpoints", ",", "serviceReady", ":=", "s", ".", "correlateEndpoints", "(", "svcID", ")", "\n", "if", "serviceReady", "{", "s", ".", "Events", "<-", "ServiceEvent", "{", "Action", ":", "UpdateService", ",", "ID", ":", "svcID", ",", "Service", ":", "newService", ",", "Endpoints", ":", "endpoints", ",", "}", "\n", "}", "\n\n", "return", "svcID", "\n", "}" ]

[ "UpdateService", "parses", "a", "Kubernetes", "service", "and", "adds", "or", "updates", "it", "in", "the", "ServiceCache", ".", "Returns", "the", "ServiceID", "unless", "the", "Kubernetes", "service", "could", "not", "be", "parsed", "and", "a", "bool", "to", "indicate", "whether", "the", "service", "was", "changed", "in", "the", "cache", "or", "not", "." ]

[ "func", "(", "s", "*", "ServiceCache", ")", "DeleteService", "(", "k8sSvc", "*", "types", ".", "Service", ")", "{", "svcID", ":=", "ParseServiceID", "(", "k8sSvc", ")", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "oldService", ",", "serviceOK", ":=", "s", ".", "services", "[", "svcID", "]", "\n", "endpoints", ",", "_", ":=", "s", ".", "correlateEndpoints", "(", "svcID", ")", "\n", "delete", "(", "s", ".", "services", ",", "svcID", ")", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "serviceOK", "{", "s", ".", "Events", "<-", "ServiceEvent", "{", "Action", ":", "DeleteService", ",", "ID", ":", "svcID", ",", "Service", ":", "oldService", ",", "Endpoints", ":", "endpoints", ",", "}", "\n", "}", "\n", "}" ]

[ "DeleteService", "parses", "a", "Kubernetes", "service", "and", "removes", "it", "from", "the", "ServiceCache" ]

[ "func", "(", "s", "*", "ServiceCache", ")", "UpdateEndpoints", "(", "k8sEndpoints", "*", "types", ".", "Endpoints", ")", "(", "ServiceID", ",", "*", "Endpoints", ")", "{", "svcID", ",", "newEndpoints", ":=", "ParseEndpoints", "(", "k8sEndpoints", ")", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "oldEndpoints", ",", "ok", ":=", "s", ".", "endpoints", "[", "svcID", "]", ";", "ok", "{", "if", "oldEndpoints", ".", "DeepEquals", "(", "newEndpoints", ")", "{", "return", "svcID", ",", "newEndpoints", "\n", "}", "\n", "}", "\n\n", "s", ".", "endpoints", "[", "svcID", "]", "=", "newEndpoints", "\n\n", "// Check if the corresponding Endpoints resource is already available", "service", ",", "ok", ":=", "s", ".", "services", "[", "svcID", "]", "\n", "endpoints", ",", "serviceReady", ":=", "s", ".", "correlateEndpoints", "(", "svcID", ")", "\n", "if", "ok", "&&", "serviceReady", "{", "s", ".", "Events", "<-", "ServiceEvent", "{", "Action", ":", "UpdateService", ",", "ID", ":", "svcID", ",", "Service", ":", "service", ",", "Endpoints", ":", "endpoints", ",", "}", "\n", "}", "\n\n", "return", "svcID", ",", "newEndpoints", "\n", "}" ]

[ "UpdateEndpoints", "parses", "a", "Kubernetes", "endpoints", "and", "adds", "or", "updates", "it", "in", "the", "ServiceCache", ".", "Returns", "the", "ServiceID", "unless", "the", "Kubernetes", "endpoints", "could", "not", "be", "parsed", "and", "a", "bool", "to", "indicate", "whether", "the", "endpoints", "was", "changed", "in", "the", "cache", "or", "not", "." ]

[ "func", "(", "s", "*", "ServiceCache", ")", "DeleteEndpoints", "(", "k8sEndpoints", "*", "types", ".", "Endpoints", ")", "ServiceID", "{", "svcID", ":=", "ParseEndpointsID", "(", "k8sEndpoints", ")", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "service", ",", "serviceOK", ":=", "s", ".", "services", "[", "svcID", "]", "\n", "delete", "(", "s", ".", "endpoints", ",", "svcID", ")", "\n", "endpoints", ",", "serviceReady", ":=", "s", ".", "correlateEndpoints", "(", "svcID", ")", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "serviceOK", "{", "event", ":=", "ServiceEvent", "{", "Action", ":", "DeleteService", ",", "ID", ":", "svcID", ",", "Service", ":", "service", ",", "Endpoints", ":", "endpoints", ",", "}", "\n\n", "if", "serviceReady", "{", "event", ".", "Action", "=", "UpdateService", "\n", "}", "\n\n", "s", ".", "Events", "<-", "event", "\n", "}", "\n\n", "return", "svcID", "\n", "}" ]

[ "DeleteEndpoints", "parses", "a", "Kubernetes", "endpoints", "and", "removes", "it", "from", "the", "ServiceCache" ]

[ "func", "(", "s", "*", "ServiceCache", ")", "UpdateIngress", "(", "ingress", "*", "types", ".", "Ingress", ",", "host", "net", ".", "IP", ")", "(", "ServiceID", ",", "error", ")", "{", "svcID", ",", "newService", ",", "err", ":=", "ParseIngress", "(", "ingress", ",", "host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "svcID", ",", "err", "\n", "}", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "oldService", ",", "ok", ":=", "s", ".", "ingresses", "[", "svcID", "]", ";", "ok", "{", "if", "oldService", ".", "DeepEquals", "(", "newService", ")", "{", "return", "svcID", ",", "nil", "\n", "}", "\n", "}", "\n\n", "s", ".", "ingresses", "[", "svcID", "]", "=", "newService", "\n\n", "s", ".", "Events", "<-", "ServiceEvent", "{", "Action", ":", "UpdateIngress", ",", "ID", ":", "svcID", ",", "Service", ":", "newService", ",", "}", "\n\n", "return", "svcID", ",", "nil", "\n", "}" ]

[ "UpdateIngress", "parses", "a", "Kubernetes", "ingress", "and", "adds", "or", "updates", "it", "in", "the", "ServiceCache", "." ]

[ "func", "(", "s", "*", "ServiceCache", ")", "DeleteIngress", "(", "ingress", "*", "types", ".", "Ingress", ")", "{", "svcID", ":=", "ParseIngressID", "(", "ingress", ")", "\n\n", "s", ".", "mutex", ".", "Lock", "(", ")", "\n", "oldService", ",", "ok", ":=", "s", ".", "ingresses", "[", "svcID", "]", "\n", "endpoints", ",", "_", ":=", "s", ".", "endpoints", "[", "svcID", "]", "\n", "delete", "(", "s", ".", "ingresses", ",", "svcID", ")", "\n", "s", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "if", "ok", "{", "s", ".", "Events", "<-", "ServiceEvent", "{", "Action", ":", "DeleteIngress", ",", "ID", ":", "svcID", ",", "Service", ":", "oldService", ",", "Endpoints", ":", "endpoints", ",", "}", "\n", "}", "\n", "}" ]

[ "DeleteIngress", "parses", "a", "Kubernetes", "ingress", "and", "removes", "it", "from", "the", "ServiceCache" ]

[ "func", "(", "l", "FrontendList", ")", "LooseMatch", "(", "frontend", "loadbalancer", ".", "L3n4Addr", ")", "(", "exists", "bool", ")", "{", "switch", "frontend", ".", "Protocol", "{", "case", "loadbalancer", ".", "NONE", ":", "for", "_", ",", "protocol", ":=", "range", "loadbalancer", ".", "AllProtocols", "{", "frontend", ".", "Protocol", "=", "protocol", "\n", "_", ",", "exists", "=", "l", "[", "frontend", ".", "StringWithProtocol", "(", ")", "]", "\n", "if", "exists", "{", "return", "\n", "}", "\n", "}", "\n\n", "// If the protocol is set, perform an exact match", "default", ":", "_", ",", "exists", "=", "l", "[", "frontend", ".", "StringWithProtocol", "(", ")", "]", "\n", "}", "\n", "return", "\n", "}" ]

[ "LooseMatch", "returns", "true", "if", "the", "provided", "frontend", "is", "found", "in", "the", "FrontendList", ".", "If", "the", "frontend", "has", "a", "protocol", "value", "set", "it", "only", "matches", "a", "k8s", "service", "with", "a", "matching", "protocol", ".", "If", "no", "protocol", "is", "set", "any", "k8s", "service", "matching", "frontend", "IP", "and", "port", "is", "considered", "a", "match", "regardless", "of", "protocol", "." ]

[ "func", "(", "s", "*", "ServiceCache", ")", "UniqueServiceFrontends", "(", ")", "FrontendList", "{", "uniqueFrontends", ":=", "FrontendList", "{", "}", "\n\n", "s", ".", "mutex", ".", "RLock", "(", ")", "\n", "defer", "s", ".", "mutex", ".", "RUnlock", "(", ")", "\n\n", "for", "_", ",", "svc", ":=", "range", "s", ".", "services", "{", "for", "_", ",", "p", ":=", "range", "svc", ".", "Ports", "{", "address", ":=", "loadbalancer", ".", "L3n4Addr", "{", "IP", ":", "svc", ".", "FrontendIP", ",", "L4Addr", ":", "*", "p", ".", "L4Addr", ",", "}", "\n\n", "uniqueFrontends", "[", "address", ".", "StringWithProtocol", "(", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n\n", "return", "uniqueFrontends", "\n", "}" ]

[ "UniqueServiceFrontends", "returns", "all", "services", "known", "to", "the", "service", "cache", "as", "a", "map", "indexed", "by", "the", "string", "representation", "of", "a", "loadbalancer", ".", "L3n4Addr" ]

[ "func", "(", "s", "*", "ServiceCache", ")", "DebugStatus", "(", ")", "string", "{", "s", ".", "mutex", ".", "RLock", "(", ")", "\n", "str", ":=", "spew", ".", "Sdump", "(", "s", ")", "\n", "s", ".", "mutex", ".", "RUnlock", "(", ")", "\n", "return", "str", "\n", "}" ]

[ "DebugStatus", "implements", "debug", ".", "StatusObject", "to", "provide", "debug", "status", "collection", "ability" ]

[ "func", "NewGetEndpointIDHealthz", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetEndpointIDHealthzHandler", ")", "*", "GetEndpointIDHealthz", "{", "return", "&", "GetEndpointIDHealthz", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetEndpointIDHealthz", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "endpoint", "ID", "healthz", "operation" ]

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

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

[ "func", "GetProgNextID", "(", "current", "uint32", ")", "(", "uint32", ",", "error", ")", "{", "attr", ":=", "attrProg", "{", "progID", ":", "current", ",", "}", "\n\n", "duration", ":=", "spanstat", ".", "Start", "(", ")", "\n", "ret", ",", "_", ",", "err", ":=", "unix", ".", "Syscall", "(", "unix", ".", "SYS_BPF", ",", "BPF_PROG_GET_NEXT_ID", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "attr", ")", ")", ",", "unsafe", ".", "Sizeof", "(", "attr", ")", ")", "\n", "metricSyscallDuration", ".", "WithLabelValues", "(", "metricOpProgGetNextID", ",", "metrics", ".", "Errno2Outcome", "(", "err", ")", ")", ".", "Observe", "(", "duration", ".", "End", "(", "err", "==", "0", ")", ".", "Total", "(", ")", ".", "Seconds", "(", ")", ")", "\n", "if", "ret", "!=", "0", "||", "err", "!=", "0", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "attr", ".", "nextID", ",", "nil", "\n", "}" ]

[ "GetProgNextID", "takes", "a", "current", "program", "ID", "and", "returns", "the", "next", "program", "ID", "." ]

[ "func", "GetProgFDByID", "(", "id", "uint32", ")", "(", "int", ",", "error", ")", "{", "attr", ":=", "attrProg", "{", "progID", ":", "uint32", "(", "uintptr", "(", "id", ")", ")", ",", "}", "\n\n", "fd", ",", "_", ",", "err", ":=", "unix", ".", "Syscall", "(", "unix", ".", "SYS_BPF", ",", "BPF_PROG_GET_FD_BY_ID", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "attr", ")", ")", ",", "unsafe", ".", "Sizeof", "(", "attr", ")", ")", "\n", "if", "fd", "<", "0", "||", "err", "!=", "0", "{", "return", "int", "(", "fd", ")", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ",", "err", ")", "\n", "}", "\n\n", "return", "int", "(", "fd", ")", ",", "nil", "\n", "}" ]

[ "GetProgFDByID", "returns", "the", "file", "descriptor", "for", "the", "program", "id", "." ]

[ "func", "GetProgInfoByFD", "(", "fd", "int", ")", "(", "ProgInfo", ",", "error", ")", "{", "info", ":=", "ProgInfo", "{", "}", "\n", "attrInfo", ":=", "attrObjInfo", "{", "bpfFD", ":", "uint32", "(", "fd", ")", ",", "infoLen", ":", "uint32", "(", "unsafe", ".", "Sizeof", "(", "info", ")", ")", ",", "info", ":", "uint64", "(", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "info", ")", ")", ")", ",", "}", "\n", "// This struct must be in sync with union bpf_attr's anonymous struct", "attr", ":=", "struct", "{", "info", "attrObjInfo", "\n", "}", "{", "info", ":", "attrInfo", ",", "}", "\n\n", "duration", ":=", "spanstat", ".", "Start", "(", ")", "\n", "ret", ",", "_", ",", "err", ":=", "unix", ".", "Syscall", "(", "unix", ".", "SYS_BPF", ",", "BPF_OBJ_GET_INFO_BY_FD", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "&", "attr", ")", ")", ",", "unsafe", ".", "Sizeof", "(", "attr", ")", ")", "\n", "metricSyscallDuration", ".", "WithLabelValues", "(", "metricOpObjGetInfoByFD", ",", "metrics", ".", "Errno2Outcome", "(", "err", ")", ")", ".", "Observe", "(", "duration", ".", "End", "(", "err", "==", "0", ")", ".", "Total", "(", ")", ".", "Seconds", "(", ")", ")", "\n", "if", "ret", "!=", "0", "||", "err", "!=", "0", "{", "return", "ProgInfo", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "GetProgInfoByFD", "gets", "the", "bpf", "program", "info", "from", "its", "file", "descriptor", "." ]

[ "func", "NewGetEndpoint", "(", "ctx", "*", "middleware", ".", "Context", ",", "handler", "GetEndpointHandler", ")", "*", "GetEndpoint", "{", "return", "&", "GetEndpoint", "{", "Context", ":", "ctx", ",", "Handler", ":", "handler", "}", "\n", "}" ]

[ "NewGetEndpoint", "creates", "a", "new", "http", ".", "Handler", "for", "the", "get", "endpoint", "operation" ]

[ "func", "DiffCIDRLists", "(", "old", ",", "new", "[", "]", "*", "CIDR", ")", "(", "add", ",", "remove", "[", "]", "*", "CIDR", ")", "{", "add", "=", "listMissingIPNets", "(", "createIPNetMap", "(", "old", ")", ",", "new", ")", "\n", "remove", "=", "listMissingIPNets", "(", "createIPNetMap", "(", "new", ")", ",", "old", ")", "\n", "return", "\n", "}" ]

[ "DiffCIDRLists", "compares", "an", "old", "and", "new", "list", "of", "CIDRs", "and", "returns", "the", "list", "of", "removed", "and", "added", "CIDRs" ]

[ "func", "NewAckingResourceMutatorWrapper", "(", "mutator", "ResourceMutator", ",", "nodeToID", "NodeToIDFunc", ")", "*", "AckingResourceMutatorWrapper", "{", "return", "&", "AckingResourceMutatorWrapper", "{", "mutator", ":", "mutator", ",", "nodeToID", ":", "nodeToID", ",", "pendingCompletions", ":", "make", "(", "map", "[", "*", "completion", ".", "Completion", "]", "*", "pendingCompletion", ")", ",", "}", "\n", "}" ]

[ "NewAckingResourceMutatorWrapper", "creates", "a", "new", "AckingResourceMutatorWrapper", "to", "wrap", "the", "given", "ResourceMutator", ".", "The", "given", "NodeToIDFunc", "is", "used", "to", "extract", "a", "string", "identifier", "from", "an", "Envoy", "Node", "identifier", "." ]

[ "func", "(", "m", "*", "AckingResourceMutatorWrapper", ")", "HandleResourceVersionAck", "(", "ackVersion", "uint64", ",", "nackVersion", "uint64", ",", "node", "*", "envoy_api_v2_core", ".", "Node", ",", "resourceNames", "[", "]", "string", ",", "typeURL", "string", ",", "detail", "string", ")", "{", "ackLog", ":=", "log", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "logfields", ".", "XDSVersionInfo", ":", "ackVersion", ",", "logfields", ".", "XDSNonce", ":", "nackVersion", ",", "logfields", ".", "XDSClientNode", ":", "node", ",", "logfields", ".", "XDSTypeURL", ":", "typeURL", ",", "}", ")", "\n\n", "nodeID", ",", "err", ":=", "m", ".", "nodeToID", "(", "node", ")", "\n", "if", "err", "!=", "nil", "{", "// Ignore ACKs from unknown or misconfigured nodes which have invalid", "// node identifiers.", "ackLog", ".", "WithError", "(", "err", ")", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n\n", "m", ".", "locker", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "locker", ".", "Unlock", "(", ")", "\n\n", "remainingCompletions", ":=", "make", "(", "map", "[", "*", "completion", ".", "Completion", "]", "*", "pendingCompletion", ",", "len", "(", "m", ".", "pendingCompletions", ")", ")", "\n\n", "for", "comp", ",", "pending", ":=", "range", "m", ".", "pendingCompletions", "{", "if", "comp", ".", "Err", "(", ")", "!=", "nil", "{", "// Completion was canceled or timed out.", "// Remove from pending list.", "ackLog", ".", "Debugf", "(", "\"", "\"", ",", "pending", ")", "\n", "continue", "\n", "}", "\n\n", "if", "pending", ".", "typeURL", "==", "typeURL", "{", "if", "pending", ".", "version", "<=", "nackVersion", "{", "// Get the set of resource names we are still waiting for the node", "// to ACK.", "remainingResourceNames", ",", "found", ":=", "pending", ".", "remainingNodesResources", "[", "nodeID", "]", "\n", "if", "found", "{", "for", "_", ",", "name", ":=", "range", "resourceNames", "{", "delete", "(", "remainingResourceNames", ",", "name", ")", "\n", "}", "\n", "if", "len", "(", "remainingResourceNames", ")", "==", "0", "{", "delete", "(", "pending", ".", "remainingNodesResources", ",", "nodeID", ")", "\n", "}", "\n", "if", "len", "(", "pending", ".", "remainingNodesResources", ")", "==", "0", "{", "// Completed. Notify and remove from pending list.", "if", "pending", ".", "version", "<=", "ackVersion", "{", "ackLog", ".", "Debugf", "(", "\"", "\"", ",", "pending", ")", "\n", "comp", ".", "Complete", "(", "nil", ")", "\n", "}", "else", "{", "ackLog", ".", "Debugf", "(", "\"", "\"", ",", "pending", ")", "\n", "comp", ".", "Complete", "(", "&", "ProxyError", "{", "Err", ":", "ErrNackReceived", ",", "Detail", ":", "detail", "}", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Completion didn't match or is still waiting for some ACKs. Keep it", "// in the pending list.", "remainingCompletions", "[", "comp", "]", "=", "pending", "\n", "}", "\n\n", "m", ".", "pendingCompletions", "=", "remainingCompletions", "\n", "}" ]

[ "ackVersion", "is", "the", "last", "version", "that", "was", "acked", ".", "nackVersion", "if", "greater", "than", "nackVersion", "is", "the", "last", "version", "that", "was", "NACKed", "." ]

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

[ "sort", "a", "slice", "of", "symbols", "by", "offset", "." ]

[ "func", "(", "h", "*", "APIPanicHandler", ")", "ServeHTTP", "(", "wr", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "defer", "func", "(", ")", "{", "if", "r", ":=", "recover", "(", ")", ";", "r", "!=", "nil", "{", "fields", ":=", "logrus", ".", "Fields", "{", "\"", "\"", ":", "r", ",", "\"", "\"", ":", "req", ".", "URL", ".", "String", "(", ")", ",", "\"", "\"", ":", "req", ".", "Method", ",", "\"", "\"", ":", "req", ".", "RemoteAddr", ",", "}", "\n", "log", ".", "WithFields", "(", "fields", ")", ".", "Warn", "(", "\"", "\"", ")", "\n", "if", "logging", ".", "DefaultLogger", ".", "IsLevelEnabled", "(", "logrus", ".", "DebugLevel", ")", "{", "os", ".", "Stdout", ".", "Write", "(", "debug", ".", "Stack", "(", ")", ")", "\n", "}", "\n", "wr", ".", "WriteHeader", "(", "http", ".", "StatusInternalServerError", ")", "\n", "if", "_", ",", "err", ":=", "wr", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ";", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "h", ".", "Next", ".", "ServeHTTP", "(", "wr", ",", "req", ")", "\n", "}" ]

[ "ServeHTTP", "implements", "the", "http", ".", "Handler", "interface", ".", "It", "recovers", "from", "panics", "of", "all", "next", "handlers", "and", "logs", "them" ]