Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "CreateTwoWayMergePatch", "(", "original", ",", "modified", "[", "]", "byte", ",", "dataStruct", "interface", "{", "}", ",", "fns", "...", "PreconditionFunc", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "originalMap", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "if", "len", "(", "original", ")", ">", "0", "{", "if", "err", ":=", "json", ".", "Unmarshal", "(", "original", ",", "&", "originalMap", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errBadJSONDoc", "\n", "}", "\n", "}", "\n\n", "modifiedMap", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "if", "len", "(", "modified", ")", ">", "0", "{", "if", "err", ":=", "json", ".", "Unmarshal", "(", "modified", ",", "&", "modifiedMap", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "errBadJSONDoc", "\n", "}", "\n", "}", "\n\n", "t", ",", "err", ":=", "getTagStructType", "(", "dataStruct", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "patchMap", ",", "err", ":=", "diffMaps", "(", "originalMap", ",", "modifiedMap", ",", "t", ",", "false", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Apply the preconditions to the patch, and return an error if any of them fail.", "for", "_", ",", "fn", ":=", "range", "fns", "{", "if", "!", "fn", "(", "patchMap", ")", "{", "return", "nil", ",", "newErrPreconditionFailed", "(", "patchMap", ")", "\n", "}", "\n", "}", "\n\n", "return", "json", ".", "Marshal", "(", "patchMap", ")", "\n", "}" ]

[ "CreateTwoWayMergePatch", "creates", "a", "patch", "that", "can", "be", "passed", "to", "StrategicMergePatch", "from", "an", "original", "document", "and", "a", "modified", "document", "which", "are", "passed", "to", "the", "method", "as", "json", "encoded", "content", ".", "It", "will", "return", "a", "patch", "that", "yields", "the", "modified", "document", "when", "applied", "to", "the", "original", "document", "or", "an", "error", "if", "either", "of", "the", "two", "documents", "is", "invalid", "." ]

[ "func", "HasConflicts", "(", "left", ",", "right", "interface", "{", "}", ")", "(", "bool", ",", "error", ")", "{", "switch", "typedLeft", ":=", "left", ".", "(", "type", ")", "{", "case", "map", "[", "string", "]", "interface", "{", "}", ":", "switch", "typedRight", ":=", "right", ".", "(", "type", ")", "{", "case", "map", "[", "string", "]", "interface", "{", "}", ":", "for", "key", ",", "leftValue", ":=", "range", "typedLeft", "{", "rightValue", ",", "ok", ":=", "typedRight", "[", "key", "]", "\n", "if", "!", "ok", "{", "return", "false", ",", "nil", "\n", "}", "\n", "return", "HasConflicts", "(", "leftValue", ",", "rightValue", ")", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "default", ":", "return", "true", ",", "nil", "\n", "}", "\n", "case", "[", "]", "interface", "{", "}", ":", "switch", "typedRight", ":=", "right", ".", "(", "type", ")", "{", "case", "[", "]", "interface", "{", "}", ":", "if", "len", "(", "typedLeft", ")", "!=", "len", "(", "typedRight", ")", "{", "return", "true", ",", "nil", "\n", "}", "\n\n", "for", "i", ":=", "range", "typedLeft", "{", "return", "HasConflicts", "(", "typedLeft", "[", "i", "]", ",", "typedRight", "[", "i", "]", ")", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "default", ":", "return", "true", ",", "nil", "\n", "}", "\n", "case", "string", ",", "float64", ",", "bool", ",", "int", ",", "int64", ",", "nil", ":", "return", "!", "reflect", ".", "DeepEqual", "(", "left", ",", "right", ")", ",", "nil", "\n", "default", ":", "return", "true", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "left", ")", ")", "\n", "}", "\n", "}" ]

[ "HasConflicts", "returns", "true", "if", "the", "left", "and", "right", "JSON", "interface", "objects", "overlap", "with", "different", "values", "in", "any", "key", ".", "All", "keys", "are", "required", "to", "be", "strings", ".", "Since", "patches", "of", "the", "same", "Type", "have", "congruent", "keys", "this", "is", "valid", "for", "multiple", "patch", "types", ".", "This", "method", "supports", "JSON", "merge", "patch", "semantics", "." ]

[ "func", "New", "(", "w", "io", ".", "Writer", ",", "n", "int64", ")", "io", ".", "Writer", "{", "return", "&", "limitWriter", "{", "w", ":", "w", ",", "n", ":", "n", ",", "}", "\n", "}" ]

[ "New", "creates", "a", "writer", "that", "is", "limited", "to", "writing", "at", "most", "n", "bytes", "to", "w", ".", "This", "writer", "is", "not", "thread", "safe", "." ]

[ "func", "(", "s", "*", "Session", ")", "SendRequest", "(", "name", "string", ",", "wantReply", "bool", ",", "payload", "[", "]", "byte", ")", "(", "bool", ",", "error", ")", "{", "return", "s", ".", "ch", ".", "SendRequest", "(", "name", ",", "wantReply", ",", "payload", ")", "\n", "}" ]

[ "SendRequest", "sends", "an", "out", "-", "of", "-", "band", "channel", "request", "on", "the", "SSH", "channel", "underlying", "the", "session", "." ]

[ "func", "(", "s", "*", "Session", ")", "Setenv", "(", "name", ",", "value", "string", ")", "error", "{", "msg", ":=", "setenvRequest", "{", "Name", ":", "name", ",", "Value", ":", "value", ",", "}", "\n", "ok", ",", "err", ":=", "s", ".", "ch", ".", "SendRequest", "(", "\"", "\"", ",", "true", ",", "Marshal", "(", "&", "msg", ")", ")", "\n", "if", "err", "==", "nil", "&&", "!", "ok", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Setenv", "sets", "an", "environment", "variable", "that", "will", "be", "applied", "to", "any", "command", "executed", "by", "Shell", "or", "Run", "." ]

[ "func", "(", "s", "*", "Session", ")", "RequestPty", "(", "term", "string", ",", "h", ",", "w", "int", ",", "termmodes", "TerminalModes", ")", "error", "{", "var", "tm", "[", "]", "byte", "\n", "for", "k", ",", "v", ":=", "range", "termmodes", "{", "kv", ":=", "struct", "{", "Key", "byte", "\n", "Val", "uint32", "\n", "}", "{", "k", ",", "v", "}", "\n\n", "tm", "=", "append", "(", "tm", ",", "Marshal", "(", "&", "kv", ")", "...", ")", "\n", "}", "\n", "tm", "=", "append", "(", "tm", ",", "tty_OP_END", ")", "\n", "req", ":=", "ptyRequestMsg", "{", "Term", ":", "term", ",", "Columns", ":", "uint32", "(", "w", ")", ",", "Rows", ":", "uint32", "(", "h", ")", ",", "Width", ":", "uint32", "(", "w", "*", "8", ")", ",", "Height", ":", "uint32", "(", "h", "*", "8", ")", ",", "Modelist", ":", "string", "(", "tm", ")", ",", "}", "\n", "ok", ",", "err", ":=", "s", ".", "ch", ".", "SendRequest", "(", "\"", "\"", ",", "true", ",", "Marshal", "(", "&", "req", ")", ")", "\n", "if", "err", "==", "nil", "&&", "!", "ok", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "RequestPty", "requests", "the", "association", "of", "a", "pty", "with", "the", "session", "on", "the", "remote", "host", "." ]

[ "func", "(", "s", "*", "Session", ")", "RequestSubsystem", "(", "subsystem", "string", ")", "error", "{", "msg", ":=", "subsystemRequestMsg", "{", "Subsystem", ":", "subsystem", ",", "}", "\n", "ok", ",", "err", ":=", "s", ".", "ch", ".", "SendRequest", "(", "\"", "\"", ",", "true", ",", "Marshal", "(", "&", "msg", ")", ")", "\n", "if", "err", "==", "nil", "&&", "!", "ok", "{", "err", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "RequestSubsystem", "requests", "the", "association", "of", "a", "subsystem", "with", "the", "session", "on", "the", "remote", "host", ".", "A", "subsystem", "is", "a", "predefined", "command", "that", "runs", "in", "the", "background", "when", "the", "ssh", "session", "is", "initiated" ]

[ "func", "(", "s", "*", "Session", ")", "Start", "(", "cmd", "string", ")", "error", "{", "if", "s", ".", "started", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "req", ":=", "execMsg", "{", "Command", ":", "cmd", ",", "}", "\n\n", "ok", ",", "err", ":=", "s", ".", "ch", ".", "SendRequest", "(", "\"", "\"", ",", "true", ",", "Marshal", "(", "&", "req", ")", ")", "\n", "if", "err", "==", "nil", "&&", "!", "ok", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cmd", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "s", ".", "start", "(", ")", "\n", "}" ]

[ "Start", "runs", "cmd", "on", "the", "remote", "host", ".", "Typically", "the", "remote", "server", "passes", "cmd", "to", "the", "shell", "for", "interpretation", ".", "A", "Session", "only", "accepts", "one", "call", "to", "Run", "Start", "or", "Shell", "." ]

[ "func", "(", "s", "*", "Session", ")", "Output", "(", "cmd", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "s", ".", "Stdout", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "b", "bytes", ".", "Buffer", "\n", "s", ".", "Stdout", "=", "&", "b", "\n", "err", ":=", "s", ".", "Run", "(", "cmd", ")", "\n", "return", "b", ".", "Bytes", "(", ")", ",", "err", "\n", "}" ]

[ "Output", "runs", "cmd", "on", "the", "remote", "host", "and", "returns", "its", "standard", "output", "." ]

[ "func", "(", "s", "*", "Session", ")", "CombinedOutput", "(", "cmd", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "s", ".", "Stdout", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "s", ".", "Stderr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "b", "singleWriter", "\n", "s", ".", "Stdout", "=", "&", "b", "\n", "s", ".", "Stderr", "=", "&", "b", "\n", "err", ":=", "s", ".", "Run", "(", "cmd", ")", "\n", "return", "b", ".", "b", ".", "Bytes", "(", ")", ",", "err", "\n", "}" ]

[ "CombinedOutput", "runs", "cmd", "on", "the", "remote", "host", "and", "returns", "its", "combined", "standard", "output", "and", "standard", "error", "." ]

[ "func", "(", "s", "*", "Session", ")", "Shell", "(", ")", "error", "{", "if", "s", ".", "started", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "ok", ",", "err", ":=", "s", ".", "ch", ".", "SendRequest", "(", "\"", "\"", ",", "true", ",", "nil", ")", "\n", "if", "err", "==", "nil", "&&", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "s", ".", "start", "(", ")", "\n", "}" ]

[ "Shell", "starts", "a", "login", "shell", "on", "the", "remote", "host", ".", "A", "Session", "only", "accepts", "one", "call", "to", "Run", "Start", "Shell", "Output", "or", "CombinedOutput", "." ]

[ "func", "(", "s", "*", "Session", ")", "StdinPipe", "(", ")", "(", "io", ".", "WriteCloser", ",", "error", ")", "{", "if", "s", ".", "Stdin", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "s", ".", "started", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "s", ".", "stdinpipe", "=", "true", "\n", "return", "&", "sessionStdin", "{", "s", ".", "ch", ",", "s", ".", "ch", "}", ",", "nil", "\n", "}" ]

[ "StdinPipe", "returns", "a", "pipe", "that", "will", "be", "connected", "to", "the", "remote", "command", "s", "standard", "input", "when", "the", "command", "starts", "." ]

[ "func", "(", "s", "*", "Session", ")", "StdoutPipe", "(", ")", "(", "io", ".", "Reader", ",", "error", ")", "{", "if", "s", ".", "Stdout", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "s", ".", "started", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "s", ".", "stdoutpipe", "=", "true", "\n", "return", "s", ".", "ch", ",", "nil", "\n", "}" ]

[ "StdoutPipe", "returns", "a", "pipe", "that", "will", "be", "connected", "to", "the", "remote", "command", "s", "standard", "output", "when", "the", "command", "starts", ".", "There", "is", "a", "fixed", "amount", "of", "buffering", "that", "is", "shared", "between", "stdout", "and", "stderr", "streams", ".", "If", "the", "StdoutPipe", "reader", "is", "not", "serviced", "fast", "enough", "it", "may", "eventually", "cause", "the", "remote", "command", "to", "block", "." ]

[ "func", "(", "s", "*", "Session", ")", "StderrPipe", "(", ")", "(", "io", ".", "Reader", ",", "error", ")", "{", "if", "s", ".", "Stderr", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "s", ".", "started", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "s", ".", "stderrpipe", "=", "true", "\n", "return", "s", ".", "ch", ".", "Stderr", "(", ")", ",", "nil", "\n", "}" ]

[ "StderrPipe", "returns", "a", "pipe", "that", "will", "be", "connected", "to", "the", "remote", "command", "s", "standard", "error", "when", "the", "command", "starts", ".", "There", "is", "a", "fixed", "amount", "of", "buffering", "that", "is", "shared", "between", "stdout", "and", "stderr", "streams", ".", "If", "the", "StderrPipe", "reader", "is", "not", "serviced", "fast", "enough", "it", "may", "eventually", "cause", "the", "remote", "command", "to", "block", "." ]

[ "func", "newSession", "(", "ch", "Channel", ",", "reqs", "<-", "chan", "*", "Request", ")", "(", "*", "Session", ",", "error", ")", "{", "s", ":=", "&", "Session", "{", "ch", ":", "ch", ",", "}", "\n", "s", ".", "exitStatus", "=", "make", "(", "chan", "error", ",", "1", ")", "\n", "go", "func", "(", ")", "{", "s", ".", "exitStatus", "<-", "s", ".", "wait", "(", "reqs", ")", "\n", "}", "(", ")", "\n\n", "return", "s", ",", "nil", "\n", "}" ]

[ "newSession", "returns", "a", "new", "interactive", "session", "on", "the", "remote", "host", "." ]

[ "func", "NewNotRegisteredErr", "(", "gvk", "unversioned", ".", "GroupVersionKind", ",", "t", "reflect", ".", "Type", ")", "error", "{", "return", "&", "notRegisteredErr", "{", "gvk", ":", "gvk", ",", "t", ":", "t", "}", "\n", "}" ]

[ "NewNotRegisteredErr", "is", "exposed", "for", "testing", "." ]

[ "func", "GetAffinityFromPodAnnotations", "(", "annotations", "map", "[", "string", "]", "string", ")", "(", "Affinity", ",", "error", ")", "{", "var", "affinity", "Affinity", "\n", "if", "len", "(", "annotations", ")", ">", "0", "&&", "annotations", "[", "AffinityAnnotationKey", "]", "!=", "\"", "\"", "{", "err", ":=", "json", ".", "Unmarshal", "(", "[", "]", "byte", "(", "annotations", "[", "AffinityAnnotationKey", "]", ")", ",", "&", "affinity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "affinity", ",", "err", "\n", "}", "\n", "}", "\n", "return", "affinity", ",", "nil", "\n", "}" ]

[ "GetAffinityFromPod", "gets", "the", "json", "serialized", "affinity", "data", "from", "Pod", ".", "Annotations", "and", "converts", "it", "to", "the", "Affinity", "type", "in", "api", "." ]

[ "func", "(", "f", "CodecFactory", ")", "CodecForVersions", "(", "serializer", "runtime", ".", "Serializer", ",", "encode", "[", "]", "unversioned", ".", "GroupVersion", ",", "decode", "[", "]", "unversioned", ".", "GroupVersion", ")", "runtime", ".", "Codec", "{", "return", "versioning", ".", "NewCodecForScheme", "(", "f", ".", "scheme", ",", "serializer", ",", "encode", ",", "decode", ")", "\n", "}" ]

[ "CodecFor", "creates", "a", "codec", "with", "the", "provided", "serializer", ".", "If", "an", "object", "is", "decoded", "and", "its", "group", "is", "not", "in", "the", "list", "it", "will", "default", "to", "runtime", ".", "APIVersionInternal", ".", "If", "encode", "is", "not", "specified", "for", "an", "object", "s", "group", "the", "object", "is", "not", "converted", ".", "If", "encode", "or", "decode", "are", "nil", "no", "conversion", "is", "performed", "." ]

[ "func", "(", "f", "CodecFactory", ")", "SerializerForMediaType", "(", "mediaType", "string", ",", "options", "map", "[", "string", "]", "string", ")", "(", "runtime", ".", "Serializer", ",", "bool", ")", "{", "for", "_", ",", "s", ":=", "range", "f", ".", "serializers", "{", "for", "_", ",", "accepted", ":=", "range", "s", ".", "AcceptContentTypes", "{", "if", "accepted", "==", "mediaType", "{", "if", "v", ",", "ok", ":=", "options", "[", "\"", "\"", "]", ";", "ok", "&&", "v", "==", "\"", "\"", "&&", "s", ".", "PrettySerializer", "!=", "nil", "{", "return", "s", ".", "PrettySerializer", ",", "true", "\n", "}", "\n", "return", "s", ".", "Serializer", ",", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "SerializerForMediaType", "returns", "a", "serializer", "that", "matches", "the", "provided", "RFC2046", "mediaType", "or", "false", "if", "no", "such", "serializer", "exists" ]

[ "func", "(", "f", "CodecFactory", ")", "SerializerForFileExtension", "(", "extension", "string", ")", "(", "runtime", ".", "Serializer", ",", "bool", ")", "{", "for", "_", ",", "s", ":=", "range", "f", ".", "serializers", "{", "for", "_", ",", "ext", ":=", "range", "s", ".", "FileExtensions", "{", "if", "extension", "==", "ext", "{", "return", "s", ".", "Serializer", ",", "true", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "SerializerForFileExtension", "returns", "a", "serializer", "for", "the", "provided", "extension", "or", "false", "if", "no", "serializer", "matches", "." ]

[ "func", "(", "c", "*", "requestContextMap", ")", "Update", "(", "req", "*", "http", ".", "Request", ",", "context", "Context", ")", "error", "{", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "_", ",", "ok", ":=", "c", ".", "contexts", "[", "req", "]", ";", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "// TODO: ensure the new context is a descendant of the existing one", "c", ".", "contexts", "[", "req", "]", "=", "context", "\n", "return", "nil", "\n", "}" ]

[ "Update", "maps", "the", "request", "to", "the", "given", "context", ".", "If", "no", "context", "was", "previously", "associated", "with", "the", "request", "an", "error", "is", "returned", "and", "the", "context", "is", "ignored", "." ]

[ "func", "(", "c", "*", "requestContextMap", ")", "init", "(", "req", "*", "http", ".", "Request", ",", "context", "Context", ")", "bool", "{", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "_", ",", "exists", ":=", "c", ".", "contexts", "[", "req", "]", ";", "exists", "{", "return", "false", "\n", "}", "\n", "c", ".", "contexts", "[", "req", "]", "=", "context", "\n", "return", "true", "\n", "}" ]

[ "init", "maps", "the", "request", "to", "the", "given", "context", "and", "returns", "true", "if", "there", "was", "no", "context", "associated", "with", "the", "request", "already", ".", "if", "a", "context", "was", "already", "associated", "with", "the", "request", "it", "ignores", "the", "given", "context", "and", "returns", "false", ".", "init", "is", "intentionally", "unexported", "to", "ensure", "that", "all", "init", "calls", "are", "paired", "with", "a", "remove", "after", "a", "request", "is", "handled" ]

[ "func", "(", "c", "*", "requestContextMap", ")", "remove", "(", "req", "*", "http", ".", "Request", ")", "{", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "delete", "(", "c", ".", "contexts", ",", "req", ")", "\n", "}" ]

[ "remove", "is", "intentionally", "unexported", "to", "ensure", "that", "the", "context", "is", "not", "removed", "until", "a", "request", "is", "handled" ]

[ "func", "NewRequestContextFilter", "(", "mapper", "RequestContextMapper", ",", "handler", "http", ".", "Handler", ")", "(", "http", ".", "Handler", ",", "error", ")", "{", "if", "mapper", ",", "ok", ":=", "mapper", ".", "(", "*", "requestContextMap", ")", ";", "ok", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "{", "if", "mapper", ".", "init", "(", "req", ",", "NewContext", "(", ")", ")", "{", "// If we were the ones to successfully initialize, pair with a remove", "defer", "mapper", ".", "remove", "(", "req", ")", "\n", "}", "\n", "handler", ".", "ServeHTTP", "(", "w", ",", "req", ")", "\n", "}", ")", ",", "nil", "\n", "}", "else", "{", "return", "handler", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "}" ]

[ "NewRequestContextFilter", "ensures", "there", "is", "a", "Context", "object", "associated", "with", "the", "request", "before", "calling", "the", "passed", "handler", ".", "After", "the", "passed", "handler", "runs", "the", "context", "is", "cleaned", "up", "." ]

[ "func", "IsEmpty", "(", "requestsToContexts", "RequestContextMapper", ")", "(", "bool", ",", "error", ")", "{", "if", "requestsToContexts", ",", "ok", ":=", "requestsToContexts", ".", "(", "*", "requestContextMap", ")", ";", "ok", "{", "return", "len", "(", "requestsToContexts", ".", "contexts", ")", "==", "0", ",", "nil", "\n", "}", "\n", "return", "true", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "IsEmpty", "returns", "true", "if", "there", "are", "no", "contexts", "registered", "or", "an", "error", "if", "it", "could", "not", "be", "determined", ".", "Intended", "for", "use", "by", "tests", "." ]

[ "func", "ByteSliceCopy", "(", "in", "*", "[", "]", "byte", ",", "out", "*", "[", "]", "byte", ",", "s", "Scope", ")", "error", "{", "*", "out", "=", "make", "(", "[", "]", "byte", ",", "len", "(", "*", "in", ")", ")", "\n", "copy", "(", "*", "out", ",", "*", "in", ")", "\n", "return", "nil", "\n", "}" ]

[ "ByteSliceCopy", "prevents", "recursing", "into", "every", "byte" ]

[ "func", "(", "c", "*", "Converter", ")", "RegisterGeneratedConversionFunc", "(", "conversionFunc", "interface", "{", "}", ")", "error", "{", "fv", ":=", "reflect", ".", "ValueOf", "(", "conversionFunc", ")", "\n", "ft", ":=", "fv", ".", "Type", "(", ")", "\n", "if", "err", ":=", "verifyConversionFunctionSignature", "(", "ft", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "generatedConversionFuncs", "[", "typePair", "{", "ft", ".", "In", "(", "0", ")", ".", "Elem", "(", ")", ",", "ft", ".", "In", "(", "1", ")", ".", "Elem", "(", ")", "}", "]", "=", "fv", "\n", "return", "nil", "\n", "}" ]

[ "Similar", "to", "RegisterConversionFunc", "but", "registers", "conversion", "function", "that", "were", "automatically", "generated", "." ]

[ "func", "(", "c", "*", "Converter", ")", "convert", "(", "sv", ",", "dv", "reflect", ".", "Value", ",", "scope", "*", "scope", ")", "error", "{", "dt", ",", "st", ":=", "dv", ".", "Type", "(", ")", ",", "sv", ".", "Type", "(", ")", "\n", "// Apply default values.", "if", "fv", ",", "ok", ":=", "c", ".", "defaultingFuncs", "[", "st", "]", ";", "ok", "{", "if", "c", ".", "Debug", "!=", "nil", "{", "c", ".", "Debug", ".", "Logf", "(", "\"", "\"", ",", "st", ")", "\n", "}", "\n", "args", ":=", "[", "]", "reflect", ".", "Value", "{", "sv", ".", "Addr", "(", ")", "}", "\n", "fv", ".", "Call", "(", "args", ")", "\n", "}", "\n\n", "// Convert sv to dv.", "if", "fv", ",", "ok", ":=", "c", ".", "conversionFuncs", "[", "typePair", "{", "st", ",", "dt", "}", "]", ";", "ok", "{", "if", "c", ".", "Debug", "!=", "nil", "{", "c", ".", "Debug", ".", "Logf", "(", "\"", "\"", ",", "st", ",", "dt", ")", "\n", "}", "\n", "return", "c", ".", "callCustom", "(", "sv", ",", "dv", ",", "fv", ",", "scope", ")", "\n", "}", "\n", "if", "fv", ",", "ok", ":=", "c", ".", "generatedConversionFuncs", "[", "typePair", "{", "st", ",", "dt", "}", "]", ";", "ok", "{", "if", "c", ".", "Debug", "!=", "nil", "{", "c", ".", "Debug", ".", "Logf", "(", "\"", "\"", ",", "st", ",", "dt", ")", "\n", "}", "\n", "return", "c", ".", "callCustom", "(", "sv", ",", "dv", ",", "fv", ",", "scope", ")", "\n", "}", "\n\n", "return", "c", ".", "defaultConvert", "(", "sv", ",", "dv", ",", "scope", ")", "\n", "}" ]

[ "convert", "recursively", "copies", "sv", "into", "dv", "calling", "an", "appropriate", "conversion", "function", "if", "one", "is", "registered", "." ]

[ "func", "(", "r", "*", "Request", ")", "LabelsSelectorParam", "(", "s", "labels", ".", "Selector", ")", "*", "Request", "{", "if", "r", ".", "err", "!=", "nil", "{", "return", "r", "\n", "}", "\n", "if", "s", "==", "nil", "{", "return", "r", "\n", "}", "\n", "if", "s", ".", "Empty", "(", ")", "{", "return", "r", "\n", "}", "\n", "return", "r", ".", "setParam", "(", "unversioned", ".", "LabelSelectorQueryParam", "(", "r", ".", "groupVersion", ".", "String", "(", ")", ")", ",", "s", ".", "String", "(", ")", ")", "\n", "}" ]

[ "LabelsSelectorParam", "adds", "the", "given", "selector", "as", "a", "query", "parameter" ]

[ "func", "(", "r", "Result", ")", "Get", "(", ")", "(", "runtime", ".", "Object", ",", "error", ")", "{", "if", "r", ".", "err", "!=", "nil", "{", "return", "nil", ",", "r", ".", "err", "\n", "}", "\n", "return", "r", ".", "codec", ".", "Decode", "(", "r", ".", "body", ")", "\n", "}" ]

[ "Get", "returns", "the", "result", "as", "an", "object", "." ]

[ "func", "(", "r", "Result", ")", "Into", "(", "obj", "runtime", ".", "Object", ")", "error", "{", "if", "r", ".", "err", "!=", "nil", "{", "return", "r", ".", "err", "\n", "}", "\n", "return", "r", ".", "codec", ".", "DecodeInto", "(", "r", ".", "body", ",", "obj", ")", "\n", "}" ]

[ "Into", "stores", "the", "result", "into", "obj", "if", "possible", "." ]

[ "func", "(", "q", "*", "Quantity", ")", "Neg", "(", "y", "Quantity", ")", "error", "{", "switch", "{", "case", "y", ".", "Amount", "==", "nil", ":", "*", "q", "=", "y", "\n", "case", "q", ".", "Amount", "==", "nil", ":", "q", ".", "Amount", "=", "&", "inf", ".", "Dec", "{", "}", "\n", "fallthrough", "\n", "default", ":", "q", ".", "Amount", ".", "Neg", "(", "y", ".", "Amount", ")", "\n", "q", ".", "Format", "=", "y", ".", "Format", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Neg", "sets", "q", "to", "the", "negative", "value", "of", "y", ".", "It", "updates", "the", "format", "of", "q", "to", "match", "y", "." ]

[ "func", "typeTag", "(", "structType", "reflect", ".", "Type", ")", "byte", "{", "var", "tag", "byte", "\n", "var", "tagStr", "string", "\n", "tagStr", "=", "structType", ".", "Field", "(", "0", ")", ".", "Tag", ".", "Get", "(", "\"", "\"", ")", "\n", "i", ",", "err", ":=", "strconv", ".", "Atoi", "(", "tagStr", ")", "\n", "if", "err", "==", "nil", "{", "tag", "=", "byte", "(", "i", ")", "\n", "}", "\n", "return", "tag", "\n", "}" ]

[ "typeTag", "returns", "the", "type", "byte", "for", "the", "given", "type", ".", "The", "type", "should", "be", "struct", "." ]

[ "func", "decode", "(", "packet", "[", "]", "byte", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "var", "msg", "interface", "{", "}", "\n", "switch", "packet", "[", "0", "]", "{", "case", "msgDisconnect", ":", "msg", "=", "new", "(", "disconnectMsg", ")", "\n", "case", "msgServiceRequest", ":", "msg", "=", "new", "(", "serviceRequestMsg", ")", "\n", "case", "msgServiceAccept", ":", "msg", "=", "new", "(", "serviceAcceptMsg", ")", "\n", "case", "msgKexInit", ":", "msg", "=", "new", "(", "kexInitMsg", ")", "\n", "case", "msgKexDHInit", ":", "msg", "=", "new", "(", "kexDHInitMsg", ")", "\n", "case", "msgKexDHReply", ":", "msg", "=", "new", "(", "kexDHReplyMsg", ")", "\n", "case", "msgUserAuthRequest", ":", "msg", "=", "new", "(", "userAuthRequestMsg", ")", "\n", "case", "msgUserAuthFailure", ":", "msg", "=", "new", "(", "userAuthFailureMsg", ")", "\n", "case", "msgUserAuthPubKeyOk", ":", "msg", "=", "new", "(", "userAuthPubKeyOkMsg", ")", "\n", "case", "msgGlobalRequest", ":", "msg", "=", "new", "(", "globalRequestMsg", ")", "\n", "case", "msgRequestSuccess", ":", "msg", "=", "new", "(", "globalRequestSuccessMsg", ")", "\n", "case", "msgRequestFailure", ":", "msg", "=", "new", "(", "globalRequestFailureMsg", ")", "\n", "case", "msgChannelOpen", ":", "msg", "=", "new", "(", "channelOpenMsg", ")", "\n", "case", "msgChannelOpenConfirm", ":", "msg", "=", "new", "(", "channelOpenConfirmMsg", ")", "\n", "case", "msgChannelOpenFailure", ":", "msg", "=", "new", "(", "channelOpenFailureMsg", ")", "\n", "case", "msgChannelWindowAdjust", ":", "msg", "=", "new", "(", "windowAdjustMsg", ")", "\n", "case", "msgChannelEOF", ":", "msg", "=", "new", "(", "channelEOFMsg", ")", "\n", "case", "msgChannelClose", ":", "msg", "=", "new", "(", "channelCloseMsg", ")", "\n", "case", "msgChannelRequest", ":", "msg", "=", "new", "(", "channelRequestMsg", ")", "\n", "case", "msgChannelSuccess", ":", "msg", "=", "new", "(", "channelRequestSuccessMsg", ")", "\n", "case", "msgChannelFailure", ":", "msg", "=", "new", "(", "channelRequestFailureMsg", ")", "\n", "default", ":", "return", "nil", ",", "unexpectedMessageError", "(", "0", ",", "packet", "[", "0", "]", ")", "\n", "}", "\n", "if", "err", ":=", "Unmarshal", "(", "packet", ",", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "msg", ",", "nil", "\n", "}" ]

[ "Decode", "a", "packet", "into", "its", "corresponding", "message", "." ]

[ "func", "NewLineDelimiter", "(", "output", "io", ".", "Writer", ",", "delimiter", "string", ")", "*", "LineDelimiter", "{", "return", "&", "LineDelimiter", "{", "output", ":", "output", ",", "delimiter", ":", "[", "]", "byte", "(", "delimiter", ")", "}", "\n", "}" ]

[ "NewLineDelimiter", "allocates", "a", "new", "io", ".", "Writer", "that", "will", "split", "input", "on", "lines", "and", "bracket", "each", "line", "with", "the", "delimiter", "string", ".", "This", "can", "be", "useful", "in", "output", "tests", "where", "it", "is", "difficult", "to", "see", "and", "test", "trailing", "whitespace", "." ]

[ "func", "(", "ld", "*", "LineDelimiter", ")", "Write", "(", "buf", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "ld", ".", "buf", ".", "Write", "(", "buf", ")", "\n", "}" ]

[ "Write", "writes", "buf", "to", "the", "LineDelimiter", "ld", ".", "The", "only", "errors", "returned", "are", "ones", "encountered", "while", "writing", "to", "the", "underlying", "output", "stream", "." ]

[ "func", "(", "ld", "*", "LineDelimiter", ")", "Flush", "(", ")", "(", "err", "error", ")", "{", "lines", ":=", "strings", ".", "Split", "(", "ld", ".", "buf", ".", "String", "(", ")", ",", "\"", "\\n", "\"", ")", "\n", "for", "_", ",", "line", ":=", "range", "lines", "{", "if", "_", ",", "err", "=", "ld", ".", "output", ".", "Write", "(", "ld", ".", "delimiter", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "_", ",", "err", "=", "ld", ".", "output", ".", "Write", "(", "[", "]", "byte", "(", "line", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "_", ",", "err", "=", "ld", ".", "output", ".", "Write", "(", "ld", ".", "delimiter", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "_", ",", "err", "=", "ld", ".", "output", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Flush", "all", "lines", "up", "until", "now", ".", "This", "will", "assume", "insert", "a", "linebreak", "at", "the", "current", "point", "of", "the", "stream", "." ]

[ "func", "NewEncodableList", "(", "e", "Encoder", ",", "objects", "[", "]", "Object", ",", "versions", "...", "unversioned", ".", "GroupVersion", ")", "[", "]", "Object", "{", "out", ":=", "make", "(", "[", "]", "Object", ",", "len", "(", "objects", ")", ")", "\n", "for", "i", ":=", "range", "objects", "{", "if", "_", ",", "ok", ":=", "objects", "[", "i", "]", ".", "(", "*", "Unknown", ")", ";", "ok", "{", "out", "[", "i", "]", "=", "objects", "[", "i", "]", "\n", "continue", "\n", "}", "\n", "out", "[", "i", "]", "=", "NewEncodable", "(", "e", ",", "objects", "[", "i", "]", ",", "versions", "...", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "NewEncodableList", "creates", "an", "object", "that", "will", "be", "encoded", "with", "the", "provided", "codec", "on", "demand", ".", "Provided", "as", "a", "convenience", "for", "test", "cases", "dealing", "with", "internal", "objects", "." ]

[ "func", "(", "ete", "TestTime", ")", "Add", "(", "testName", ",", "nodeName", ",", "Endtime", "string", ")", "{", "if", "_", ",", "ok", ":=", "ete", "[", "nodeName", "]", ";", "!", "ok", "{", "ete", "[", "nodeName", "]", "=", "make", "(", "map", "[", "string", "]", "time", ".", "Time", ")", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "ete", "[", "nodeName", "]", "[", "testName", "]", ";", "!", "ok", "{", "end", ",", "err", ":=", "time", ".", "Parse", "(", "testLogTimeFormat", ",", "Endtime", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "ete", "[", "nodeName", "]", "[", "testName", "]", "=", "end", "\n", "}", "\n", "}" ]

[ "Add", "adds", "one", "end", "time", "into", "TestTime", "." ]

[ "func", "(", "ete", "TestTime", ")", "Sort", "(", ")", "SortedTestTimePerNode", "{", "sortedTestTimePerNode", ":=", "make", "(", "SortedTestTimePerNode", ")", "\n", "for", "nodeName", ",", "testTimeMap", ":=", "range", "ete", "{", "sortedTestTime", ":=", "SortedTestTime", "{", "}", "\n", "for", "testName", ",", "endTime", ":=", "range", "testTimeMap", "{", "sortedTestTime", "=", "append", "(", "sortedTestTime", ",", "TestTimeRange", "{", "TestName", ":", "testName", ",", "EndTime", ":", "endTime", ",", "}", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "sortedTestTime", ")", "\n", "sortedTestTimePerNode", "[", "nodeName", "]", "=", "sortedTestTime", "\n", "}", "\n", "return", "sortedTestTimePerNode", "\n", "}" ]

[ "Sort", "sorts", "all", "end", "time", "of", "tests", "for", "each", "node", "and", "return", "a", "map", "of", "sorted", "array", "." ]

[ "func", "ParseKubeletLog", "(", "d", "Downloader", ",", "job", "string", ",", "buildNumber", "int", ",", "testTime", "TestTime", ")", "string", "{", "sortedTestTimePerNode", ":=", "testTime", ".", "Sort", "(", ")", "\n", "result", ":=", "\"", "\"", "\n", "for", "nodeName", ",", "sortedTestTime", ":=", "range", "sortedTestTimePerNode", "{", "result", "+=", "GrabTracingKubelet", "(", "d", ",", "job", ",", "buildNumber", ",", "nodeName", ",", "sortedTestTime", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "ParseKubeletLog", "calls", "GrabTracingKubelet", "to", "parse", "tracing", "data", "while", "using", "test", "end", "time", "from", "build", "-", "log", ".", "txt", "to", "separate", "tests", ".", "It", "returns", "the", "parsed", "tracing", "data", "as", "a", "string", "in", "time", "series", "data", "format", "." ]

[ "func", "GrabTracingKubelet", "(", "d", "Downloader", ",", "job", "string", ",", "buildNumber", "int", ",", "nodeName", "string", ",", "sortedTestTime", "SortedTestTime", ")", "string", "{", "// Return empty string if there is no test in list.", "if", "len", "(", "sortedTestTime", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n\n", "file", ",", "err", ":=", "d", ".", "GetFile", "(", "job", ",", "buildNumber", ",", "path", ".", "Join", "(", "\"", "\"", ",", "nodeName", ",", "kubeletLogFile", ")", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "defer", "file", ".", "Close", "(", ")", "\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "file", ")", "\n", "result", ":=", "\"", "\"", "\n", "currentTestIndex", ":=", "0", "\n", "testStarted", ":=", "false", "\n\n", "tracingData", ":=", "TracingData", "{", "Labels", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "sortedTestTime", "[", "currentTestIndex", "]", ".", "TestName", ",", "\"", "\"", ":", "nodeName", ",", "}", ",", "Data", ":", "map", "[", "string", "]", "int64arr", "{", "}", ",", "// Version is unspecified since this data will only be used", "// internally by parseTracingData().", "}", "\n", "statePerPod", ":=", "map", "[", "string", "]", "*", "PodState", "{", "}", "\n\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "if", "regexMapCadvisorLog", ".", "Match", "(", "[", "]", "byte", "(", "line", ")", ")", "{", "continue", "\n", "}", "\n", "// Found a tracing event in kubelet log.", "detectedEntry", ":=", "parseLogEntry", "(", "[", "]", "byte", "(", "line", ")", ",", "statePerPod", ")", "\n", "if", "detectedEntry", "!=", "nil", "{", "// Detect whether the log timestamp is out of current test time range.", "if", "sortedTestTime", "[", "currentTestIndex", "]", ".", "EndTime", ".", "Before", "(", "detectedEntry", ".", "Timestamp", ")", "{", "currentTestIndex", "++", "\n", "if", "currentTestIndex", ">=", "len", "(", "sortedTestTime", ")", "{", "break", "\n", "}", "\n", "tracingData", ".", "SortData", "(", ")", "\n", "result", "+=", "timeSeriesTag", "+", "tracingData", ".", "ToSeriesData", "(", ")", "+", "\"", "\\n", "\\n", "\"", "+", "timeSeriesEnd", "+", "\"", "\\n", "\"", "\n", "// Move on to the next test.", "tracingData", "=", "TracingData", "{", "Labels", ":", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "sortedTestTime", "[", "currentTestIndex", "]", ".", "TestName", ",", "\"", "\"", ":", "nodeName", ",", "}", ",", "Data", ":", "map", "[", "string", "]", "int64arr", "{", "}", ",", "// Version is unspecified since this data will only be used", "// internally by parseTracingData().", "}", "\n", "statePerPod", "=", "map", "[", "string", "]", "*", "PodState", "{", "}", "\n", "testStarted", "=", "false", "\n", "}", "\n", "if", "detectedEntry", ".", "Probe", "==", "probeFirstseen", "{", "testStarted", "=", "true", "\n", "}", "\n", "if", "testStarted", "==", "false", "{", "continue", "\n", "}", "\n", "tracingData", ".", "AppendData", "(", "detectedEntry", ".", "Probe", ",", "detectedEntry", ".", "Timestamp", ".", "UnixNano", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n\n", "tracingData", ".", "SortData", "(", ")", "\n", "return", "result", "+", "timeSeriesTag", "+", "tracingData", ".", "ToSeriesData", "(", ")", "+", "\"", "\\n", "\\n", "\"", "+", "timeSeriesEnd", "+", "\"", "\\n", "\"", "\n", "}" ]

[ "GrabTracingKubelet", "parse", "tracing", "data", "using", "kubelet", ".", "log", "." ]

[ "func", "parseLogEntry", "(", "line", "[", "]", "byte", ",", "statePerPod", "map", "[", "string", "]", "*", "PodState", ")", "*", "DetectedEntry", "{", "for", "probe", ",", "regex", ":=", "range", "regexMap", "{", "if", "regex", ".", "Match", "(", "line", ")", "{", "matchResult", ":=", "regex", ".", "FindSubmatch", "(", "line", ")", "\n", "if", "matchResult", "!=", "nil", "{", "ts", ",", "err", ":=", "time", ".", "Parse", "(", "kubeletLogTimeFormat", ",", "currentYear", "+", "\"", "\"", "+", "string", "(", "matchResult", "[", "1", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "\"", "\"", ")", "\n", "}", "\n", "switch", "probe", "{", "// 'container starts' reported by PLEG event.", "case", "probeContainerStartPLEG", ":", "{", "pod", ":=", "string", "(", "matchResult", "[", "2", "]", ")", "\n", "if", "_", ",", "ok", ":=", "statePerPod", "[", "pod", "]", ";", "!", "ok", "{", "statePerPod", "[", "pod", "]", "=", "&", "PodState", "{", "ContainerNrPLEG", ":", "1", "}", "\n", "}", "else", "{", "statePerPod", "[", "pod", "]", ".", "ContainerNrPLEG", "++", "\n", "}", "\n", "// In our test the pod contains an infra container and test container.", "switch", "statePerPod", "[", "pod", "]", ".", "ContainerNrPLEG", "{", "case", "1", ":", "probe", "=", "probeInfraContainerPLEG", "\n", "case", "2", ":", "probe", "=", "probeTestContainerPLEG", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}", "\n", "// 'container starts' detected by PLEG reported in Kublet SyncPod.", "case", "probeContainerStartPLEGSync", ":", "{", "pod", ":=", "string", "(", "matchResult", "[", "2", "]", ")", "\n", "if", "_", ",", "ok", ":=", "statePerPod", "[", "pod", "]", ";", "!", "ok", "{", "statePerPod", "[", "pod", "]", "=", "&", "PodState", "{", "ContainerNrPLEGSync", ":", "1", "}", "\n", "}", "else", "{", "statePerPod", "[", "pod", "]", ".", "ContainerNrPLEGSync", "++", "\n", "}", "\n", "// In our test the pod contains an infra container and test container.", "switch", "statePerPod", "[", "pod", "]", ".", "ContainerNrPLEGSync", "{", "case", "1", ":", "probe", "=", "probeInfraContainerPLEGSync", "\n", "case", "2", ":", "probe", "=", "probeTestContainerPLEGSync", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}", "\n", "// 'pod running' reported by Kubelet status manager.", "case", "probeStatusUpdate", ":", "{", "// We only trace the first status update event.", "pod", ":=", "string", "(", "matchResult", "[", "2", "]", ")", "\n", "if", "_", ",", "ok", ":=", "statePerPod", "[", "pod", "]", ";", "!", "ok", "{", "statePerPod", "[", "pod", "]", "=", "&", "PodState", "{", "}", "\n", "}", "\n", "if", "statePerPod", "[", "pod", "]", ".", "StatusUpdated", "{", "return", "nil", "\n", "}", "\n", "statePerPod", "[", "pod", "]", ".", "StatusUpdated", "=", "true", "\n", "}", "\n", "}", "\n", "return", "&", "DetectedEntry", "{", "Probe", ":", "probe", ",", "Timestamp", ":", "ts", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "parseLogEntry", "parses", "one", "line", "in", "Kubelet", "log", "." ]

[ "func", "(", "td", "*", "TracingData", ")", "AppendData", "(", "probe", "string", ",", "timestamp", "int64", ")", "{", "td", ".", "Data", "[", "probe", "]", "=", "append", "(", "td", ".", "Data", "[", "probe", "]", ",", "timestamp", ")", "\n", "}" ]

[ "AppendData", "adds", "a", "new", "tracing", "event", "into", "tracing", "data", "." ]

[ "func", "(", "td", "*", "TracingData", ")", "SortData", "(", ")", "{", "for", "_", ",", "arr", ":=", "range", "td", ".", "Data", "{", "sort", ".", "Sort", "(", "arr", ")", "\n", "}", "\n", "}" ]

[ "SortData", "sorts", "all", "time", "series", "data", "." ]

[ "func", "(", "td", "*", "TracingData", ")", "ToSeriesData", "(", ")", "string", "{", "seriesData", ",", "err", ":=", "json", ".", "Marshal", "(", "td", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "return", "string", "(", "seriesData", ")", "\n", "}" ]

[ "ToSeriesData", "returns", "stringified", "tracing", "data", "in", "JSON", "." ]

[ "func", "LoadFromFile", "(", "filename", "string", ")", "(", "*", "clientcmdapi", ".", "Config", ",", "error", ")", "{", "kubeconfigBytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "config", ",", "err", ":=", "Load", "(", "kubeconfigBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "glog", ".", "V", "(", "3", ")", ".", "Infoln", "(", "\"", "\"", ",", "filename", ")", "\n\n", "// set LocationOfOrigin on every Cluster, User, and Context", "for", "key", ",", "obj", ":=", "range", "config", ".", "AuthInfos", "{", "obj", ".", "LocationOfOrigin", "=", "filename", "\n", "config", ".", "AuthInfos", "[", "key", "]", "=", "obj", "\n", "}", "\n", "for", "key", ",", "obj", ":=", "range", "config", ".", "Clusters", "{", "obj", ".", "LocationOfOrigin", "=", "filename", "\n", "config", ".", "Clusters", "[", "key", "]", "=", "obj", "\n", "}", "\n", "for", "key", ",", "obj", ":=", "range", "config", ".", "Contexts", "{", "obj", ".", "LocationOfOrigin", "=", "filename", "\n", "config", ".", "Contexts", "[", "key", "]", "=", "obj", "\n", "}", "\n\n", "if", "config", ".", "AuthInfos", "==", "nil", "{", "config", ".", "AuthInfos", "=", "map", "[", "string", "]", "*", "clientcmdapi", ".", "AuthInfo", "{", "}", "\n", "}", "\n", "if", "config", ".", "Clusters", "==", "nil", "{", "config", ".", "Clusters", "=", "map", "[", "string", "]", "*", "clientcmdapi", ".", "Cluster", "{", "}", "\n", "}", "\n", "if", "config", ".", "Contexts", "==", "nil", "{", "config", ".", "Contexts", "=", "map", "[", "string", "]", "*", "clientcmdapi", ".", "Context", "{", "}", "\n", "}", "\n\n", "return", "config", ",", "nil", "\n", "}" ]

[ "LoadFromFile", "takes", "a", "filename", "and", "deserializes", "the", "contents", "into", "Config", "object" ]

[ "func", "(", "s", "*", "streamPacketCipher", ")", "readPacket", "(", "seqNum", "uint32", ",", "r", "io", ".", "Reader", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "r", ",", "s", ".", "prefix", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "s", ".", "cipher", ".", "XORKeyStream", "(", "s", ".", "prefix", "[", ":", "]", ",", "s", ".", "prefix", "[", ":", "]", ")", "\n", "length", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "s", ".", "prefix", "[", "0", ":", "4", "]", ")", "\n", "paddingLength", ":=", "uint32", "(", "s", ".", "prefix", "[", "4", "]", ")", "\n\n", "var", "macSize", "uint32", "\n", "if", "s", ".", "mac", "!=", "nil", "{", "s", ".", "mac", ".", "Reset", "(", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "s", ".", "seqNumBytes", "[", ":", "]", ",", "seqNum", ")", "\n", "s", ".", "mac", ".", "Write", "(", "s", ".", "seqNumBytes", "[", ":", "]", ")", "\n", "s", ".", "mac", ".", "Write", "(", "s", ".", "prefix", "[", ":", "]", ")", "\n", "macSize", "=", "uint32", "(", "s", ".", "mac", ".", "Size", "(", ")", ")", "\n", "}", "\n\n", "if", "length", "<=", "paddingLength", "+", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "length", ">", "maxPacket", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// the maxPacket check above ensures that length-1+macSize", "// does not overflow.", "if", "uint32", "(", "cap", "(", "s", ".", "packetData", ")", ")", "<", "length", "-", "1", "+", "macSize", "{", "s", ".", "packetData", "=", "make", "(", "[", "]", "byte", ",", "length", "-", "1", "+", "macSize", ")", "\n", "}", "else", "{", "s", ".", "packetData", "=", "s", ".", "packetData", "[", ":", "length", "-", "1", "+", "macSize", "]", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "r", ",", "s", ".", "packetData", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mac", ":=", "s", ".", "packetData", "[", "length", "-", "1", ":", "]", "\n", "data", ":=", "s", ".", "packetData", "[", ":", "length", "-", "1", "]", "\n", "s", ".", "cipher", ".", "XORKeyStream", "(", "data", ",", "data", ")", "\n\n", "if", "s", ".", "mac", "!=", "nil", "{", "s", ".", "mac", ".", "Write", "(", "data", ")", "\n", "s", ".", "macResult", "=", "s", ".", "mac", ".", "Sum", "(", "s", ".", "macResult", "[", ":", "0", "]", ")", "\n", "if", "subtle", ".", "ConstantTimeCompare", "(", "s", ".", "macResult", ",", "mac", ")", "!=", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "s", ".", "packetData", "[", ":", "length", "-", "paddingLength", "-", "1", "]", ",", "nil", "\n", "}" ]

[ "readPacket", "reads", "and", "decrypt", "a", "single", "packet", "from", "the", "reader", "argument", "." ]

[ "func", "(", "s", "*", "streamPacketCipher", ")", "writePacket", "(", "seqNum", "uint32", ",", "w", "io", ".", "Writer", ",", "rand", "io", ".", "Reader", ",", "packet", "[", "]", "byte", ")", "error", "{", "if", "len", "(", "packet", ")", ">", "maxPacket", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "paddingLength", ":=", "packetSizeMultiple", "-", "(", "prefixLen", "+", "len", "(", "packet", ")", ")", "%", "packetSizeMultiple", "\n", "if", "paddingLength", "<", "4", "{", "paddingLength", "+=", "packetSizeMultiple", "\n", "}", "\n\n", "length", ":=", "len", "(", "packet", ")", "+", "1", "+", "paddingLength", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "s", ".", "prefix", "[", ":", "]", ",", "uint32", "(", "length", ")", ")", "\n", "s", ".", "prefix", "[", "4", "]", "=", "byte", "(", "paddingLength", ")", "\n", "padding", ":=", "s", ".", "padding", "[", ":", "paddingLength", "]", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "rand", ",", "padding", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "s", ".", "mac", "!=", "nil", "{", "s", ".", "mac", ".", "Reset", "(", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "s", ".", "seqNumBytes", "[", ":", "]", ",", "seqNum", ")", "\n", "s", ".", "mac", ".", "Write", "(", "s", ".", "seqNumBytes", "[", ":", "]", ")", "\n", "s", ".", "mac", ".", "Write", "(", "s", ".", "prefix", "[", ":", "]", ")", "\n", "s", ".", "mac", ".", "Write", "(", "packet", ")", "\n", "s", ".", "mac", ".", "Write", "(", "padding", ")", "\n", "}", "\n\n", "s", ".", "cipher", ".", "XORKeyStream", "(", "s", ".", "prefix", "[", ":", "]", ",", "s", ".", "prefix", "[", ":", "]", ")", "\n", "s", ".", "cipher", ".", "XORKeyStream", "(", "packet", ",", "packet", ")", "\n", "s", ".", "cipher", ".", "XORKeyStream", "(", "padding", ",", "padding", ")", "\n\n", "if", "_", ",", "err", ":=", "w", ".", "Write", "(", "s", ".", "prefix", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "_", ",", "err", ":=", "w", ".", "Write", "(", "packet", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "_", ",", "err", ":=", "w", ".", "Write", "(", "padding", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "s", ".", "mac", "!=", "nil", "{", "s", ".", "macResult", "=", "s", ".", "mac", ".", "Sum", "(", "s", ".", "macResult", "[", ":", "0", "]", ")", "\n", "if", "_", ",", "err", ":=", "w", ".", "Write", "(", "s", ".", "macResult", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "writePacket", "encrypts", "and", "sends", "a", "packet", "of", "data", "to", "the", "writer", "argument" ]

[ "func", "NewParameterCodec", "(", "scheme", "*", "Scheme", ")", "ParameterCodec", "{", "return", "&", "parameterCodec", "{", "typer", ":", "ObjectTyperToTyper", "(", "scheme", ")", ",", "convertor", ":", "scheme", ",", "creator", ":", "scheme", ",", "}", "\n", "}" ]

[ "NewParameterCodec", "creates", "a", "ParameterCodec", "capable", "of", "transforming", "url", "values", "into", "versioned", "objects", "and", "back", "." ]

[ "func", "DiscardRequests", "(", "in", "<-", "chan", "*", "Request", ")", "{", "for", "req", ":=", "range", "in", "{", "if", "req", ".", "WantReply", "{", "req", ".", "Reply", "(", "false", ",", "nil", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "DiscardRequests", "consumes", "and", "rejects", "all", "requests", "from", "the", "passed", "-", "in", "channel", "." ]

[ "func", "(", "t", "*", "ThirdPartyController", ")", "SyncOneResource", "(", "rsrc", "*", "expapi", ".", "ThirdPartyResource", ")", "error", "{", "// TODO: we also need to test if the existing installed resource matches the resource we are sync-ing.", "// Currently, if there is an older, incompatible resource installed, we won't remove it. We should detect", "// older, incompatible resources and remove them before testing if the resource exists.", "hasResource", ",", "err", ":=", "t", ".", "master", ".", "HasThirdPartyResource", "(", "rsrc", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "hasResource", "{", "return", "t", ".", "master", ".", "InstallThirdPartyResource", "(", "rsrc", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Synchronize", "a", "single", "resource", "with", "RESTful", "resources", "on", "the", "master" ]

[ "func", "(", "t", "*", "ThirdPartyController", ")", "SyncResources", "(", ")", "error", "{", "list", ",", "err", ":=", "t", ".", "thirdPartyResourceRegistry", ".", "List", "(", "api", ".", "NewDefaultContext", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "t", ".", "syncResourceList", "(", "list", ")", "\n", "}" ]

[ "Synchronize", "all", "resources", "with", "RESTful", "resources", "on", "the", "master" ]

[ "func", "WarnWordSepNormalizeFunc", "(", "f", "*", "pflag", ".", "FlagSet", ",", "name", "string", ")", "pflag", ".", "NormalizedName", "{", "if", "strings", ".", "Contains", "(", "name", ",", "\"", "\"", ")", "{", "nname", ":=", "strings", ".", "Replace", "(", "name", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "glog", ".", "Warningf", "(", "\"", "\"", ",", "name", ",", "nname", ")", "\n\n", "return", "pflag", ".", "NormalizedName", "(", "nname", ")", "\n", "}", "\n", "return", "pflag", ".", "NormalizedName", "(", "name", ")", "\n", "}" ]

[ "WarnWordSepNormalizeFunc", "changes", "and", "warns", "for", "flags", "that", "contain", "_", "separators" ]

[ "func", "InitFlags", "(", ")", "{", "pflag", ".", "CommandLine", ".", "SetNormalizeFunc", "(", "WordSepNormalizeFunc", ")", "\n", "pflag", ".", "CommandLine", ".", "AddGoFlagSet", "(", "goflag", ".", "CommandLine", ")", "\n", "pflag", ".", "Parse", "(", ")", "\n", "}" ]

[ "InitFlags", "normalizes", "and", "parses", "the", "command", "line", "flags" ]

[ "func", "NewCertSigner", "(", "cert", "*", "Certificate", ",", "signer", "Signer", ")", "(", "Signer", ",", "error", ")", "{", "if", "bytes", ".", "Compare", "(", "cert", ".", "Key", ".", "Marshal", "(", ")", ",", "signer", ".", "PublicKey", "(", ")", ".", "Marshal", "(", ")", ")", "!=", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "openSSHCertSigner", "{", "cert", ",", "signer", "}", ",", "nil", "\n", "}" ]

[ "NewCertSigner", "returns", "a", "Signer", "that", "signs", "with", "the", "given", "Certificate", "whose", "private", "key", "is", "held", "by", "signer", ".", "It", "returns", "an", "error", "if", "the", "public", "key", "in", "cert", "doesn", "t", "match", "the", "key", "used", "by", "signer", "." ]

[ "func", "(", "c", "*", "CertChecker", ")", "CheckHostKey", "(", "addr", "string", ",", "remote", "net", ".", "Addr", ",", "key", "PublicKey", ")", "error", "{", "cert", ",", "ok", ":=", "key", ".", "(", "*", "Certificate", ")", "\n", "if", "!", "ok", "{", "if", "c", ".", "HostKeyFallback", "!=", "nil", "{", "return", "c", ".", "HostKeyFallback", "(", "addr", ",", "remote", ",", "key", ")", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cert", ".", "CertType", "!=", "HostCert", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cert", ".", "CertType", ")", "\n", "}", "\n\n", "return", "c", ".", "CheckCert", "(", "addr", ",", "cert", ")", "\n", "}" ]

[ "CheckHostKey", "checks", "a", "host", "key", "certificate", ".", "This", "method", "can", "be", "plugged", "into", "ClientConfig", ".", "HostKeyCallback", "." ]

[ "func", "(", "c", "*", "CertChecker", ")", "Authenticate", "(", "conn", "ConnMetadata", ",", "pubKey", "PublicKey", ")", "(", "*", "Permissions", ",", "error", ")", "{", "cert", ",", "ok", ":=", "pubKey", ".", "(", "*", "Certificate", ")", "\n", "if", "!", "ok", "{", "if", "c", ".", "UserKeyFallback", "!=", "nil", "{", "return", "c", ".", "UserKeyFallback", "(", "conn", ",", "pubKey", ")", "\n", "}", "\n", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "cert", ".", "CertType", "!=", "UserCert", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cert", ".", "CertType", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "CheckCert", "(", "conn", ".", "User", "(", ")", ",", "cert", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "cert", ".", "Permissions", ",", "nil", "\n", "}" ]

[ "Authenticate", "checks", "a", "user", "certificate", ".", "Authenticate", "can", "be", "used", "as", "a", "value", "for", "ServerConfig", ".", "PublicKeyCallback", "." ]

[ "func", "(", "c", "*", "Certificate", ")", "SignCert", "(", "rand", "io", ".", "Reader", ",", "authority", "Signer", ")", "error", "{", "c", ".", "Nonce", "=", "make", "(", "[", "]", "byte", ",", "32", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "rand", ",", "c", ".", "Nonce", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "SignatureKey", "=", "authority", ".", "PublicKey", "(", ")", "\n\n", "sig", ",", "err", ":=", "authority", ".", "Sign", "(", "rand", ",", "c", ".", "bytesForSigning", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "Signature", "=", "sig", "\n", "return", "nil", "\n", "}" ]

[ "SignCert", "sets", "c", ".", "SignatureKey", "to", "the", "authority", "s", "public", "key", "and", "stores", "a", "Signature", "by", "authority", "in", "the", "certificate", "." ]

[ "func", "certToPrivAlgo", "(", "algo", "string", ")", "string", "{", "for", "privAlgo", ",", "pubAlgo", ":=", "range", "certAlgoNames", "{", "if", "pubAlgo", "==", "algo", "{", "return", "privAlgo", "\n", "}", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "certToPrivAlgo", "returns", "the", "underlying", "algorithm", "for", "a", "certificate", "algorithm", ".", "Panics", "if", "a", "non", "-", "certificate", "algorithm", "is", "passed", "." ]

[ "func", "(", "c", "*", "Certificate", ")", "Marshal", "(", ")", "[", "]", "byte", "{", "generic", ":=", "genericCertData", "{", "Serial", ":", "c", ".", "Serial", ",", "CertType", ":", "c", ".", "CertType", ",", "KeyId", ":", "c", ".", "KeyId", ",", "ValidPrincipals", ":", "marshalStringList", "(", "c", ".", "ValidPrincipals", ")", ",", "ValidAfter", ":", "uint64", "(", "c", ".", "ValidAfter", ")", ",", "ValidBefore", ":", "uint64", "(", "c", ".", "ValidBefore", ")", ",", "CriticalOptions", ":", "marshalTuples", "(", "c", ".", "CriticalOptions", ")", ",", "Extensions", ":", "marshalTuples", "(", "c", ".", "Extensions", ")", ",", "Reserved", ":", "c", ".", "Reserved", ",", "SignatureKey", ":", "c", ".", "SignatureKey", ".", "Marshal", "(", ")", ",", "}", "\n", "if", "c", ".", "Signature", "!=", "nil", "{", "generic", ".", "Signature", "=", "Marshal", "(", "c", ".", "Signature", ")", "\n", "}", "\n", "genericBytes", ":=", "Marshal", "(", "&", "generic", ")", "\n", "keyBytes", ":=", "c", ".", "Key", ".", "Marshal", "(", ")", "\n", "_", ",", "keyBytes", ",", "_", "=", "parseString", "(", "keyBytes", ")", "\n", "prefix", ":=", "Marshal", "(", "&", "struct", "{", "Name", "string", "\n", "Nonce", "[", "]", "byte", "\n", "Key", "[", "]", "byte", "`ssh:\"rest\"`", "\n", "}", "{", "c", ".", "Type", "(", ")", ",", "c", ".", "Nonce", ",", "keyBytes", "}", ")", "\n\n", "result", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "prefix", ")", "+", "len", "(", "genericBytes", ")", ")", "\n", "result", "=", "append", "(", "result", ",", "prefix", "...", ")", "\n", "result", "=", "append", "(", "result", ",", "genericBytes", "...", ")", "\n", "return", "result", "\n", "}" ]

[ "Marshal", "serializes", "c", "into", "OpenSSH", "s", "wire", "format", ".", "It", "is", "part", "of", "the", "PublicKey", "interface", "." ]

[ "func", "(", "c", "*", "Certificate", ")", "Type", "(", ")", "string", "{", "algo", ",", "ok", ":=", "certAlgoNames", "[", "c", ".", "Key", ".", "Type", "(", ")", "]", "\n", "if", "!", "ok", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "algo", "\n", "}" ]

[ "Type", "returns", "the", "key", "name", ".", "It", "is", "part", "of", "the", "PublicKey", "interface", "." ]

[ "func", "(", "c", "*", "Certificate", ")", "Verify", "(", "data", "[", "]", "byte", ",", "sig", "*", "Signature", ")", "error", "{", "return", "c", ".", "Key", ".", "Verify", "(", "data", ",", "sig", ")", "\n", "}" ]

[ "Verify", "verifies", "a", "signature", "against", "the", "certificate", "s", "public", "key", ".", "It", "is", "part", "of", "the", "PublicKey", "interface", "." ]

[ "func", "ignoreReceives", "(", "ws", "*", "websocket", ".", "Conn", ",", "timeout", "time", ".", "Duration", ")", "{", "defer", "util", ".", "HandleCrash", "(", ")", "\n", "var", "data", "[", "]", "byte", "\n", "for", "{", "resetTimeout", "(", "ws", ",", "timeout", ")", "\n", "if", "err", ":=", "websocket", ".", "Message", ".", "Receive", "(", "ws", ",", "&", "data", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "ignoreReceives", "reads", "from", "a", "WebSocket", "until", "it", "is", "closed", "then", "returns", ".", "If", "timeout", "is", "set", "the", "read", "and", "write", "deadlines", "are", "pushed", "every", "time", "a", "new", "message", "is", "received", "." ]

[ "func", "(", "conn", "*", "Conn", ")", "handle", "(", "ws", "*", "websocket", ".", "Conn", ")", "{", "defer", "conn", ".", "Close", "(", ")", "\n", "conn", ".", "initialize", "(", "ws", ")", "\n\n", "for", "{", "conn", ".", "resetTimeout", "(", ")", "\n", "var", "data", "[", "]", "byte", "\n", "if", "err", ":=", "websocket", ".", "Message", ".", "Receive", "(", "ws", ",", "&", "data", ")", ";", "err", "!=", "nil", "{", "if", "err", "!=", "io", ".", "EOF", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "break", "\n", "}", "\n", "if", "len", "(", "data", ")", "==", "0", "{", "continue", "\n", "}", "\n", "channel", ":=", "data", "[", "0", "]", "\n", "if", "conn", ".", "codec", "==", "base64Codec", "{", "channel", "=", "channel", "-", "'0'", "\n", "}", "\n", "data", "=", "data", "[", "1", ":", "]", "\n", "if", "int", "(", "channel", ")", ">=", "len", "(", "conn", ".", "channels", ")", "{", "glog", ".", "V", "(", "6", ")", ".", "Infof", "(", "\"", "\"", ",", "channel", ")", "\n", "continue", "\n", "}", "\n", "if", "_", ",", "err", ":=", "conn", ".", "channels", "[", "channel", "]", ".", "DataFromSocket", "(", "data", ")", ";", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "channel", ",", "err", ",", "string", "(", "data", ")", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "}" ]

[ "handle", "implements", "a", "websocket", "handler", "." ]

[ "func", "getOverlappingControllers", "(", "c", "client", ".", "ReplicationControllerInterface", ",", "rc", "*", "api", ".", "ReplicationController", ")", "(", "[", "]", "api", ".", "ReplicationController", ",", "error", ")", "{", "rcs", ",", "err", ":=", "c", ".", "List", "(", "api", ".", "ListOptions", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "var", "matchingRCs", "[", "]", "api", ".", "ReplicationController", "\n", "rcLabels", ":=", "labels", ".", "Set", "(", "rc", ".", "Spec", ".", "Selector", ")", "\n", "for", "_", ",", "controller", ":=", "range", "rcs", ".", "Items", "{", "newRCLabels", ":=", "labels", ".", "Set", "(", "controller", ".", "Spec", ".", "Selector", ")", "\n", "if", "labels", ".", "SelectorFromSet", "(", "newRCLabels", ")", ".", "Matches", "(", "rcLabels", ")", "||", "labels", ".", "SelectorFromSet", "(", "rcLabels", ")", ".", "Matches", "(", "newRCLabels", ")", "{", "matchingRCs", "=", "append", "(", "matchingRCs", ",", "controller", ")", "\n", "}", "\n", "}", "\n", "return", "matchingRCs", ",", "nil", "\n", "}" ]

[ "getOverlappingControllers", "finds", "rcs", "that", "this", "controller", "overlaps", "as", "well", "as", "rcs", "overlapping", "this", "controller", "." ]

[ "func", "(", "c", "*", "Converter", ")", "IsConversionIgnored", "(", "inType", ",", "outType", "reflect", ".", "Type", ")", "bool", "{", "_", ",", "found", ":=", "c", ".", "ignoredConversions", "[", "typePair", "{", "inType", ",", "outType", "}", "]", "\n", "return", "found", "\n", "}" ]

[ "IsConversionIgnored", "returns", "true", "if", "the", "specified", "objects", "should", "be", "dropped", "during", "conversion", "." ]

[ "func", "NewDiscoveryClientForConfigOrDie", "(", "c", "*", "Config", ")", "*", "DiscoveryClient", "{", "client", ",", "err", ":=", "NewDiscoveryClientForConfig", "(", "c", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "client", "\n\n", "}" ]

[ "NewDiscoveryClientForConfig", "creates", "a", "new", "DiscoveryClient", "for", "the", "given", "config", ".", "If", "there", "is", "an", "error", "it", "panics", "." ]

[ "func", "handleDockercfgContent", "(", "username", ",", "password", ",", "email", ",", "server", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "dockercfgAuth", ":=", "credentialprovider", ".", "DockerConfigEntry", "{", "Username", ":", "username", ",", "Password", ":", "password", ",", "Email", ":", "email", ",", "}", "\n\n", "dockerCfg", ":=", "map", "[", "string", "]", "credentialprovider", ".", "DockerConfigEntry", "{", "server", ":", "dockercfgAuth", "}", "\n\n", "return", "json", ".", "Marshal", "(", "dockerCfg", ")", "\n", "}" ]

[ "handleDockercfgContent", "serializes", "a", "dockercfg", "json", "file" ]

[ "func", "NewBuilder", "(", "mapper", "meta", ".", "RESTMapper", ",", "typer", "runtime", ".", "ObjectTyper", ",", "clientMapper", "ClientMapper", ",", "decoder", "runtime", ".", "Decoder", ")", "*", "Builder", "{", "return", "&", "Builder", "{", "mapper", ":", "&", "Mapper", "{", "typer", ",", "mapper", ",", "clientMapper", ",", "decoder", "}", ",", "requireObject", ":", "true", ",", "}", "\n", "}" ]

[ "NewBuilder", "creates", "a", "builder", "that", "operates", "on", "generic", "objects", "." ]

[ "func", "(", "b", "*", "Builder", ")", "Selector", "(", "selector", "labels", ".", "Selector", ")", "*", "Builder", "{", "b", ".", "selector", "=", "selector", "\n", "return", "b", "\n", "}" ]

[ "Selector", "accepts", "a", "selector", "directly", "and", "if", "non", "nil", "will", "trigger", "a", "list", "action", "." ]

[ "func", "(", "b", "*", "Builder", ")", "replaceAliases", "(", "input", "string", ")", "string", "{", "replaced", ":=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "arg", ":=", "range", "strings", ".", "Split", "(", "input", ",", "\"", "\"", ")", "{", "if", "aliases", ",", "ok", ":=", "b", ".", "mapper", ".", "AliasesForResource", "(", "arg", ")", ";", "ok", "{", "arg", "=", "strings", ".", "Join", "(", "aliases", ",", "\"", "\"", ")", "\n", "}", "\n", "replaced", "=", "append", "(", "replaced", ",", "arg", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "replaced", ",", "\"", "\"", ")", "\n", "}" ]

[ "replaceAliases", "accepts", "an", "argument", "and", "tries", "to", "expand", "any", "existing", "aliases", "found", "in", "it" ]

[ "func", "RegisterGroup", "(", "groupMeta", "apimachinery", ".", "GroupMeta", ")", "error", "{", "groupName", ":=", "groupMeta", ".", "GroupVersion", ".", "Group", "\n", "if", "_", ",", "found", ":=", "groupMetaMap", "[", "groupName", "]", ";", "found", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "groupMetaMap", ")", "\n", "}", "\n", "groupMetaMap", "[", "groupName", "]", "=", "&", "groupMeta", "\n", "return", "nil", "\n", "}" ]

[ "RegisterGroup", "adds", "the", "given", "group", "to", "the", "list", "of", "registered", "groups", "." ]

[ "func", "EnableVersions", "(", "versions", "...", "unversioned", ".", "GroupVersion", ")", "error", "{", "var", "unregisteredVersions", "[", "]", "unversioned", ".", "GroupVersion", "\n", "for", "_", ",", "v", ":=", "range", "versions", "{", "if", "_", ",", "found", ":=", "registeredVersions", "[", "v", "]", ";", "!", "found", "{", "unregisteredVersions", "=", "append", "(", "unregisteredVersions", ",", "v", ")", "\n", "}", "\n", "enabledVersions", "[", "v", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "if", "len", "(", "unregisteredVersions", ")", "!=", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "unregisteredVersions", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "EnableVersions", "adds", "the", "versions", "for", "the", "given", "group", "to", "the", "list", "of", "enabled", "versions", ".", "Note", "that", "the", "caller", "should", "call", "RegisterGroup", "before", "calling", "this", "method", ".", "The", "caller", "of", "this", "function", "is", "responsible", "to", "add", "the", "versions", "to", "scheme", "and", "RESTMapper", "." ]

[ "func", "IsAllowedVersion", "(", "v", "unversioned", ".", "GroupVersion", ")", "bool", "{", "if", "len", "(", "envRequestedVersions", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "_", ",", "found", ":=", "envRequestedVersions", "[", "v", "]", "\n", "return", "found", "\n", "}" ]

[ "IsAllowedVersion", "returns", "if", "the", "version", "is", "allowed", "by", "the", "KUBE_API_VERSIONS", "environment", "variable", ".", "If", "the", "environment", "variable", "is", "empty", "then", "it", "always", "returns", "true", "." ]

[ "func", "IsEnabledVersion", "(", "v", "unversioned", ".", "GroupVersion", ")", "bool", "{", "_", ",", "found", ":=", "enabledVersions", "[", "v", "]", "\n", "return", "found", "\n", "}" ]

[ "IsEnabledVersion", "returns", "if", "a", "version", "is", "enabled", "." ]

[ "func", "EnabledVersions", "(", ")", "[", "]", "unversioned", ".", "GroupVersion", "{", "ret", ":=", "[", "]", "unversioned", ".", "GroupVersion", "{", "}", "\n", "for", "_", ",", "groupMeta", ":=", "range", "groupMetaMap", "{", "ret", "=", "append", "(", "ret", ",", "groupMeta", ".", "GroupVersions", "...", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "EnabledVersions", "returns", "all", "enabled", "versions", ".", "Groups", "are", "randomly", "ordered", "but", "versions", "within", "groups", "are", "priority", "order", "from", "best", "to", "worst" ]

[ "func", "EnabledVersionsForGroup", "(", "group", "string", ")", "[", "]", "unversioned", ".", "GroupVersion", "{", "groupMeta", ",", "ok", ":=", "groupMetaMap", "[", "group", "]", "\n", "if", "!", "ok", "{", "return", "[", "]", "unversioned", ".", "GroupVersion", "{", "}", "\n", "}", "\n\n", "return", "append", "(", "[", "]", "unversioned", ".", "GroupVersion", "{", "}", ",", "groupMeta", ".", "GroupVersions", "...", ")", "\n", "}" ]

[ "EnabledVersionsForGroup", "returns", "all", "enabled", "versions", "for", "a", "group", "in", "order", "of", "best", "to", "worst" ]

[ "func", "Group", "(", "group", "string", ")", "(", "*", "apimachinery", ".", "GroupMeta", ",", "error", ")", "{", "groupMeta", ",", "found", ":=", "groupMetaMap", "[", "group", "]", "\n", "if", "!", "found", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "group", ")", "\n", "}", "\n", "groupMetaCopy", ":=", "*", "groupMeta", "\n", "return", "&", "groupMetaCopy", ",", "nil", "\n", "}" ]

[ "Group", "returns", "the", "metadata", "of", "a", "group", "if", "the", "gruop", "is", "registered", "otherwise", "an", "erorr", "is", "returned", "." ]

[ "func", "ValidateEnvRequestedVersions", "(", ")", "[", "]", "unversioned", ".", "GroupVersion", "{", "var", "missingVersions", "[", "]", "unversioned", ".", "GroupVersion", "\n", "for", "v", ":=", "range", "envRequestedVersions", "{", "if", "_", ",", "found", ":=", "enabledVersions", "[", "v", "]", ";", "!", "found", "{", "missingVersions", "=", "append", "(", "missingVersions", ",", "v", ")", "\n", "}", "\n", "}", "\n", "return", "missingVersions", "\n", "}" ]

[ "ValidateEnvRequestedVersions", "returns", "a", "list", "of", "versions", "that", "are", "requested", "in", "the", "KUBE_API_VERSIONS", "environment", "variable", "but", "not", "enabled", "." ]

[ "func", "reset", "(", ")", "{", "registeredVersions", "=", "map", "[", "unversioned", ".", "GroupVersion", "]", "struct", "{", "}", "{", "}", "\n", "enabledVersions", "=", "map", "[", "unversioned", ".", "GroupVersion", "]", "struct", "{", "}", "{", "}", "\n", "groupMetaMap", "=", "map", "[", "string", "]", "*", "apimachinery", ".", "GroupMeta", "{", "}", "\n\n", "}" ]

[ "Resets", "the", "state", ".", "Should", "not", "be", "used", "by", "anyone", "else", "than", "tests", "." ]

[ "func", "(", "self", "*", "Scheme", ")", "fromScope", "(", "s", "conversion", ".", "Scope", ")", "(", "inVersion", ",", "outVersion", "string", ",", "scheme", "*", "Scheme", ")", "{", "scheme", "=", "self", "\n", "inVersion", "=", "s", ".", "Meta", "(", ")", ".", "SrcVersion", "\n", "outVersion", "=", "s", ".", "Meta", "(", ")", ".", "DestVersion", "\n", "return", "inVersion", ",", "outVersion", ",", "scheme", "\n", "}" ]

[ "fromScope", "gets", "the", "input", "version", "desired", "output", "version", "and", "desired", "Scheme", "from", "a", "conversion", ".", "Scope", "." ]

[ "func", "(", "self", "*", "Scheme", ")", "rawExtensionToRuntimeObjectArray", "(", "in", "*", "[", "]", "RawExtension", ",", "out", "*", "[", "]", "Object", ",", "s", "conversion", ".", "Scope", ")", "error", "{", "src", ":=", "*", "in", "\n", "dest", ":=", "make", "(", "[", "]", "Object", ",", "len", "(", "src", ")", ")", "\n\n", "_", ",", "_", ",", "scheme", ":=", "self", ".", "fromScope", "(", "s", ")", "\n\n", "for", "i", ":=", "range", "src", "{", "data", ":=", "src", "[", "i", "]", ".", "RawJSON", "\n", "dataKind", ",", "err", ":=", "scheme", ".", "raw", ".", "DataKind", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "dest", "[", "i", "]", "=", "&", "Unknown", "{", "TypeMeta", ":", "TypeMeta", "{", "APIVersion", ":", "dataKind", ".", "GroupVersion", "(", ")", ".", "String", "(", ")", ",", "Kind", ":", "dataKind", ".", "Kind", ",", "}", ",", "RawJSON", ":", "data", ",", "}", "\n", "}", "\n", "*", "out", "=", "dest", "\n", "return", "nil", "\n", "}" ]

[ "rawExtensionToRuntimeObjectArray", "attempts", "to", "decode", "objects", "from", "the", "array", "-", "if", "they", "are", "unrecognized", "objects", "they", "are", "added", "as", "Unknown", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "AddInternalGroupVersion", "(", "gv", "unversioned", ".", "GroupVersion", ")", "{", "s", ".", "raw", ".", "InternalVersions", "[", "gv", ".", "Group", "]", "=", "gv", "\n", "}" ]

[ "AddInternalGroupVersion", "registers", "an", "internal", "GroupVersion", "with", "the", "scheme", ".", "This", "can", "later", "be", "used", "to", "lookup", "the", "internal", "GroupVersion", "for", "a", "given", "Group" ]

[ "func", "(", "s", "*", "Scheme", ")", "KnownTypes", "(", "gv", "unversioned", ".", "GroupVersion", ")", "map", "[", "string", "]", "reflect", ".", "Type", "{", "return", "s", ".", "raw", ".", "KnownTypes", "(", "gv", ")", "\n", "}" ]

[ "KnownTypes", "returns", "the", "types", "known", "for", "the", "given", "version", ".", "Return", "value", "must", "be", "treated", "as", "read", "-", "only", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "ObjectKind", "(", "obj", "Object", ")", "(", "unversioned", ".", "GroupVersionKind", ",", "error", ")", "{", "return", "s", ".", "raw", ".", "ObjectKind", "(", "obj", ")", "\n", "}" ]

[ "ObjectKind", "returns", "the", "default", "group", "version", "kind", "of", "the", "given", "Object", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "New", "(", "kind", "unversioned", ".", "GroupVersionKind", ")", "(", "Object", ",", "error", ")", "{", "obj", ",", "err", ":=", "s", ".", "raw", ".", "NewObject", "(", "kind", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "obj", ".", "(", "Object", ")", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "API", "object", "of", "the", "given", "kind", "or", "an", "error", "if", "it", "hasn", "t", "been", "registered", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "AddStructFieldConversion", "(", "srcFieldType", "interface", "{", "}", ",", "srcFieldName", "string", ",", "destFieldType", "interface", "{", "}", ",", "destFieldName", "string", ")", "error", "{", "return", "s", ".", "raw", ".", "AddStructFieldConversion", "(", "srcFieldType", ",", "srcFieldName", ",", "destFieldType", ",", "destFieldName", ")", "\n", "}" ]

[ "AddStructFieldConversion", "allows", "you", "to", "specify", "a", "mechanical", "copy", "for", "a", "moved", "or", "renamed", "struct", "field", "without", "writing", "an", "entire", "conversion", "function", ".", "See", "the", "comment", "in", "conversion", ".", "Converter", ".", "SetStructFieldCopy", "for", "parameter", "details", ".", "Call", "as", "many", "times", "as", "needed", "even", "on", "the", "same", "fields", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "Convert", "(", "in", ",", "out", "interface", "{", "}", ")", "error", "{", "return", "s", ".", "raw", ".", "Convert", "(", "in", ",", "out", ")", "\n", "}" ]

[ "Convert", "will", "attempt", "to", "convert", "in", "into", "out", ".", "Both", "must", "be", "pointers", ".", "For", "easy", "testing", "of", "conversion", "functions", ".", "Returns", "an", "error", "if", "the", "conversion", "isn", "t", "possible", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "DecodeIntoWithSpecifiedVersionKind", "(", "data", "[", "]", "byte", ",", "obj", "Object", ",", "gvk", "unversioned", ".", "GroupVersionKind", ")", "error", "{", "return", "s", ".", "raw", ".", "DecodeIntoWithSpecifiedVersionKind", "(", "data", ",", "obj", ",", "gvk", ")", "\n", "}" ]

[ "DecodeIntoWithSpecifiedVersionKind", "coerces", "the", "data", "into", "the", "obj", "assuming", "that", "the", "data", "is", "of", "type", "GroupVersionKind" ]

[ "func", "(", "e", "*", "ErrorStats", ")", "rate", "(", "l", "string", ")", "float64", "{", "if", "e", ".", "total", "[", "l", "]", "==", "0", "{", "return", "0.0", "\n", "}", "\n", "return", "float64", "(", "e", ".", "enum", "[", "l", "]", ")", "/", "float64", "(", "e", ".", "total", "[", "l", "]", ")", "\n", "}" ]

[ "rate", "should", "be", "used", "with", "lock", "protection" ]

[ "func", "(", "r", "*", "Request", ")", "Reply", "(", "ok", "bool", ",", "payload", "[", "]", "byte", ")", "error", "{", "if", "!", "r", ".", "WantReply", "{", "return", "nil", "\n", "}", "\n\n", "if", "r", ".", "ch", "==", "nil", "{", "return", "r", ".", "mux", ".", "ackRequest", "(", "ok", ",", "payload", ")", "\n", "}", "\n\n", "return", "r", ".", "ch", ".", "ackRequest", "(", "ok", ")", "\n", "}" ]

[ "Reply", "sends", "a", "response", "to", "a", "request", ".", "It", "must", "be", "called", "for", "all", "requests", "where", "WantReply", "is", "true", "and", "is", "a", "no", "-", "op", "otherwise", ".", "The", "payload", "argument", "is", "ignored", "for", "replies", "to", "channel", "-", "specific", "requests", "." ]

[ "func", "(", "r", "RejectionReason", ")", "String", "(", ")", "string", "{", "switch", "r", "{", "case", "Prohibited", ":", "return", "\"", "\"", "\n", "case", "ConnectionFailed", ":", "return", "\"", "\"", "\n", "case", "UnknownChannelType", ":", "return", "\"", "\"", "\n", "case", "ResourceShortage", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "int", "(", "r", ")", ")", "\n", "}" ]

[ "String", "converts", "the", "rejection", "reason", "to", "human", "readable", "form", "." ]

[ "func", "(", "c", "*", "channel", ")", "writePacket", "(", "packet", "[", "]", "byte", ")", "error", "{", "c", ".", "writeMu", ".", "Lock", "(", ")", "\n", "if", "c", ".", "sentClose", "{", "c", ".", "writeMu", ".", "Unlock", "(", ")", "\n", "return", "io", ".", "EOF", "\n", "}", "\n", "c", ".", "sentClose", "=", "(", "packet", "[", "0", "]", "==", "msgChannelClose", ")", "\n", "err", ":=", "c", ".", "mux", ".", "conn", ".", "writePacket", "(", "packet", ")", "\n", "c", ".", "writeMu", ".", "Unlock", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "writePacket", "sends", "a", "packet", ".", "If", "the", "packet", "is", "a", "channel", "close", "it", "updates", "sentClose", ".", "This", "method", "takes", "the", "lock", "c", ".", "writeMu", "." ]

[ "func", "(", "c", "*", "channel", ")", "WriteExtended", "(", "data", "[", "]", "byte", ",", "extendedCode", "uint32", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "c", ".", "sentEOF", "{", "return", "0", ",", "io", ".", "EOF", "\n", "}", "\n", "// 1 byte message type, 4 bytes remoteId, 4 bytes data length", "opCode", ":=", "byte", "(", "msgChannelData", ")", "\n", "headerLength", ":=", "uint32", "(", "9", ")", "\n", "if", "extendedCode", ">", "0", "{", "headerLength", "+=", "4", "\n", "opCode", "=", "msgChannelExtendedData", "\n", "}", "\n\n", "c", ".", "writeMu", ".", "Lock", "(", ")", "\n", "packet", ":=", "c", ".", "packetPool", "[", "extendedCode", "]", "\n", "// We don't remove the buffer from packetPool, so", "// WriteExtended calls from different goroutines will be", "// flagged as errors by the race detector.", "c", ".", "writeMu", ".", "Unlock", "(", ")", "\n\n", "for", "len", "(", "data", ")", ">", "0", "{", "space", ":=", "min", "(", "c", ".", "maxRemotePayload", ",", "len", "(", "data", ")", ")", "\n", "if", "space", ",", "err", "=", "c", ".", "remoteWin", ".", "reserve", "(", "space", ")", ";", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n", "if", "want", ":=", "headerLength", "+", "space", ";", "uint32", "(", "cap", "(", "packet", ")", ")", "<", "want", "{", "packet", "=", "make", "(", "[", "]", "byte", ",", "want", ")", "\n", "}", "else", "{", "packet", "=", "packet", "[", ":", "want", "]", "\n", "}", "\n\n", "todo", ":=", "data", "[", ":", "space", "]", "\n\n", "packet", "[", "0", "]", "=", "opCode", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "packet", "[", "1", ":", "]", ",", "c", ".", "remoteId", ")", "\n", "if", "extendedCode", ">", "0", "{", "binary", ".", "BigEndian", ".", "PutUint32", "(", "packet", "[", "5", ":", "]", ",", "uint32", "(", "extendedCode", ")", ")", "\n", "}", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "packet", "[", "headerLength", "-", "4", ":", "]", ",", "uint32", "(", "len", "(", "todo", ")", ")", ")", "\n", "copy", "(", "packet", "[", "headerLength", ":", "]", ",", "todo", ")", "\n", "if", "err", "=", "c", ".", "writePacket", "(", "packet", ")", ";", "err", "!=", "nil", "{", "return", "n", ",", "err", "\n", "}", "\n\n", "n", "+=", "len", "(", "todo", ")", "\n", "data", "=", "data", "[", "len", "(", "todo", ")", ":", "]", "\n", "}", "\n\n", "c", ".", "writeMu", ".", "Lock", "(", ")", "\n", "c", ".", "packetPool", "[", "extendedCode", "]", "=", "packet", "\n", "c", ".", "writeMu", ".", "Unlock", "(", ")", "\n\n", "return", "n", ",", "err", "\n", "}" ]

[ "WriteExtended", "writes", "data", "to", "a", "specific", "extended", "stream", ".", "These", "streams", "are", "used", "for", "example", "for", "stderr", "." ]

[ "func", "(", "c", "*", "channel", ")", "responseMessageReceived", "(", ")", "error", "{", "if", "c", ".", "direction", "==", "channelInbound", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "decided", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "c", ".", "decided", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "responseMessageReceived", "is", "called", "when", "a", "success", "or", "failure", "message", "is", "received", "on", "a", "channel", "to", "check", "that", "such", "a", "message", "is", "reasonable", "for", "the", "given", "channel", "." ]

[ "func", "(", "ch", "*", "channel", ")", "Extended", "(", "code", "uint32", ")", "io", ".", "ReadWriter", "{", "if", "!", "ch", ".", "decided", "{", "return", "nil", "\n", "}", "\n", "return", "&", "extChannel", "{", "code", ",", "ch", "}", "\n", "}" ]

[ "Extended", "returns", "an", "io", ".", "ReadWriter", "that", "sends", "and", "receives", "data", "on", "the", "given", "SSH", "extended", "stream", ".", "Such", "streams", "are", "used", "for", "example", "for", "stderr", "." ]

[ "func", "(", "ch", "*", "channel", ")", "ackRequest", "(", "ok", "bool", ")", "error", "{", "if", "!", "ch", ".", "decided", "{", "return", "errUndecided", "\n", "}", "\n\n", "var", "msg", "interface", "{", "}", "\n", "if", "!", "ok", "{", "msg", "=", "channelRequestFailureMsg", "{", "PeersId", ":", "ch", ".", "remoteId", ",", "}", "\n", "}", "else", "{", "msg", "=", "channelRequestSuccessMsg", "{", "PeersId", ":", "ch", ".", "remoteId", ",", "}", "\n", "}", "\n", "return", "ch", ".", "sendMessage", "(", "msg", ")", "\n", "}" ]

[ "ackRequest", "either", "sends", "an", "ack", "or", "nack", "to", "the", "channel", "request", "." ]

[ "func", "(", "c", "*", "pubKeyCache", ")", "add", "(", "candidate", "cachedPubKey", ")", "{", "if", "len", "(", "c", ".", "keys", ")", "<", "maxCachedPubKeys", "{", "c", ".", "keys", "=", "append", "(", "c", ".", "keys", ",", "candidate", ")", "\n", "}", "\n", "}" ]

[ "add", "adds", "the", "given", "tuple", "to", "the", "cache", "." ]

[ "func", "NewServerConn", "(", "c", "net", ".", "Conn", ",", "config", "*", "ServerConfig", ")", "(", "*", "ServerConn", ",", "<-", "chan", "NewChannel", ",", "<-", "chan", "*", "Request", ",", "error", ")", "{", "fullConf", ":=", "*", "config", "\n", "fullConf", ".", "SetDefaults", "(", ")", "\n", "s", ":=", "&", "connection", "{", "sshConn", ":", "sshConn", "{", "conn", ":", "c", "}", ",", "}", "\n", "perms", ",", "err", ":=", "s", ".", "serverHandshake", "(", "&", "fullConf", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "Close", "(", ")", "\n", "return", "nil", ",", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "&", "ServerConn", "{", "s", ",", "perms", "}", ",", "s", ".", "mux", ".", "incomingChannels", ",", "s", ".", "mux", ".", "incomingRequests", ",", "nil", "\n", "}" ]

[ "NewServerConn", "starts", "a", "new", "SSH", "server", "with", "c", "as", "the", "underlying", "transport", ".", "It", "starts", "with", "a", "handshake", "and", "if", "the", "handshake", "is", "unsuccessful", "it", "closes", "the", "connection", "and", "returns", "an", "error", ".", "The", "Request", "and", "NewChannel", "channels", "must", "be", "serviced", "or", "the", "connection", "will", "hang", "." ]