Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "a", "*", "AuthWithRoles", ")", "SetClusterConfig", "(", "c", "services", ".", "ClusterConfig", ")", "error", "{", "if", "err", ":=", "a", ".", "action", "(", "defaults", ".", "Namespace", ",", "services", ".", "KindClusterConfig", ",", "services", ".", "VerbCreate", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "a", ".", "action", "(", "defaults", ".", "Namespace", ",", "services", ".", "KindClusterConfig", ",", "services", ".", "VerbUpdate", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "a", ".", "authServer", ".", "SetClusterConfig", "(", "c", ")", "\n", "}" ]

[ "SetClusterConfig", "sets", "cluster", "level", "configuration", "." ]

[ "func", "(", "a", "*", "AuthWithRoles", ")", "GetClusterName", "(", "opts", "...", "services", ".", "MarshalOption", ")", "(", "services", ".", "ClusterName", ",", "error", ")", "{", "if", "err", ":=", "a", ".", "action", "(", "defaults", ".", "Namespace", ",", "services", ".", "KindClusterName", ",", "services", ".", "VerbRead", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "a", ".", "authServer", ".", "GetClusterName", "(", ")", "\n", "}" ]

[ "GetClusterName", "gets", "the", "name", "of", "the", "cluster", "." ]

[ "func", "(", "a", "*", "AuthWithRoles", ")", "SetClusterName", "(", "c", "services", ".", "ClusterName", ")", "error", "{", "if", "err", ":=", "a", ".", "action", "(", "defaults", ".", "Namespace", ",", "services", ".", "KindClusterName", ",", "services", ".", "VerbCreate", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", ":=", "a", ".", "action", "(", "defaults", ".", "Namespace", ",", "services", ".", "KindClusterName", ",", "services", ".", "VerbUpdate", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "a", ".", "authServer", ".", "SetClusterName", "(", "c", ")", "\n", "}" ]

[ "SetClusterName", "sets", "the", "name", "of", "the", "cluster", ".", "SetClusterName", "can", "only", "be", "called", "once", "." ]

[ "func", "NewAdminAuthServer", "(", "authServer", "*", "AuthServer", ",", "sessions", "session", ".", "Service", ",", "alog", "events", ".", "IAuditLog", ")", "(", "ClientI", ",", "error", ")", "{", "ctx", ",", "err", ":=", "NewAdminContext", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "&", "AuthWithRoles", "{", "authServer", ":", "authServer", ",", "checker", ":", "ctx", ".", "Checker", ",", "user", ":", "ctx", ".", "User", ",", "alog", ":", "alog", ",", "sessions", ":", "sessions", ",", "}", ",", "nil", "\n", "}" ]

[ "NewAdminAuthServer", "returns", "auth", "server", "authorized", "as", "admin", "used", "for", "auth", "server", "cached", "access" ]

[ "func", "NewAuthWithRoles", "(", "authServer", "*", "AuthServer", ",", "checker", "services", ".", "AccessChecker", ",", "user", "services", ".", "User", ",", "sessions", "session", ".", "Service", ",", "alog", "events", ".", "IAuditLog", ")", "*", "AuthWithRoles", "{", "return", "&", "AuthWithRoles", "{", "authServer", ":", "authServer", ",", "checker", ":", "checker", ",", "sessions", ":", "sessions", ",", "user", ":", "user", ",", "alog", ":", "alog", ",", "}", "\n", "}" ]

[ "NewAuthWithRoles", "creates", "new", "auth", "server", "with", "access", "control" ]

[ "func", "(", "l", "*", "localFileSystem", ")", "SetChmod", "(", "path", "string", ",", "mode", "int", ")", "error", "{", "chmode", ":=", "os", ".", "FileMode", "(", "mode", "&", "int", "(", "os", ".", "ModePerm", ")", ")", "\n", "if", "err", ":=", "os", ".", "Chmod", "(", "path", ",", "chmode", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "SetChmod", "sets", "file", "permissions" ]

[ "func", "(", "l", "*", "localFileSystem", ")", "MkDir", "(", "path", "string", ",", "mode", "int", ")", "error", "{", "fileMode", ":=", "os", ".", "FileMode", "(", "mode", "&", "int", "(", "os", ".", "ModePerm", ")", ")", "\n", "err", ":=", "os", ".", "MkdirAll", "(", "path", ",", "fileMode", ")", "\n", "if", "err", "!=", "nil", "&&", "!", "os", ".", "IsExist", "(", "err", ")", "{", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "MkDir", "creates", "a", "directory" ]

[ "func", "(", "l", "*", "localFileSystem", ")", "OpenFile", "(", "filePath", "string", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "f", ",", "nil", "\n", "}" ]

[ "OpenFile", "opens", "a", "file", "for", "read", "operations", "and", "returns", "a", "Reader" ]

[ "func", "(", "l", "*", "localFileSystem", ")", "GetFileInfo", "(", "filePath", "string", ")", "(", "FileInfo", ",", "error", ")", "{", "info", ",", "err", ":=", "makeFileInfo", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "info", ",", "nil", "\n", "}" ]

[ "GetFileInfo", "returns", "FileInfo", "for", "a", "given", "file", "path" ]

[ "func", "(", "l", "*", "localFileSystem", ")", "CreateFile", "(", "filePath", "string", ",", "length", "uint64", ")", "(", "io", ".", "WriteCloser", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Create", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "f", ",", "nil", "\n", "}" ]

[ "CreateFile", "creates", "a", "new", "file", "and", "returns", "a", "Writer" ]

[ "func", "(", "l", "*", "localFileInfo", ")", "ReadDir", "(", ")", "(", "[", "]", "FileInfo", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "l", ".", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "fis", ",", "err", ":=", "f", ".", "Readdir", "(", "0", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "infos", ":=", "make", "(", "[", "]", "FileInfo", ",", "len", "(", "fis", ")", ")", "\n", "for", "i", ":=", "range", "fis", "{", "fi", ":=", "fis", "[", "i", "]", "\n", "info", ",", "err", ":=", "makeFileInfo", "(", "filepath", ".", "Join", "(", "l", ".", "GetPath", "(", ")", ",", "fi", ".", "Name", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "infos", "[", "i", "]", "=", "info", "\n", "}", "\n\n", "return", "infos", ",", "nil", "\n", "}" ]

[ "ReadDir", "returns", "all", "files", "in", "this", "directory" ]

[ "func", "(", "l", "*", "localFileInfo", ")", "GetModePerm", "(", ")", "os", ".", "FileMode", "{", "return", "l", ".", "fileInfo", ".", "Mode", "(", ")", "&", "os", ".", "ModePerm", "\n", "}" ]

[ "GetModePerm", "returns", "file", "permissions" ]

[ "func", "(", "s", "*", "remoteSite", ")", "Close", "(", ")", "error", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "s", ".", "cancel", "(", ")", "\n", "for", "i", ":=", "range", "s", ".", "connections", "{", "s", ".", "connections", "[", "i", "]", ".", "Close", "(", ")", "\n", "}", "\n", "s", ".", "connections", "=", "[", "]", "*", "remoteConn", "{", "}", "\n", "return", "nil", "\n", "}" ]

[ "Clos", "closes", "remote", "cluster", "connections" ]

[ "func", "(", "s", "*", "remoteSite", ")", "nextConn", "(", ")", "(", "*", "remoteConn", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "s", ".", "removeInvalidConns", "(", ")", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "s", ".", "connections", ")", ";", "i", "++", "{", "s", ".", "lastUsed", "=", "(", "s", ".", "lastUsed", "+", "1", ")", "%", "len", "(", "s", ".", "connections", ")", "\n", "remoteConn", ":=", "s", ".", "connections", "[", "s", ".", "lastUsed", "]", "\n", "// connection could have been initated, but agent", "// on the other side is not ready yet.", "// Proxy assumes that connection is ready to serve when", "// it has received a first heartbeat, otherwise", "// it could attempt to use it before the agent", "// had a chance to start handling connection requests,", "// what could lead to proxy marking the connection", "// as invalid without a good reason.", "if", "remoteConn", ".", "isReady", "(", ")", "{", "return", "remoteConn", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "s", ".", "GetName", "(", ")", ",", "s", ".", "srv", ".", "ClusterName", ")", "\n", "}" ]

[ "nextConn", "returns", "next", "connection", "that", "is", "ready", "and", "has", "not", "been", "marked", "as", "invalid", "it", "will", "close", "connections", "marked", "as", "invalid" ]

[ "func", "(", "s", "*", "remoteSite", ")", "removeInvalidConns", "(", ")", "{", "// for first pass, do nothing if no connections are marked", "count", ":=", "0", "\n", "for", "_", ",", "conn", ":=", "range", "s", ".", "connections", "{", "if", "conn", ".", "isInvalid", "(", ")", "{", "count", "++", "\n", "}", "\n", "}", "\n", "if", "count", "==", "0", "{", "return", "\n", "}", "\n", "s", ".", "lastUsed", "=", "0", "\n", "conns", ":=", "make", "(", "[", "]", "*", "remoteConn", ",", "0", ",", "len", "(", "s", ".", "connections", ")", "-", "count", ")", "\n", "for", "i", ":=", "range", "s", ".", "connections", "{", "if", "!", "s", ".", "connections", "[", "i", "]", ".", "isInvalid", "(", ")", "{", "conns", "=", "append", "(", "conns", ",", "s", ".", "connections", "[", "i", "]", ")", "\n", "}", "else", "{", "go", "s", ".", "connections", "[", "i", "]", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n", "s", ".", "connections", "=", "conns", "\n", "}" ]

[ "removeInvalidConns", "removes", "connections", "marked", "as", "invalid", "it", "should", "be", "called", "only", "under", "write", "lock" ]

[ "func", "(", "s", "*", "remoteSite", ")", "addConn", "(", "conn", "net", ".", "Conn", ",", "sconn", "ssh", ".", "Conn", ")", "(", "*", "remoteConn", ",", "error", ")", "{", "s", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "Unlock", "(", ")", "\n\n", "cn", ",", "err", ":=", "s", ".", "localAccessPoint", ".", "GetClusterName", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "rconn", ":=", "newRemoteConn", "(", "&", "connConfig", "{", "conn", ":", "conn", ",", "sconn", ":", "sconn", ",", "accessPoint", ":", "s", ".", "localAccessPoint", ",", "tunnelID", ":", "cn", ".", "GetClusterName", "(", ")", ",", "tunnelType", ":", "string", "(", "services", ".", "ProxyTunnel", ")", ",", "proxyName", ":", "s", ".", "connInfo", ".", "GetProxyName", "(", ")", ",", "clusterName", ":", "s", ".", "domainName", ",", "}", ")", "\n\n", "s", ".", "connections", "=", "append", "(", "s", ".", "connections", ",", "rconn", ")", "\n", "s", ".", "lastUsed", "=", "0", "\n", "return", "rconn", ",", "nil", "\n", "}" ]

[ "addConn", "helper", "adds", "a", "new", "active", "remote", "cluster", "connection", "to", "the", "list", "of", "such", "connections" ]

[ "func", "(", "s", "*", "remoteSite", ")", "deleteConnectionRecord", "(", ")", "{", "s", ".", "localAccessPoint", ".", "DeleteTunnelConnection", "(", "s", ".", "connInfo", ".", "GetClusterName", "(", ")", ",", "s", ".", "connInfo", ".", "GetName", "(", ")", ")", "\n", "}" ]

[ "deleteConnectionRecord", "deletes", "connection", "record", "to", "let", "know", "peer", "proxies", "that", "this", "node", "lost", "the", "connection", "and", "needs", "to", "be", "discovered" ]

[ "func", "(", "s", "*", "remoteSite", ")", "handleHeartbeat", "(", "conn", "*", "remoteConn", ",", "ch", "ssh", ".", "Channel", ",", "reqC", "<-", "chan", "*", "ssh", ".", "Request", ")", "{", "defer", "func", "(", ")", "{", "s", ".", "Infof", "(", "\"", "\"", ")", "\n", "conn", ".", "Close", "(", ")", "\n", "}", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "s", ".", "ctx", ".", "Done", "(", ")", ":", "s", ".", "Infof", "(", "\"", "\"", ")", "\n", "return", "\n", "case", "req", ":=", "<-", "reqC", ":", "if", "req", "==", "nil", "{", "s", ".", "Infof", "(", "\"", "\"", ")", "\n", "conn", ".", "markInvalid", "(", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ")", ")", "\n", "if", "!", "s", ".", "hasValidConnections", "(", ")", "{", "s", ".", "Debugf", "(", "\"", "\"", ")", "\n", "s", ".", "deleteConnectionRecord", "(", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "var", "timeSent", "time", ".", "Time", "\n", "var", "roundtrip", "time", ".", "Duration", "\n", "if", "req", ".", "Payload", "!=", "nil", "{", "if", "err", ":=", "timeSent", ".", "UnmarshalText", "(", "req", ".", "Payload", ")", ";", "err", "==", "nil", "{", "roundtrip", "=", "s", ".", "srv", ".", "Clock", ".", "Now", "(", ")", ".", "Sub", "(", "timeSent", ")", "\n", "}", "\n", "}", "\n", "if", "roundtrip", "!=", "0", "{", "s", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "roundtrip", "}", ")", ".", "Debugf", "(", "\"", "\"", ",", "conn", ".", "conn", ".", "RemoteAddr", "(", ")", ")", "\n", "}", "else", "{", "s", ".", "Debugf", "(", "\"", "\"", ",", "conn", ".", "conn", ".", "RemoteAddr", "(", ")", ")", "\n", "}", "\n", "tm", ":=", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", "\n", "conn", ".", "setLastHeartbeat", "(", "tm", ")", "\n", "go", "s", ".", "registerHeartbeat", "(", "tm", ")", "\n", "// since we block on select, time.After is re-created everytime we process a request.", "case", "<-", "time", ".", "After", "(", "defaults", ".", "ReverseTunnelOfflineThreshold", ")", ":", "conn", ".", "markInvalid", "(", "trace", ".", "ConnectionProblem", "(", "nil", ",", "\"", "\"", ",", "defaults", ".", "ReverseTunnelOfflineThreshold", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "handleHearbeat", "receives", "heartbeat", "messages", "from", "the", "connected", "agent", "if", "the", "agent", "has", "missed", "several", "heartbeats", "in", "a", "row", "Proxy", "marks", "the", "connection", "as", "invalid", "." ]

[ "func", "(", "s", "*", "remoteSite", ")", "updateCertAuthorities", "(", ")", "error", "{", "// update main cluster cert authorities on the remote side", "// remote side makes sure that only relevant fields", "// are updated", "hostCA", ",", "err", ":=", "s", ".", "localClient", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "HostCA", ",", "DomainName", ":", "s", ".", "srv", ".", "ClusterName", ",", "}", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "s", ".", "remoteClient", ".", "RotateExternalCertAuthority", "(", "hostCA", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "userCA", ",", "err", ":=", "s", ".", "localClient", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "UserCA", ",", "DomainName", ":", "s", ".", "srv", ".", "ClusterName", ",", "}", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "s", ".", "remoteClient", ".", "RotateExternalCertAuthority", "(", "userCA", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// update remote cluster's host cert authoritiy on a local cluster", "// local proxy is authorized to perform this operation only for", "// host authorities of remote clusters.", "remoteCA", ",", "err", ":=", "s", ".", "remoteClient", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "HostCA", ",", "DomainName", ":", "s", ".", "domainName", ",", "}", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "if", "remoteCA", ".", "GetClusterName", "(", ")", "!=", "s", ".", "domainName", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "remoteCA", ".", "GetClusterName", "(", ")", ",", "s", ".", "domainName", ")", "\n", "}", "\n", "err", "=", "s", ".", "localClient", ".", "UpsertCertAuthority", "(", "remoteCA", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "s", ".", "compareAndSwapCertAuthority", "(", "remoteCA", ")", "\n", "}" ]

[ "updateCertAuthorities", "updates", "local", "and", "remote", "cert", "authorities" ]

[ "func", "(", "r", "*", "ReporterConfig", ")", "CheckAndSetDefaults", "(", ")", "error", "{", "if", "r", ".", "Backend", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "r", ".", "Component", "==", "\"", "\"", "{", "r", ".", "Component", "=", "teleport", ".", "ComponentBackend", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "checks", "and", "sets" ]

[ "func", "NewReporter", "(", "cfg", "ReporterConfig", ")", "(", "*", "Reporter", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "r", ":=", "&", "Reporter", "{", "ReporterConfig", ":", "cfg", ",", "}", "\n", "return", "r", ",", "nil", "\n", "}" ]

[ "NewReporter", "returns", "a", "new", "Reporter", "." ]

[ "func", "(", "s", "*", "Reporter", ")", "trackRequest", "(", "opType", "OpType", ",", "key", "[", "]", "byte", ",", "endKey", "[", "]", "byte", ")", "{", "if", "!", "s", ".", "TrackTopRequests", "{", "return", "\n", "}", "\n", "if", "len", "(", "key", ")", "==", "0", "{", "return", "\n", "}", "\n", "// take just the first two parts, otherwise too many distinct requests", "// can end up in the map", "parts", ":=", "bytes", ".", "Split", "(", "key", ",", "[", "]", "byte", "{", "Separator", "}", ")", "\n", "if", "len", "(", "parts", ")", ">", "3", "{", "parts", "=", "parts", "[", ":", "3", "]", "\n", "}", "\n", "rangeSuffix", ":=", "teleport", ".", "TagFalse", "\n", "if", "len", "(", "endKey", ")", "!=", "0", "{", "// Range denotes range queries in stat entry", "rangeSuffix", "=", "teleport", ".", "TagTrue", "\n", "}", "\n", "counter", ",", "err", ":=", "requests", ".", "GetMetricWithLabelValues", "(", "s", ".", "Component", ",", "string", "(", "bytes", ".", "Join", "(", "parts", ",", "[", "]", "byte", "{", "Separator", "}", ")", ")", ",", "rangeSuffix", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "counter", ".", "Inc", "(", ")", "\n", "}" ]

[ "trackRequests", "tracks", "top", "requests", "endKey", "is", "supplied", "for", "ranges" ]

[ "func", "NewReporterWatcher", "(", "ctx", "context", ".", "Context", ",", "component", "string", ",", "w", "Watcher", ")", "*", "ReporterWatcher", "{", "rw", ":=", "&", "ReporterWatcher", "{", "Watcher", ":", "w", ",", "Component", ":", "component", ",", "}", "\n", "go", "rw", ".", "watch", "(", "ctx", ")", "\n", "return", "rw", "\n", "}" ]

[ "NewReporterWatcher", "creates", "new", "reporter", "watcher", "instance" ]

[ "func", "MakeTable", "(", "headers", "[", "]", "string", ")", "Table", "{", "t", ":=", "MakeHeadlessTable", "(", "len", "(", "headers", ")", ")", "\n", "for", "i", ":=", "range", "t", ".", "columns", "{", "t", ".", "columns", "[", "i", "]", ".", "title", "=", "headers", "[", "i", "]", "\n", "t", ".", "columns", "[", "i", "]", ".", "width", "=", "len", "(", "headers", "[", "i", "]", ")", "\n", "}", "\n", "return", "t", "\n", "}" ]

[ "MakeTable", "creates", "a", "new", "instance", "of", "the", "table", "with", "given", "column", "names", "." ]

[ "func", "MakeHeadlessTable", "(", "columnCount", "int", ")", "Table", "{", "return", "Table", "{", "columns", ":", "make", "(", "[", "]", "column", ",", "columnCount", ")", ",", "rows", ":", "make", "(", "[", "]", "[", "]", "string", ",", "0", ")", ",", "}", "\n", "}" ]

[ "MakeTable", "creates", "a", "new", "instance", "of", "the", "table", "without", "any", "column", "names", ".", "The", "number", "of", "columns", "is", "required", "." ]

[ "func", "(", "t", "*", "Table", ")", "AddRow", "(", "row", "[", "]", "string", ")", "{", "limit", ":=", "min", "(", "len", "(", "row", ")", ",", "len", "(", "t", ".", "columns", ")", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "limit", ";", "i", "++", "{", "cellWidth", ":=", "len", "(", "row", "[", "i", "]", ")", "\n", "t", ".", "columns", "[", "i", "]", ".", "width", "=", "max", "(", "cellWidth", ",", "t", ".", "columns", "[", "i", "]", ".", "width", ")", "\n", "}", "\n", "t", ".", "rows", "=", "append", "(", "t", ".", "rows", ",", "row", "[", ":", "limit", "]", ")", "\n", "}" ]

[ "AddRow", "adds", "a", "row", "of", "cells", "to", "the", "table", "." ]

[ "func", "(", "t", "*", "Table", ")", "IsHeadless", "(", ")", "bool", "{", "total", ":=", "0", "\n", "for", "i", ":=", "range", "t", ".", "columns", "{", "total", "+=", "len", "(", "t", ".", "columns", "[", "i", "]", ".", "title", ")", "\n", "}", "\n", "return", "total", "==", "0", "\n", "}" ]

[ "IsHeadless", "returns", "true", "if", "none", "of", "the", "table", "title", "cells", "contains", "any", "text", "." ]

[ "func", "ParseSessionsURI", "(", "in", "string", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "{", "if", "in", "==", "\"", "\"", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "u", ",", "err", ":=", "url", ".", "Parse", "(", "in", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "in", ",", "err", ")", "\n", "}", "\n", "if", "u", ".", "Scheme", "==", "\"", "\"", "{", "u", ".", "Scheme", "=", "teleport", ".", "SchemeFile", "\n", "}", "\n", "return", "u", ",", "nil", "\n", "}" ]

[ "ParseSessionsURI", "parses", "uri", "per", "convention", "of", "session", "upload", "URIs", "file", "is", "a", "default", "scheme" ]

[ "func", "GetIterations", "(", ")", "int", "{", "out", ":=", "os", ".", "Getenv", "(", "teleport", ".", "IterationsEnvVar", ")", "\n", "if", "out", "==", "\"", "\"", "{", "return", "1", "\n", "}", "\n", "iter", ",", "err", ":=", "strconv", ".", "Atoi", "(", "out", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "iter", ")", "\n", "return", "iter", "\n", "}" ]

[ "GetIterations", "provides", "a", "simple", "way", "to", "add", "iterations", "to", "the", "test", "by", "setting", "environment", "variable", "ITERATIONS", "by", "default", "it", "returns", "1" ]

[ "func", "UserMessageFromError", "(", "err", "error", ")", "string", "{", "// untrusted cert?", "switch", "innerError", ":=", "trace", ".", "Unwrap", "(", "err", ")", ".", "(", "type", ")", "{", "case", "x509", ".", "HostnameError", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\\n", "\"", ",", "innerError", ".", "Host", ",", "innerError", ".", "Error", "(", ")", ",", "\"", "\"", ")", "\n", "case", "x509", ".", "UnknownAuthorityError", ":", "return", "`WARNING:\n\n The proxy you are connecting to has presented a certificate signed by a\n unknown authority. This is most likely due to either being presented\n with a self-signed certificate or the certificate was truly signed by an\n authority not known to the client.\n\n If you know the certificate is self-signed and would like to ignore this\n error use the --insecure flag.\n\n If you have your own certificate authority that you would like to use to\n validate the certificate chain presented by the proxy, set the\n SSL_CERT_FILE and SSL_CERT_DIR environment variables respectively and try\n again.\n\n If you think something malicious may be occurring, contact your Teleport\n system administrator to resolve this issue.\n`", "\n", "case", "x509", ".", "CertificateInvalidError", ":", "return", "fmt", ".", "Sprintf", "(", "`WARNING:\n\n The certificate presented by the proxy is invalid: %v.\n\n Contact your Teleport system administrator to resolve this issue.`", ",", "innerError", ")", "\n", "}", "\n", "if", "log", ".", "GetLevel", "(", ")", "==", "log", ".", "DebugLevel", "{", "return", "trace", ".", "DebugReport", "(", "err", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "// If the error is a trace error, check if it has a user message embedded in", "// it. If a user message is embedded in it, print the user message and the", "// original error. Otherwise return the original with a generic \"A fatal", "// error occurred\" message.", "if", "er", ",", "ok", ":=", "err", ".", "(", "*", "trace", ".", "TraceErr", ")", ";", "ok", "{", "if", "er", ".", "Message", "!=", "\"", "\"", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "EscapeControl", "(", "er", ".", "Message", ")", ")", "\n", "}", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "EscapeControl", "(", "err", ".", "Error", "(", ")", ")", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "UserMessageFromError", "returns", "user", "friendly", "error", "message", "from", "error" ]

[ "func", "InitCLIParser", "(", "appName", ",", "appHelp", "string", ")", "(", "app", "*", "kingpin", ".", "Application", ")", "{", "app", "=", "kingpin", ".", "New", "(", "appName", ",", "appHelp", ")", "\n\n", "// hide \"--help\" flag", "app", ".", "HelpFlag", ".", "Hidden", "(", ")", "\n", "app", ".", "HelpFlag", ".", "NoEnvar", "(", ")", "\n\n", "// set our own help template", "return", "app", ".", "UsageTemplate", "(", "defaultUsageTemplate", ")", "\n", "}" ]

[ "InitCLIParser", "configures", "kingpin", "command", "line", "args", "parser", "with", "some", "defaults", "common", "for", "all", "Teleport", "CLI", "tools" ]

[ "func", "needsQuoting", "(", "text", "string", ")", "bool", "{", "for", "_", ",", "r", ":=", "range", "text", "{", "if", "!", "strconv", ".", "IsPrint", "(", "r", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "needsQuoting", "returns", "true", "if", "any", "non", "-", "printable", "characters", "are", "found", "." ]

[ "func", "MakeServers", "(", "clusterName", "string", ",", "servers", "[", "]", "services", ".", "Server", ")", "[", "]", "Server", "{", "uiServers", ":=", "[", "]", "Server", "{", "}", "\n", "for", "_", ",", "server", ":=", "range", "servers", "{", "uiLabels", ":=", "[", "]", "Label", "{", "}", "\n", "serverLabels", ":=", "server", ".", "GetLabels", "(", ")", "\n", "for", "name", ",", "value", ":=", "range", "serverLabels", "{", "uiLabels", "=", "append", "(", "uiLabels", ",", "Label", "{", "Name", ":", "name", ",", "Value", ":", "value", ",", "}", ")", "\n", "}", "\n\n", "serverCmdLabels", ":=", "server", ".", "GetCmdLabels", "(", ")", "\n", "for", "name", ",", "cmd", ":=", "range", "serverCmdLabels", "{", "uiLabels", "=", "append", "(", "uiLabels", ",", "Label", "{", "Name", ":", "name", ",", "Value", ":", "cmd", ".", "GetResult", "(", ")", ",", "}", ")", "\n", "}", "\n\n", "sort", ".", "Sort", "(", "sortedLabels", "(", "uiLabels", ")", ")", "\n\n", "uiServers", "=", "append", "(", "uiServers", ",", "Server", "{", "ClusterName", ":", "clusterName", ",", "Name", ":", "server", ".", "GetName", "(", ")", ",", "Hostname", ":", "server", ".", "GetHostname", "(", ")", ",", "Addr", ":", "server", ".", "GetAddr", "(", ")", ",", "Labels", ":", "uiLabels", ",", "}", ")", "\n", "}", "\n\n", "return", "uiServers", "\n", "}" ]

[ "MakeServers", "creates", "server", "objects", "for", "webapp" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "printShutdownStatus", "(", "ctx", "context", ".", "Context", ")", "{", "t", ":=", "time", ".", "NewTicker", "(", "defaults", ".", "HighResReportingPeriod", ")", "\n", "defer", "t", ".", "Stop", "(", ")", "\n", "for", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "case", "<-", "t", ".", "C", ":", "log", ".", "Infof", "(", "\"", "\"", ",", "process", ".", "Supervisor", ".", "Services", "(", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "printShutdownStatus", "prints", "running", "services", "until", "shut", "down" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "closeImportedDescriptors", "(", "prefix", "string", ")", "error", "{", "process", ".", "Lock", "(", ")", "\n", "defer", "process", ".", "Unlock", "(", ")", "\n\n", "var", "errors", "[", "]", "error", "\n", "for", "i", ":=", "range", "process", ".", "importedDescriptors", "{", "d", ":=", "process", ".", "importedDescriptors", "[", "i", "]", "\n", "if", "strings", ".", "HasPrefix", "(", "d", ".", "Type", ",", "prefix", ")", "{", "process", ".", "Infof", "(", "\"", "\"", ",", "d", ".", "Type", ",", "d", ".", "Address", ")", "\n", "errors", "=", "append", "(", "errors", ",", "d", ".", "File", ".", "Close", "(", ")", ")", "\n", "}", "\n", "}", "\n", "return", "trace", ".", "NewAggregate", "(", "errors", "...", ")", "\n", "}" ]

[ "closeImportedDescriptors", "closes", "imported", "but", "unused", "file", "descriptors", "what", "could", "happen", "if", "service", "has", "updated", "configuration" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "importListener", "(", "listenerType", ",", "address", "string", ")", "(", "net", ".", "Listener", ",", "error", ")", "{", "process", ".", "Lock", "(", ")", "\n", "defer", "process", ".", "Unlock", "(", ")", "\n\n", "for", "i", ":=", "range", "process", ".", "importedDescriptors", "{", "d", ":=", "process", ".", "importedDescriptors", "[", "i", "]", "\n", "if", "d", ".", "Type", "==", "listenerType", "&&", "d", ".", "Address", "==", "address", "{", "l", ",", "err", ":=", "d", ".", "ToListener", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "process", ".", "importedDescriptors", "=", "append", "(", "process", ".", "importedDescriptors", "[", ":", "i", "]", ",", "process", ".", "importedDescriptors", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "process", ".", "registeredListeners", "=", "append", "(", "process", ".", "registeredListeners", ",", "RegisteredListener", "{", "Type", ":", "listenerType", ",", "Address", ":", "address", ",", "Listener", ":", "l", "}", ")", "\n", "return", "l", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "listenerType", ",", "address", ")", "\n", "}" ]

[ "importListener", "imports", "listener", "passed", "by", "the", "parent", "process", "if", "no", "listener", "is", "found", "returns", "NotFound", "otherwise", "removes", "the", "file", "from", "the", "list" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "createListener", "(", "listenerType", ",", "address", "string", ")", "(", "net", ".", "Listener", ",", "error", ")", "{", "listener", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "process", ".", "Lock", "(", ")", "\n", "defer", "process", ".", "Unlock", "(", ")", "\n", "r", ":=", "RegisteredListener", "{", "Type", ":", "listenerType", ",", "Address", ":", "address", ",", "Listener", ":", "listener", "}", "\n", "process", ".", "registeredListeners", "=", "append", "(", "process", ".", "registeredListeners", ",", "r", ")", "\n", "return", "listener", ",", "nil", "\n", "}" ]

[ "createListener", "creates", "listener", "and", "adds", "to", "a", "list", "of", "tracked", "listeners" ]

[ "func", "(", "process", "*", "TeleportProcess", ")", "ExportFileDescriptors", "(", ")", "(", "[", "]", "FileDescriptor", ",", "error", ")", "{", "var", "out", "[", "]", "FileDescriptor", "\n", "process", ".", "Lock", "(", ")", "\n", "defer", "process", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "r", ":=", "range", "process", ".", "registeredListeners", "{", "file", ",", "err", ":=", "utils", ".", "GetListenerFile", "(", "r", ".", "Listener", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "out", "=", "append", "(", "out", ",", "FileDescriptor", "{", "File", ":", "file", ",", "Type", ":", "r", ".", "Type", ",", "Address", ":", "r", ".", "Address", "}", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "ExportFileDescriptors", "exports", "file", "descriptors", "to", "be", "passed", "to", "child", "process" ]

[ "func", "importFileDescriptors", "(", ")", "(", "[", "]", "FileDescriptor", ",", "error", ")", "{", "// These files may be passed in by the parent process", "filesString", ":=", "os", ".", "Getenv", "(", "teleportFilesEnvVar", ")", "\n", "if", "filesString", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "files", ",", "err", ":=", "filesFromString", "(", "filesString", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "len", "(", "files", ")", "!=", "0", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "files", ")", "\n", "}", "\n\n", "return", "files", ",", "nil", "\n", "}" ]

[ "importFileDescriptors", "imports", "file", "descriptors", "from", "environment", "if", "there", "are", "any" ]

[ "func", "NewForwardRecorder", "(", "cfg", "ForwardRecorderConfig", ")", "(", "*", "ForwardRecorder", ",", "error", ")", "{", "if", "err", ":=", "cfg", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "// Always write sessions to local disk first, then forward them to the Auth", "// Server later.", "auditLog", ",", "err", ":=", "NewForwarder", "(", "ForwarderConfig", "{", "SessionID", ":", "cfg", ".", "SessionID", ",", "ServerID", ":", "teleport", ".", "ComponentUpload", ",", "DataDir", ":", "cfg", ".", "DataDir", ",", "RecordSessions", ":", "cfg", ".", "RecordSessions", ",", "Namespace", ":", "cfg", ".", "Namespace", ",", "ForwardTo", ":", "cfg", ".", "ForwardTo", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "sr", ":=", "&", "ForwardRecorder", "{", "ForwardRecorderConfig", ":", "cfg", ",", "Entry", ":", "logrus", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "trace", ".", "Component", ":", "cfg", ".", "Component", ",", "}", ")", ",", "AuditLog", ":", "auditLog", ",", "}", "\n", "return", "sr", ",", "nil", "\n", "}" ]

[ "NewForwardRecorder", "returns", "a", "new", "instance", "of", "session", "recorder" ]

[ "func", "(", "r", "*", "ForwardRecorder", ")", "Write", "(", "data", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "// we are copying buffer to prevent data corruption:", "// io.Copy allocates single buffer and calls multiple writes in a loop", "// our PostSessionSlice is async and sends reader wrapping buffer", "// to the channel. This can lead to cases when the buffer is re-used", "// and data is corrupted unless we copy the data buffer in the first place", "dataCopy", ":=", "make", "(", "[", "]", "byte", ",", "len", "(", "data", ")", ")", "\n", "copy", "(", "dataCopy", ",", "data", ")", "\n", "// post the chunk of bytes to the audit log:", "chunk", ":=", "&", "SessionChunk", "{", "EventType", ":", "SessionPrintEvent", ",", "Data", ":", "dataCopy", ",", "Time", ":", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "UnixNano", "(", ")", ",", "}", "\n", "if", "err", ":=", "r", ".", "AuditLog", ".", "PostSessionSlice", "(", "SessionSlice", "{", "Namespace", ":", "r", ".", "Namespace", ",", "SessionID", ":", "string", "(", "r", ".", "SessionID", ")", ",", "Chunks", ":", "[", "]", "*", "SessionChunk", "{", "chunk", "}", ",", "}", ")", ";", "err", "!=", "nil", "{", "r", ".", "Error", "(", "trace", ".", "DebugReport", "(", "err", ")", ")", "\n", "}", "\n", "return", "len", "(", "data", ")", ",", "nil", "\n", "}" ]

[ "Write", "takes", "a", "chunk", "and", "writes", "it", "into", "the", "audit", "log" ]

[ "func", "(", "r", "*", "ForwardRecorder", ")", "Close", "(", ")", "error", "{", "var", "errors", "[", "]", "error", "\n", "err", ":=", "r", ".", "AuditLog", ".", "Close", "(", ")", "\n", "errors", "=", "append", "(", "errors", ",", "err", ")", "\n\n", "// wait until all events from recorder get flushed, it is important", "// to do so before we send SessionEndEvent to advise the audit log", "// to release resources associated with this session.", "// not doing so will not result in memory leak, but could result", "// in missing playback events", "context", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "context", ".", "TODO", "(", ")", ",", "defaults", ".", "ReadHeadersTimeout", ")", "\n", "defer", "cancel", "(", ")", "// releases resources if slowOperation completes before timeout elapses", "\n", "err", "=", "r", ".", "AuditLog", ".", "WaitForDelivery", "(", "context", ")", "\n", "if", "err", "!=", "nil", "{", "errors", "=", "append", "(", "errors", ",", "err", ")", "\n", "r", ".", "Warnf", "(", "\"", "\"", ",", "trace", ".", "DebugReport", "(", "err", ")", ")", "\n", "}", "\n\n", "return", "trace", ".", "NewAggregate", "(", "errors", "...", ")", "\n", "}" ]

[ "Close", "closes", "audit", "log", "session", "recorder" ]

[ "func", "AcquireLock", "(", "ctx", "context", ".", "Context", ",", "backend", "Backend", ",", "lockName", "string", ",", "ttl", "time", ".", "Duration", ")", "(", "err", "error", ")", "{", "if", "lockName", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "key", ":=", "[", "]", "byte", "(", "filepath", ".", "Join", "(", "locksPrefix", ",", "lockName", ")", ")", "\n", "for", "{", "// Get will clear TTL on a lock", "backend", ".", "Get", "(", "ctx", ",", "key", ")", "\n\n", "// CreateVal is atomic:", "_", ",", "err", "=", "backend", ".", "Create", "(", "ctx", ",", "Item", "{", "Key", ":", "key", ",", "Value", ":", "[", "]", "byte", "{", "1", "}", ",", "Expires", ":", "backend", ".", "Clock", "(", ")", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Add", "(", "ttl", ")", "}", ")", "\n", "if", "err", "==", "nil", "{", "break", "// success", "\n", "}", "\n", "if", "trace", ".", "IsAlreadyExists", "(", "err", ")", "{", "// locked? wait and repeat:", "backend", ".", "Clock", "(", ")", ".", "Sleep", "(", "250", "*", "time", ".", "Millisecond", ")", "\n", "continue", "\n", "}", "\n", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AcquireLock", "grabs", "a", "lock", "that", "will", "be", "released", "automatically", "in", "TTL" ]

[ "func", "ReleaseLock", "(", "ctx", "context", ".", "Context", ",", "backend", "Backend", ",", "lockName", "string", ")", "error", "{", "if", "lockName", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "key", ":=", "[", "]", "byte", "(", "filepath", ".", "Join", "(", "locksPrefix", ",", "lockName", ")", ")", "\n", "if", "err", ":=", "backend", ".", "Delete", "(", "ctx", ",", "key", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ReleaseLock", "forces", "lock", "release" ]

[ "func", "(", "c", "*", "HostCertParams", ")", "Check", "(", ")", "error", "{", "if", "c", ".", "HostID", "==", "\"", "\"", "&&", "len", "(", "c", ".", "Principals", ")", "==", "0", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "c", ".", "HostID", ",", "c", ".", "Principals", ")", "\n", "}", "\n", "if", "c", ".", "ClusterName", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "c", ".", "ClusterName", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "Roles", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Check", "checks", "parameters", "for", "errors" ]

[ "func", "MarshalCertRoles", "(", "roles", "[", "]", "string", ")", "(", "string", ",", "error", ")", "{", "out", ",", "err", ":=", "json", ".", "Marshal", "(", "CertRoles", "{", "Version", ":", "V1", ",", "Roles", ":", "roles", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "string", "(", "out", ")", ",", "err", "\n", "}" ]

[ "MarshalCertRoles", "marshal", "roles", "list", "to", "OpenSSH" ]

[ "func", "UnmarshalCertRoles", "(", "data", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "certRoles", "CertRoles", "\n", "if", "err", ":=", "utils", ".", "UnmarshalWithSchema", "(", "CertRolesSchema", ",", "&", "certRoles", ",", "[", "]", "byte", "(", "data", ")", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "certRoles", ".", "Roles", ",", "nil", "\n", "}" ]

[ "UnmarshalCertRoles", "marshals", "roles", "list", "to", "OpenSSH" ]

[ "func", "CertPoolFromCertAuthorities", "(", "cas", "[", "]", "CertAuthority", ")", "(", "*", "x509", ".", "CertPool", ",", "error", ")", "{", "certPool", ":=", "x509", ".", "NewCertPool", "(", ")", "\n", "for", "_", ",", "ca", ":=", "range", "cas", "{", "keyPairs", ":=", "ca", ".", "GetTLSKeyPairs", "(", ")", "\n", "if", "len", "(", "keyPairs", ")", "==", "0", "{", "continue", "\n", "}", "\n", "for", "_", ",", "keyPair", ":=", "range", "keyPairs", "{", "cert", ",", "err", ":=", "tlsca", ".", "ParseCertificatePEM", "(", "keyPair", ".", "Cert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "certPool", ".", "AddCert", "(", "cert", ")", "\n", "}", "\n", "return", "certPool", ",", "nil", "\n", "}", "\n", "return", "certPool", ",", "nil", "\n", "}" ]

[ "CertPoolFromCertAuthorities", "returns", "certificate", "pools", "from", "TLS", "certificates", "set", "up", "in", "the", "certificate", "authorities", "list" ]

[ "func", "TLSCerts", "(", "ca", "CertAuthority", ")", "[", "]", "[", "]", "byte", "{", "pairs", ":=", "ca", ".", "GetTLSKeyPairs", "(", ")", "\n", "out", ":=", "make", "(", "[", "]", "[", "]", "byte", ",", "len", "(", "pairs", ")", ")", "\n", "for", "i", ",", "pair", ":=", "range", "pairs", "{", "out", "[", "i", "]", "=", "append", "(", "[", "]", "byte", "{", "}", ",", "pair", ".", "Cert", "...", ")", "\n", "}", "\n", "return", "out", "\n", "}" ]

[ "TLSCerts", "returns", "TLS", "certificates", "from", "CA" ]

[ "func", "NewCertAuthority", "(", "caType", "CertAuthType", ",", "clusterName", "string", ",", "signingKeys", ",", "checkingKeys", "[", "]", "[", "]", "byte", ",", "roles", "[", "]", "string", ")", "CertAuthority", "{", "return", "&", "CertAuthorityV2", "{", "Kind", ":", "KindCertAuthority", ",", "Version", ":", "V2", ",", "SubKind", ":", "string", "(", "caType", ")", ",", "Metadata", ":", "Metadata", "{", "Name", ":", "clusterName", ",", "Namespace", ":", "defaults", ".", "Namespace", ",", "}", ",", "Spec", ":", "CertAuthoritySpecV2", "{", "Roles", ":", "roles", ",", "Type", ":", "caType", ",", "ClusterName", ":", "clusterName", ",", "CheckingKeys", ":", "checkingKeys", ",", "SigningKeys", ":", "signingKeys", ",", "}", ",", "}", "\n", "}" ]

[ "NewCertAuthority", "returns", "new", "cert", "authority" ]

[ "func", "CertAuthoritiesToV1", "(", "in", "[", "]", "CertAuthority", ")", "(", "[", "]", "CertAuthorityV1", ",", "error", ")", "{", "out", ":=", "make", "(", "[", "]", "CertAuthorityV1", ",", "len", "(", "in", ")", ")", "\n", "type", "cav1", "interface", "{", "V1", "(", ")", "*", "CertAuthorityV1", "\n", "}", "\n", "for", "i", ",", "ca", ":=", "range", "in", "{", "v1", ",", "ok", ":=", "ca", ".", "(", "cav1", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "out", "[", "i", "]", "=", "*", "(", "v1", ".", "V1", "(", ")", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "CertAuthoritiesToV1", "converts", "list", "of", "cert", "authorities", "to", "V1", "slice" ]

[ "func", "(", "c", "*", "CertAuthorityV2", ")", "Clone", "(", ")", "CertAuthority", "{", "out", ":=", "*", "c", "\n", "out", ".", "Spec", ".", "CheckingKeys", "=", "utils", ".", "CopyByteSlices", "(", "c", ".", "Spec", ".", "CheckingKeys", ")", "\n", "out", ".", "Spec", ".", "SigningKeys", "=", "utils", ".", "CopyByteSlices", "(", "c", ".", "Spec", ".", "SigningKeys", ")", "\n", "for", "i", ",", "kp", ":=", "range", "c", ".", "Spec", ".", "TLSKeyPairs", "{", "out", ".", "Spec", ".", "TLSKeyPairs", "[", "i", "]", "=", "TLSKeyPair", "{", "Key", ":", "utils", ".", "CopyByteSlice", "(", "kp", ".", "Key", ")", ",", "Cert", ":", "utils", ".", "CopyByteSlice", "(", "kp", ".", "Cert", ")", ",", "}", "\n", "}", "\n", "out", ".", "Spec", ".", "Roles", "=", "utils", ".", "CopyStrings", "(", "c", ".", "Spec", ".", "Roles", ")", "\n", "return", "&", "out", "\n", "}" ]

[ "Clone", "returns", "a", "copy", "of", "the", "cert", "authority", "object", "." ]

[ "func", "(", "c", "*", "CertAuthorityV2", ")", "GetRotation", "(", ")", "Rotation", "{", "if", "c", ".", "Spec", ".", "Rotation", "==", "nil", "{", "return", "Rotation", "{", "}", "\n", "}", "\n", "return", "*", "c", ".", "Spec", ".", "Rotation", "\n", "}" ]

[ "GetRotation", "returns", "rotation", "state", "." ]

[ "func", "(", "c", "*", "CertAuthorityV2", ")", "TLSCA", "(", ")", "(", "*", "tlsca", ".", "CertAuthority", ",", "error", ")", "{", "if", "len", "(", "c", ".", "Spec", ".", "TLSKeyPairs", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "tlsca", ".", "New", "(", "c", ".", "Spec", ".", "TLSKeyPairs", "[", "0", "]", ".", "Cert", ",", "c", ".", "Spec", ".", "TLSKeyPairs", "[", "0", "]", ".", "Key", ")", "\n", "}" ]

[ "TLSCA", "returns", "TLS", "certificate", "authority" ]

[ "func", "(", "c", "*", "CertAuthorityV2", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "GetClusterName", "(", ")", ",", "c", ".", "GetType", "(", ")", ")", "\n", "}" ]

[ "String", "returns", "human", "readable", "version", "of", "the", "CertAuthorityV2", "." ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "AddRole", "(", "name", "string", ")", "{", "for", "_", ",", "r", ":=", "range", "ca", ".", "Spec", ".", "Roles", "{", "if", "r", "==", "name", "{", "return", "\n", "}", "\n", "}", "\n", "ca", ".", "Spec", ".", "Roles", "=", "append", "(", "ca", ".", "Spec", ".", "Roles", ",", "name", ")", "\n", "}" ]

[ "AddRole", "adds", "a", "role", "to", "ca", "role", "list" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "SetSigningKeys", "(", "keys", "[", "]", "[", "]", "byte", ")", "error", "{", "ca", ".", "Spec", ".", "SigningKeys", "=", "keys", "\n", "return", "nil", "\n", "}" ]

[ "SetSigningKeys", "sets", "signing", "keys" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "SetCheckingKeys", "(", "keys", "[", "]", "[", "]", "byte", ")", "error", "{", "ca", ".", "Spec", ".", "CheckingKeys", "=", "keys", "\n", "return", "nil", "\n", "}" ]

[ "SetCheckingKeys", "sets", "SSH", "public", "keys" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "GetID", "(", ")", "CertAuthID", "{", "return", "CertAuthID", "{", "Type", ":", "ca", ".", "Spec", ".", "Type", ",", "DomainName", ":", "ca", ".", "Metadata", ".", "Name", "}", "\n", "}" ]

[ "GetID", "returns", "certificate", "authority", "ID", "-", "combined", "type", "and", "name" ]

[ "func", "(", "c", "*", "CertAuthorityV2", ")", "SetRoleMap", "(", "m", "RoleMap", ")", "{", "c", ".", "Spec", ".", "RoleMap", "=", "[", "]", "RoleMapping", "(", "m", ")", "\n", "}" ]

[ "SetRoleMap", "sets", "role", "map" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "FirstSigningKey", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "ca", ".", "Spec", ".", "SigningKeys", ")", "==", "0", "{", "return", "nil", ",", "trace", ".", "NotFound", "(", "\"", "\"", ",", "ca", ".", "Metadata", ".", "Name", ")", "\n", "}", "\n", "return", "ca", ".", "Spec", ".", "SigningKeys", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "FirstSigningKey", "returns", "first", "signing", "key", "or", "returns", "error", "if", "it", "s", "not", "here" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "Checkers", "(", ")", "(", "[", "]", "ssh", ".", "PublicKey", ",", "error", ")", "{", "out", ":=", "make", "(", "[", "]", "ssh", ".", "PublicKey", ",", "0", ",", "len", "(", "ca", ".", "Spec", ".", "CheckingKeys", ")", ")", "\n", "for", "_", ",", "keyBytes", ":=", "range", "ca", ".", "Spec", ".", "CheckingKeys", "{", "key", ",", "_", ",", "_", ",", "_", ",", "err", ":=", "ssh", ".", "ParseAuthorizedKey", "(", "keyBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "len", "(", "keyBytes", ")", ",", "err", ")", "\n", "}", "\n", "out", "=", "append", "(", "out", ",", "key", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "Checkers", "returns", "public", "keys", "that", "can", "be", "used", "to", "check", "cert", "authorities" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "Signers", "(", ")", "(", "[", "]", "ssh", ".", "Signer", ",", "error", ")", "{", "out", ":=", "make", "(", "[", "]", "ssh", ".", "Signer", ",", "0", ",", "len", "(", "ca", ".", "Spec", ".", "SigningKeys", ")", ")", "\n", "for", "_", ",", "keyBytes", ":=", "range", "ca", ".", "Spec", ".", "SigningKeys", "{", "signer", ",", "err", ":=", "ssh", ".", "ParsePrivateKey", "(", "keyBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "out", "=", "append", "(", "out", ",", "signer", ")", "\n", "}", "\n", "return", "out", ",", "nil", "\n", "}" ]

[ "Signers", "returns", "a", "list", "of", "signers", "that", "could", "be", "used", "to", "sign", "keys" ]

[ "func", "(", "ca", "*", "CertAuthorityV2", ")", "Check", "(", ")", "error", "{", "err", ":=", "ca", ".", "ID", "(", ")", ".", "Check", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "ca", ".", "Checkers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "ca", ".", "Signers", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "// This is to force users to migrate", "if", "len", "(", "ca", ".", "Spec", ".", "Roles", ")", "!=", "0", "&&", "len", "(", "ca", ".", "Spec", ".", "RoleMap", ")", "!=", "0", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "RoleMap", "(", "ca", ".", "Spec", ".", "RoleMap", ")", ".", "Check", "(", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Check", "checks", "if", "all", "passed", "parameters", "are", "valid" ]

[ "func", "RemoveCASecrets", "(", "ca", "CertAuthority", ")", "{", "ca", ".", "SetSigningKeys", "(", "nil", ")", "\n", "keyPairs", ":=", "ca", ".", "GetTLSKeyPairs", "(", ")", "\n", "for", "i", ":=", "range", "keyPairs", "{", "keyPairs", "[", "i", "]", ".", "Key", "=", "nil", "\n", "}", "\n", "ca", ".", "SetTLSKeyPairs", "(", "keyPairs", ")", "\n", "}" ]

[ "RemoveCASecrets", "removes", "secret", "values", "and", "keys", "from", "the", "certificate", "authority" ]

[ "func", "(", "s", "*", "Rotation", ")", "Matches", "(", "rotation", "Rotation", ")", "bool", "{", "return", "s", ".", "CurrentID", "==", "rotation", ".", "CurrentID", "&&", "s", ".", "State", "==", "rotation", ".", "State", "&&", "s", ".", "Phase", "==", "rotation", ".", "Phase", "\n", "}" ]

[ "Matches", "returns", "true", "if", "this", "state", "rotation", "matches", "external", "rotation", "state", "phase", "and", "rotation", "ID", "should", "match", "notice", "that", "matches", "does", "not", "behave", "like", "Equals", "because", "it", "does", "not", "require", "all", "fields", "to", "be", "the", "same", "." ]

[ "func", "(", "r", "*", "Rotation", ")", "LastRotatedDescription", "(", ")", "string", "{", "if", "r", ".", "LastRotated", ".", "IsZero", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "LastRotated", ".", "Format", "(", "teleport", ".", "HumanDateFormatSeconds", ")", ")", "\n", "}" ]

[ "LastRotatedDescription", "returns", "human", "friendly", "description", "." ]

[ "func", "(", "r", "*", "Rotation", ")", "PhaseDescription", "(", ")", "string", "{", "switch", "r", ".", "Phase", "{", "case", "RotationPhaseInit", ":", "return", "\"", "\"", "\n", "case", "RotationPhaseStandby", ",", "\"", "\"", ":", "return", "\"", "\"", "\n", "case", "RotationPhaseUpdateClients", ":", "return", "\"", "\"", "\n", "case", "RotationPhaseUpdateServers", ":", "return", "\"", "\"", "\n", "case", "RotationPhaseRollback", ":", "return", "\"", "\"", "\n", "default", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "Phase", ")", "\n", "}", "\n", "}" ]

[ "PhaseDescription", "returns", "human", "friendly", "description", "of", "a", "current", "rotation", "phase", "." ]

[ "func", "(", "r", "*", "Rotation", ")", "String", "(", ")", "string", "{", "switch", "r", ".", "State", "{", "case", "\"", "\"", ",", "RotationStateStandby", ":", "if", "r", ".", "LastRotated", ".", "IsZero", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "LastRotated", ".", "Format", "(", "teleport", ".", "HumanDateFormatSeconds", ")", ")", "\n", "case", "RotationStateInProgress", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ".", "PhaseDescription", "(", ")", ",", "r", ".", "Mode", ",", "r", ".", "Started", ".", "Format", "(", "teleport", ".", "HumanDateFormatSeconds", ")", ",", "r", ".", "Started", ".", "Add", "(", "r", ".", "GracePeriod", ".", "Duration", "(", ")", ")", ".", "Format", "(", "teleport", ".", "HumanDateFormatSeconds", ")", ",", ")", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "String", "returns", "user", "friendly", "information", "about", "certificate", "authority", "." ]

[ "func", "(", "r", "*", "Rotation", ")", "CheckAndSetDefaults", "(", "clock", "clockwork", ".", "Clock", ")", "error", "{", "switch", "r", ".", "Phase", "{", "case", "\"", "\"", ",", "RotationPhaseRollback", ",", "RotationPhaseUpdateClients", ",", "RotationPhaseUpdateServers", ":", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "r", ".", "Phase", ")", "\n", "}", "\n", "switch", "r", ".", "Mode", "{", "case", "\"", "\"", ",", "RotationModeAuto", ",", "RotationModeManual", ":", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "r", ".", "Mode", ")", "\n", "}", "\n", "switch", "r", ".", "State", "{", "case", "\"", "\"", ":", "r", ".", "State", "=", "RotationStateStandby", "\n", "case", "RotationStateStandby", ":", "case", "RotationStateInProgress", ":", "if", "r", ".", "CurrentID", "==", "\"", "\"", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "r", ".", "Started", ".", "IsZero", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "r", ".", "State", ",", "RotationStateStandby", ",", "RotationStateInProgress", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "checks", "and", "sets", "default", "rotation", "parameters", "." ]

[ "func", "GenerateSchedule", "(", "clock", "clockwork", ".", "Clock", ",", "gracePeriod", "time", ".", "Duration", ")", "(", "*", "RotationSchedule", ",", "error", ")", "{", "if", "gracePeriod", "<=", "0", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "gracePeriod", ")", "\n", "}", "\n", "return", "&", "RotationSchedule", "{", "UpdateClients", ":", "clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Add", "(", "gracePeriod", "/", "3", ")", ".", "UTC", "(", ")", ",", "UpdateServers", ":", "clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Add", "(", "(", "gracePeriod", "*", "2", ")", "/", "3", ")", ".", "UTC", "(", ")", ",", "Standby", ":", "clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Add", "(", "gracePeriod", ")", ".", "UTC", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "GenerateSchedule", "generates", "schedule", "based", "on", "the", "time", "period", "using", "even", "time", "periods", "between", "rotation", "phases", "." ]

[ "func", "(", "s", "*", "RotationSchedule", ")", "CheckAndSetDefaults", "(", "clock", "clockwork", ".", "Clock", ")", "error", "{", "if", "s", ".", "UpdateServers", ".", "IsZero", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "RotationPhaseUpdateServers", ")", "\n", "}", "\n", "if", "s", ".", "Standby", ".", "IsZero", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "RotationPhaseStandby", ")", "\n", "}", "\n", "if", "s", ".", "Standby", ".", "Before", "(", "s", ".", "UpdateServers", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "RotationPhaseStandby", ",", "RotationPhaseUpdateServers", ")", "\n", "}", "\n", "if", "s", ".", "UpdateServers", ".", "Before", "(", "clock", ".", "Now", "(", ")", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "RotationPhaseUpdateServers", ")", "\n", "}", "\n", "if", "s", ".", "Standby", ".", "Before", "(", "clock", ".", "Now", "(", ")", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "RotationPhaseStandby", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "checks", "and", "sets", "default", "values", "of", "the", "rotation", "schedule", "." ]

[ "func", "(", "c", "*", "CertAuthorityV1", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "DomainName", ",", "c", ".", "Type", ")", "\n", "}" ]

[ "String", "returns", "human", "readable", "version", "of", "the", "CertAuthorityV1", "." ]

[ "func", "GetCertAuthoritySchema", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "V2SchemaTemplate", ",", "MetadataSchema", ",", "fmt", ".", "Sprintf", "(", "CertAuthoritySpecV2Schema", ",", "RotationSchema", ",", "RoleMapSchema", ")", ",", "DefaultDefinitions", ")", "\n", "}" ]

[ "GetCertAuthoritySchema", "returns", "JSON", "Schema", "for", "cert", "authorities" ]

[ "func", "(", "*", "TeleportCertAuthorityMarshaler", ")", "UnmarshalCertAuthority", "(", "bytes", "[", "]", "byte", ",", "opts", "...", "MarshalOption", ")", "(", "CertAuthority", ",", "error", ")", "{", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "h", "ResourceHeader", "\n", "err", "=", "utils", ".", "FastUnmarshal", "(", "bytes", ",", "&", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "switch", "h", ".", "Version", "{", "case", "\"", "\"", ":", "var", "ca", "CertAuthorityV1", "\n", "err", ":=", "json", ".", "Unmarshal", "(", "bytes", ",", "&", "ca", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "ca", ".", "V2", "(", ")", ",", "nil", "\n", "case", "V2", ":", "var", "ca", "CertAuthorityV2", "\n", "if", "cfg", ".", "SkipValidation", "{", "if", "err", ":=", "utils", ".", "FastUnmarshal", "(", "bytes", ",", "&", "ca", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "if", "err", ":=", "utils", ".", "UnmarshalWithSchema", "(", "GetCertAuthoritySchema", "(", ")", ",", "&", "ca", ",", "bytes", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n", "if", "err", ":=", "ca", ".", "CheckAndSetDefaults", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "cfg", ".", "ID", "!=", "0", "{", "ca", ".", "SetResourceID", "(", "cfg", ".", "ID", ")", "\n", "}", "\n", "return", "&", "ca", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "h", ".", "Version", ")", "\n", "}" ]

[ "UnmarshalCertAuthority", "unmarshals", "cert", "authority", "from", "JSON" ]

[ "func", "(", "*", "TeleportCertAuthorityMarshaler", ")", "MarshalCertAuthority", "(", "ca", "CertAuthority", ",", "opts", "...", "MarshalOption", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "cfg", ",", "err", ":=", "collectOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "type", "cav1", "interface", "{", "V1", "(", ")", "*", "CertAuthorityV1", "\n", "}", "\n\n", "type", "cav2", "interface", "{", "V2", "(", ")", "*", "CertAuthorityV2", "\n", "}", "\n", "version", ":=", "cfg", ".", "GetVersion", "(", ")", "\n", "switch", "version", "{", "case", "V1", ":", "v", ",", "ok", ":=", "ca", ".", "(", "cav1", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "V1", ")", "\n", "}", "\n", "return", "utils", ".", "FastMarshal", "(", "v", ".", "V1", "(", ")", ")", "\n", "case", "V2", ":", "v", ",", "ok", ":=", "ca", ".", "(", "cav2", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "V2", ")", "\n", "}", "\n", "v2", ":=", "v", ".", "V2", "(", ")", "\n", "if", "!", "cfg", ".", "PreserveResourceID", "{", "// avoid modifying the original object", "// to prevent unexpected data races", "copy", ":=", "*", "v2", "\n", "copy", ".", "SetResourceID", "(", "0", ")", "\n", "v2", "=", "&", "copy", "\n", "}", "\n", "return", "utils", ".", "FastMarshal", "(", "v2", ")", "\n", "default", ":", "return", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "version", ")", "\n", "}", "\n", "}" ]

[ "MarshalCertAuthority", "marshalls", "cert", "authority", "into", "JSON" ]

[ "func", "UpdateEventFields", "(", "event", "Event", ",", "fields", "EventFields", ",", "clock", "clockwork", ".", "Clock", ",", "uid", "utils", ".", "UID", ")", "(", "err", "error", ")", "{", "additionalFields", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "if", "fields", ".", "GetType", "(", ")", "==", "\"", "\"", "{", "additionalFields", "[", "EventType", "]", "=", "event", ".", "Name", "\n", "}", "\n", "if", "fields", ".", "GetID", "(", ")", "==", "\"", "\"", "{", "additionalFields", "[", "EventID", "]", "=", "uid", ".", "New", "(", ")", "\n", "}", "\n", "if", "fields", ".", "GetTimestamp", "(", ")", ".", "IsZero", "(", ")", "{", "additionalFields", "[", "EventTime", "]", "=", "clock", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Round", "(", "time", ".", "Second", ")", "\n", "}", "\n", "if", "event", ".", "Code", "!=", "\"", "\"", "{", "additionalFields", "[", "EventCode", "]", "=", "event", ".", "Code", "\n", "}", "\n", "for", "k", ",", "v", ":=", "range", "additionalFields", "{", "fields", "[", "k", "]", "=", "v", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "UpdateEventFields", "updates", "passed", "event", "fields", "with", "additional", "information", "common", "for", "all", "event", "types", "such", "as", "unique", "IDs", "timestamps", "codes", "etc", ".", "This", "method", "is", "a", "final", "stop", "for", "various", "audit", "log", "implementations", "for", "updating", "event", "fields", "before", "it", "gets", "persisted", "in", "the", "backend", "." ]

[ "func", "(", "d", "*", "DialParams", ")", "CheckAndSetDefaults", "(", ")", "error", "{", "if", "d", ".", "From", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "d", ".", "To", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "makes", "sure", "the", "minimal", "parameters", "are", "set", "." ]

[ "func", "NewTrustedCluster", "(", "name", "string", ",", "spec", "TrustedClusterSpecV2", ")", "(", "TrustedCluster", ",", "error", ")", "{", "return", "&", "TrustedClusterV2", "{", "Kind", ":", "KindTrustedCluster", ",", "Version", ":", "V2", ",", "Metadata", ":", "Metadata", "{", "Name", ":", "name", ",", "Namespace", ":", "defaults", ".", "Namespace", ",", "}", ",", "Spec", ":", "spec", ",", "}", ",", "nil", "\n", "}" ]

[ "NewTrustedCluster", "is", "a", "convenience", "wa", "to", "create", "a", "TrustedCluster", "resource", "." ]

[ "func", "(", "r", "RoleMap", ")", "Equals", "(", "o", "RoleMap", ")", "bool", "{", "if", "len", "(", "r", ")", "!=", "len", "(", "o", ")", "{", "return", "false", "\n", "}", "\n", "for", "i", ":=", "range", "r", "{", "if", "!", "r", "[", "i", "]", ".", "Equals", "(", "o", "[", "i", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Equals", "checks", "if", "the", "two", "role", "maps", "are", "equal", "." ]

[ "func", "(", "r", "RoleMap", ")", "String", "(", ")", "string", "{", "values", ",", "err", ":=", "r", ".", "parse", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "len", "(", "values", ")", "!=", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "values", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "String", "prints", "user", "friendly", "representation", "of", "role", "mapping" ]

[ "func", "(", "r", "RoleMap", ")", "Map", "(", "remoteRoles", "[", "]", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "_", ",", "err", ":=", "r", ".", "parse", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "outRoles", "[", "]", "string", "\n", "// when no remote roles is specified, assume that", "// there is a single empty remote role (that should match wildcards)", "if", "len", "(", "remoteRoles", ")", "==", "0", "{", "remoteRoles", "=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "}", "\n", "for", "_", ",", "mapping", ":=", "range", "r", "{", "expression", ":=", "mapping", ".", "Remote", "\n", "for", "_", ",", "remoteRole", ":=", "range", "remoteRoles", "{", "// never map default implicit role, it is always", "// added by default", "if", "remoteRole", "==", "teleport", ".", "DefaultImplicitRole", "{", "continue", "\n", "}", "\n", "for", "_", ",", "replacementRole", ":=", "range", "mapping", ".", "Local", "{", "replacement", ",", "err", ":=", "utils", ".", "ReplaceRegexp", "(", "expression", ",", "replacementRole", ",", "remoteRole", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "// empty replacement can occur when $2 expand refers", "// to non-existing capture group in match expression", "if", "replacement", "!=", "\"", "\"", "{", "outRoles", "=", "append", "(", "outRoles", ",", "replacement", ")", "\n", "}", "\n", "case", "trace", ".", "IsNotFound", "(", "err", ")", ":", "continue", "\n", "default", ":", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "outRoles", ",", "nil", "\n", "}" ]

[ "Map", "maps", "local", "roles", "to", "remote", "roles" ]

[ "func", "(", "r", "RoleMap", ")", "Check", "(", ")", "error", "{", "_", ",", "err", ":=", "r", ".", "parse", "(", ")", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "Check", "checks", "RoleMap", "for", "errors" ]

[ "func", "(", "r", "RoleMapping", ")", "Equals", "(", "o", "RoleMapping", ")", "bool", "{", "if", "r", ".", "Remote", "!=", "o", ".", "Remote", "{", "return", "false", "\n", "}", "\n", "if", "!", "utils", ".", "StringSlicesEqual", "(", "r", ".", "Local", ",", "r", ".", "Local", ")", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Equals", "checks", "if", "the", "two", "role", "mappings", "are", "equal", "." ]

[ "func", "(", "c", "*", "TrustedClusterV2", ")", "CanChangeStateTo", "(", "t", "TrustedCluster", ")", "error", "{", "if", "c", ".", "GetToken", "(", ")", "!=", "t", ".", "GetToken", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "GetProxyAddress", "(", ")", "!=", "t", ".", "GetProxyAddress", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "c", ".", "GetReverseTunnelAddress", "(", ")", "!=", "t", ".", "GetReverseTunnelAddress", "(", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "utils", ".", "StringSlicesEqual", "(", "c", ".", "GetRoles", "(", ")", ",", "t", ".", "GetRoles", "(", ")", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "c", ".", "GetRoleMap", "(", ")", ".", "Equals", "(", "t", ".", "GetRoleMap", "(", ")", ")", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "c", ".", "GetEnabled", "(", ")", "==", "t", ".", "GetEnabled", "(", ")", "{", "if", "t", ".", "GetEnabled", "(", ")", "==", "true", "{", "return", "trace", ".", "AlreadyExists", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "trace", ".", "AlreadyExists", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CanChangeState", "checks", "if", "the", "state", "change", "is", "allowed", "or", "not", ".", "If", "not", "returns", "an", "error", "explaining", "the", "reason", "." ]

[ "func", "(", "c", "*", "TrustedClusterV2", ")", "String", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "Spec", ".", "Enabled", ",", "c", ".", "Spec", ".", "Roles", ",", "c", ".", "Spec", ".", "Token", ",", "c", ".", "Spec", ".", "ProxyAddress", ",", "c", ".", "Spec", ".", "ReverseTunnelAddress", ")", "\n", "}" ]

[ "String", "represents", "a", "human", "readable", "version", "of", "trusted", "cluster", "settings", "." ]

[ "func", "GetTrustedClusterSchema", "(", "extensionSchema", "string", ")", "string", "{", "var", "trustedClusterSchema", "string", "\n", "if", "extensionSchema", "==", "\"", "\"", "{", "trustedClusterSchema", "=", "fmt", ".", "Sprintf", "(", "TrustedClusterSpecSchemaTemplate", ",", "RoleMapSchema", ",", "\"", "\"", ")", "\n", "}", "else", "{", "trustedClusterSchema", "=", "fmt", ".", "Sprintf", "(", "TrustedClusterSpecSchemaTemplate", ",", "RoleMapSchema", ",", "\"", "\"", "+", "extensionSchema", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "V2SchemaTemplate", ",", "MetadataSchema", ",", "trustedClusterSchema", ",", "DefaultDefinitions", ")", "\n", "}" ]

[ "GetTrustedClusterSchema", "returns", "the", "schema", "with", "optionally", "injected", "schema", "for", "extensions", "." ]

[ "func", "(", "s", "SortedTrustedCluster", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "s", "[", "i", "]", ".", "GetName", "(", ")", "<", "s", "[", "j", "]", ".", "GetName", "(", ")", "\n", "}" ]

[ "Less", "compares", "items", "by", "name", "." ]

[ "func", "(", "s", "SortedTrustedCluster", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "s", "[", "i", "]", ",", "s", "[", "j", "]", "=", "s", "[", "j", "]", ",", "s", "[", "i", "]", "\n", "}" ]

[ "Swap", "swaps", "two", "items", "in", "a", "list", "." ]

[ "func", "(", "c", "*", "ClientProfile", ")", "Name", "(", ")", "string", "{", "if", "c", ".", "ProxyHost", "!=", "\"", "\"", "{", "return", "c", ".", "ProxyHost", "\n", "}", "\n\n", "addr", ",", "_", ",", "err", ":=", "net", ".", "SplitHostPort", "(", "c", ".", "WebProxyAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "c", ".", "WebProxyAddr", "\n", "}", "\n\n", "return", "addr", "\n", "}" ]

[ "Name", "returns", "the", "name", "of", "the", "profile", "." ]

[ "func", "UnlinkCurrentProfile", "(", ")", "error", "{", "return", "trace", ".", "Wrap", "(", "os", ".", "Remove", "(", "filepath", ".", "Join", "(", "FullProfilePath", "(", "\"", "\"", ")", ",", "CurrentProfileSymlink", ")", ")", ")", "\n", "}" ]

[ "If", "there", "s", "a", "current", "profile", "symlink", "remove", "it" ]

[ "func", "ProfileFromFile", "(", "filePath", "string", ")", "(", "*", "ClientProfile", ",", "error", ")", "{", "bytes", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "filePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "var", "cp", "*", "ClientProfile", "\n", "if", "err", "=", "yaml", ".", "Unmarshal", "(", "bytes", ",", "&", "cp", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "cp", ",", "nil", "\n", "}" ]

[ "ProfileFromFile", "loads", "the", "profile", "from", "a", "YAML", "file" ]

[ "func", "(", "cp", "*", "ClientProfile", ")", "SaveTo", "(", "loc", "ProfileLocation", ")", "error", "{", "bytes", ",", "err", ":=", "yaml", ".", "Marshal", "(", "&", "cp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "err", "=", "ioutil", ".", "WriteFile", "(", "loc", ".", "Path", ",", "bytes", ",", "0660", ")", ";", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "loc", ".", "AliasPath", "!=", "\"", "\"", "&&", "filepath", ".", "Base", "(", "loc", ".", "AliasPath", ")", "!=", "filepath", ".", "Base", "(", "loc", ".", "Path", ")", "{", "if", "err", ":=", "os", ".", "Remove", "(", "loc", ".", "AliasPath", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", ":=", "os", ".", "Symlink", "(", "filepath", ".", "Base", "(", "loc", ".", "Path", ")", ",", "loc", ".", "AliasPath", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "// set 'current' symlink:", "if", "loc", ".", "Options", "&", "ProfileMakeCurrent", "!=", "0", "{", "symlink", ":=", "filepath", ".", "Join", "(", "filepath", ".", "Dir", "(", "loc", ".", "Path", ")", ",", "CurrentProfileSymlink", ")", "\n", "if", "err", ":=", "os", ".", "Remove", "(", "symlink", ")", ";", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "err", "=", "os", ".", "Symlink", "(", "filepath", ".", "Base", "(", "loc", ".", "Path", ")", ",", "symlink", ")", "\n", "}", "\n", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}" ]

[ "SaveTo", "saves", "the", "profile", "into", "a", "given", "filename", "optionally", "overwriting", "it", "." ]

[ "func", "CreateUploaderDir", "(", "dir", "string", ")", "error", "{", "err", ":=", "os", ".", "MkdirAll", "(", "filepath", ".", "Join", "(", "dir", ",", "teleport", ".", "LogsDir", ",", "teleport", ".", "ComponentUpload", ",", "events", ".", "SessionLogsDir", ",", "defaults", ".", "Namespace", ")", ",", "teleport", ".", "SharedDirMode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "ConvertSystemError", "(", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CreateUploaderDir", "creates", "directory", "for", "file", "uploader", "service" ]

[ "func", "GenerateCertificate", "(", "authServer", "*", "AuthServer", ",", "identity", "TestIdentity", ")", "(", "[", "]", "byte", ",", "[", "]", "byte", ",", "error", ")", "{", "switch", "id", ":=", "identity", ".", "I", ".", "(", "type", ")", "{", "case", "LocalUser", ":", "user", ",", "err", ":=", "authServer", ".", "GetUser", "(", "id", ".", "Username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "roles", ",", "err", ":=", "services", ".", "FetchRoles", "(", "user", ".", "GetRoles", "(", ")", ",", "authServer", ",", "user", ".", "GetTraits", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "if", "identity", ".", "TTL", "==", "0", "{", "identity", ".", "TTL", "=", "time", ".", "Hour", "\n", "}", "\n", "priv", ",", "pub", ",", "err", ":=", "authServer", ".", "GenerateKeyPair", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "certs", ",", "err", ":=", "authServer", ".", "generateUserCert", "(", "certRequest", "{", "publicKey", ":", "pub", ",", "user", ":", "user", ",", "roles", ":", "roles", ",", "ttl", ":", "identity", ".", "TTL", ",", "usage", ":", "identity", ".", "AcceptedUsage", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "certs", ".", "tls", ",", "priv", ",", "nil", "\n", "case", "BuiltinRole", ":", "keys", ",", "err", ":=", "authServer", ".", "GenerateServerKeys", "(", "GenerateServerKeysRequest", "{", "HostID", ":", "id", ".", "Username", ",", "NodeName", ":", "id", ".", "Username", ",", "Roles", ":", "teleport", ".", "Roles", "{", "id", ".", "Role", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "keys", ".", "TLSCert", ",", "keys", ".", "Key", ",", "nil", "\n", "default", ":", "return", "nil", ",", "nil", ",", "trace", ".", "BadParameter", "(", "\"", "\"", ",", "identity", ")", "\n", "}", "\n", "}" ]

[ "GenerateCertificate", "generates", "certificate", "for", "identity", "returns", "private", "public", "key", "pair" ]

[ "func", "(", "a", "*", "TestAuthServer", ")", "NewCertificate", "(", "identity", "TestIdentity", ")", "(", "*", "tls", ".", "Certificate", ",", "error", ")", "{", "cert", ",", "key", ",", "err", ":=", "GenerateCertificate", "(", "a", ".", "AuthServer", ",", "identity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsCert", ",", "err", ":=", "tls", ".", "X509KeyPair", "(", "cert", ",", "key", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "&", "tlsCert", ",", "nil", "\n", "}" ]

[ "NewCertificate", "returns", "new", "TLS", "credentials", "generated", "by", "test", "auth", "server" ]

[ "func", "(", "a", "*", "TestAuthServer", ")", "Trust", "(", "remote", "*", "TestAuthServer", ",", "roleMap", "services", ".", "RoleMap", ")", "error", "{", "remoteCA", ",", "err", ":=", "remote", ".", "AuthServer", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "HostCA", ",", "DomainName", ":", "remote", ".", "ClusterName", ",", "}", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "err", "=", "a", ".", "AuthServer", ".", "UpsertCertAuthority", "(", "remoteCA", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "remoteCA", ",", "err", "=", "remote", ".", "AuthServer", ".", "GetCertAuthority", "(", "services", ".", "CertAuthID", "{", "Type", ":", "services", ".", "UserCA", ",", "DomainName", ":", "remote", ".", "ClusterName", ",", "}", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "remoteCA", ".", "SetRoleMap", "(", "roleMap", ")", "\n", "err", "=", "a", ".", "AuthServer", ".", "UpsertCertAuthority", "(", "remoteCA", ")", "\n", "if", "err", "!=", "nil", "{", "return", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Trust", "adds", "other", "server", "host", "certificate", "authority", "as", "trusted" ]

[ "func", "(", "a", "*", "TestAuthServer", ")", "NewRemoteClient", "(", "identity", "TestIdentity", ",", "addr", "net", ".", "Addr", ",", "pool", "*", "x509", ".", "CertPool", ")", "(", "*", "Client", ",", "error", ")", "{", "tlsConfig", ":=", "utils", ".", "TLSConfig", "(", "a", ".", "CipherSuites", ")", "\n", "cert", ",", "err", ":=", "a", ".", "NewCertificate", "(", "identity", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsConfig", ".", "Certificates", "=", "[", "]", "tls", ".", "Certificate", "{", "*", "cert", "}", "\n", "tlsConfig", ".", "RootCAs", "=", "pool", "\n", "addrs", ":=", "[", "]", "utils", ".", "NetAddr", "{", "{", "AddrNetwork", ":", "addr", ".", "Network", "(", ")", ",", "Addr", ":", "addr", ".", "String", "(", ")", "}", "}", "\n", "return", "NewTLSClient", "(", "ClientConfig", "{", "Addrs", ":", "addrs", ",", "TLS", ":", "tlsConfig", "}", ")", "\n", "}" ]

[ "NewRemoteClient", "creates", "new", "client", "to", "the", "remote", "server", "using", "identity", "generated", "for", "this", "certificate", "authority" ]

[ "func", "(", "cfg", "*", "TestTLSServerConfig", ")", "CheckAndSetDefaults", "(", ")", "error", "{", "if", "cfg", ".", "APIConfig", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cfg", ".", "AuthServer", "==", "nil", "{", "return", "trace", ".", "BadParameter", "(", "\"", "\"", ")", "\n", "}", "\n", "// use very permissive limiter configuration by default", "if", "cfg", ".", "Limiter", "==", "nil", "{", "cfg", ".", "Limiter", "=", "&", "limiter", ".", "LimiterConfig", "{", "MaxConnections", ":", "1000", ",", "MaxNumberOfUsers", ":", "1000", ",", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckAndSetDefaults", "checks", "and", "sets", "limiter", "defaults" ]

[ "func", "(", "t", "*", "TestTLSServer", ")", "NewClientFromWebSession", "(", "sess", "services", ".", "WebSession", ")", "(", "*", "Client", ",", "error", ")", "{", "tlsConfig", ",", "err", ":=", "t", ".", "Identity", ".", "TLSConfig", "(", "t", ".", "AuthServer", ".", "CipherSuites", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ")", "\n", "}", "\n", "tlsCert", ",", "err", ":=", "tls", ".", "X509KeyPair", "(", "sess", ".", "GetTLSCert", "(", ")", ",", "sess", ".", "GetPriv", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "trace", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "tlsConfig", ".", "Certificates", "=", "[", "]", "tls", ".", "Certificate", "{", "tlsCert", "}", "\n", "addrs", ":=", "[", "]", "utils", ".", "NetAddr", "{", "utils", ".", "FromAddr", "(", "t", ".", "Listener", ".", "Addr", "(", ")", ")", "}", "\n", "return", "NewTLSClient", "(", "ClientConfig", "{", "Addrs", ":", "addrs", ",", "TLS", ":", "tlsConfig", "}", ")", "\n", "}" ]

[ "NewClientFromWebSession", "returns", "new", "authenticated", "client", "from", "web", "session" ]