Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "t", "*", "TestTLSServer", ")", "CertPool", "(", ")", "(", "*", "x509", ".", "CertPool", ",", "error", ")", "{", "tlsConfig", ",", "err", ":=", "t", ".", "Identity", ".", "TLSConfig", "(", "t", ".", "AuthServer", ".", "CipherSuites", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "tlsConfig", ".", "RootCAs", ",", "nil", "\n", "}" ]

[ "CertPool", "returns", "cert", "pool", "that", "auth", "server", "represents" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "ClientTLSConfig", "(", "identity", "TestIdentity", ")", "(", "*", "tls", ".", "Config", ",", "error", ")", "{", "tlsConfig", ",", "err", ":=", "t", ".", "Identity", ".", "TLSConfig", "(", "t", ".", "AuthServer", ".", "CipherSuites", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "identity", ".", "I", "!=", "nil", "{", "cert", ",", "err", ":=", "t", ".", "AuthServer", ".", "NewCertificate", "(", "identity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsConfig", ".", "Certificates", "=", "[", "]", "tls", ".", "Certificate", "{", "*", "cert", "}", "\n", "}", "else", "{", "// this client is not authenticated, which means that auth", "// server should apply Nop builtin role", "tlsConfig", ".", "Certificates", "=", "nil", "\n", "}", "\n", "return", "tlsConfig", ",", "nil", "\n", "}" ]

[ "ClientTLSConfig", "returns", "client", "TLS", "config", "based", "on", "the", "identity" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "CloneClient", "(", "clt", "*", "Client", ")", "*", "Client", "{", "addr", ":=", "[", "]", "utils", ".", "NetAddr", "{", "{", "Addr", ":", "t", ".", "Addr", "(", ")", ".", "String", "(", ")", ",", "AddrNetwork", ":", "t", ".", "Addr", "(", ")", ".", "Network", "(", ")", "}", "}", "\n", "newClient", ",", "err", ":=", "NewTLSClient", "(", "ClientConfig", "{", "Addrs", ":", "addr", ",", "TLS", ":", "clt", ".", "TLSConfig", "(", ")", "}", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "newClient", "\n", "}" ]

[ "CloneClient", "uses", "the", "same", "credentials", "as", "the", "passed", "client", "but", "forces", "the", "client", "to", "be", "recreated" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "NewClient", "(", "identity", "TestIdentity", ")", "(", "*", "Client", ",", "error", ")", "{", "tlsConfig", ",", "err", ":=", "t", ".", "ClientTLSConfig", "(", "identity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "addrs", ":=", "[", "]", "utils", ".", "NetAddr", "{", "utils", ".", "FromAddr", "(", "t", ".", "Listener", ".", "Addr", "(", ")", ")", "}", "\n", "return", "NewTLSClient", "(", "ClientConfig", "{", "Addrs", ":", "addrs", ",", "TLS", ":", "tlsConfig", "}", ")", "\n", "}" ]

[ "NewClient", "returns", "new", "client", "to", "test", "server", "authenticated", "with", "identity" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "Start", "(", ")", "error", "{", "var", "err", "error", "\n", "if", "t", ".", "Listener", "==", "nil", "{", "t", ".", "Listener", ",", "err", "=", "net", ".", "Listen", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "go", "t", ".", "TLSServer", ".", "Serve", "(", "t", ".", "Listener", ")", "\n", "return", "nil", "\n", "}" ]

[ "Start", "starts", "TLS", "server", "on", "loopback", "address", "on", "the", "first", "lisenting", "socket" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "Close", "(", ")", "error", "{", "err", ":=", "t", ".", "TLSServer", ".", "Close", "(", ")", "\n", "if", "t", ".", "Listener", "!=", "nil", "{", "t", ".", "Listener", ".", "Close", "(", ")", "\n", "}", "\n", "if", "t", ".", "AuthServer", ".", "Backend", "!=", "nil", "{", "t", ".", "AuthServer", ".", "Backend", ".", "Close", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Close", "closes", "the", "listener", "and", "HTTP", "server" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "Stop", "(", ")", "error", "{", "err", ":=", "t", ".", "TLSServer", ".", "Close", "(", ")", "\n", "if", "t", ".", "Listener", "!=", "nil", "{", "t", ".", "Listener", ".", "Close", "(", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "Stop", "stops", "listening", "server", "but", "does", "not", "close", "the", "auth", "backend" ]

[ "func", "NewServerIdentity", "(", "clt", "*", "AuthServer", ",", "hostID", "string", ",", "role", "teleport", ".", "Role", ")", "(", "*", "Identity", ",", "error", ")", "{", "keys", ",", "err", ":=", "clt", ".", "GenerateServerKeys", "(", "GenerateServerKeysRequest", "{", "HostID", ":", "hostID", ",", "NodeName", ":", "hostID", ",", "Roles", ":", "teleport", ".", "Roles", "{", "teleport", ".", "RoleAuth", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "ReadIdentityFromKeyPair", "(", "keys", ")", "\n", "}" ]

[ "NewServerIdentity", "generates", "new", "server", "identity", "used", "in", "tests" ]

[ "func", "CreateUserAndRole", "(", "clt", "clt", ",", "username", "string", ",", "allowedLogins", "[", "]", "string", ")", "(", "services", ".", "User", ",", "services", ".", "Role", ",", "error", ")", "{", "user", ",", "err", ":=", "services", ".", "NewUser", "(", "username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "role", ":=", "services", ".", "RoleForUser", "(", "user", ")", "\n", "role", ".", "SetLogins", "(", "services", ".", "Allow", ",", "[", "]", "string", "{", "user", ".", "GetName", "(", ")", "}", ")", "\n", "err", "=", "clt", ".", "UpsertRole", "(", "role", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "user", ".", "AddRole", "(", "role", ".", "GetName", "(", ")", ")", "\n", "err", "=", "clt", ".", "UpsertUser", "(", "user", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "user", ",", "role", ",", "nil", "\n", "}" ]

[ "CreateUserAndRole", "creates", "user", "and", "role", "and", "assignes", "role", "to", "a", "user", "used", "in", "tests" ]

[ "func", "CreateUserAndRoleWithoutRoles", "(", "clt", "clt", ",", "username", "string", ",", "allowedLogins", "[", "]", "string", ")", "(", "services", ".", "User", ",", "services", ".", "Role", ",", "error", ")", "{", "user", ",", "err", ":=", "services", ".", "NewUser", "(", "username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "role", ":=", "services", ".", "RoleForUser", "(", "user", ")", "\n", "set", ":=", "services", ".", "MakeRuleSet", "(", "role", ".", "GetRules", "(", "services", ".", "Allow", ")", ")", "\n", "delete", "(", "set", ",", "services", ".", "KindRole", ")", "\n", "role", ".", "SetRules", "(", "services", ".", "Allow", ",", "set", ".", "Slice", "(", ")", ")", "\n", "role", ".", "SetLogins", "(", "services", ".", "Allow", ",", "[", "]", "string", "{", "user", ".", "GetName", "(", ")", "}", ")", "\n", "err", "=", "clt", ".", "UpsertRole", "(", "role", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "user", ".", "AddRole", "(", "role", ".", "GetName", "(", ")", ")", "\n", "err", "=", "clt", ".", "UpsertUser", "(", "user", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "user", ",", "role", ",", "nil", "\n", "}" ]

[ "CreateUserAndRoleWithoutRoles", "creates", "user", "and", "role", "but", "does", "not", "assign", "user", "to", "a", "role", "used", "in", "tests" ]

[ "func", "(", "cfg", "*", "UploaderConfig", ")", "CheckAndSetDefaults", "(", ")", "error", "{", "if", "cfg", ".", "ServerID", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "AuditLog", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "DataDir", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "Namespace", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "ConcurrentUploads", "<=", "0", "{", "cfg", ".", "ConcurrentUploads", "=", "defaults", ".", "UploaderConcurrentUploads", "\n", "}", "\n", "if", "cfg", ".", "ScanPeriod", "<=", "0", "{", "cfg", ".", "ScanPeriod", "=", "defaults", ".", "UploaderScanPeriod", "\n", "}", "\n", "if", "cfg", ".", "Context", "==", "nil", "{", "cfg", ".", "Context", "=", "context", ".", "TODO", "(", ")", "\n", "}", "\n", "if", "cfg", ".", "Clock", "==", "nil", "{", "cfg", ".", "Clock", "=", "clockwork", ".", "NewRealClock", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "checks", "and", "sets", "default", "values", "of", "UploaderConfig" ]

[ "func", "NewUploader", "(", "cfg", "UploaderConfig", ")", "(", "*", "Uploader", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "cfg", ".", "Context", ")", "\n", "uploader", ":=", "&", "Uploader", "{", "UploaderConfig", ":", "cfg", ",", "Entry", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "teleport", ".", "ComponentAuditLog", ",", "}", ")", ",", "cancel", ":", "cancel", ",", "ctx", ":", "ctx", ",", "semaphore", ":", "make", "(", "chan", "struct", "{", "}", ",", "cfg", ".", "ConcurrentUploads", ")", ",", "scanDir", ":", "filepath", ".", "Join", "(", "cfg", ".", "DataDir", ",", "cfg", ".", "ServerID", ",", "SessionLogsDir", ",", "cfg", ".", "Namespace", ")", ",", "}", "\n", "return", "uploader", ",", "nil", "\n", "}" ]

[ "NewUploader", "creates", "new", "disk", "based", "session", "logger" ]

[ "func", "(", "u", "*", "Uploader", ")", "Scan", "(", ")", "error", "{", "df", ",", "err", ":=", "os", ".", "Open", "(", "u", ".", "scanDir", ")", "\n", "err", "=", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "df", ".", "Close", "(", ")", "\n", "entries", ",", "err", ":=", "df", ".", "Readdir", "(", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "var", "count", "int", "\n", "for", "i", ":=", "range", "entries", "{", "fi", ":=", "entries", "[", "i", "]", "\n", "if", "fi", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "fi", ".", "Name", "(", ")", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "parts", ":=", "strings", ".", "Split", "(", "fi", ".", "Name", "(", ")", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "<", "2", "{", "u", ".", "Debugf", "(", "\"", "\"", ",", "fi", ".", "Name", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "sessionID", ":=", "session", ".", "ID", "(", "parts", "[", "0", "]", ")", "\n", "lockFilePath", ":=", "filepath", ".", "Join", "(", "u", ".", "scanDir", ",", "fi", ".", "Name", "(", ")", ")", "\n", "if", "err", ":=", "u", ".", "uploadFile", "(", "lockFilePath", ",", "sessionID", ")", ";", "err", "!=", "nil", "{", "if", "trace", ".", "IsCompareFailed", "(", "err", ")", "{", "u", ".", "Debugf", "(", "\"", "\"", ",", "lockFilePath", ")", "\n", "continue", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "count", "+=", "1", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Scan", "scans", "the", "directory", "and", "uploads", "recordings" ]

[ "func", "MakeDefaultConfig", "(", ")", "*", "Config", "{", "return", "&", "Config", "{", "Stdout", ":", "os", ".", "Stdout", ",", "Stderr", ":", "os", ".", "Stderr", ",", "Stdin", ":", "os", ".", "Stdin", ",", "}", "\n", "}" ]

[ "MakeDefaultConfig", "returns", "default", "client", "config" ]

[ "func", "(", "p", "*", "ProfileStatus", ")", "IsExpired", "(", "clock", "clockwork", ".", "Clock", ")", "bool", "{", "return", "p", ".", "ValidUntil", ".", "Sub", "(", "clock", ".", "Now", "(", ")", ")", "<=", "0", "\n", "}" ]

[ "IsExpired", "returns", "true", "if", "profile", "is", "not", "expired", "yet" ]

[ "func", "RetryWithRelogin", "(", "ctx", "context", ".", "Context", ",", "tc", "*", "TeleportClient", ",", "fn", "func", "(", ")", "error", ")", "error", "{", "err", ":=", "fn", "(", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "// Assume that failed handshake is a result of expired credentials,", "// retry the login procedure", "if", "!", "utils", ".", "IsHandshakeFailedError", "(", "err", ")", "&&", "!", "utils", ".", "IsCertExpiredError", "(", "err", ")", "&&", "!", "trace", ".", "IsBadParameter", "(", "err", ")", "&&", "trace", ".", "IsTrustError", "(", "err", ")", "{", "return", "err", "\n", "}", "\n", "key", ",", "err", ":=", "tc", ".", "Login", "(", "ctx", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsTrustError", "(", "err", ")", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\\n", "\"", ",", "tc", ".", "Config", ".", "SSHProxyAddr", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// Save profile to record proxy credentials", "if", "err", ":=", "tc", ".", "SaveProfile", "(", "key", ".", "ProxyHost", ",", "\"", "\"", ",", "ProfileCreateNew", "|", "ProfileMakeCurrent", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// Override client's auth methods, current cluster and user name", "authMethod", ",", "err", ":=", "key", ".", "AsAuthMethod", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// After successful login we have local agent updated with latest", "// and greatest auth information, setup client to try only this new", "// method fetched from key, to isolate the retry", "tc", ".", "Config", ".", "AuthMethods", "=", "[", "]", "ssh", ".", "AuthMethod", "{", "authMethod", "}", "\n", "return", "fn", "(", ")", "\n", "}" ]

[ "RetryWithRelogin", "is", "a", "helper", "error", "handling", "method", "attempts", "to", "relogin", "and", "retry", "the", "function", "once" ]

[ "func", "fullProfileName", "(", "profileDir", "string", ",", "proxyHost", "string", ")", "(", "string", ",", "error", ")", "{", "var", "err", "error", "\n", "var", "profileName", "string", "\n\n", "// If no profile name was passed in, try and extract the active profile from", "// the ~/.tsh/profile symlink. If one was passed in, append .yaml to name.", "if", "proxyHost", "==", "\"", "\"", "{", "profileName", ",", "err", "=", "os", ".", "Readlink", "(", "filepath", ".", "Join", "(", "profileDir", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "profileName", "=", "proxyHost", "+", "\"", "\"", "\n", "}", "\n\n", "// Make sure the profile requested actually exists.", "_", ",", "err", "=", "os", ".", "Stat", "(", "filepath", ".", "Join", "(", "profileDir", ",", "profileName", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n\n", "return", "profileName", ",", "nil", "\n", "}" ]

[ "fullProfileName", "takes", "a", "profile", "directory", "and", "the", "host", "the", "user", "is", "trying", "to", "connect", "to", "and", "returns", "the", "name", "of", "the", "profile", "file", "." ]

[ "func", "Status", "(", "profileDir", "string", ",", "proxyHost", "string", ")", "(", "*", "ProfileStatus", ",", "[", "]", "*", "ProfileStatus", ",", "error", ")", "{", "var", "err", "error", "\n", "var", "profile", "*", "ProfileStatus", "\n", "var", "others", "[", "]", "*", "ProfileStatus", "\n\n", "// remove ports from proxy host, because profile name is stored", "// by host name", "if", "proxyHost", "!=", "\"", "\"", "{", "proxyHost", ",", "err", "=", "utils", ".", "Host", "(", "proxyHost", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// Construct the full path to the profile requested and make sure it exists.", "profileDir", "=", "FullProfilePath", "(", "profileDir", ")", "\n", "stat", ",", "err", ":=", "os", ".", "Stat", "(", "profileDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "!", "stat", ".", "IsDir", "(", ")", "{", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Construct the name of the profile requested. If an empty string was", "// passed in, the name of the active profile will be extracted from the", "// ~/.tsh/profile symlink.", "profileName", ",", "err", ":=", "fullProfileName", "(", "profileDir", ",", "proxyHost", ")", "\n", "if", "err", "!=", "nil", "{", "if", "trace", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Read in the active profile first. If readProfile returns trace.NotFound,", "// that means the profile may have been corrupted (for example keys were", "// deleted but profile exists), treat this as the user not being logged in.", "profile", ",", "err", "=", "readProfile", "(", "profileDir", ",", "profileName", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "trace", ".", "IsNotFound", "(", "err", ")", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// Make sure the profile is nil, which tsh uses to detect that no", "// active profile exists.", "profile", "=", "nil", "\n", "}", "\n\n", "// Next, get list of all other available profiles. Filter out logged in", "// profile if it exists and return a slice of *ProfileStatus.", "files", ",", "err", ":=", "ioutil", ".", "ReadDir", "(", "profileDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "for", "_", ",", "file", ":=", "range", "files", "{", "if", "file", ".", "IsDir", "(", ")", "{", "continue", "\n", "}", "\n", "if", "file", ".", "Mode", "(", ")", "&", "os", ".", "ModeSymlink", "!=", "0", "{", "continue", "\n", "}", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "file", ".", "Name", "(", ")", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "if", "file", ".", "Name", "(", ")", "==", "profileName", "{", "continue", "\n", "}", "\n", "ps", ",", "err", ":=", "readProfile", "(", "profileDir", ",", "file", ".", "Name", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "// parts of profile are missing?", "// status skips these files", "if", "trace", ".", "IsNotFound", "(", "err", ")", "{", "continue", "\n", "}", "\n", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "others", "=", "append", "(", "others", ",", "ps", ")", "\n", "}", "\n\n", "return", "profile", ",", "others", ",", "nil", "\n", "}" ]

[ "Status", "returns", "the", "active", "profile", "as", "well", "as", "a", "list", "of", "available", "profiles", "." ]

[ "func", "(", "c", "*", "Config", ")", "KubeProxyHostPort", "(", ")", "(", "string", ",", "int", ")", "{", "if", "c", ".", "KubeProxyAddr", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "c", ".", "KubeProxyAddr", ")", "\n", "if", "err", "==", "nil", "{", "return", "addr", ".", "Host", "(", ")", ",", "addr", ".", "Port", "(", "defaults", ".", "KubeProxyListenPort", ")", "\n", "}", "\n", "}", "\n\n", "webProxyHost", ",", "_", ":=", "c", ".", "WebProxyHostPort", "(", ")", "\n", "return", "webProxyHost", ",", "defaults", ".", "KubeProxyListenPort", "\n", "}" ]

[ "KubeProxyHostPort", "returns", "the", "host", "and", "port", "of", "the", "Kubernetes", "proxy", "." ]

[ "func", "(", "c", "*", "Config", ")", "WebProxyHostPort", "(", ")", "(", "string", ",", "int", ")", "{", "if", "c", ".", "WebProxyAddr", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "c", ".", "WebProxyAddr", ")", "\n", "if", "err", "==", "nil", "{", "return", "addr", ".", "Host", "(", ")", ",", "addr", ".", "Port", "(", "defaults", ".", "HTTPListenPort", ")", "\n", "}", "\n", "}", "\n\n", "webProxyHost", ",", "_", ":=", "c", ".", "WebProxyHostPort", "(", ")", "\n", "return", "webProxyHost", ",", "defaults", ".", "HTTPListenPort", "\n", "}" ]

[ "WebProxyHostPort", "returns", "the", "host", "and", "port", "of", "the", "web", "proxy", "." ]

[ "func", "(", "c", "*", "Config", ")", "SSHProxyHostPort", "(", ")", "(", "string", ",", "int", ")", "{", "if", "c", ".", "SSHProxyAddr", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "c", ".", "SSHProxyAddr", ")", "\n", "if", "err", "==", "nil", "{", "return", "addr", ".", "Host", "(", ")", ",", "addr", ".", "Port", "(", "defaults", ".", "SSHProxyListenPort", ")", "\n", "}", "\n", "}", "\n\n", "webProxyHost", ",", "_", ":=", "c", ".", "WebProxyHostPort", "(", ")", "\n", "return", "webProxyHost", ",", "defaults", ".", "SSHProxyListenPort", "\n", "}" ]

[ "SSHProxyHostPort", "returns", "the", "host", "and", "port", "of", "the", "SSH", "proxy", "." ]

[ "func", "NewClient", "(", "c", "*", "Config", ")", "(", "tc", "*", "TeleportClient", ",", "err", "error", ")", "{", "// validate configuration", "if", "c", ".", "Username", "==", "\"", "\"", "{", "c", ".", "Username", ",", "err", "=", "Username", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "c", ".", "Username", ")", "\n", "}", "\n", "if", "c", ".", "WebProxyAddr", "==", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "HostLogin", "==", "\"", "\"", "{", "c", ".", "HostLogin", ",", "err", "=", "Username", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "c", ".", "HostLogin", ")", "\n", "}", "\n", "if", "c", ".", "KeyTTL", "==", "0", "{", "c", ".", "KeyTTL", "=", "defaults", ".", "CertDuration", "\n", "}", "\n", "c", ".", "Namespace", "=", "services", ".", "ProcessNamespace", "(", "c", ".", "Namespace", ")", "\n\n", "tc", "=", "&", "TeleportClient", "{", "Config", ":", "*", "c", "}", "\n\n", "if", "tc", ".", "Stdout", "==", "nil", "{", "tc", ".", "Stdout", "=", "os", ".", "Stdout", "\n", "}", "\n", "if", "tc", ".", "Stderr", "==", "nil", "{", "tc", ".", "Stderr", "=", "os", ".", "Stderr", "\n", "}", "\n", "if", "tc", ".", "Stdin", "==", "nil", "{", "tc", ".", "Stdin", "=", "os", ".", "Stdin", "\n", "}", "\n\n", "// Create a buffered channel to hold events that occurred during this session.", "// This channel must be buffered because the SSH connection directly feeds", "// into it. Delays in pulling messages off the global SSH request channel", "// could lead to the connection hanging.", "tc", ".", "eventsCh", "=", "make", "(", "chan", "events", ".", "EventFields", ",", "1024", ")", "\n\n", "// Create a client that can be used for the initial fetch of credentials.", "tc", ".", "credClient", ",", "err", "=", "NewCredentialsClient", "(", "c", ".", "WebProxyAddr", ",", "c", ".", "InsecureSkipVerify", ",", "loopbackPool", "(", "c", ".", "WebProxyAddr", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// sometimes we need to use external auth without using local auth", "// methods, e.g. in automation daemons", "if", "c", ".", "SkipLocalAuth", "{", "if", "len", "(", "c", ".", "AuthMethods", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "// if the client was passed an agent in the configuration and skip local auth, use", "// the passed in agent.", "if", "c", ".", "Agent", "!=", "nil", "{", "tc", ".", "localAgent", "=", "&", "LocalKeyAgent", "{", "Agent", ":", "c", ".", "Agent", "}", "\n", "}", "\n", "}", "else", "{", "// initialize the local agent (auth agent which uses local SSH keys signed by the CA):", "webProxyHost", ",", "_", ":=", "tc", ".", "WebProxyHostPort", "(", ")", "\n", "tc", ".", "localAgent", ",", "err", "=", "NewLocalAgent", "(", "c", ".", "KeysDir", ",", "webProxyHost", ",", "c", ".", "Username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "tc", ".", "HostKeyCallback", "==", "nil", "{", "tc", ".", "HostKeyCallback", "=", "tc", ".", "localAgent", ".", "CheckHostSignature", "\n", "}", "\n", "}", "\n\n", "return", "tc", ",", "nil", "\n", "}" ]

[ "NewClient", "creates", "a", "TeleportClient", "object", "and", "fully", "configures", "it" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "accessPoint", "(", "clt", "auth", ".", "AccessPoint", ",", "proxyHostPort", "string", ",", "clusterName", "string", ")", "(", "auth", ".", "AccessPoint", ",", "error", ")", "{", "// If no caching policy was set or on Windows (where Teleport does not", "// support file locking at the moment), return direct access to the access", "// point.", "if", "tc", ".", "CachePolicy", "==", "nil", "||", "runtime", ".", "GOOS", "==", "teleport", ".", "WindowsOS", "{", "log", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "clt", ",", "nil", "\n", "}", "\n", "return", "clt", ",", "nil", "\n", "}" ]

[ "accessPoint", "returns", "access", "point", "based", "on", "the", "cache", "policy" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "getTargetNodes", "(", "ctx", "context", ".", "Context", ",", "proxy", "*", "ProxyClient", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "nodes", "[", "]", "services", ".", "Server", "\n", "retval", "=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", ")", "\n", "if", "tc", ".", "Labels", "!=", "nil", "&&", "len", "(", "tc", ".", "Labels", ")", ">", "0", "{", "nodes", ",", "err", "=", "proxy", ".", "FindServersByLabels", "(", "ctx", ",", "tc", ".", "Namespace", ",", "tc", ".", "Labels", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "nodes", ")", ";", "i", "++", "{", "retval", "=", "append", "(", "retval", ",", "nodes", "[", "i", "]", ".", "GetAddr", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "nodes", ")", "==", "0", "{", "retval", "=", "append", "(", "retval", ",", "net", ".", "JoinHostPort", "(", "tc", ".", "Host", ",", "strconv", ".", "Itoa", "(", "tc", ".", "HostPort", ")", ")", ")", "\n", "}", "\n", "return", "retval", ",", "nil", "\n", "}" ]

[ "getTargetNodes", "returns", "a", "list", "of", "node", "addresses", "this", "SSH", "command", "needs", "to", "operate", "on", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "Play", "(", "ctx", "context", ".", "Context", ",", "namespace", ",", "sessionId", "string", ")", "(", "err", "error", ")", "{", "if", "namespace", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "auth", ".", "MissingNamespaceError", ")", "\n", "}", "\n", "sid", ",", "err", ":=", "session", ".", "ParseID", "(", "sessionId", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sid", ")", "\n", "}", "\n", "// connect to the auth server (site) who made the recording", "proxyClient", ",", "err", ":=", "tc", ".", "ConnectToProxy", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "site", ",", "err", ":=", "proxyClient", ".", "ConnectToCurrentCluster", "(", "ctx", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// request events for that session (to get timing data)", "sessionEvents", ",", "err", ":=", "site", ".", "GetSessionEvents", "(", "namespace", ",", "*", "sid", ",", "0", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// read the stream into a buffer:", "var", "stream", "[", "]", "byte", "\n", "for", "err", "==", "nil", "{", "tmp", ",", "err", ":=", "site", ".", "GetSessionChunk", "(", "namespace", ",", "*", "sid", ",", "len", "(", "stream", ")", ",", "events", ".", "MaxChunkBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "tmp", ")", "==", "0", "{", "err", "=", "io", ".", "EOF", "\n", "break", "\n", "}", "\n", "stream", "=", "append", "(", "stream", ",", "tmp", "...", ")", "\n", "}", "\n\n", "// configure terminal for direct unbuffered echo-less input:", "if", "term", ".", "IsTerminal", "(", "0", ")", "{", "state", ",", "err", ":=", "term", ".", "SetRawTerminal", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "defer", "term", ".", "RestoreTerminal", "(", "0", ",", "state", ")", "\n", "}", "\n", "player", ":=", "newSessionPlayer", "(", "sessionEvents", ",", "stream", ")", "\n", "// keys:", "const", "(", "keyCtrlC", "=", "3", "\n", "keyCtrlD", "=", "4", "\n", "keySpace", "=", "32", "\n", "keyLeft", "=", "68", "\n", "keyRight", "=", "67", "\n", "keyUp", "=", "65", "\n", "keyDown", "=", "66", "\n", ")", "\n", "// playback control goroutine", "go", "func", "(", ")", "{", "defer", "player", ".", "Stop", "(", ")", "\n", "key", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "for", "{", "_", ",", "err", "=", "os", ".", "Stdin", ".", "Read", "(", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "switch", "key", "[", "0", "]", "{", "// Ctrl+C or Ctrl+D", "case", "keyCtrlC", ",", "keyCtrlD", ":", "return", "\n", "// Space key", "case", "keySpace", ":", "player", ".", "TogglePause", "(", ")", "\n", "// <- arrow", "case", "keyLeft", ",", "keyDown", ":", "player", ".", "Rewind", "(", ")", "\n", "// -> arrow", "case", "keyRight", ",", "keyUp", ":", "player", ".", "Forward", "(", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "// player starts playing in its own goroutine", "player", ".", "Play", "(", ")", "\n\n", "// wait for keypresses loop to end", "<-", "player", ".", "stopC", "\n", "fmt", ".", "Println", "(", "\"", "\\n", "\\n", "\"", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "Play", "replays", "the", "recorded", "session" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "ExecuteSCP", "(", "ctx", "context", ".", "Context", ",", "cmd", "scp", ".", "Command", ")", "(", "err", "error", ")", "{", "// connect to proxy first:", "if", "!", "tc", ".", "Config", ".", "ProxySpecified", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "proxyClient", ",", "err", ":=", "tc", ".", "ConnectToProxy", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "proxyClient", ".", "Close", "(", ")", "\n\n", "clusterInfo", ",", "err", ":=", "proxyClient", ".", "currentCluster", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// which nodes are we executing this commands on?", "nodeAddrs", ",", "err", ":=", "tc", ".", "getTargetNodes", "(", "ctx", ",", "proxyClient", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "nodeAddrs", ")", "==", "0", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "nodeClient", ",", "err", ":=", "proxyClient", ".", "ConnectToNode", "(", "ctx", ",", "nodeAddrs", "[", "0", "]", "+", "\"", "\"", "+", "tc", ".", "Namespace", "+", "\"", "\"", "+", "clusterInfo", ".", "Name", ",", "tc", ".", "Config", ".", "HostLogin", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "tc", ".", "ExitStatus", "=", "1", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "nodeClient", ".", "ExecuteSCP", "(", "cmd", ")", "\n", "if", "err", "!=", "nil", "{", "// converts SSH error code to tc.ExitStatus", "exitError", ",", "_", ":=", "trace", ".", "Unwrap", "(", "err", ")", ".", "(", "*", "ssh", ".", "ExitError", ")", "\n", "if", "exitError", "!=", "nil", "{", "tc", ".", "ExitStatus", "=", "exitError", ".", "ExitStatus", "(", ")", "\n", "}", "\n", "return", "err", "\n\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ExecuteSCP", "executes", "SCP", "command", ".", "It", "executes", "scp", ".", "Command", "using", "lower", "-", "level", "API", "integrations", "that", "mimic", "SCP", "CLI", "command", "behavior" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "ListNodes", "(", "ctx", "context", ".", "Context", ")", "(", "[", "]", "services", ".", "Server", ",", "error", ")", "{", "var", "err", "error", "\n", "// userhost is specified? that must be labels", "if", "tc", ".", "Host", "!=", "\"", "\"", "{", "tc", ".", "Labels", ",", "err", "=", "ParseLabelSpec", "(", "tc", ".", "Host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// connect to the proxy and ask it to return a full list of servers", "proxyClient", ",", "err", ":=", "tc", ".", "ConnectToProxy", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "proxyClient", ".", "Close", "(", ")", "\n\n", "return", "proxyClient", ".", "FindServersByLabels", "(", "ctx", ",", "tc", ".", "Namespace", ",", "tc", ".", "Labels", ")", "\n", "}" ]

[ "ListNodes", "returns", "a", "list", "of", "nodes", "connected", "to", "a", "proxy" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "runCommand", "(", "ctx", "context", ".", "Context", ",", "siteName", "string", ",", "nodeAddresses", "[", "]", "string", ",", "proxyClient", "*", "ProxyClient", ",", "command", "[", "]", "string", ")", "error", "{", "resultsC", ":=", "make", "(", "chan", "error", ",", "len", "(", "nodeAddresses", ")", ")", "\n", "for", "_", ",", "address", ":=", "range", "nodeAddresses", "{", "go", "func", "(", "address", "string", ")", "{", "var", "(", "err", "error", "\n", "nodeSession", "*", "NodeSession", "\n", ")", "\n", "defer", "func", "(", ")", "{", "resultsC", "<-", "err", "\n", "}", "(", ")", "\n", "var", "nodeClient", "*", "NodeClient", "\n", "nodeClient", ",", "err", "=", "proxyClient", ".", "ConnectToNode", "(", "ctx", ",", "address", "+", "\"", "\"", "+", "tc", ".", "Namespace", "+", "\"", "\"", "+", "siteName", ",", "tc", ".", "Config", ".", "HostLogin", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "tc", ".", "Stderr", ",", "err", ")", "\n", "return", "\n", "}", "\n", "defer", "nodeClient", ".", "Close", "(", ")", "\n\n", "// run the command on one node:", "if", "len", "(", "nodeAddresses", ")", ">", "1", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "address", ")", "\n", "}", "\n", "nodeSession", ",", "err", "=", "newSession", "(", "nodeClient", ",", "nil", ",", "tc", ".", "Config", ".", "Env", ",", "tc", ".", "Stdin", ",", "tc", ".", "Stdout", ",", "tc", ".", "Stderr", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Error", "(", "err", ")", "\n", "return", "\n", "}", "\n", "defer", "nodeSession", ".", "Close", "(", ")", "\n", "if", "err", "=", "nodeSession", ".", "runCommand", "(", "ctx", ",", "command", ",", "tc", ".", "OnShellCreated", ",", "tc", ".", "Config", ".", "Interactive", ")", ";", "err", "!=", "nil", "{", "originErr", ":=", "trace", ".", "Unwrap", "(", "err", ")", "\n", "exitErr", ",", "ok", ":=", "originErr", ".", "(", "*", "ssh", ".", "ExitError", ")", "\n", "if", "ok", "{", "tc", ".", "ExitStatus", "=", "exitErr", ".", "ExitStatus", "(", ")", "\n", "}", "else", "{", "// if an error occurs, but no exit status is passed back, GoSSH returns", "// a generic error like this. in this case the error message is printed", "// to stderr by the remote process so we have to quietly return 1:", "if", "strings", ".", "Contains", "(", "originErr", ".", "Error", "(", ")", ",", "\"", "\"", ")", "{", "tc", ".", "ExitStatus", "=", "1", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "(", "address", ")", "\n", "}", "\n", "var", "lastError", "error", "\n", "for", "range", "nodeAddresses", "{", "if", "err", ":=", "<-", "resultsC", ";", "err", "!=", "nil", "{", "lastError", "=", "err", "\n", "}", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "lastError", ")", "\n", "}" ]

[ "runCommand", "executes", "a", "given", "bash", "command", "on", "a", "bunch", "of", "remote", "nodes" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "getProxySSHPrincipal", "(", ")", "string", "{", "proxyPrincipal", ":=", "tc", ".", "Config", ".", "HostLogin", "\n", "if", "tc", ".", "DefaultPrincipal", "!=", "\"", "\"", "{", "proxyPrincipal", "=", "tc", ".", "DefaultPrincipal", "\n", "}", "\n", "// see if we already have a signed key in the cache, we'll use that instead", "if", "!", "tc", ".", "Config", ".", "SkipLocalAuth", "&&", "tc", ".", "LocalAgent", "(", ")", "!=", "nil", "{", "signers", ",", "err", ":=", "tc", ".", "LocalAgent", "(", ")", ".", "Signers", "(", ")", "\n", "if", "err", "!=", "nil", "||", "len", "(", "signers", ")", "==", "0", "{", "return", "proxyPrincipal", "\n", "}", "\n", "cert", ",", "ok", ":=", "signers", "[", "0", "]", ".", "PublicKey", "(", ")", ".", "(", "*", "ssh", ".", "Certificate", ")", "\n", "if", "ok", "&&", "len", "(", "cert", ".", "ValidPrincipals", ")", ">", "0", "{", "return", "cert", ".", "ValidPrincipals", "[", "0", "]", "\n", "}", "\n", "}", "\n", "return", "proxyPrincipal", "\n", "}" ]

[ "getProxyLogin", "determines", "which", "SSH", "principal", "to", "use", "when", "connecting", "to", "proxy", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "ConnectToProxy", "(", "ctx", "context", ".", "Context", ")", "(", "*", "ProxyClient", ",", "error", ")", "{", "var", "err", "error", "\n", "var", "proxyClient", "*", "ProxyClient", "\n\n", "// Use connectContext and the cancel function to signal when a response is", "// returned from connectToProxy.", "connectContext", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "go", "func", "(", ")", "{", "defer", "cancel", "(", ")", "\n", "proxyClient", ",", "err", "=", "tc", ".", "connectToProxy", "(", "ctx", ")", "\n", "}", "(", ")", "\n\n", "select", "{", "// ConnectToProxy returned a result, return that back to the caller.", "case", "<-", "connectContext", ".", "Done", "(", ")", ":", "return", "proxyClient", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "// The passed in context timed out. This is often due to the network being", "// down and the user hitting Ctrl-C.", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "nil", ",", "trace", ".", "ConnectionProblem", "(", "ctx", ".", "Err", "(", ")", ",", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "ConnectToProxy", "will", "dial", "to", "the", "proxy", "server", "and", "return", "a", "ProxyClient", "when", "successful", ".", "If", "the", "passed", "in", "context", "is", "canceled", "this", "function", "will", "return", "a", "trace", ".", "ConnectionProblem", "right", "away", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "connectToProxy", "(", "ctx", "context", ".", "Context", ")", "(", "*", "ProxyClient", ",", "error", ")", "{", "var", "err", "error", "\n\n", "proxyPrincipal", ":=", "tc", ".", "getProxySSHPrincipal", "(", ")", "\n", "sshConfig", ":=", "&", "ssh", ".", "ClientConfig", "{", "User", ":", "proxyPrincipal", ",", "HostKeyCallback", ":", "tc", ".", "HostKeyCallback", ",", "}", "\n\n", "// helper to create a ProxyClient struct", "makeProxyClient", ":=", "func", "(", "sshClient", "*", "ssh", ".", "Client", ",", "m", "ssh", ".", "AuthMethod", ")", "*", "ProxyClient", "{", "return", "&", "ProxyClient", "{", "teleportClient", ":", "tc", ",", "Client", ":", "sshClient", ",", "proxyAddress", ":", "tc", ".", "Config", ".", "SSHProxyAddr", ",", "proxyPrincipal", ":", "proxyPrincipal", ",", "hostKeyCallback", ":", "sshConfig", ".", "HostKeyCallback", ",", "authMethod", ":", "m", ",", "hostLogin", ":", "tc", ".", "Config", ".", "HostLogin", ",", "siteName", ":", "tc", ".", "Config", ".", "SiteName", ",", "clientAddr", ":", "tc", ".", "ClientAddr", ",", "}", "\n", "}", "\n", "successMsg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "tc", ".", "Config", ".", "SSHProxyAddr", ")", "\n", "// try to authenticate using every non interactive auth method we have:", "for", "i", ",", "m", ":=", "range", "tc", ".", "authMethods", "(", ")", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "tc", ".", "Config", ".", "SSHProxyAddr", ",", "sshConfig", ".", "User", ",", "i", ")", "\n", "var", "sshClient", "*", "ssh", ".", "Client", "\n\n", "sshConfig", ".", "Auth", "=", "[", "]", "ssh", ".", "AuthMethod", "{", "m", "}", "\n", "sshClient", ",", "err", "=", "ssh", ".", "Dial", "(", "\"", "\"", ",", "tc", ".", "Config", ".", "SSHProxyAddr", ",", "sshConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "log", ".", "Infof", "(", "successMsg", ")", "\n", "return", "makeProxyClient", "(", "sshClient", ",", "m", ")", ",", "nil", "\n", "}", "\n", "// we have exhausted all auth existing auth methods and local login", "// is disabled in configuration, or the user refused connecting to untrusted hosts", "if", "err", "==", "nil", "{", "err", "=", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "tc", ".", "Config", ".", "SSHProxyAddr", ")", "\n", "}", "\n", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "connectToProxy", "will", "dial", "to", "the", "proxy", "server", "and", "return", "a", "ProxyClient", "when", "successful", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "Logout", "(", ")", "error", "{", "err", ":=", "tc", ".", "localAgent", ".", "DeleteKey", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Logout", "removes", "certificate", "and", "key", "for", "the", "currently", "logged", "in", "user", "from", "the", "filesystem", "and", "agent", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "LogoutAll", "(", ")", "error", "{", "err", ":=", "tc", ".", "localAgent", ".", "DeleteKeys", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "LogoutAll", "removes", "all", "certificates", "for", "all", "users", "from", "the", "filesystem", "and", "agent", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "GetTrustedCA", "(", "ctx", "context", ".", "Context", ",", "clusterName", "string", ")", "(", "[", "]", "services", ".", "CertAuthority", ",", "error", ")", "{", "// Connect to the proxy.", "if", "!", "tc", ".", "Config", ".", "ProxySpecified", "(", ")", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "proxyClient", ",", "err", ":=", "tc", ".", "ConnectToProxy", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "proxyClient", ".", "Close", "(", ")", "\n\n", "// Get a client to the Auth Server.", "clt", ",", "err", ":=", "proxyClient", ".", "ClusterAccessPoint", "(", "ctx", ",", "clusterName", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Get the list of host certificates that this cluster knows about.", "return", "clt", ".", "GetCertAuthorities", "(", "services", ".", "HostCA", ",", "false", ")", "\n", "}" ]

[ "GetTrustedCA", "returns", "a", "list", "of", "host", "certificate", "authorities", "trusted", "by", "the", "cluster", "client", "is", "authenticated", "with", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "applyProxySettings", "(", "proxySettings", "ProxySettings", ")", "error", "{", "// Kubernetes proxy settings.", "if", "proxySettings", ".", "Kube", ".", "Enabled", "&&", "proxySettings", ".", "Kube", ".", "PublicAddr", "!=", "\"", "\"", "&&", "tc", ".", "KubeProxyAddr", "==", "\"", "\"", "{", "_", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "proxySettings", ".", "Kube", ".", "PublicAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "proxySettings", ".", "Kube", ".", "PublicAddr", ")", "\n", "}", "\n", "tc", ".", "KubeProxyAddr", "=", "proxySettings", ".", "Kube", ".", "PublicAddr", "\n", "}", "else", "if", "proxySettings", ".", "Kube", ".", "Enabled", "&&", "tc", ".", "KubeProxyAddr", "==", "\"", "\"", "{", "webProxyHost", ",", "_", ":=", "tc", ".", "WebProxyHostPort", "(", ")", "\n", "tc", ".", "KubeProxyAddr", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "webProxyHost", ",", "defaults", ".", "KubeProxyListenPort", ")", "\n", "}", "\n\n", "// Read in settings for HTTP endpoint of the proxy.", "if", "proxySettings", ".", "SSH", ".", "PublicAddr", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "proxySettings", ".", "SSH", ".", "PublicAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "proxySettings", ".", "SSH", ".", "PublicAddr", ")", "\n", "}", "\n", "tc", ".", "WebProxyAddr", "=", "net", ".", "JoinHostPort", "(", "addr", ".", "Host", "(", ")", ",", "strconv", ".", "Itoa", "(", "addr", ".", "Port", "(", "defaults", ".", "HTTPListenPort", ")", ")", ")", "\n\n", "// Update local agent (that reads/writes to ~/.tsh) with the new address", "// of the web proxy. This will control where the keys are stored on disk", "// after login.", "tc", ".", "localAgent", ".", "UpdateProxyHost", "(", "addr", ".", "Host", "(", ")", ")", "\n", "}", "\n", "// Read in settings for the SSH endpoint of the proxy.", "//", "// If listen_addr is set, take host from ProxyWebHost and port from what", "// was set. This is to maintain backward compatibility when Teleport only", "// supported public_addr.", "if", "proxySettings", ".", "SSH", ".", "ListenAddr", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "proxySettings", ".", "SSH", ".", "ListenAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "proxySettings", ".", "SSH", ".", "ListenAddr", ")", "\n", "}", "\n", "webProxyHost", ",", "_", ":=", "tc", ".", "WebProxyHostPort", "(", ")", "\n", "tc", ".", "SSHProxyAddr", "=", "net", ".", "JoinHostPort", "(", "webProxyHost", ",", "strconv", ".", "Itoa", "(", "addr", ".", "Port", "(", "defaults", ".", "SSHProxyListenPort", ")", ")", ")", "\n", "}", "\n", "// If ssh_public_addr is set, override settings from listen_addr.", "if", "proxySettings", ".", "SSH", ".", "SSHPublicAddr", "!=", "\"", "\"", "{", "addr", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "proxySettings", ".", "SSH", ".", "SSHPublicAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "proxySettings", ".", "SSH", ".", "ListenAddr", ")", "\n", "}", "\n", "tc", ".", "SSHProxyAddr", "=", "net", ".", "JoinHostPort", "(", "addr", ".", "Host", "(", ")", ",", "strconv", ".", "Itoa", "(", "addr", ".", "Port", "(", "defaults", ".", "SSHProxyListenPort", ")", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "applyProxySettings", "updates", "configuration", "changes", "based", "on", "the", "advertised", "proxy", "settings", "user", "supplied", "values", "take", "precedence", "-", "will", "be", "preserved", "if", "set" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "AddTrustedCA", "(", "ca", "services", ".", "CertAuthority", ")", "error", "{", "err", ":=", "tc", ".", "LocalAgent", "(", ")", ".", "AddHostSignersToCache", "(", "auth", ".", "AuthoritiesToTrustedCerts", "(", "[", "]", "services", ".", "CertAuthority", "{", "ca", "}", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// only host CA has TLS certificates, user CA will overwrite trusted certs", "// to empty file if called", "if", "ca", ".", "GetType", "(", ")", "==", "services", ".", "HostCA", "{", "err", "=", "tc", ".", "LocalAgent", "(", ")", ".", "SaveCerts", "(", "auth", ".", "AuthoritiesToTrustedCerts", "(", "[", "]", "services", ".", "CertAuthority", "{", "ca", "}", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Adds", "a", "new", "CA", "as", "trusted", "CA", "for", "this", "client", "used", "in", "tests" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "directLogin", "(", "ctx", "context", ".", "Context", ",", "secondFactorType", "string", ",", "pub", "[", "]", "byte", ")", "(", "*", "auth", ".", "SSHLoginResponse", ",", "error", ")", "{", "var", "err", "error", "\n\n", "var", "password", "string", "\n", "var", "otpToken", "string", "\n\n", "password", ",", "err", "=", "tc", ".", "AskPassword", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// only ask for a second factor if it's enabled", "if", "secondFactorType", "!=", "teleport", ".", "OFF", "{", "otpToken", ",", "err", "=", "tc", ".", "AskOTP", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "// ask the CA (via proxy) to sign our public key:", "response", ",", "err", ":=", "tc", ".", "credClient", ".", "SSHAgentLogin", "(", "ctx", ",", "tc", ".", "Config", ".", "Username", ",", "password", ",", "otpToken", ",", "pub", ",", "tc", ".", "KeyTTL", ",", "tc", ".", "CertificateFormat", ")", "\n\n", "return", "response", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "directLogin", "asks", "for", "a", "password", "+", "HOTP", "token", "makes", "a", "request", "to", "CA", "via", "proxy" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "ssoLogin", "(", "ctx", "context", ".", "Context", ",", "connectorID", "string", ",", "pub", "[", "]", "byte", ",", "protocol", "string", ")", "(", "*", "auth", ".", "SSHLoginResponse", ",", "error", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ")", "\n", "// ask the CA (via proxy) to sign our public key:", "response", ",", "err", ":=", "tc", ".", "credClient", ".", "SSHAgentSSOLogin", "(", "SSHLogin", "{", "Context", ":", "ctx", ",", "ConnectorID", ":", "connectorID", ",", "PubKey", ":", "pub", ",", "TTL", ":", "tc", ".", "KeyTTL", ",", "Protocol", ":", "protocol", ",", "Compatibility", ":", "tc", ".", "CertificateFormat", ",", "BindAddr", ":", "tc", ".", "BindAddr", ",", "}", ")", "\n", "return", "response", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "samlLogin", "opens", "browser", "window", "and", "uses", "OIDC", "or", "SAML", "redirect", "cycle", "with", "browser" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "u2fLogin", "(", "ctx", "context", ".", "Context", ",", "pub", "[", "]", "byte", ")", "(", "*", "auth", ".", "SSHLoginResponse", ",", "error", ")", "{", "// U2F login requires the official u2f-host executable", "_", ",", "err", ":=", "exec", ".", "LookPath", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "password", ",", "err", ":=", "tc", ".", "AskPassword", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "response", ",", "err", ":=", "tc", ".", "credClient", ".", "SSHAgentU2FLogin", "(", "ctx", ",", "tc", ".", "Config", ".", "Username", ",", "password", ",", "pub", ",", "tc", ".", "KeyTTL", ",", "tc", ".", "CertificateFormat", ")", "\n\n", "return", "response", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "directLogin", "asks", "for", "a", "password", "and", "performs", "the", "challenge", "-", "response", "authentication" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "SendEvent", "(", "ctx", "context", ".", "Context", ",", "e", "events", ".", "EventFields", ")", "error", "{", "// Try and send the event to the eventsCh. If blocking, keep blocking until", "// the passed in context in canceled.", "select", "{", "case", "tc", ".", "eventsCh", "<-", "e", ":", "return", "nil", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "trace", ".", "Wrap", "(", "ctx", ".", "Err", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "SendEvent", "adds", "a", "events", ".", "EventFields", "to", "the", "channel", "." ]

[ "func", "loopbackPool", "(", "proxyAddr", "string", ")", "*", "x509", ".", "CertPool", "{", "if", "!", "utils", ".", "IsLoopback", "(", "proxyAddr", ")", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "proxyAddr", ")", "\n", "return", "nil", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "proxyAddr", ")", "\n", "certPool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n\n", "certPath", ":=", "filepath", ".", "Join", "(", "defaults", ".", "DataDir", ",", "defaults", ".", "SelfSignedCertPath", ")", "\n", "pemByte", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "certPath", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "certPath", ")", "\n", "return", "nil", "\n", "}", "\n\n", "for", "{", "var", "block", "*", "pem", ".", "Block", "\n", "block", ",", "pemByte", "=", "pem", ".", "Decode", "(", "pemByte", ")", "\n", "if", "block", "==", "nil", "{", "break", "\n", "}", "\n", "cert", ",", "err", ":=", "x509", ".", "ParseCertificate", "(", "block", ".", "Bytes", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Debugf", "(", "\"", "\"", ",", "certPath", ",", "err", ")", "\n", "return", "nil", "\n", "}", "\n", "certPool", ".", "AddCert", "(", "cert", ")", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "certPath", ",", "err", ")", "\n", "return", "certPool", "\n", "}" ]

[ "loopbackPool", "reads", "trusted", "CAs", "if", "it", "finds", "it", "in", "a", "predefined", "location", "and", "will", "work", "only", "if", "target", "proxy", "address", "is", "loopback" ]

[ "func", "connectToSSHAgent", "(", ")", "agent", ".", "Agent", "{", "socketPath", ":=", "os", ".", "Getenv", "(", "teleport", ".", "SSHAuthSock", ")", "\n", "conn", ",", "err", ":=", "agentconn", ".", "Dial", "(", "socketPath", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "socketPath", ")", "\n", "return", "nil", "\n", "}", "\n\n", "log", ".", "Infof", "(", "\"", "\"", ",", "socketPath", ")", "\n", "return", "agent", ".", "NewClient", "(", "conn", ")", "\n", "}" ]

[ "connectToSSHAgent", "connects", "to", "the", "local", "SSH", "agent", "and", "returns", "a", "agent", ".", "Agent", "." ]

[ "func", "Username", "(", ")", "(", "string", ",", "error", ")", "{", "u", ",", "err", ":=", "user", ".", "Current", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "u", ".", "Username", ",", "nil", "\n", "}" ]

[ "Username", "returns", "the", "current", "user", "s", "username" ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "AskOTP", "(", ")", "(", "token", "string", ",", "err", "error", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "token", ",", "err", "=", "lineFromConsole", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "tc", ".", "Stderr", ",", "err", ")", "\n", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "token", ",", "nil", "\n", "}" ]

[ "AskOTP", "prompts", "the", "user", "to", "enter", "the", "OTP", "token", "." ]

[ "func", "(", "tc", "*", "TeleportClient", ")", "AskPassword", "(", ")", "(", "pwd", "string", ",", "err", "error", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "tc", ".", "Config", ".", "Username", ")", "\n", "pwd", ",", "err", "=", "passwordFromConsole", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintln", "(", "tc", ".", "Stderr", ",", "err", ")", "\n", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "pwd", ",", "nil", "\n", "}" ]

[ "AskPassword", "prompts", "the", "user", "to", "enter", "the", "password" ]

[ "func", "passwordFromConsole", "(", ")", "(", "string", ",", "error", ")", "{", "fd", ":=", "syscall", ".", "Stdin", "\n", "state", ",", "err", ":=", "terminal", ".", "GetState", "(", "int", "(", "fd", ")", ")", "\n\n", "// intercept Ctr+C and restore terminal", "sigCh", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "closeCh", ":=", "make", "(", "chan", "int", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "signal", ".", "Notify", "(", "sigCh", ",", "syscall", ".", "SIGINT", ")", "\n", "go", "func", "(", ")", "{", "select", "{", "case", "<-", "sigCh", ":", "terminal", ".", "Restore", "(", "int", "(", "fd", ")", ",", "state", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "case", "<-", "closeCh", ":", "}", "\n", "}", "(", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "close", "(", "closeCh", ")", "\n", "}", "(", ")", "\n\n", "bytes", ",", "err", ":=", "terminal", ".", "ReadPassword", "(", "int", "(", "fd", ")", ")", "\n", "return", "string", "(", "bytes", ")", ",", "err", "\n", "}" ]

[ "passwordFromConsole", "reads", "from", "stdin", "without", "echoing", "typed", "characters", "to", "stdout" ]

[ "func", "lineFromConsole", "(", ")", "(", "string", ",", "error", ")", "{", "bytes", ",", "_", ",", "err", ":=", "bufio", ".", "NewReader", "(", "os", ".", "Stdin", ")", ".", "ReadLine", "(", ")", "\n", "return", "string", "(", "bytes", ")", ",", "err", "\n", "}" ]

[ "lineFromConsole", "reads", "a", "line", "from", "stdin" ]

[ "func", "(", "fp", "DynamicForwardedPorts", ")", "String", "(", ")", "(", "retval", "[", "]", "string", ")", "{", "for", "_", ",", "p", ":=", "range", "fp", "{", "retval", "=", "append", "(", "retval", ",", "p", ".", "ToString", "(", ")", ")", "\n", "}", "\n", "return", "retval", "\n", "}" ]

[ "String", "returns", "the", "same", "string", "spec", "which", "can", "be", "parsed", "by", "ParseDynamicPortForwardSpec", "." ]

[ "func", "InsecureSkipHostKeyChecking", "(", "host", "string", ",", "remote", "net", ".", "Addr", ",", "key", "ssh", ".", "PublicKey", ")", "error", "{", "return", "nil", "\n", "}" ]

[ "InsecureSkipHostKeyChecking", "is", "used", "when", "the", "user", "passes", "in", "StrictHostKeyChecking", "yes", "." ]

[ "func", "(", "c", "*", "remoteConn", ")", "OpenChannel", "(", "name", "string", ",", "data", "[", "]", "byte", ")", "(", "ssh", ".", "Channel", ",", "error", ")", "{", "channel", ",", "_", ",", "err", ":=", "c", ".", "sconn", ".", "OpenChannel", "(", "name", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "channel", ",", "nil", "\n", "}" ]

[ "OpenChannel", "will", "open", "a", "SSH", "channel", "to", "the", "remote", "side", "." ]

[ "func", "(", "c", "*", "remoteConn", ")", "ChannelConn", "(", "channel", "ssh", ".", "Channel", ")", "net", ".", "Conn", "{", "return", "utils", ".", "NewChConn", "(", "c", ".", "sconn", ",", "channel", ")", "\n", "}" ]

[ "ChannelConn", "creates", "a", "net", ".", "Conn", "over", "a", "SSH", "channel", "." ]

[ "func", "(", "c", "*", "remoteConn", ")", "findAndSend", "(", ")", "error", "{", "// Find all proxies that don't have a connection to a remote agent. If all", "// proxies have connections, return right away.", "disconnectedProxies", ",", "err", ":=", "c", ".", "findDisconnectedProxies", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "disconnectedProxies", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "c", ".", "log", ".", "Debugf", "(", "\"", "\"", ",", "c", ".", "proxyName", ",", "string", "(", "c", ".", "tunnelType", ")", ",", "c", ".", "tunnelID", ",", "Proxies", "(", "disconnectedProxies", ")", ")", "\n\n", "req", ":=", "discoveryRequest", "{", "TunnelID", ":", "c", ".", "tunnelID", ",", "Type", ":", "string", "(", "c", ".", "tunnelType", ")", ",", "Proxies", ":", "disconnectedProxies", ",", "}", "\n\n", "err", "=", "c", ".", "sendDiscoveryRequests", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "sendDiscovery", "requests", "sends", "special", "Discovery", "Requests", "back", "to", "the", "connected", "agent", ".", "Discovery", "request", "consists", "of", "the", "proxies", "that", "are", "part", "of", "the", "cluster", "but", "did", "not", "receive", "the", "connection", "from", "the", "agent", ".", "Agent", "will", "act", "on", "a", "discovery", "request", "attempting", "to", "establish", "connection", "to", "the", "proxies", "that", "were", "not", "discovered", "." ]

[ "func", "(", "c", "*", "remoteConn", ")", "findDisconnectedProxies", "(", ")", "(", "[", "]", "services", ".", "Server", ",", "error", ")", "{", "// Find all proxies that have connection from the remote domain.", "conns", ",", "err", ":=", "c", ".", "accessPoint", ".", "GetTunnelConnections", "(", "c", ".", "clusterName", ",", "services", ".", "SkipValidation", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "connected", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "for", "_", ",", "conn", ":=", "range", "conns", "{", "if", "c", ".", "isOnline", "(", "conn", ")", "{", "connected", "[", "conn", ".", "GetProxyName", "(", ")", "]", "=", "true", "\n", "}", "\n", "}", "\n\n", "// Build a list of local proxies that do not have a remote connection to them.", "var", "missing", "[", "]", "services", ".", "Server", "\n", "proxies", ",", "err", ":=", "c", ".", "accessPoint", ".", "GetProxies", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "for", "i", ":=", "range", "proxies", "{", "proxy", ":=", "proxies", "[", "i", "]", "\n\n", "// A proxy should never add itself to the list of missing proxies.", "if", "proxy", ".", "GetName", "(", ")", "==", "c", ".", "proxyName", "{", "continue", "\n", "}", "\n\n", "if", "!", "connected", "[", "proxy", ".", "GetName", "(", ")", "]", "{", "missing", "=", "append", "(", "missing", ",", "proxy", ")", "\n", "}", "\n", "}", "\n\n", "return", "missing", ",", "nil", "\n", "}" ]

[ "findDisconnectedProxies", "finds", "proxies", "that", "do", "not", "have", "inbound", "reverse", "tunnel", "connections", "." ]

[ "func", "(", "c", "*", "remoteConn", ")", "sendDiscoveryRequests", "(", "req", "discoveryRequest", ")", "error", "{", "discoveryCh", ",", "err", ":=", "c", ".", "openDiscoveryChannel", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Marshal and send the request. If the connection failed, mark the", "// connection as invalid so it will be removed later.", "payload", ",", "err", ":=", "marshalDiscoveryRequest", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "discoveryCh", ".", "SendRequest", "(", "chanDiscoveryReq", ",", "false", ",", "payload", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "markInvalid", "(", "err", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "sendDiscoveryRequests", "sends", "a", "discovery", "request", "with", "missing", "proxies", "." ]

[ "func", "TunnelAuthDialer", "(", "proxyAddr", "string", ",", "sshConfig", "*", "ssh", ".", "ClientConfig", ")", "auth", ".", "DialContext", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "network", "string", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "// Connect to the reverse tunnel server.", "dialer", ":=", "proxy", ".", "DialerFromEnvironment", "(", "proxyAddr", ")", "\n", "sconn", ",", "err", ":=", "dialer", ".", "Dial", "(", "\"", "\"", ",", "proxyAddr", ",", "sshConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "conn", ",", "err", ":=", "connectProxyTransport", "(", "sconn", ".", "Conn", ",", "RemoteAuthServer", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "conn", ",", "nil", "\n", "}", "\n", "}" ]

[ "TunnelAuthDialer", "connects", "to", "the", "Auth", "Server", "through", "the", "reverse", "tunnel", "." ]

[ "func", "connectProxyTransport", "(", "sconn", "ssh", ".", "Conn", ",", "addr", "string", ")", "(", "net", ".", "Conn", ",", "error", ")", "{", "channel", ",", "_", ",", "err", ":=", "sconn", ".", "OpenChannel", "(", "chanTransport", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Send a special SSH out-of-band request called \"teleport-transport\"", "// the agent on the other side will create a new TCP/IP connection to", "// 'addr' on its network and will start proxying that connection over", "// this SSH channel.", "ok", ",", "err", ":=", "channel", ".", "SendRequest", "(", "chanTransportDialReq", ",", "true", ",", "[", "]", "byte", "(", "addr", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "!", "ok", "{", "defer", "channel", ".", "Close", "(", ")", "\n\n", "// Pull the error message from the tunnel client (remote cluster)", "// passed to us via stderr.", "errMessage", ",", "_", ":=", "ioutil", ".", "ReadAll", "(", "channel", ".", "Stderr", "(", ")", ")", "\n", "if", "errMessage", "==", "nil", "{", "errMessage", "=", "[", "]", "byte", "(", "\"", "\"", "+", "addr", ")", "\n", "}", "\n", "return", "nil", ",", "trace", ".", "Errorf", "(", "strings", ".", "TrimSpace", "(", "string", "(", "errMessage", ")", ")", ")", "\n", "}", "\n\n", "return", "utils", ".", "NewChConn", "(", "sconn", ",", "channel", ")", ",", "nil", "\n", "}" ]

[ "connectProxyTransport", "opens", "a", "channel", "over", "the", "remote", "tunnel", "and", "connects", "to", "the", "requested", "host", "." ]

[ "func", "(", "c", "*", "Connector", ")", "Close", "(", ")", "error", "{", "if", "c", ".", "Client", "!=", "nil", "{", "return", "c", ".", "Close", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Close", "closes", "resources", "associated", "with", "connector" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "getConnectors", "(", ")", "[", "]", "*", "Connector", "{", "process", ".", "Lock", "(", ")", "\n", "defer", "process", ".", "Unlock", "(", ")", "\n\n", "out", ":=", "make", "(", "[", "]", "*", "Connector", ",", "0", ",", "len", "(", "process", ".", "connectors", ")", ")", "\n", "for", "role", ":=", "range", "process", ".", "connectors", "{", "out", "=", "append", "(", "out", ",", "process", ".", "connectors", "[", "role", "]", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "getConnectors", "returns", "a", "copy", "of", "the", "identities", "registered", "for", "auth", "server" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "addConnector", "(", "connector", "*", "Connector", ")", "{", "process", ".", "Lock", "(", ")", "\n", "defer", "process", ".", "Unlock", "(", ")", "\n\n", "process", ".", "connectors", "[", "connector", ".", "ClientIdentity", ".", "ID", ".", "Role", "]", "=", "connector", "\n", "}" ]

[ "addConnector", "adds", "connector", "to", "registered", "connectors", "list", "it", "will", "overwrite", "the", "connector", "for", "the", "same", "role" ]

[ "func", "Run", "(", "ctx", "context", ".", "Context", ",", "cfg", "Config", ",", "newTeleport", "NewProcess", ")", "error", "{", "if", "newTeleport", "==", "nil", "{", "newTeleport", "=", "newTeleportProcess", "\n", "}", "\n", "copyCfg", ":=", "cfg", "\n", "srv", ",", "err", ":=", "newTeleport", "(", "&", "copyCfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "srv", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "srv", ".", "Start", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "// Wait and reload until called exit.", "for", "{", "srv", ",", "err", "=", "waitAndReload", "(", "ctx", ",", "cfg", ",", "srv", ",", "newTeleport", ")", "\n", "if", "err", "!=", "nil", "{", "// This error means that was a clean shutdown", "// and no reload is necessary.", "if", "err", "==", "ErrTeleportExited", "{", "return", "nil", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Run", "starts", "teleport", "processes", "waits", "for", "signals", "and", "handles", "internal", "process", "reloads", "." ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "notifyParent", "(", ")", "{", "signalPipe", ",", "err", ":=", "process", ".", "importSignalPipe", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "!", "trace", ".", "IsNotFound", "(", "err", ")", "{", "process", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "\n", "process", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "defer", "signalPipe", ".", "Close", "(", ")", "\n\n", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "process", ".", "ExitContext", "(", ")", ",", "signalPipeTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n\n", "eventC", ":=", "make", "(", "chan", "Event", ",", "1", ")", "\n", "process", ".", "WaitForEvent", "(", "ctx", ",", "TeleportReadyEvent", ",", "eventC", ")", "\n", "select", "{", "case", "<-", "eventC", ":", "process", ".", "Infof", "(", "\"", "\"", ")", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "process", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Err", "(", ")", ")", "\n", "if", "err", ":=", "process", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "process", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n\n", "if", "err", ":=", "process", ".", "writeToSignalPipe", "(", "signalPipe", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "os", ".", "Getpid", "(", ")", ")", ")", ";", "err", "!=", "nil", "{", "process", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "// despite the failure, it's ok to proceed,", "// it could mean that the parent process has crashed and the pipe", "// is no longer valid.", "}", "\n", "}" ]

[ "notifyParent", "notifies", "parent", "process", "that", "this", "process", "has", "started", "by", "writing", "to", "in", "-", "memory", "pipe", "used", "by", "communication", "channel", "." ]

[ "func", "adminCreds", "(", ")", "(", "*", "int", ",", "*", "int", ",", "error", ")", "{", "if", "runtime", ".", "GOOS", "!=", "teleport", ".", "LinuxOS", "{", "return", "nil", ",", "nil", ",", "nil", "\n", "}", "\n", "// if the user member of adm linux group,", "// make audit log folder readable by admins", "isAdmin", ",", "err", ":=", "utils", ".", "IsGroupMember", "(", "teleport", ".", "LinuxAdminGID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "!", "isAdmin", "{", "return", "nil", ",", "nil", ",", "nil", "\n", "}", "\n", "uid", ":=", "os", ".", "Getuid", "(", ")", "\n", "gid", ":=", "teleport", ".", "LinuxAdminGID", "\n", "return", "&", "uid", ",", "&", "gid", ",", "nil", "\n", "}" ]

[ "adminCreds", "returns", "admin", "UID", "and", "GID", "settings", "based", "on", "the", "OS" ]

[ "func", "initUploadHandler", "(", "auditConfig", "services", ".", "AuditConfig", ")", "(", "events", ".", "UploadHandler", ",", "error", ")", "{", "if", "auditConfig", ".", "AuditSessionsURI", "==", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "}", "\n", "uri", ",", "err", ":=", "utils", ".", "ParseSessionsURI", "(", "auditConfig", ".", "AuditSessionsURI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "switch", "uri", ".", "Scheme", "{", "case", "teleport", ".", "SchemeS3", ":", "region", ":=", "auditConfig", ".", "Region", "\n", "if", "uriRegion", ":=", "uri", ".", "Query", "(", ")", ".", "Get", "(", "teleport", ".", "Region", ")", ";", "uriRegion", "!=", "\"", "\"", "{", "region", "=", "uriRegion", "\n", "}", "\n", "handler", ",", "err", ":=", "s3sessions", ".", "NewHandler", "(", "s3sessions", ".", "Config", "{", "Bucket", ":", "uri", ".", "Host", ",", "Region", ":", "region", ",", "Path", ":", "uri", ".", "Path", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "handler", ",", "nil", "\n", "case", "teleport", ".", "SchemeFile", ":", "if", "err", ":=", "os", ".", "MkdirAll", "(", "uri", ".", "Path", ",", "teleport", ".", "SharedDirMode", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "handler", ",", "err", ":=", "filesessions", ".", "NewHandler", "(", "filesessions", ".", "Config", "{", "Directory", ":", "uri", ".", "Path", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "handler", ",", "nil", "\n", "default", ":", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "uri", ".", "Scheme", ",", "teleport", ".", "SchemeS3", ",", "teleport", ".", "SchemeFile", ")", "\n", "}", "\n", "}" ]

[ "initUploadHandler", "initializes", "upload", "handler", "based", "on", "the", "config", "settings", "currently", "the", "only", "upload", "handler", "supported", "is", "S3", "the", "call", "can", "return", "trace", ".", "NotFOund", "if", "no", "upload", "handler", "is", "setup" ]

[ "func", "initExternalLog", "(", "auditConfig", "services", ".", "AuditConfig", ")", "(", "events", ".", "IAuditLog", ",", "error", ")", "{", "if", "auditConfig", ".", "AuditTableName", "!=", "\"", "\"", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "dynamo", ".", "GetName", "(", ")", ",", "auditConfig", ".", "AuditTableName", ")", "\n", "if", "len", "(", "auditConfig", ".", "AuditEventsURI", ")", "!=", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "auditConfig", ".", "AuditEventsURI", "=", "[", "]", "string", "{", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dynamo", ".", "GetName", "(", ")", ",", "auditConfig", ".", "AuditTableName", ")", "}", "\n", "}", "\n", "if", "len", "(", "auditConfig", ".", "AuditEventsURI", ")", ">", "0", "&&", "!", "auditConfig", ".", "ShouldUploadSessions", "(", ")", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "hasNonFileLog", "bool", "\n", "var", "loggers", "[", "]", "events", ".", "IAuditLog", "\n", "for", "_", ",", "eventsURI", ":=", "range", "auditConfig", ".", "AuditEventsURI", "{", "uri", ",", "err", ":=", "utils", ".", "ParseSessionsURI", "(", "eventsURI", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "switch", "uri", ".", "Scheme", "{", "case", "dynamo", ".", "GetName", "(", ")", ":", "hasNonFileLog", "=", "true", "\n", "logger", ",", "err", ":=", "dynamoevents", ".", "New", "(", "dynamoevents", ".", "Config", "{", "Tablename", ":", "uri", ".", "Host", ",", "Region", ":", "auditConfig", ".", "Region", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "loggers", "=", "append", "(", "loggers", ",", "logger", ")", "\n", "case", "teleport", ".", "SchemeFile", ":", "if", "err", ":=", "os", ".", "MkdirAll", "(", "uri", ".", "Path", ",", "teleport", ".", "SharedDirMode", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "logger", ",", "err", ":=", "events", ".", "NewFileLog", "(", "events", ".", "FileLogConfig", "{", "Dir", ":", "uri", ".", "Path", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "loggers", "=", "append", "(", "loggers", ",", "logger", ")", "\n", "default", ":", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "uri", ".", "Scheme", ",", "dynamo", ".", "GetName", "(", ")", ",", "teleport", ".", "SchemeFile", ")", "\n", "}", "\n", "}", "\n", "// only file external loggers are prohibited (they are not supposed", "// to be used on their own, only in combo with external loggers)", "// they also don't implement certain features, so they are going", "// to be inefficient", "switch", "len", "(", "loggers", ")", "{", "case", "0", ":", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ")", "\n", "case", "1", ":", "if", "!", "hasNonFileLog", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "loggers", "[", "0", "]", ",", "nil", "\n", "default", ":", "if", "!", "hasNonFileLog", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "events", ".", "NewMultiLog", "(", "loggers", "...", ")", ",", "nil", "\n", "}", "\n", "}" ]

[ "initExternalLog", "initializes", "external", "storage", "if", "the", "storage", "is", "not", "setup", "returns", "nil" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "onExit", "(", "serviceName", "string", ",", "callback", "func", "(", "interface", "{", "}", ")", ")", "{", "process", ".", "RegisterFunc", "(", "serviceName", ",", "func", "(", ")", "error", "{", "eventC", ":=", "make", "(", "chan", "Event", ")", "\n", "process", ".", "WaitForEvent", "(", "context", ".", "TODO", "(", ")", ",", "TeleportExitEvent", ",", "eventC", ")", "\n", "select", "{", "case", "event", ":=", "<-", "eventC", ":", "callback", "(", "event", ".", "Payload", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "onExit", "allows", "individual", "services", "to", "register", "a", "callback", "function", "which", "will", "be", "called", "when", "Teleport", "Process", "is", "asked", "to", "exit", ".", "Usually", "services", "terminate", "themselves", "when", "the", "callback", "is", "called" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "newAccessCache", "(", "cfg", "accessCacheConfig", ")", "(", "*", "cache", ".", "Cache", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "cacheBackend", "backend", ".", "Backend", "\n", "if", "cfg", ".", "inMemory", "{", "mem", ",", "err", ":=", "memory", ".", "New", "(", "memory", ".", "Config", "{", "Context", ":", "process", ".", "ExitContext", "(", ")", ",", "EventsOff", ":", "!", "cfg", ".", "events", ",", "Mirror", ":", "true", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "cacheBackend", "=", "mem", "\n", "}", "else", "{", "path", ":=", "filepath", ".", "Join", "(", "append", "(", "[", "]", "string", "{", "process", ".", "Config", ".", "DataDir", ",", "\"", "\"", "}", ",", "cfg", ".", "cacheName", "...", ")", "...", ")", "\n", "if", "err", ":=", "os", ".", "MkdirAll", "(", "path", ",", "teleport", ".", "SharedDirMode", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "liteBackend", ",", "err", ":=", "lite", ".", "NewWithConfig", "(", "process", ".", "ExitContext", "(", ")", ",", "lite", ".", "Config", "{", "Path", ":", "path", ",", "EventsOff", ":", "!", "cfg", ".", "events", ",", "Memory", ":", "false", ",", "Mirror", ":", "true", ",", "PollStreamPeriod", ":", "100", "*", "time", ".", "Millisecond", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "cacheBackend", "=", "liteBackend", "\n", "}", "\n", "reporter", ",", "err", ":=", "backend", ".", "NewReporter", "(", "backend", ".", "ReporterConfig", "{", "Component", ":", "teleport", ".", "ComponentCache", ",", "Backend", ":", "cacheBackend", ",", "TrackTopRequests", ":", "process", ".", "Config", ".", "Debug", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "cache", ".", "New", "(", "cfg", ".", "setup", "(", "cache", ".", "Config", "{", "Context", ":", "process", ".", "ExitContext", "(", ")", ",", "Backend", ":", "reporter", ",", "Events", ":", "cfg", ".", "services", ",", "ClusterConfig", ":", "cfg", ".", "services", ",", "Provisioner", ":", "cfg", ".", "services", ",", "Trust", ":", "cfg", ".", "services", ",", "Users", ":", "cfg", ".", "services", ",", "Access", ":", "cfg", ".", "services", ",", "Presence", ":", "cfg", ".", "services", ",", "Component", ":", "teleport", ".", "Component", "(", "append", "(", "cfg", ".", "cacheName", ",", "process", ".", "id", ",", "teleport", ".", "ComponentCache", ")", "...", ")", ",", "MetricComponent", ":", "teleport", ".", "Component", "(", "append", "(", "cfg", ".", "cacheName", ",", "teleport", ".", "ComponentCache", ")", "...", ")", ",", "}", ")", ")", "\n", "}" ]

[ "newAccessCache", "returns", "new", "local", "cache", "access", "point" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "setupCachePolicy", "(", "in", "cache", ".", "SetupConfigFn", ")", "cache", ".", "SetupConfigFn", "{", "return", "func", "(", "c", "cache", ".", "Config", ")", "cache", ".", "Config", "{", "config", ":=", "in", "(", "c", ")", "\n", "config", ".", "PreferRecent", "=", "cache", ".", "PreferRecent", "{", "Enabled", ":", "process", ".", "Config", ".", "CachePolicy", ".", "Enabled", ",", "NeverExpires", ":", "process", ".", "Config", ".", "CachePolicy", ".", "NeverExpires", ",", "MaxTTL", ":", "process", ".", "Config", ".", "CachePolicy", ".", "TTL", ",", "}", "\n", "return", "config", "\n", "}", "\n", "}" ]

[ "setupCachePolicy", "sets", "up", "cache", "policy", "based", "on", "teleport", "configuration", "it", "is", "a", "wrapper", "function", "that", "sets", "up", "configuration" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "newLocalCacheForProxy", "(", "clt", "auth", ".", "ClientI", ",", "cacheName", "[", "]", "string", ")", "(", "auth", ".", "AccessPoint", ",", "error", ")", "{", "return", "process", ".", "newLocalCache", "(", "clt", ",", "cache", ".", "ForProxy", ",", "cacheName", ")", "\n", "}" ]

[ "newAccessPointCache", "returns", "new", "instance", "of", "access", "point", "configured", "for", "proxy" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "newLocalCache", "(", "clt", "auth", ".", "ClientI", ",", "setupConfig", "cache", ".", "SetupConfigFn", ",", "cacheName", "[", "]", "string", ")", "(", "auth", ".", "AccessPoint", ",", "error", ")", "{", "// if caching is disabled, return access point", "if", "!", "process", ".", "Config", ".", "CachePolicy", ".", "Enabled", "{", "return", "clt", ",", "nil", "\n", "}", "\n", "cache", ",", "err", ":=", "process", ".", "newAccessCache", "(", "accessCacheConfig", "{", "services", ":", "clt", ",", "setup", ":", "process", ".", "setupCachePolicy", "(", "setupConfig", ")", ",", "cacheName", ":", "cacheName", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "auth", ".", "NewWrapper", "(", "clt", ",", "cache", ")", ",", "nil", "\n", "}" ]

[ "newAccessPointCache", "returns", "new", "instance", "of", "access", "point" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "registerWithAuthServer", "(", "role", "teleport", ".", "Role", ",", "eventName", "string", ")", "{", "serviceName", ":=", "strings", ".", "ToLower", "(", "role", ".", "String", "(", ")", ")", "\n", "process", ".", "RegisterCriticalFunc", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "serviceName", ")", ",", "func", "(", ")", "error", "{", "connector", ",", "err", ":=", "process", ".", "reconnectToAuthService", "(", "role", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "process", ".", "onExit", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "serviceName", ")", ",", "func", "(", "interface", "{", "}", ")", "{", "process", ".", "Debugf", "(", "\"", "\"", ",", "role", ")", "\n", "err", ":=", "connector", ".", "Client", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "process", ".", "Debugf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", ")", "\n", "process", ".", "BroadcastEvent", "(", "Event", "{", "Name", ":", "eventName", ",", "Payload", ":", "connector", "}", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "registerWithAuthServer", "uses", "one", "time", "provisioning", "token", "obtained", "earlier", "from", "the", "server", "to", "get", "a", "pair", "of", "SSH", "keys", "signed", "by", "Auth", "server", "host", "certificate", "authority" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "getAdditionalPrincipals", "(", "role", "teleport", ".", "Role", ")", "(", "[", "]", "string", ",", "[", "]", "string", ",", "error", ")", "{", "var", "principals", "[", "]", "string", "\n", "var", "dnsNames", "[", "]", "string", "\n", "if", "process", ".", "Config", ".", "Hostname", "!=", "\"", "\"", "{", "principals", "=", "append", "(", "principals", ",", "process", ".", "Config", ".", "Hostname", ")", "\n", "}", "\n", "var", "addrs", "[", "]", "utils", ".", "NetAddr", "\n", "switch", "role", "{", "case", "teleport", ".", "RoleProxy", ":", "addrs", "=", "append", "(", "process", ".", "Config", ".", "Proxy", ".", "PublicAddrs", ",", "utils", ".", "NetAddr", "{", "Addr", ":", "reversetunnel", ".", "RemoteKubeProxy", "}", ")", "\n", "addrs", "=", "append", "(", "addrs", ",", "process", ".", "Config", ".", "Proxy", ".", "SSHPublicAddrs", "...", ")", "\n", "addrs", "=", "append", "(", "addrs", ",", "process", ".", "Config", ".", "Proxy", ".", "TunnelPublicAddrs", "...", ")", "\n", "addrs", "=", "append", "(", "addrs", ",", "process", ".", "Config", ".", "Proxy", ".", "Kube", ".", "PublicAddrs", "...", ")", "\n", "// Automatically add wildcards for every proxy public address for k8s SNI routing", "if", "process", ".", "Config", ".", "Proxy", ".", "Kube", ".", "Enabled", "{", "for", "_", ",", "publicAddr", ":=", "range", "utils", ".", "JoinAddrSlices", "(", "process", ".", "Config", ".", "Proxy", ".", "PublicAddrs", ",", "process", ".", "Config", ".", "Proxy", ".", "Kube", ".", "PublicAddrs", ")", "{", "host", ",", "err", ":=", "utils", ".", "Host", "(", "publicAddr", ".", "Addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "ip", ":=", "net", ".", "ParseIP", "(", "host", ")", ";", "ip", "==", "nil", "{", "dnsNames", "=", "append", "(", "dnsNames", ",", "\"", "\"", "+", "host", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "case", "teleport", ".", "RoleAuth", ",", "teleport", ".", "RoleAdmin", ":", "addrs", "=", "process", ".", "Config", ".", "Auth", ".", "PublicAddrs", "\n", "case", "teleport", ".", "RoleNode", ":", "addrs", "=", "process", ".", "Config", ".", "SSH", ".", "PublicAddrs", "\n", "// If advertise IP is set, add it to the list of principals. Otherwise", "// add in the default (0.0.0.0) which will be replaced by the Auth Server", "// when a host certificate is issued.", "if", "process", ".", "Config", ".", "AdvertiseIP", "!=", "\"", "\"", "{", "advertiseIP", ",", "err", ":=", "utils", ".", "ParseAddr", "(", "process", ".", "Config", ".", "AdvertiseIP", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "addrs", "=", "append", "(", "addrs", ",", "*", "advertiseIP", ")", "\n", "}", "else", "{", "addrs", "=", "append", "(", "addrs", ",", "process", ".", "Config", ".", "SSH", ".", "Addr", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "addr", ":=", "range", "addrs", "{", "host", ",", "err", ":=", "utils", ".", "Host", "(", "addr", ".", "Addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "principals", "=", "append", "(", "principals", ",", "host", ")", "\n", "}", "\n", "return", "principals", ",", "dnsNames", ",", "nil", "\n", "}" ]

[ "getAdditionalPrincipals", "returns", "a", "list", "of", "additional", "principals", "to", "add", "to", "role", "s", "service", "certificates", "." ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "initAuthStorage", "(", ")", "(", "bk", "backend", ".", "Backend", ",", "err", "error", ")", "{", "bc", ":=", "&", "process", ".", "Config", ".", "Auth", ".", "StorageConfig", "\n", "process", ".", "Debugf", "(", "\"", "\"", ",", "bc", ".", "Type", ")", "\n", "switch", "bc", ".", "Type", "{", "case", "lite", ".", "GetName", "(", ")", ":", "bk", ",", "err", "=", "lite", ".", "New", "(", "context", ".", "TODO", "(", ")", ",", "bc", ".", "Params", ")", "\n", "// legacy bolt backend, import all data into SQLite and return", "// SQLite data", "case", "boltbk", ".", "GetName", "(", ")", ":", "litebk", ",", "err", ":=", "lite", ".", "New", "(", "context", ".", "TODO", "(", ")", ",", "bc", ".", "Params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "legacy", ".", "Import", "(", "context", ".", "TODO", "(", ")", ",", "litebk", ",", "func", "(", ")", "(", "legacy", ".", "Exporter", ",", "error", ")", "{", "return", "boltbk", ".", "New", "(", "legacy", ".", "Params", "(", "bc", ".", "Params", ")", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "bk", "=", "litebk", "\n", "// legacy filesystem backend, import all data into SQLite and return", "// SQLite data", "case", "dir", ".", "GetName", "(", ")", ":", "litebk", ",", "err", ":=", "lite", ".", "New", "(", "context", ".", "TODO", "(", ")", ",", "bc", ".", "Params", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "legacy", ".", "Import", "(", "context", ".", "TODO", "(", ")", ",", "litebk", ",", "func", "(", ")", "(", "legacy", ".", "Exporter", ",", "error", ")", "{", "return", "dir", ".", "New", "(", "legacy", ".", "Params", "(", "bc", ".", "Params", ")", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "bk", "=", "litebk", "\n", "// DynamoDB backend:", "case", "dynamo", ".", "GetName", "(", ")", ":", "bk", ",", "err", "=", "dynamo", ".", "New", "(", "context", ".", "TODO", "(", ")", ",", "bc", ".", "Params", ")", "\n", "// etcd backend:", "case", "etcdbk", ".", "GetName", "(", ")", ":", "bk", ",", "err", "=", "etcdbk", ".", "New", "(", "context", ".", "TODO", "(", ")", ",", "bc", ".", "Params", ")", "\n", "default", ":", "err", "=", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "bc", ".", "Type", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "reporter", ",", "err", ":=", "backend", ".", "NewReporter", "(", "backend", ".", "ReporterConfig", "{", "Component", ":", "teleport", ".", "ComponentBackend", ",", "Backend", ":", "backend", ".", "NewSanitizer", "(", "bk", ")", ",", "TrackTopRequests", ":", "process", ".", "Config", ".", "Debug", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "process", ".", "setReporter", "(", "reporter", ")", "\n", "return", "reporter", ",", "nil", "\n", "}" ]

[ "initAuthStorage", "initializes", "the", "storage", "backend", "for", "the", "auth", "service", "." ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "WaitWithContext", "(", "ctx", "context", ".", "Context", ")", "{", "local", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "go", "func", "(", ")", "{", "defer", "cancel", "(", ")", "\n", "process", ".", "Supervisor", ".", "Wait", "(", ")", "\n", "}", "(", ")", "\n", "select", "{", "case", "<-", "local", ".", "Done", "(", ")", ":", "return", "\n", "}", "\n", "}" ]

[ "WaitWithContext", "waits", "until", "all", "internal", "services", "stop", "." ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "StartShutdown", "(", "ctx", "context", ".", "Context", ")", "context", ".", "Context", "{", "process", ".", "BroadcastEvent", "(", "Event", "{", "Name", ":", "TeleportExitEvent", ",", "Payload", ":", "ctx", "}", ")", "\n", "localCtx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "go", "func", "(", ")", "{", "defer", "cancel", "(", ")", "\n", "process", ".", "Supervisor", ".", "Wait", "(", ")", "\n", "process", ".", "Debugf", "(", "\"", "\"", ")", "\n", "localAuth", ":=", "process", ".", "getLocalAuth", "(", ")", "\n", "if", "localAuth", "!=", "nil", "{", "if", "err", ":=", "process", ".", "localAuth", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "process", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "go", "process", ".", "printShutdownStatus", "(", "localCtx", ")", "\n", "return", "localCtx", "\n", "}" ]

[ "StartShutdown", "launches", "non", "-", "blocking", "graceful", "shutdown", "process", "that", "signals", "completion", "returns", "context", "that", "will", "be", "closed", "once", "the", "shutdown", "is", "done" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "Shutdown", "(", "ctx", "context", ".", "Context", ")", "{", "localCtx", ":=", "process", ".", "StartShutdown", "(", "ctx", ")", "\n", "// wait until parent context closes", "select", "{", "case", "<-", "localCtx", ".", "Done", "(", ")", ":", "process", ".", "Debugf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Shutdown", "launches", "graceful", "shutdown", "process", "and", "waits", "for", "it", "to", "complete" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "Close", "(", ")", "error", "{", "process", ".", "BroadcastEvent", "(", "Event", "{", "Name", ":", "TeleportExitEvent", "}", ")", "\n\n", "process", ".", "Config", ".", "Keygen", ".", "Close", "(", ")", "\n\n", "var", "errors", "[", "]", "error", "\n", "localAuth", ":=", "process", ".", "getLocalAuth", "(", ")", "\n", "if", "localAuth", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "process", ".", "localAuth", ".", "Close", "(", ")", ")", "\n", "}", "\n\n", "if", "process", ".", "storage", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "process", ".", "storage", ".", "Close", "(", ")", ")", "\n", "}", "\n\n", "return", "trace", ".", "NewAggregate", "(", "errors", "...", ")", "\n", "}" ]

[ "Close", "broadcasts", "close", "signals", "and", "exits", "immediately" ]

[ "func", "initSelfSignedHTTPSCert", "(", "cfg", "*", "Config", ")", "(", "err", "error", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ")", "\n\n", "keyPath", ":=", "filepath", ".", "Join", "(", "cfg", ".", "DataDir", ",", "defaults", ".", "SelfSignedKeyPath", ")", "\n", "certPath", ":=", "filepath", ".", "Join", "(", "cfg", ".", "DataDir", ",", "defaults", ".", "SelfSignedCertPath", ")", "\n\n", "cfg", ".", "Proxy", ".", "TLSKey", "=", "keyPath", "\n", "cfg", ".", "Proxy", ".", "TLSCert", "=", "certPath", "\n\n", "// return the existing pair if they have already been generated:", "_", ",", "err", "=", "tls", ".", "LoadX509KeyPair", "(", "certPath", ",", "keyPath", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "log", ".", "Warningf", "(", "\"", "\"", ",", "keyPath", ",", "certPath", ")", "\n\n", "creds", ",", "err", ":=", "utils", ".", "GenerateSelfSignedCert", "(", "[", "]", "string", "{", "cfg", ".", "Hostname", ",", "\"", "\"", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "keyPath", ",", "creds", ".", "PrivateKey", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "ioutil", ".", "WriteFile", "(", "certPath", ",", "creds", ".", "Cert", ",", "0600", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "initSelfSignedHTTPSCert", "generates", "and", "self", "-", "signs", "a", "TLS", "key", "+", "cert", "pair", "for", "https", "connection", "to", "the", "proxy", "server", "." ]

[ "func", "GetKubeClient", "(", "configPath", "string", ")", "(", "client", "*", "kubernetes", ".", "Clientset", ",", "config", "*", "rest", ".", "Config", ",", "err", "error", ")", "{", "// if path to kubeconfig was provided, init config from it", "if", "configPath", "!=", "\"", "\"", "{", "config", ",", "err", "=", "clientcmd", ".", "BuildConfigFromFlags", "(", "\"", "\"", ",", "configPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "else", "{", "// otherwise attempt to init as if connecting from cluster", "config", ",", "err", "=", "rest", ".", "InClusterConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "client", ",", "err", "=", "kubernetes", ".", "NewForConfig", "(", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "client", ",", "config", ",", "nil", "\n", "}" ]

[ "GetKubeClient", "returns", "instance", "of", "client", "to", "the", "kubernetes", "cluster", "using", "in", "-", "cluster", "configuration", "if", "available", "and", "falling", "back", "to", "configuration", "file", "under", "configPath", "otherwise" ]

[ "func", "GetKubeConfig", "(", "configPath", "string", ")", "(", "*", "rest", ".", "Config", ",", "error", ")", "{", "// if path to kubeconfig was provided, init config from it", "if", "configPath", "!=", "\"", "\"", "{", "return", "clientcmd", ".", "BuildConfigFromFlags", "(", "\"", "\"", ",", "configPath", ")", "\n", "}", "\n", "return", "rest", ".", "InClusterConfig", "(", ")", "\n", "}" ]

[ "GetKubeConfig", "returns", "kubernetes", "configuration", "from", "configPath", "file", "or", "by", "default", "reads", "in", "-", "cluster", "configuration" ]

[ "func", "MustCreateProvisionToken", "(", "token", "string", ",", "roles", "teleport", ".", "Roles", ",", "expires", "time", ".", "Time", ")", "ProvisionToken", "{", "t", ",", "err", ":=", "NewProvisionToken", "(", "token", ",", "roles", ",", "expires", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "t", "\n", "}" ]

[ "MustCreateProvisionToken", "returns", "a", "new", "valid", "provision", "token", "or", "panics", "used", "in", "testes" ]

[ "func", "NewProvisionToken", "(", "token", "string", ",", "roles", "teleport", ".", "Roles", ",", "expires", "time", ".", "Time", ")", "(", "ProvisionToken", ",", "error", ")", "{", "t", ":=", "&", "ProvisionTokenV2", "{", "Kind", ":", "KindToken", ",", "Version", ":", "V2", ",", "Metadata", ":", "Metadata", "{", "Name", ":", "token", ",", "Expires", ":", "&", "expires", ",", "Namespace", ":", "defaults", ".", "Namespace", ",", "}", ",", "Spec", ":", "ProvisionTokenSpecV2", "{", "Roles", ":", "roles", ",", "}", ",", "}", "\n", "if", "err", ":=", "t", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "t", ",", "nil", "\n", "}" ]

[ "NewProvisionToken", "returns", "a", "new", "instance", "of", "provision", "token", "resource" ]

[ "func", "ProvisionTokensToV1", "(", "in", "[", "]", "ProvisionToken", ")", "[", "]", "ProvisionTokenV1", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "make", "(", "[", "]", "ProvisionTokenV1", ",", "len", "(", "in", ")", ")", "\n", "for", "i", ":=", "range", "in", "{", "out", "[", "i", "]", "=", "*", "in", "[", "i", "]", ".", "V1", "(", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "ProvisionTokensToV1", "converts", "provision", "tokens", "to", "V1", "list" ]

[ "func", "ProvisionTokensFromV1", "(", "in", "[", "]", "ProvisionTokenV1", ")", "[", "]", "ProvisionToken", "{", "if", "in", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "out", ":=", "make", "(", "[", "]", "ProvisionToken", ",", "len", "(", "in", ")", ")", "\n", "for", "i", ":=", "range", "in", "{", "out", "[", "i", "]", "=", "in", "[", "i", "]", ".", "V2", "(", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "ProvisionTokensFromV1", "converts", "V1", "provision", "tokens", "to", "resource", "list" ]

[ "func", "(", "p", "*", "ProvisionTokenV2", ")", "SetRoles", "(", "r", "teleport", ".", "Roles", ")", "{", "p", ".", "Spec", ".", "Roles", "=", "r", "\n", "}" ]

[ "SetRoles", "sets", "teleport", "roles" ]

[ "func", "UnmarshalProvisionToken", "(", "data", "[", "]", "byte", ",", "opts", "...", "MarshalOption", ")", "(", "ProvisionToken", ",", "error", ")", "{", "if", "len", "(", "data", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "var", "h", "ResourceHeader", "\n", "err", "=", "utils", ".", "FastUnmarshal", "(", "data", ",", "&", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "switch", "h", ".", "Version", "{", "case", "\"", "\"", ":", "var", "p", "ProvisionTokenV1", "\n", "err", ":=", "utils", ".", "FastUnmarshal", "(", "data", ",", "&", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "v2", ":=", "p", ".", "V2", "(", ")", "\n", "if", "cfg", ".", "ID", "!=", "0", "{", "v2", ".", "SetResourceID", "(", "cfg", ".", "ID", ")", "\n", "}", "\n", "return", "v2", ",", "nil", "\n", "case", "V2", ":", "var", "p", "ProvisionTokenV2", "\n", "if", "cfg", ".", "SkipValidation", "{", "if", "err", ":=", "utils", ".", "FastUnmarshal", "(", "data", ",", "&", "p", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "if", "err", ":=", "utils", ".", "UnmarshalWithSchema", "(", "GetProvisionTokenSchema", "(", ")", ",", "&", "p", ",", "data", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "p", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "cfg", ".", "ID", "!=", "0", "{", "p", ".", "SetResourceID", "(", "cfg", ".", "ID", ")", "\n", "}", "\n", "return", "&", "p", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "h", ".", "Version", ")", "\n", "}" ]

[ "UnmarshalProvisionToken", "unmarshals", "provision", "token", "from", "JSON", "or", "YAML", "sets", "defaults", "and", "checks", "the", "schema" ]

[ "func", "MarshalProvisionToken", "(", "t", "ProvisionToken", ",", "opts", "...", "MarshalOption", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "type", "token1", "interface", "{", "V1", "(", ")", "*", "ProvisionTokenV1", "\n", "}", "\n", "type", "token2", "interface", "{", "V2", "(", ")", "*", "ProvisionTokenV2", "\n", "}", "\n", "version", ":=", "cfg", ".", "GetVersion", "(", ")", "\n", "switch", "version", "{", "case", "V1", ":", "v", ",", "ok", ":=", "t", ".", "(", "token1", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "V1", ")", "\n", "}", "\n", "return", "utils", ".", "FastMarshal", "(", "v", ".", "V1", "(", ")", ")", "\n", "case", "V2", ":", "v", ",", "ok", ":=", "t", ".", "(", "token2", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "V2", ")", "\n", "}", "\n", "return", "utils", ".", "FastMarshal", "(", "v", ".", "V2", "(", ")", ")", "\n", "default", ":", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "version", ")", "\n", "}", "\n", "}" ]

[ "MarshalProvisionToken", "marshals", "provisioning", "token", "into", "JSON", "." ]

[ "func", "NewClientConnWithDeadline", "(", "conn", "net", ".", "Conn", ",", "addr", "string", ",", "config", "*", "ssh", ".", "ClientConfig", ")", "(", "*", "ssh", ".", "Client", ",", "error", ")", "{", "if", "config", ".", "Timeout", ">", "0", "{", "conn", ".", "SetReadDeadline", "(", "time", ".", "Now", "(", ")", ".", "Add", "(", "config", ".", "Timeout", ")", ")", "\n", "}", "\n", "c", ",", "chans", ",", "reqs", ",", "err", ":=", "ssh", ".", "NewClientConn", "(", "conn", ",", "addr", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "config", ".", "Timeout", ">", "0", "{", "conn", ".", "SetReadDeadline", "(", "time", ".", "Time", "{", "}", ")", "\n", "}", "\n", "return", "ssh", ".", "NewClient", "(", "c", ",", "chans", ",", "reqs", ")", ",", "nil", "\n", "}" ]

[ "NewClientConnWithDeadline", "establishes", "new", "client", "connection", "with", "specified", "deadline" ]

[ "func", "DialWithDeadline", "(", "network", "string", ",", "addr", "string", ",", "config", "*", "ssh", ".", "ClientConfig", ")", "(", "*", "ssh", ".", "Client", ",", "error", ")", "{", "conn", ",", "err", ":=", "net", ".", "DialTimeout", "(", "network", ",", "addr", ",", "config", ".", "Timeout", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "NewClientConnWithDeadline", "(", "conn", ",", "addr", ",", "config", ")", "\n", "}" ]

[ "DialWithDeadline", "works", "around", "the", "case", "when", "net", ".", "DialWithTimeout", "succeeds", "but", "key", "exchange", "hangs", ".", "Setting", "deadline", "on", "connection", "prevents", "this", "case", "from", "happening" ]

[ "func", "(", "d", "directDial", ")", "Dial", "(", "network", "string", ",", "addr", "string", ",", "config", "*", "ssh", ".", "ClientConfig", ")", "(", "*", "ssh", ".", "Client", ",", "error", ")", "{", "return", "DialWithDeadline", "(", "network", ",", "addr", ",", "config", ")", "\n", "}" ]

[ "Dial", "calls", "ssh", ".", "Dial", "directly", "." ]

[ "func", "(", "d", "proxyDial", ")", "Dial", "(", "network", "string", ",", "addr", "string", ",", "config", "*", "ssh", ".", "ClientConfig", ")", "(", "*", "ssh", ".", "Client", ",", "error", ")", "{", "// Build a proxy connection first.", "pconn", ",", "err", ":=", "dialProxy", "(", "context", ".", "Background", "(", ")", ",", "d", ".", "proxyHost", ",", "addr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "config", ".", "Timeout", ">", "0", "{", "pconn", ".", "SetReadDeadline", "(", "time", ".", "Now", "(", ")", ".", "Add", "(", "config", ".", "Timeout", ")", ")", "\n", "}", "\n", "// Do the same as ssh.Dial but pass in proxy connection.", "c", ",", "chans", ",", "reqs", ",", "err", ":=", "ssh", ".", "NewClientConn", "(", "pconn", ",", "addr", ",", "config", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "config", ".", "Timeout", ">", "0", "{", "pconn", ".", "SetReadDeadline", "(", "time", ".", "Time", "{", "}", ")", "\n", "}", "\n", "return", "ssh", ".", "NewClient", "(", "c", ",", "chans", ",", "reqs", ")", ",", "nil", "\n", "}" ]

[ "Dial", "first", "connects", "to", "a", "proxy", "then", "uses", "the", "connection", "to", "establish", "a", "new", "SSH", "connection", "." ]

[ "func", "DialerFromEnvironment", "(", "addr", "string", ")", "Dialer", "{", "// Try and get proxy addr from the environment.", "proxyAddr", ":=", "getProxyAddress", "(", "addr", ")", "\n\n", "// If no proxy settings are in environment return regular ssh dialer,", "// otherwise return a proxy dialer.", "if", "proxyAddr", "==", "\"", "\"", "{", "log", ".", "Debugf", "(", "\"", "\"", ")", "\n", "return", "directDial", "{", "}", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "proxyAddr", ")", "\n", "return", "proxyDial", "{", "proxyHost", ":", "proxyAddr", "}", "\n", "}" ]

[ "DialerFromEnvironment", "returns", "a", "Dial", "function", ".", "If", "the", "https_proxy", "or", "http_proxy", "environment", "variable", "are", "set", "it", "returns", "a", "function", "that", "will", "dial", "through", "said", "proxy", "server", ".", "If", "neither", "variable", "is", "set", "it", "will", "connect", "to", "the", "SSH", "server", "directly", "." ]

[ "func", "New", "(", "ctx", "context", ".", "Context", ",", "params", "backend", ".", "Params", ")", "(", "*", "EtcdBackend", ",", "error", ")", "{", "var", "err", "error", "\n", "if", "params", "==", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// convert generic backend parameters structure to etcd config:", "var", "cfg", "*", "Config", "\n", "if", "err", "=", "utils", ".", "ObjectToStruct", "(", "params", ",", "&", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "err", "=", "cfg", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "buf", ",", "err", ":=", "backend", ".", "NewCircularBuffer", "(", "ctx", ",", "cfg", ".", "BufferSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "closeCtx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "watchStarted", ",", "signalWatchStart", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n", "b", ":=", "&", "EtcdBackend", "{", "Entry", ":", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "trace", ".", "Component", ":", "GetName", "(", ")", "}", ")", ",", "cfg", ":", "cfg", ",", "nodes", ":", "cfg", ".", "Nodes", ",", "cancelC", ":", "make", "(", "chan", "bool", ",", "1", ")", ",", "stopC", ":", "make", "(", "chan", "bool", ",", "1", ")", ",", "clock", ":", "clockwork", ".", "NewRealClock", "(", ")", ",", "cancel", ":", "cancel", ",", "ctx", ":", "closeCtx", ",", "watchStarted", ":", "watchStarted", ",", "signalWatchStart", ":", "signalWatchStart", ",", "buf", ":", "buf", ",", "}", "\n", "if", "err", "=", "b", ".", "reconnect", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// Wrap backend in a input sanitizer and return it.", "return", "b", ",", "nil", "\n", "}" ]

[ "New", "returns", "new", "instance", "of", "Etcd", "-", "powered", "backend" ]

[ "func", "(", "b", "*", "EtcdBackend", ")", "KeepAlive", "(", "ctx", "context", ".", "Context", ",", "lease", "backend", ".", "Lease", ",", "expires", "time", ".", "Time", ")", "error", "{", "if", "lease", ".", "ID", "==", "0", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "re", ",", "err", ":=", "b", ".", "client", ".", "Get", "(", "ctx", ",", "prependPrefix", "(", "lease", ".", "Key", ")", ",", "clientv3", ".", "WithSerializable", "(", ")", ",", "clientv3", ".", "WithKeysOnly", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "convertErr", "(", "err", ")", "\n", "}", "\n", "if", "len", "(", "re", ".", "Kvs", ")", "==", "0", "{", "return", "trace", ".", "NotFound", "(", "\"", "\"", ",", "string", "(", "lease", ".", "Key", ")", ")", "\n", "}", "\n", "// instead of keep-alive on the old lease, setup a new lease", "// because we would like the event to be generated", "// which does not happen in case of lease keep-alive", "var", "opts", "[", "]", "clientv3", ".", "OpOption", "\n", "var", "newLease", "backend", ".", "Lease", "\n", "if", "err", ":=", "b", ".", "setupLease", "(", "ctx", ",", "backend", ".", "Item", "{", "Expires", ":", "expires", "}", ",", "&", "newLease", ",", "&", "opts", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "opts", "=", "append", "(", "opts", ",", "clientv3", ".", "WithIgnoreValue", "(", ")", ")", "\n", "kv", ":=", "re", ".", "Kvs", "[", "0", "]", "\n", "_", ",", "err", "=", "b", ".", "client", ".", "Put", "(", "ctx", ",", "string", "(", "kv", ".", "Key", ")", ",", "\"", "\"", ",", "opts", "...", ")", "\n", "return", "convertErr", "(", "err", ")", "\n", "}" ]

[ "KeepAlive", "updates", "TTL", "on", "the", "lease", "ID" ]

[ "func", "seconds", "(", "ttl", "time", ".", "Duration", ")", "int64", "{", "i", ":=", "int64", "(", "ttl", "/", "time", ".", "Second", ")", "\n", "if", "i", "<=", "0", "{", "i", "=", "1", "\n", "}", "\n", "return", "i", "\n", "}" ]

[ "seconds", "converts", "duration", "to", "seconds", "rounds", "up", "to", "1", "second" ]

[ "func", "(", "a", "*", "AuthCommand", ")", "GenerateKeys", "(", ")", "error", "{", "keygen", ",", "err", ":=", "native", ".", "New", "(", "context", ".", "TODO", "(", ")", ",", "native", ".", "PrecomputeKeys", "(", "0", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "defer", "keygen", ".", "Close", "(", ")", "\n", "privBytes", ",", "pubBytes", ",", "err", ":=", "keygen", ".", "GenerateKeyPair", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "ioutil", ".", "WriteFile", "(", "a", ".", "genPubPath", ",", "pubBytes", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "err", "=", "ioutil", ".", "WriteFile", "(", "a", ".", "genPrivPath", ",", "privBytes", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "a", ".", "genPubPath", ",", "a", ".", "genPrivPath", ")", "\n", "return", "nil", "\n", "}" ]

[ "GenerateKeys", "generates", "a", "new", "keypair" ]

[ "func", "(", "a", "*", "AuthCommand", ")", "GenerateAndSignKeys", "(", "clusterApi", "auth", ".", "ClientI", ")", "error", "{", "switch", "{", "case", "a", ".", "genUser", "!=", "\"", "\"", "&&", "a", ".", "genHost", "==", "\"", "\"", ":", "return", "a", ".", "generateUserKeys", "(", "clusterApi", ")", "\n", "case", "a", ".", "genUser", "==", "\"", "\"", "&&", "a", ".", "genHost", "!=", "\"", "\"", ":", "return", "a", ".", "generateHostKeys", "(", "clusterApi", ")", "\n", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "GenerateAndSignKeys", "generates", "a", "new", "keypair", "and", "signs", "it", "for", "role" ]

[ "func", "(", "a", "*", "AuthCommand", ")", "RotateCertAuthority", "(", "client", "auth", ".", "ClientI", ")", "error", "{", "req", ":=", "auth", ".", "RotateRequest", "{", "Type", ":", "services", ".", "CertAuthType", "(", "a", ".", "rotateType", ")", ",", "GracePeriod", ":", "&", "a", ".", "rotateGracePeriod", ",", "TargetPhase", ":", "a", ".", "rotateTargetPhase", ",", "}", "\n", "if", "a", ".", "rotateManualMode", "{", "req", ".", "Mode", "=", "services", ".", "RotationModeManual", "\n", "}", "else", "{", "req", ".", "Mode", "=", "services", ".", "RotationModeAuto", "\n", "}", "\n", "if", "err", ":=", "client", ".", "RotateCertAuthority", "(", "req", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "a", ".", "rotateTargetPhase", "!=", "\"", "\"", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "a", ".", "rotateTargetPhase", ")", "\n", "}", "else", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "RotateCertAuthority", "starts", "or", "restarts", "certificate", "authority", "rotation", "process" ]

[ "func", "CollectOptions", "(", "opts", "[", "]", "OpOption", ")", "(", "*", "OpConfig", ",", "error", ")", "{", "cfg", ":=", "OpConfig", "{", "}", "\n", "for", "_", ",", "o", ":=", "range", "opts", "{", "if", "err", ":=", "o", "(", "&", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "&", "cfg", ",", "nil", "\n", "}" ]

[ "CollectOptions", "collects", "all", "options", "from", "functional", "arg", "and", "returns", "config" ]

[ "func", "ValidateLockTTL", "(", "ttl", "time", ".", "Duration", ")", "error", "{", "if", "ttl", "==", "Forever", "||", "ttl", ">", "MaxLockDuration", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "MaxLockDuration", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ValidateLockTTL", "helper", "allows", "all", "backends", "to", "validate", "lock", "TTL", "parameter" ]

[ "func", "TTL", "(", "clock", "clockwork", ".", "Clock", ",", "t", "time", ".", "Time", ")", "time", ".", "Duration", "{", "if", "t", ".", "IsZero", "(", ")", "{", "return", "Forever", "\n", "}", "\n", "diff", ":=", "t", ".", "UTC", "(", ")", ".", "Sub", "(", "clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ")", "\n", "if", "diff", "<", "0", "{", "return", "Forever", "\n", "}", "\n", "return", "diff", "\n", "}" ]

[ "TTL", "converts", "time", "to", "TTL", "from", "current", "time", "supplied", "by", "provider", "if", "t", "is", "zero", "returns", "forever" ]