repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/auth/auth.go | WithUserLock | func (s *AuthServer) WithUserLock(username string, authenticateFn func() error) error {
user, err := s.Identity.GetUser(username)
if err != nil {
return trace.Wrap(err)
}
status := user.GetStatus()
if status.IsLocked && status.LockExpires.After(s.clock.Now().UTC()) {
return trace.AccessDenied("%v exceeds %v failed login attempts, locked until %v",
user.GetName(), defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
}
fnErr := authenticateFn()
if fnErr == nil {
// upon successful login, reset the failed attempt counter
err = s.DeleteUserLoginAttempts(username)
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
return nil
}
// do not lock user in case if DB is flaky or down
if trace.IsConnectionProblem(err) {
return trace.Wrap(fnErr)
}
// log failed attempt and possibly lock user
attempt := services.LoginAttempt{Time: s.clock.Now().UTC(), Success: false}
err = s.AddUserLoginAttempt(username, attempt, defaults.AttemptTTL)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
loginAttempts, err := s.Identity.GetUserLoginAttempts(username)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
if !services.LastFailed(defaults.MaxLoginAttempts, loginAttempts) {
log.Debugf("%v user has less than %v failed login attempts", username, defaults.MaxLoginAttempts)
return trace.Wrap(fnErr)
}
lockUntil := s.clock.Now().UTC().Add(defaults.AccountLockInterval)
message := fmt.Sprintf("%v exceeds %v failed login attempts, locked until %v",
username, defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
log.Debug(message)
user.SetLocked(lockUntil, "user has exceeded maximum failed login attempts")
err = s.Identity.UpsertUser(user)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
return trace.AccessDenied(message)
} | go | func (s *AuthServer) WithUserLock(username string, authenticateFn func() error) error {
user, err := s.Identity.GetUser(username)
if err != nil {
return trace.Wrap(err)
}
status := user.GetStatus()
if status.IsLocked && status.LockExpires.After(s.clock.Now().UTC()) {
return trace.AccessDenied("%v exceeds %v failed login attempts, locked until %v",
user.GetName(), defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
}
fnErr := authenticateFn()
if fnErr == nil {
// upon successful login, reset the failed attempt counter
err = s.DeleteUserLoginAttempts(username)
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
return nil
}
// do not lock user in case if DB is flaky or down
if trace.IsConnectionProblem(err) {
return trace.Wrap(fnErr)
}
// log failed attempt and possibly lock user
attempt := services.LoginAttempt{Time: s.clock.Now().UTC(), Success: false}
err = s.AddUserLoginAttempt(username, attempt, defaults.AttemptTTL)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
loginAttempts, err := s.Identity.GetUserLoginAttempts(username)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
if !services.LastFailed(defaults.MaxLoginAttempts, loginAttempts) {
log.Debugf("%v user has less than %v failed login attempts", username, defaults.MaxLoginAttempts)
return trace.Wrap(fnErr)
}
lockUntil := s.clock.Now().UTC().Add(defaults.AccountLockInterval)
message := fmt.Sprintf("%v exceeds %v failed login attempts, locked until %v",
username, defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
log.Debug(message)
user.SetLocked(lockUntil, "user has exceeded maximum failed login attempts")
err = s.Identity.UpsertUser(user)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
return trace.AccessDenied(message)
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"WithUserLock",
"(",
"username",
"string",
",",
"authenticateFn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"user",
",",
"err",
":=",
"s",
".",
"Identity",
".",
"GetUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"status",
":=",
"user",
".",
"GetStatus",
"(",
")",
"\n",
"if",
"status",
".",
"IsLocked",
"&&",
"status",
".",
"LockExpires",
".",
"After",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
")",
"{",
"return",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
",",
"user",
".",
"GetName",
"(",
")",
",",
"defaults",
".",
"MaxLoginAttempts",
",",
"utils",
".",
"HumanTimeFormat",
"(",
"status",
".",
"LockExpires",
")",
")",
"\n",
"}",
"\n",
"fnErr",
":=",
"authenticateFn",
"(",
")",
"\n",
"if",
"fnErr",
"==",
"nil",
"{",
"// upon successful login, reset the failed attempt counter",
"err",
"=",
"s",
".",
"DeleteUserLoginAttempts",
"(",
"username",
")",
"\n",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"// do not lock user in case if DB is flaky or down",
"if",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"// log failed attempt and possibly lock user",
"attempt",
":=",
"services",
".",
"LoginAttempt",
"{",
"Time",
":",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"Success",
":",
"false",
"}",
"\n",
"err",
"=",
"s",
".",
"AddUserLoginAttempt",
"(",
"username",
",",
"attempt",
",",
"defaults",
".",
"AttemptTTL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"loginAttempts",
",",
"err",
":=",
"s",
".",
"Identity",
".",
"GetUserLoginAttempts",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"if",
"!",
"services",
".",
"LastFailed",
"(",
"defaults",
".",
"MaxLoginAttempts",
",",
"loginAttempts",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"username",
",",
"defaults",
".",
"MaxLoginAttempts",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"lockUntil",
":=",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"defaults",
".",
"AccountLockInterval",
")",
"\n",
"message",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"username",
",",
"defaults",
".",
"MaxLoginAttempts",
",",
"utils",
".",
"HumanTimeFormat",
"(",
"status",
".",
"LockExpires",
")",
")",
"\n",
"log",
".",
"Debug",
"(",
"message",
")",
"\n",
"user",
".",
"SetLocked",
"(",
"lockUntil",
",",
"\"",
"\"",
")",
"\n",
"err",
"=",
"s",
".",
"Identity",
".",
"UpsertUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"AccessDenied",
"(",
"message",
")",
"\n",
"}"
] | // WithUserLock executes function authenticateFn that performs user authentication
// if authenticateFn returns non nil error, the login attempt will be logged in as failed.
// The only exception to this rule is ConnectionProblemError, in case if it occurs
// access will be denied, but login attempt will not be recorded
// this is done to avoid potential user lockouts due to backend failures
// In case if user exceeds defaults.MaxLoginAttempts
// the user account will be locked for defaults.AccountLockInterval | [
"WithUserLock",
"executes",
"function",
"authenticateFn",
"that",
"performs",
"user",
"authentication",
"if",
"authenticateFn",
"returns",
"non",
"nil",
"error",
"the",
"login",
"attempt",
"will",
"be",
"logged",
"in",
"as",
"failed",
".",
"The",
"only",
"exception",
"to",
"this",
"rule",
"is",
"ConnectionProblemError",
"in",
"case",
"if",
"it",
"occurs",
"access",
"will",
"be",
"denied",
"but",
"login",
"attempt",
"will",
"not",
"be",
"recorded",
"this",
"is",
"done",
"to",
"avoid",
"potential",
"user",
"lockouts",
"due",
"to",
"backend",
"failures",
"In",
"case",
"if",
"user",
"exceeds",
"defaults",
".",
"MaxLoginAttempts",
"the",
"user",
"account",
"will",
"be",
"locked",
"for",
"defaults",
".",
"AccountLockInterval"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L543-L594 | train |
gravitational/teleport | lib/auth/auth.go | PreAuthenticatedSignIn | func (s *AuthServer) PreAuthenticatedSignIn(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
return sess.WithoutSecrets(), nil
} | go | func (s *AuthServer) PreAuthenticatedSignIn(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
return sess.WithoutSecrets(), nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"PreAuthenticatedSignIn",
"(",
"user",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"user",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
".",
"WithoutSecrets",
"(",
")",
",",
"nil",
"\n",
"}"
] | // PreAuthenticatedSignIn is for 2-way authentication methods like U2F where the password is
// already checked before issuing the second factor challenge | [
"PreAuthenticatedSignIn",
"is",
"for",
"2",
"-",
"way",
"authentication",
"methods",
"like",
"U2F",
"where",
"the",
"password",
"is",
"already",
"checked",
"before",
"issuing",
"the",
"second",
"factor",
"challenge"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L598-L607 | train |
gravitational/teleport | lib/auth/auth.go | ExtendWebSession | func (s *AuthServer) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
prevSession, err := s.GetWebSession(user, prevSessionID)
if err != nil {
return nil, trace.Wrap(err)
}
// consider absolute expiry time that may be set for this session
// by some external identity serivce, so we can not renew this session
// any more without extra logic for renewal with external OIDC provider
expiresAt := prevSession.GetExpiryTime()
if !expiresAt.IsZero() && expiresAt.Before(s.clock.Now().UTC()) {
return nil, trace.NotFound("web session has expired")
}
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
sess.SetExpiryTime(expiresAt)
bearerTokenTTL := utils.MinTTL(utils.ToTTL(s.clock, expiresAt), BearerTokenTTL)
sess.SetBearerTokenExpiryTime(s.clock.Now().UTC().Add(bearerTokenTTL))
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().ExtendWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | go | func (s *AuthServer) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
prevSession, err := s.GetWebSession(user, prevSessionID)
if err != nil {
return nil, trace.Wrap(err)
}
// consider absolute expiry time that may be set for this session
// by some external identity serivce, so we can not renew this session
// any more without extra logic for renewal with external OIDC provider
expiresAt := prevSession.GetExpiryTime()
if !expiresAt.IsZero() && expiresAt.Before(s.clock.Now().UTC()) {
return nil, trace.NotFound("web session has expired")
}
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
sess.SetExpiryTime(expiresAt)
bearerTokenTTL := utils.MinTTL(utils.ToTTL(s.clock, expiresAt), BearerTokenTTL)
sess.SetBearerTokenExpiryTime(s.clock.Now().UTC().Add(bearerTokenTTL))
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().ExtendWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"ExtendWebSession",
"(",
"user",
"string",
",",
"prevSessionID",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"prevSession",
",",
"err",
":=",
"s",
".",
"GetWebSession",
"(",
"user",
",",
"prevSessionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// consider absolute expiry time that may be set for this session",
"// by some external identity serivce, so we can not renew this session",
"// any more without extra logic for renewal with external OIDC provider",
"expiresAt",
":=",
"prevSession",
".",
"GetExpiryTime",
"(",
")",
"\n",
"if",
"!",
"expiresAt",
".",
"IsZero",
"(",
")",
"&&",
"expiresAt",
".",
"Before",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
".",
"SetExpiryTime",
"(",
"expiresAt",
")",
"\n",
"bearerTokenTTL",
":=",
"utils",
".",
"MinTTL",
"(",
"utils",
".",
"ToTTL",
"(",
"s",
".",
"clock",
",",
"expiresAt",
")",
",",
"BearerTokenTTL",
")",
"\n",
"sess",
".",
"SetBearerTokenExpiryTime",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"bearerTokenTTL",
")",
")",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"user",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
"=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"ExtendWebSession",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] | // ExtendWebSession creates a new web session for a user based on a valid previous sessionID,
// method is used to renew the web session for a user | [
"ExtendWebSession",
"creates",
"a",
"new",
"web",
"session",
"for",
"a",
"user",
"based",
"on",
"a",
"valid",
"previous",
"sessionID",
"method",
"is",
"used",
"to",
"renew",
"the",
"web",
"session",
"for",
"a",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L686-L715 | train |
gravitational/teleport | lib/auth/auth.go | CreateWebSession | func (s *AuthServer) CreateWebSession(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | go | func (s *AuthServer) CreateWebSession(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"CreateWebSession",
"(",
"user",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"user",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
"=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"GenerateWebSession",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] | // CreateWebSession creates a new web session for user without any
// checks, is used by admins | [
"CreateWebSession",
"creates",
"a",
"new",
"web",
"session",
"for",
"user",
"without",
"any",
"checks",
"is",
"used",
"by",
"admins"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L719-L732 | train |
gravitational/teleport | lib/auth/auth.go | CheckAndSetDefaults | func (req *GenerateTokenRequest) CheckAndSetDefaults() error {
for _, role := range req.Roles {
if err := role.Check(); err != nil {
return trace.Wrap(err)
}
}
if req.TTL == 0 {
req.TTL = defaults.ProvisioningTokenTTL
}
if req.Token == "" {
token, err := utils.CryptoRandomHex(TokenLenBytes)
if err != nil {
return trace.Wrap(err)
}
req.Token = token
}
return nil
} | go | func (req *GenerateTokenRequest) CheckAndSetDefaults() error {
for _, role := range req.Roles {
if err := role.Check(); err != nil {
return trace.Wrap(err)
}
}
if req.TTL == 0 {
req.TTL = defaults.ProvisioningTokenTTL
}
if req.Token == "" {
token, err := utils.CryptoRandomHex(TokenLenBytes)
if err != nil {
return trace.Wrap(err)
}
req.Token = token
}
return nil
} | [
"func",
"(",
"req",
"*",
"GenerateTokenRequest",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"for",
"_",
",",
"role",
":=",
"range",
"req",
".",
"Roles",
"{",
"if",
"err",
":=",
"role",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"req",
".",
"TTL",
"==",
"0",
"{",
"req",
".",
"TTL",
"=",
"defaults",
".",
"ProvisioningTokenTTL",
"\n",
"}",
"\n",
"if",
"req",
".",
"Token",
"==",
"\"",
"\"",
"{",
"token",
",",
"err",
":=",
"utils",
".",
"CryptoRandomHex",
"(",
"TokenLenBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"req",
".",
"Token",
"=",
"token",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets default values of request | [
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"values",
"of",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L745-L762 | train |
gravitational/teleport | lib/auth/auth.go | GenerateToken | func (s *AuthServer) GenerateToken(req GenerateTokenRequest) (string, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return "", trace.Wrap(err)
}
token, err := services.NewProvisionToken(req.Token, req.Roles, s.clock.Now().UTC().Add(req.TTL))
if err != nil {
return "", trace.Wrap(err)
}
if err := s.Provisioner.UpsertToken(token); err != nil {
return "", trace.Wrap(err)
}
return req.Token, nil
} | go | func (s *AuthServer) GenerateToken(req GenerateTokenRequest) (string, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return "", trace.Wrap(err)
}
token, err := services.NewProvisionToken(req.Token, req.Roles, s.clock.Now().UTC().Add(req.TTL))
if err != nil {
return "", trace.Wrap(err)
}
if err := s.Provisioner.UpsertToken(token); err != nil {
return "", trace.Wrap(err)
}
return req.Token, nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"GenerateToken",
"(",
"req",
"GenerateTokenRequest",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"req",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"token",
",",
"err",
":=",
"services",
".",
"NewProvisionToken",
"(",
"req",
".",
"Token",
",",
"req",
".",
"Roles",
",",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"req",
".",
"TTL",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"Provisioner",
".",
"UpsertToken",
"(",
"token",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"req",
".",
"Token",
",",
"nil",
"\n",
"}"
] | // GenerateToken generates multi-purpose authentication token | [
"GenerateToken",
"generates",
"multi",
"-",
"purpose",
"authentication",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L765-L777 | train |
gravitational/teleport | lib/auth/auth.go | ExtractHostID | func ExtractHostID(hostName string, clusterName string) (string, error) {
suffix := "." + clusterName
if !strings.HasSuffix(hostName, suffix) {
return "", trace.BadParameter("expected suffix %q in %q", suffix, hostName)
}
return strings.TrimSuffix(hostName, suffix), nil
} | go | func ExtractHostID(hostName string, clusterName string) (string, error) {
suffix := "." + clusterName
if !strings.HasSuffix(hostName, suffix) {
return "", trace.BadParameter("expected suffix %q in %q", suffix, hostName)
}
return strings.TrimSuffix(hostName, suffix), nil
} | [
"func",
"ExtractHostID",
"(",
"hostName",
"string",
",",
"clusterName",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"suffix",
":=",
"\"",
"\"",
"+",
"clusterName",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"hostName",
",",
"suffix",
")",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"suffix",
",",
"hostName",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimSuffix",
"(",
"hostName",
",",
"suffix",
")",
",",
"nil",
"\n",
"}"
] | // ExtractHostID returns host id based on the hostname | [
"ExtractHostID",
"returns",
"host",
"id",
"based",
"on",
"the",
"hostname"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L780-L786 | train |
gravitational/teleport | lib/auth/auth.go | ValidateToken | func (s *AuthServer) ValidateToken(token string) (roles teleport.Roles, e error) {
tkns, err := s.GetCache().GetStaticTokens()
if err != nil {
return nil, trace.Wrap(err)
}
// First check if the token is a static token. If it is, return right away.
// Static tokens have no expiration.
for _, st := range tkns.GetStaticTokens() {
if st.GetName() == token {
return st.GetRoles(), nil
}
}
// If it's not a static token, check if it's a ephemeral token in the backend.
// If a ephemeral token is found, make sure it's still valid.
tok, err := s.GetCache().GetToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
if !s.checkTokenTTL(tok) {
return nil, trace.AccessDenied("token expired")
}
return tok.GetRoles(), nil
} | go | func (s *AuthServer) ValidateToken(token string) (roles teleport.Roles, e error) {
tkns, err := s.GetCache().GetStaticTokens()
if err != nil {
return nil, trace.Wrap(err)
}
// First check if the token is a static token. If it is, return right away.
// Static tokens have no expiration.
for _, st := range tkns.GetStaticTokens() {
if st.GetName() == token {
return st.GetRoles(), nil
}
}
// If it's not a static token, check if it's a ephemeral token in the backend.
// If a ephemeral token is found, make sure it's still valid.
tok, err := s.GetCache().GetToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
if !s.checkTokenTTL(tok) {
return nil, trace.AccessDenied("token expired")
}
return tok.GetRoles(), nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"ValidateToken",
"(",
"token",
"string",
")",
"(",
"roles",
"teleport",
".",
"Roles",
",",
"e",
"error",
")",
"{",
"tkns",
",",
"err",
":=",
"s",
".",
"GetCache",
"(",
")",
".",
"GetStaticTokens",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// First check if the token is a static token. If it is, return right away.",
"// Static tokens have no expiration.",
"for",
"_",
",",
"st",
":=",
"range",
"tkns",
".",
"GetStaticTokens",
"(",
")",
"{",
"if",
"st",
".",
"GetName",
"(",
")",
"==",
"token",
"{",
"return",
"st",
".",
"GetRoles",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If it's not a static token, check if it's a ephemeral token in the backend.",
"// If a ephemeral token is found, make sure it's still valid.",
"tok",
",",
"err",
":=",
"s",
".",
"GetCache",
"(",
")",
".",
"GetToken",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"s",
".",
"checkTokenTTL",
"(",
"tok",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"tok",
".",
"GetRoles",
"(",
")",
",",
"nil",
"\n",
"}"
] | // ValidateToken takes a provisioning token value and finds if it's valid. Returns
// a list of roles this token allows its owner to assume, or an error if the token
// cannot be found. | [
"ValidateToken",
"takes",
"a",
"provisioning",
"token",
"value",
"and",
"finds",
"if",
"it",
"s",
"valid",
".",
"Returns",
"a",
"list",
"of",
"roles",
"this",
"token",
"allows",
"its",
"owner",
"to",
"assume",
"or",
"an",
"error",
"if",
"the",
"token",
"cannot",
"be",
"found",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L993-L1018 | train |
gravitational/teleport | lib/auth/auth.go | checkTokenTTL | func (s *AuthServer) checkTokenTTL(tok services.ProvisionToken) bool {
now := s.clock.Now().UTC()
if tok.Expiry().Before(now) {
err := s.DeleteToken(tok.GetName())
if err != nil {
if !trace.IsNotFound(err) {
log.Warnf("Unable to delete token from backend: %v.", err)
}
}
return false
}
return true
} | go | func (s *AuthServer) checkTokenTTL(tok services.ProvisionToken) bool {
now := s.clock.Now().UTC()
if tok.Expiry().Before(now) {
err := s.DeleteToken(tok.GetName())
if err != nil {
if !trace.IsNotFound(err) {
log.Warnf("Unable to delete token from backend: %v.", err)
}
}
return false
}
return true
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"checkTokenTTL",
"(",
"tok",
"services",
".",
"ProvisionToken",
")",
"bool",
"{",
"now",
":=",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"if",
"tok",
".",
"Expiry",
"(",
")",
".",
"Before",
"(",
"now",
")",
"{",
"err",
":=",
"s",
".",
"DeleteToken",
"(",
"tok",
".",
"GetName",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // checkTokenTTL checks if the token is still valid. If it is not, the token
// is removed from the backend and returns false. Otherwise returns true. | [
"checkTokenTTL",
"checks",
"if",
"the",
"token",
"is",
"still",
"valid",
".",
"If",
"it",
"is",
"not",
"the",
"token",
"is",
"removed",
"from",
"the",
"backend",
"and",
"returns",
"false",
".",
"Otherwise",
"returns",
"true",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1022-L1034 | train |
gravitational/teleport | lib/auth/auth.go | CheckAndSetDefaults | func (r *RegisterUsingTokenRequest) CheckAndSetDefaults() error {
if r.HostID == "" {
return trace.BadParameter("missing parameter HostID")
}
if r.Token == "" {
return trace.BadParameter("missing parameter Token")
}
if err := r.Role.Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (r *RegisterUsingTokenRequest) CheckAndSetDefaults() error {
if r.HostID == "" {
return trace.BadParameter("missing parameter HostID")
}
if r.Token == "" {
return trace.BadParameter("missing parameter Token")
}
if err := r.Role.Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"r",
"*",
"RegisterUsingTokenRequest",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"r",
".",
"HostID",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Token",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"Role",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks for errors and sets defaults | [
"CheckAndSetDefaults",
"checks",
"for",
"errors",
"and",
"sets",
"defaults"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1064-L1075 | train |
gravitational/teleport | lib/auth/auth.go | NewWatcher | func (a *AuthServer) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return a.GetCache().NewWatcher(ctx, watch)
} | go | func (a *AuthServer) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return a.GetCache().NewWatcher(ctx, watch)
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"NewWatcher",
"(",
"ctx",
"context",
".",
"Context",
",",
"watch",
"services",
".",
"Watch",
")",
"(",
"services",
".",
"Watcher",
",",
"error",
")",
"{",
"return",
"a",
".",
"GetCache",
"(",
")",
".",
"NewWatcher",
"(",
"ctx",
",",
"watch",
")",
"\n",
"}"
] | // NewWatcher returns a new event watcher. In case of an auth server
// this watcher will return events as seen by the auth server's
// in memory cache, not the backend. | [
"NewWatcher",
"returns",
"a",
"new",
"event",
"watcher",
".",
"In",
"case",
"of",
"an",
"auth",
"server",
"this",
"watcher",
"will",
"return",
"events",
"as",
"seen",
"by",
"the",
"auth",
"server",
"s",
"in",
"memory",
"cache",
"not",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1274-L1276 | train |
gravitational/teleport | lib/auth/auth.go | Error | func (k *authKeepAliver) Error() error {
k.RLock()
defer k.RUnlock()
return k.err
} | go | func (k *authKeepAliver) Error() error {
k.RLock()
defer k.RUnlock()
return k.err
} | [
"func",
"(",
"k",
"*",
"authKeepAliver",
")",
"Error",
"(",
")",
"error",
"{",
"k",
".",
"RLock",
"(",
")",
"\n",
"defer",
"k",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"k",
".",
"err",
"\n",
"}"
] | // Error returns the error if keep aliver
// has been closed | [
"Error",
"returns",
"the",
"error",
"if",
"keep",
"aliver",
"has",
"been",
"closed"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1443-L1447 | train |
gravitational/teleport | lib/auth/auth.go | oidcConfigsEqual | func oidcConfigsEqual(a, b oidc.ClientConfig) bool {
if a.RedirectURL != b.RedirectURL {
return false
}
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
return true
} | go | func oidcConfigsEqual(a, b oidc.ClientConfig) bool {
if a.RedirectURL != b.RedirectURL {
return false
}
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
return true
} | [
"func",
"oidcConfigsEqual",
"(",
"a",
",",
"b",
"oidc",
".",
"ClientConfig",
")",
"bool",
"{",
"if",
"a",
".",
"RedirectURL",
"!=",
"b",
".",
"RedirectURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"Credentials",
".",
"ID",
"!=",
"b",
".",
"Credentials",
".",
"ID",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"Credentials",
".",
"Secret",
"!=",
"b",
".",
"Credentials",
".",
"Secret",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
".",
"Scope",
")",
"!=",
"len",
"(",
"b",
".",
"Scope",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"a",
".",
"Scope",
"{",
"if",
"a",
".",
"Scope",
"[",
"i",
"]",
"!=",
"b",
".",
"Scope",
"[",
"i",
"]",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // oidcConfigsEqual returns true if the provided OIDC configs are equal | [
"oidcConfigsEqual",
"returns",
"true",
"if",
"the",
"provided",
"OIDC",
"configs",
"are",
"equal"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1488-L1507 | train |
gravitational/teleport | lib/auth/auth.go | oauth2ConfigsEqual | func oauth2ConfigsEqual(a, b oauth2.Config) bool {
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if a.RedirectURL != b.RedirectURL {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
if a.AuthURL != b.AuthURL {
return false
}
if a.TokenURL != b.TokenURL {
return false
}
if a.AuthMethod != b.AuthMethod {
return false
}
return true
} | go | func oauth2ConfigsEqual(a, b oauth2.Config) bool {
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if a.RedirectURL != b.RedirectURL {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
if a.AuthURL != b.AuthURL {
return false
}
if a.TokenURL != b.TokenURL {
return false
}
if a.AuthMethod != b.AuthMethod {
return false
}
return true
} | [
"func",
"oauth2ConfigsEqual",
"(",
"a",
",",
"b",
"oauth2",
".",
"Config",
")",
"bool",
"{",
"if",
"a",
".",
"Credentials",
".",
"ID",
"!=",
"b",
".",
"Credentials",
".",
"ID",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"Credentials",
".",
"Secret",
"!=",
"b",
".",
"Credentials",
".",
"Secret",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"RedirectURL",
"!=",
"b",
".",
"RedirectURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
".",
"Scope",
")",
"!=",
"len",
"(",
"b",
".",
"Scope",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"a",
".",
"Scope",
"{",
"if",
"a",
".",
"Scope",
"[",
"i",
"]",
"!=",
"b",
".",
"Scope",
"[",
"i",
"]",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"a",
".",
"AuthURL",
"!=",
"b",
".",
"AuthURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"TokenURL",
"!=",
"b",
".",
"TokenURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"AuthMethod",
"!=",
"b",
".",
"AuthMethod",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // oauth2ConfigsEqual returns true if the provided OAuth2 configs are equal | [
"oauth2ConfigsEqual",
"returns",
"true",
"if",
"the",
"provided",
"OAuth2",
"configs",
"are",
"equal"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1510-L1538 | train |
gravitational/teleport | lib/auth/auth.go | isHTTPS | func isHTTPS(u string) error {
earl, err := url.Parse(u)
if err != nil {
return trace.Wrap(err)
}
if earl.Scheme != "https" {
return trace.BadParameter("expected scheme https, got %q", earl.Scheme)
}
return nil
} | go | func isHTTPS(u string) error {
earl, err := url.Parse(u)
if err != nil {
return trace.Wrap(err)
}
if earl.Scheme != "https" {
return trace.BadParameter("expected scheme https, got %q", earl.Scheme)
}
return nil
} | [
"func",
"isHTTPS",
"(",
"u",
"string",
")",
"error",
"{",
"earl",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"earl",
".",
"Scheme",
"!=",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"earl",
".",
"Scheme",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // isHTTPS checks if the scheme for a URL is https or not. | [
"isHTTPS",
"checks",
"if",
"the",
"scheme",
"for",
"a",
"URL",
"is",
"https",
"or",
"not",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1541-L1551 | train |
gravitational/teleport | lib/services/oidc.go | NewOIDCConnector | func NewOIDCConnector(name string, spec OIDCConnectorSpecV2) OIDCConnector {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | go | func NewOIDCConnector(name string, spec OIDCConnectorSpecV2) OIDCConnector {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | [
"func",
"NewOIDCConnector",
"(",
"name",
"string",
",",
"spec",
"OIDCConnectorSpecV2",
")",
"OIDCConnector",
"{",
"return",
"&",
"OIDCConnectorV2",
"{",
"Kind",
":",
"KindOIDCConnector",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"}"
] | // NewOIDCConnector returns a new OIDCConnector based off a name and OIDCConnectorSpecV2. | [
"NewOIDCConnector",
"returns",
"a",
"new",
"OIDCConnector",
"based",
"off",
"a",
"name",
"and",
"OIDCConnectorSpecV2",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L92-L102 | train |
gravitational/teleport | lib/services/oidc.go | UnmarshalOIDCConnector | func (*TeleportOIDCConnectorMarshaler) UnmarshalOIDCConnector(bytes []byte, opts ...MarshalOption) (OIDCConnector, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var c OIDCConnectorV1
err := json.Unmarshal(bytes, &c)
if err != nil {
return nil, trace.Wrap(err)
}
return c.V2(), nil
case V2:
var c OIDCConnectorV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &c); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetOIDCConnectorSchema(), &c, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := c.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
c.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
c.SetExpiry(cfg.Expires)
}
return &c, nil
}
return nil, trace.BadParameter("OIDC connector resource version %v is not supported", h.Version)
} | go | func (*TeleportOIDCConnectorMarshaler) UnmarshalOIDCConnector(bytes []byte, opts ...MarshalOption) (OIDCConnector, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var c OIDCConnectorV1
err := json.Unmarshal(bytes, &c)
if err != nil {
return nil, trace.Wrap(err)
}
return c.V2(), nil
case V2:
var c OIDCConnectorV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &c); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetOIDCConnectorSchema(), &c, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := c.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
c.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
c.SetExpiry(cfg.Expires)
}
return &c, nil
}
return nil, trace.BadParameter("OIDC connector resource version %v is not supported", h.Version)
} | [
"func",
"(",
"*",
"TeleportOIDCConnectorMarshaler",
")",
"UnmarshalOIDCConnector",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"OIDCConnector",
",",
"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",
"c",
"OIDCConnectorV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"c",
"OIDCConnectorV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetOIDCConnectorSchema",
"(",
")",
",",
"&",
"c",
",",
"bytes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"c",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"c",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"c",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"c",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalOIDCConnector unmarshals connector from | [
"UnmarshalOIDCConnector",
"unmarshals",
"connector",
"from"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L137-L180 | train |
gravitational/teleport | lib/services/oidc.go | MarshalOIDCConnector | func (*TeleportOIDCConnectorMarshaler) MarshalOIDCConnector(c OIDCConnector, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type connv1 interface {
V1() *OIDCConnectorV1
}
type connv2 interface {
V2() *OIDCConnectorV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := c.(connv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := c.(connv2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | go | func (*TeleportOIDCConnectorMarshaler) MarshalOIDCConnector(c OIDCConnector, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type connv1 interface {
V1() *OIDCConnectorV1
}
type connv2 interface {
V2() *OIDCConnectorV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := c.(connv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := c.(connv2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | [
"func",
"(",
"*",
"TeleportOIDCConnectorMarshaler",
")",
"MarshalOIDCConnector",
"(",
"c",
"OIDCConnector",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"connv1",
"interface",
"{",
"V1",
"(",
")",
"*",
"OIDCConnectorV1",
"\n",
"}",
"\n\n",
"type",
"connv2",
"interface",
"{",
"V2",
"(",
")",
"*",
"OIDCConnectorV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"c",
".",
"(",
"connv1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"c",
".",
"(",
"connv2",
")",
"\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",
"}"
] | // MarshalUser marshals OIDC connector into JSON | [
"MarshalUser",
"marshals",
"OIDC",
"connector",
"into",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L183-L220 | train |
gravitational/teleport | lib/services/oidc.go | V1 | func (o *OIDCConnectorV2) V1() *OIDCConnectorV1 {
return &OIDCConnectorV1{
ID: o.Metadata.Name,
IssuerURL: o.Spec.IssuerURL,
ClientID: o.Spec.ClientID,
ClientSecret: o.Spec.ClientSecret,
RedirectURL: o.Spec.RedirectURL,
Display: o.Spec.Display,
Scope: o.Spec.Scope,
ClaimsToRoles: o.Spec.ClaimsToRoles,
}
} | go | func (o *OIDCConnectorV2) V1() *OIDCConnectorV1 {
return &OIDCConnectorV1{
ID: o.Metadata.Name,
IssuerURL: o.Spec.IssuerURL,
ClientID: o.Spec.ClientID,
ClientSecret: o.Spec.ClientSecret,
RedirectURL: o.Spec.RedirectURL,
Display: o.Spec.Display,
Scope: o.Spec.Scope,
ClaimsToRoles: o.Spec.ClaimsToRoles,
}
} | [
"func",
"(",
"o",
"*",
"OIDCConnectorV2",
")",
"V1",
"(",
")",
"*",
"OIDCConnectorV1",
"{",
"return",
"&",
"OIDCConnectorV1",
"{",
"ID",
":",
"o",
".",
"Metadata",
".",
"Name",
",",
"IssuerURL",
":",
"o",
".",
"Spec",
".",
"IssuerURL",
",",
"ClientID",
":",
"o",
".",
"Spec",
".",
"ClientID",
",",
"ClientSecret",
":",
"o",
".",
"Spec",
".",
"ClientSecret",
",",
"RedirectURL",
":",
"o",
".",
"Spec",
".",
"RedirectURL",
",",
"Display",
":",
"o",
".",
"Spec",
".",
"Display",
",",
"Scope",
":",
"o",
".",
"Spec",
".",
"Scope",
",",
"ClaimsToRoles",
":",
"o",
".",
"Spec",
".",
"ClaimsToRoles",
",",
"}",
"\n",
"}"
] | // V1 converts OIDCConnectorV2 to OIDCConnectorV1 format | [
"V1",
"converts",
"OIDCConnectorV2",
"to",
"OIDCConnectorV1",
"format"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L272-L283 | train |
gravitational/teleport | lib/services/oidc.go | GetClaims | func (o *OIDCConnectorV2) GetClaims() []string {
var out []string
for _, mapping := range o.Spec.ClaimsToRoles {
out = append(out, mapping.Claim)
}
return utils.Deduplicate(out)
} | go | func (o *OIDCConnectorV2) GetClaims() []string {
var out []string
for _, mapping := range o.Spec.ClaimsToRoles {
out = append(out, mapping.Claim)
}
return utils.Deduplicate(out)
} | [
"func",
"(",
"o",
"*",
"OIDCConnectorV2",
")",
"GetClaims",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"mapping",
":=",
"range",
"o",
".",
"Spec",
".",
"ClaimsToRoles",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"mapping",
".",
"Claim",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"Deduplicate",
"(",
"out",
")",
"\n",
"}"
] | // GetClaims returns list of claims expected by mappings | [
"GetClaims",
"returns",
"list",
"of",
"claims",
"expected",
"by",
"mappings"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L412-L418 | train |
gravitational/teleport | lib/services/oidc.go | MapClaims | func (o *OIDCConnectorV2) MapClaims(claims jose.Claims) []string {
var roles []string
for _, mapping := range o.Spec.ClaimsToRoles {
for claimName := range claims {
if claimName != mapping.Claim {
continue
}
var claimValues []string
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
claimValues = []string{claimValue}
} else {
claimValues, _, _ = claims.StringsClaim(claimName)
}
claimLoop:
for _, claimValue := range claimValues {
for _, role := range mapping.Roles {
outRole, err := utils.ReplaceRegexp(mapping.Value, role, claimValue)
switch {
case err != nil:
if trace.IsNotFound(err) {
log.Debugf("Failed to match expression %v, replace with: %v input: %v, err: %v", mapping.Value, role, claimValue, err)
}
// this claim value clearly did not match, move on to another
continue claimLoop
// skip empty replacement or empty role
case outRole == "":
case outRole != "":
roles = append(roles, outRole)
}
}
}
}
}
return utils.Deduplicate(roles)
} | go | func (o *OIDCConnectorV2) MapClaims(claims jose.Claims) []string {
var roles []string
for _, mapping := range o.Spec.ClaimsToRoles {
for claimName := range claims {
if claimName != mapping.Claim {
continue
}
var claimValues []string
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
claimValues = []string{claimValue}
} else {
claimValues, _, _ = claims.StringsClaim(claimName)
}
claimLoop:
for _, claimValue := range claimValues {
for _, role := range mapping.Roles {
outRole, err := utils.ReplaceRegexp(mapping.Value, role, claimValue)
switch {
case err != nil:
if trace.IsNotFound(err) {
log.Debugf("Failed to match expression %v, replace with: %v input: %v, err: %v", mapping.Value, role, claimValue, err)
}
// this claim value clearly did not match, move on to another
continue claimLoop
// skip empty replacement or empty role
case outRole == "":
case outRole != "":
roles = append(roles, outRole)
}
}
}
}
}
return utils.Deduplicate(roles)
} | [
"func",
"(",
"o",
"*",
"OIDCConnectorV2",
")",
"MapClaims",
"(",
"claims",
"jose",
".",
"Claims",
")",
"[",
"]",
"string",
"{",
"var",
"roles",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"mapping",
":=",
"range",
"o",
".",
"Spec",
".",
"ClaimsToRoles",
"{",
"for",
"claimName",
":=",
"range",
"claims",
"{",
"if",
"claimName",
"!=",
"mapping",
".",
"Claim",
"{",
"continue",
"\n",
"}",
"\n",
"var",
"claimValues",
"[",
"]",
"string",
"\n",
"claimValue",
",",
"ok",
",",
"_",
":=",
"claims",
".",
"StringClaim",
"(",
"claimName",
")",
"\n",
"if",
"ok",
"{",
"claimValues",
"=",
"[",
"]",
"string",
"{",
"claimValue",
"}",
"\n",
"}",
"else",
"{",
"claimValues",
",",
"_",
",",
"_",
"=",
"claims",
".",
"StringsClaim",
"(",
"claimName",
")",
"\n",
"}",
"\n",
"claimLoop",
":",
"for",
"_",
",",
"claimValue",
":=",
"range",
"claimValues",
"{",
"for",
"_",
",",
"role",
":=",
"range",
"mapping",
".",
"Roles",
"{",
"outRole",
",",
"err",
":=",
"utils",
".",
"ReplaceRegexp",
"(",
"mapping",
".",
"Value",
",",
"role",
",",
"claimValue",
")",
"\n",
"switch",
"{",
"case",
"err",
"!=",
"nil",
":",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"mapping",
".",
"Value",
",",
"role",
",",
"claimValue",
",",
"err",
")",
"\n",
"}",
"\n",
"// this claim value clearly did not match, move on to another",
"continue",
"claimLoop",
"\n",
"// skip empty replacement or empty role",
"case",
"outRole",
"==",
"\"",
"\"",
":",
"case",
"outRole",
"!=",
"\"",
"\"",
":",
"roles",
"=",
"append",
"(",
"roles",
",",
"outRole",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"utils",
".",
"Deduplicate",
"(",
"roles",
")",
"\n",
"}"
] | // MapClaims maps claims to roles | [
"MapClaims",
"maps",
"claims",
"to",
"roles"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L421-L456 | train |
gravitational/teleport | lib/services/oidc.go | GetClaimNames | func GetClaimNames(claims jose.Claims) []string {
var out []string
for claim := range claims {
out = append(out, claim)
}
return out
} | go | func GetClaimNames(claims jose.Claims) []string {
var out []string
for claim := range claims {
out = append(out, claim)
}
return out
} | [
"func",
"GetClaimNames",
"(",
"claims",
"jose",
".",
"Claims",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"claim",
":=",
"range",
"claims",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"claim",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // GetClaimNames returns a list of claim names from the claim values | [
"GetClaimNames",
"returns",
"a",
"list",
"of",
"claim",
"names",
"from",
"the",
"claim",
"values"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L613-L619 | train |
gravitational/teleport | lib/services/oidc.go | V2 | func (o *OIDCConnectorV1) V2() *OIDCConnectorV2 {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: o.ID,
},
Spec: OIDCConnectorSpecV2{
IssuerURL: o.IssuerURL,
ClientID: o.ClientID,
ClientSecret: o.ClientSecret,
RedirectURL: o.RedirectURL,
Display: o.Display,
Scope: o.Scope,
ClaimsToRoles: o.ClaimsToRoles,
},
}
} | go | func (o *OIDCConnectorV1) V2() *OIDCConnectorV2 {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: o.ID,
},
Spec: OIDCConnectorSpecV2{
IssuerURL: o.IssuerURL,
ClientID: o.ClientID,
ClientSecret: o.ClientSecret,
RedirectURL: o.RedirectURL,
Display: o.Display,
Scope: o.Scope,
ClaimsToRoles: o.ClaimsToRoles,
},
}
} | [
"func",
"(",
"o",
"*",
"OIDCConnectorV1",
")",
"V2",
"(",
")",
"*",
"OIDCConnectorV2",
"{",
"return",
"&",
"OIDCConnectorV2",
"{",
"Kind",
":",
"KindOIDCConnector",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"o",
".",
"ID",
",",
"}",
",",
"Spec",
":",
"OIDCConnectorSpecV2",
"{",
"IssuerURL",
":",
"o",
".",
"IssuerURL",
",",
"ClientID",
":",
"o",
".",
"ClientID",
",",
"ClientSecret",
":",
"o",
".",
"ClientSecret",
",",
"RedirectURL",
":",
"o",
".",
"RedirectURL",
",",
"Display",
":",
"o",
".",
"Display",
",",
"Scope",
":",
"o",
".",
"Scope",
",",
"ClaimsToRoles",
":",
"o",
".",
"ClaimsToRoles",
",",
"}",
",",
"}",
"\n",
"}"
] | // V2 returns V2 version of the connector | [
"V2",
"returns",
"V2",
"version",
"of",
"the",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L682-L699 | train |
gravitational/teleport | lib/utils/checker.go | Authenticate | func (c *CertChecker) Authenticate(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
err := validate(key)
if err != nil {
return nil, trace.Wrap(err)
}
perms, err := c.CertChecker.Authenticate(conn, key)
if err != nil {
return nil, trace.Wrap(err)
}
return perms, nil
} | go | func (c *CertChecker) Authenticate(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
err := validate(key)
if err != nil {
return nil, trace.Wrap(err)
}
perms, err := c.CertChecker.Authenticate(conn, key)
if err != nil {
return nil, trace.Wrap(err)
}
return perms, nil
} | [
"func",
"(",
"c",
"*",
"CertChecker",
")",
"Authenticate",
"(",
"conn",
"ssh",
".",
"ConnMetadata",
",",
"key",
"ssh",
".",
"PublicKey",
")",
"(",
"*",
"ssh",
".",
"Permissions",
",",
"error",
")",
"{",
"err",
":=",
"validate",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"perms",
",",
"err",
":=",
"c",
".",
"CertChecker",
".",
"Authenticate",
"(",
"conn",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"perms",
",",
"nil",
"\n",
"}"
] | // Authenticate checks the validity of a user certificate.
// a value for ServerConfig.PublicKeyCallback. | [
"Authenticate",
"checks",
"the",
"validity",
"of",
"a",
"user",
"certificate",
".",
"a",
"value",
"for",
"ServerConfig",
".",
"PublicKeyCallback",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L43-L55 | train |
gravitational/teleport | lib/utils/checker.go | CheckCert | func (c *CertChecker) CheckCert(principal string, cert *ssh.Certificate) error {
err := validate(cert)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckCert(principal, cert)
} | go | func (c *CertChecker) CheckCert(principal string, cert *ssh.Certificate) error {
err := validate(cert)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckCert(principal, cert)
} | [
"func",
"(",
"c",
"*",
"CertChecker",
")",
"CheckCert",
"(",
"principal",
"string",
",",
"cert",
"*",
"ssh",
".",
"Certificate",
")",
"error",
"{",
"err",
":=",
"validate",
"(",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"CertChecker",
".",
"CheckCert",
"(",
"principal",
",",
"cert",
")",
"\n",
"}"
] | // CheckCert checks certificate metadata and signature. | [
"CheckCert",
"checks",
"certificate",
"metadata",
"and",
"signature",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L58-L65 | train |
gravitational/teleport | lib/utils/checker.go | CheckHostKey | func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key ssh.PublicKey) error {
err := validate(key)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckHostKey(addr, remote, key)
} | go | func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key ssh.PublicKey) error {
err := validate(key)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckHostKey(addr, remote, key)
} | [
"func",
"(",
"c",
"*",
"CertChecker",
")",
"CheckHostKey",
"(",
"addr",
"string",
",",
"remote",
"net",
".",
"Addr",
",",
"key",
"ssh",
".",
"PublicKey",
")",
"error",
"{",
"err",
":=",
"validate",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"CertChecker",
".",
"CheckHostKey",
"(",
"addr",
",",
"remote",
",",
"key",
")",
"\n",
"}"
] | // CheckHostKey checks the validity of a host certificate. | [
"CheckHostKey",
"checks",
"the",
"validity",
"of",
"a",
"host",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L68-L75 | train |
gravitational/teleport | lib/utils/checker.go | CreateCertificate | func CreateCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create RSA key for CA and certificate to be signed by CA.
caKey, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
} | go | func CreateCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create RSA key for CA and certificate to be signed by CA.
caKey, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
} | [
"func",
"CreateCertificate",
"(",
"principal",
"string",
",",
"certType",
"uint32",
")",
"(",
"*",
"ssh",
".",
"Certificate",
",",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"// Create RSA key for CA and certificate to be signed by CA.",
"caKey",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"teleport",
".",
"RSAKeySize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"key",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"teleport",
".",
"RSAKeySize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"certSigner",
",",
"err",
":=",
"createCertificate",
"(",
"principal",
",",
"certType",
",",
"caKey",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"cert",
",",
"certSigner",
",",
"nil",
"\n",
"}"
] | // CreateCertificate creates a valid 2048-bit RSA certificate. | [
"CreateCertificate",
"creates",
"a",
"valid",
"2048",
"-",
"bit",
"RSA",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L111-L128 | train |
gravitational/teleport | lib/utils/checker.go | CreateEllipticCertificate | func CreateEllipticCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create ECDSA key for CA and certificate to be signed by CA.
caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
} | go | func CreateEllipticCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create ECDSA key for CA and certificate to be signed by CA.
caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
} | [
"func",
"CreateEllipticCertificate",
"(",
"principal",
"string",
",",
"certType",
"uint32",
")",
"(",
"*",
"ssh",
".",
"Certificate",
",",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"// Create ECDSA key for CA and certificate to be signed by CA.",
"caKey",
",",
"err",
":=",
"ecdsa",
".",
"GenerateKey",
"(",
"elliptic",
".",
"P256",
"(",
")",
",",
"rand",
".",
"Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"key",
",",
"err",
":=",
"ecdsa",
".",
"GenerateKey",
"(",
"elliptic",
".",
"P256",
"(",
")",
",",
"rand",
".",
"Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"certSigner",
",",
"err",
":=",
"createCertificate",
"(",
"principal",
",",
"certType",
",",
"caKey",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"cert",
",",
"certSigner",
",",
"nil",
"\n",
"}"
] | // CreateEllipticCertificate creates a valid, but not supported, ECDSA
// SSH certificate. This certificate is used to make sure Teleport rejects
// such certificates. | [
"CreateEllipticCertificate",
"creates",
"a",
"valid",
"but",
"not",
"supported",
"ECDSA",
"SSH",
"certificate",
".",
"This",
"certificate",
"is",
"used",
"to",
"make",
"sure",
"Teleport",
"rejects",
"such",
"certificates",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L133-L150 | train |
gravitational/teleport | lib/utils/checker.go | createCertificate | func createCertificate(principal string, certType uint32, caKey crypto.Signer, key crypto.Signer) (*ssh.Certificate, ssh.Signer, error) {
// Create CA.
caPublicKey, err := ssh.NewPublicKey(caKey.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
caSigner, err := ssh.NewSignerFromKey(caKey)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create key.
publicKey, err := ssh.NewPublicKey(key.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
keySigner, err := ssh.NewSignerFromKey(key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create certificate and signer.
cert := &ssh.Certificate{
KeyId: principal,
ValidPrincipals: []string{principal},
Key: publicKey,
SignatureKey: caPublicKey,
ValidAfter: uint64(time.Now().UTC().Add(-1 * time.Minute).Unix()),
ValidBefore: uint64(time.Now().UTC().Add(1 * time.Minute).Unix()),
CertType: certType,
}
err = cert.SignCert(rand.Reader, caSigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
certSigner, err := ssh.NewCertSigner(cert, keySigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
} | go | func createCertificate(principal string, certType uint32, caKey crypto.Signer, key crypto.Signer) (*ssh.Certificate, ssh.Signer, error) {
// Create CA.
caPublicKey, err := ssh.NewPublicKey(caKey.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
caSigner, err := ssh.NewSignerFromKey(caKey)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create key.
publicKey, err := ssh.NewPublicKey(key.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
keySigner, err := ssh.NewSignerFromKey(key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create certificate and signer.
cert := &ssh.Certificate{
KeyId: principal,
ValidPrincipals: []string{principal},
Key: publicKey,
SignatureKey: caPublicKey,
ValidAfter: uint64(time.Now().UTC().Add(-1 * time.Minute).Unix()),
ValidBefore: uint64(time.Now().UTC().Add(1 * time.Minute).Unix()),
CertType: certType,
}
err = cert.SignCert(rand.Reader, caSigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
certSigner, err := ssh.NewCertSigner(cert, keySigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
} | [
"func",
"createCertificate",
"(",
"principal",
"string",
",",
"certType",
"uint32",
",",
"caKey",
"crypto",
".",
"Signer",
",",
"key",
"crypto",
".",
"Signer",
")",
"(",
"*",
"ssh",
".",
"Certificate",
",",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"// Create CA.",
"caPublicKey",
",",
"err",
":=",
"ssh",
".",
"NewPublicKey",
"(",
"caKey",
".",
"Public",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"caSigner",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"caKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Create key.",
"publicKey",
",",
"err",
":=",
"ssh",
".",
"NewPublicKey",
"(",
"key",
".",
"Public",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"keySigner",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Create certificate and signer.",
"cert",
":=",
"&",
"ssh",
".",
"Certificate",
"{",
"KeyId",
":",
"principal",
",",
"ValidPrincipals",
":",
"[",
"]",
"string",
"{",
"principal",
"}",
",",
"Key",
":",
"publicKey",
",",
"SignatureKey",
":",
"caPublicKey",
",",
"ValidAfter",
":",
"uint64",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"-",
"1",
"*",
"time",
".",
"Minute",
")",
".",
"Unix",
"(",
")",
")",
",",
"ValidBefore",
":",
"uint64",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Minute",
")",
".",
"Unix",
"(",
")",
")",
",",
"CertType",
":",
"certType",
",",
"}",
"\n",
"err",
"=",
"cert",
".",
"SignCert",
"(",
"rand",
".",
"Reader",
",",
"caSigner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certSigner",
",",
"err",
":=",
"ssh",
".",
"NewCertSigner",
"(",
"cert",
",",
"keySigner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"cert",
",",
"certSigner",
",",
"nil",
"\n",
"}"
] | // createCertificate creates a SSH certificate for the given key signed by the
// given CA key. This function exists here to allow easy key generation for
// some of the more core packages like "sshutils". | [
"createCertificate",
"creates",
"a",
"SSH",
"certificate",
"for",
"the",
"given",
"key",
"signed",
"by",
"the",
"given",
"CA",
"key",
".",
"This",
"function",
"exists",
"here",
"to",
"allow",
"easy",
"key",
"generation",
"for",
"some",
"of",
"the",
"more",
"core",
"packages",
"like",
"sshutils",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L155-L196 | train |
gravitational/teleport | lib/auth/apiserver.go | upsertServer | func (s *APIServer) upsertServer(auth ClientI, role teleport.Role, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertServerRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
var kind string
switch role {
case teleport.RoleNode:
kind = services.KindNode
case teleport.RoleAuth:
kind = services.KindAuthServer
case teleport.RoleProxy:
kind = services.KindProxy
}
server, err := services.GetServerMarshaler().UnmarshalServer(req.Server, kind)
if err != nil {
return nil, trace.Wrap(err)
}
// if server sent "local" IP address to us, replace the ip/host part with the remote address we see
// on the socket, but keep the original port:
server.SetAddr(utils.ReplaceLocalhost(server.GetAddr(), r.RemoteAddr))
if req.TTL != 0 {
server.SetTTL(s, req.TTL)
}
switch role {
case teleport.RoleNode:
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
server.SetNamespace(namespace)
handle, err := auth.UpsertNode(server)
if err != nil {
return nil, trace.Wrap(err)
}
return handle, nil
case teleport.RoleAuth:
if err := auth.UpsertAuthServer(server); err != nil {
return nil, trace.Wrap(err)
}
case teleport.RoleProxy:
if err := auth.UpsertProxy(server); err != nil {
return nil, trace.Wrap(err)
}
}
return message("ok"), nil
} | go | func (s *APIServer) upsertServer(auth ClientI, role teleport.Role, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertServerRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
var kind string
switch role {
case teleport.RoleNode:
kind = services.KindNode
case teleport.RoleAuth:
kind = services.KindAuthServer
case teleport.RoleProxy:
kind = services.KindProxy
}
server, err := services.GetServerMarshaler().UnmarshalServer(req.Server, kind)
if err != nil {
return nil, trace.Wrap(err)
}
// if server sent "local" IP address to us, replace the ip/host part with the remote address we see
// on the socket, but keep the original port:
server.SetAddr(utils.ReplaceLocalhost(server.GetAddr(), r.RemoteAddr))
if req.TTL != 0 {
server.SetTTL(s, req.TTL)
}
switch role {
case teleport.RoleNode:
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
server.SetNamespace(namespace)
handle, err := auth.UpsertNode(server)
if err != nil {
return nil, trace.Wrap(err)
}
return handle, nil
case teleport.RoleAuth:
if err := auth.UpsertAuthServer(server); err != nil {
return nil, trace.Wrap(err)
}
case teleport.RoleProxy:
if err := auth.UpsertProxy(server); err != nil {
return nil, trace.Wrap(err)
}
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertServer",
"(",
"auth",
"ClientI",
",",
"role",
"teleport",
".",
"Role",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertServerRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"kind",
"string",
"\n",
"switch",
"role",
"{",
"case",
"teleport",
".",
"RoleNode",
":",
"kind",
"=",
"services",
".",
"KindNode",
"\n",
"case",
"teleport",
".",
"RoleAuth",
":",
"kind",
"=",
"services",
".",
"KindAuthServer",
"\n",
"case",
"teleport",
".",
"RoleProxy",
":",
"kind",
"=",
"services",
".",
"KindProxy",
"\n",
"}",
"\n",
"server",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServer",
"(",
"req",
".",
"Server",
",",
"kind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"// if server sent \"local\" IP address to us, replace the ip/host part with the remote address we see",
"// on the socket, but keep the original port:",
"server",
".",
"SetAddr",
"(",
"utils",
".",
"ReplaceLocalhost",
"(",
"server",
".",
"GetAddr",
"(",
")",
",",
"r",
".",
"RemoteAddr",
")",
")",
"\n",
"if",
"req",
".",
"TTL",
"!=",
"0",
"{",
"server",
".",
"SetTTL",
"(",
"s",
",",
"req",
".",
"TTL",
")",
"\n",
"}",
"\n",
"switch",
"role",
"{",
"case",
"teleport",
".",
"RoleNode",
":",
"namespace",
":=",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"services",
".",
"IsValidNamespace",
"(",
"namespace",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"server",
".",
"SetNamespace",
"(",
"namespace",
")",
"\n",
"handle",
",",
"err",
":=",
"auth",
".",
"UpsertNode",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"handle",
",",
"nil",
"\n",
"case",
"teleport",
".",
"RoleAuth",
":",
"if",
"err",
":=",
"auth",
".",
"UpsertAuthServer",
"(",
"server",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"case",
"teleport",
".",
"RoleProxy",
":",
"if",
"err",
":=",
"auth",
".",
"UpsertProxy",
"(",
"server",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // upsertServer is a common utility function | [
"upsertServer",
"is",
"a",
"common",
"utility",
"function"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L279-L325 | train |
gravitational/teleport | lib/auth/apiserver.go | keepAliveNode | func (s *APIServer) keepAliveNode(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var handle services.KeepAlive
if err := httplib.ReadJSON(r, &handle); err != nil {
return nil, trace.Wrap(err)
}
if err := auth.KeepAliveNode(r.Context(), handle); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | go | func (s *APIServer) keepAliveNode(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var handle services.KeepAlive
if err := httplib.ReadJSON(r, &handle); err != nil {
return nil, trace.Wrap(err)
}
if err := auth.KeepAliveNode(r.Context(), handle); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"keepAliveNode",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"handle",
"services",
".",
"KeepAlive",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"KeepAliveNode",
"(",
"r",
".",
"Context",
"(",
")",
",",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // keepAliveNode updates node TTL in the backend | [
"keepAliveNode",
"updates",
"node",
"TTL",
"in",
"the",
"backend"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L328-L337 | train |
gravitational/teleport | lib/auth/apiserver.go | upsertNodes | func (s *APIServer) upsertNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertNodesReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
if !services.IsValidNamespace(req.Namespace) {
return nil, trace.BadParameter("invalid namespace %q", req.Namespace)
}
nodes, err := services.GetServerMarshaler().UnmarshalServers(req.Nodes)
if err != nil {
return nil, trace.Wrap(err)
}
err = auth.UpsertNodes(req.Namespace, nodes)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | go | func (s *APIServer) upsertNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertNodesReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
if !services.IsValidNamespace(req.Namespace) {
return nil, trace.BadParameter("invalid namespace %q", req.Namespace)
}
nodes, err := services.GetServerMarshaler().UnmarshalServers(req.Nodes)
if err != nil {
return nil, trace.Wrap(err)
}
err = auth.UpsertNodes(req.Namespace, nodes)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertNodes",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertNodesReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"services",
".",
"IsValidNamespace",
"(",
"req",
".",
"Namespace",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"req",
".",
"Namespace",
")",
"\n",
"}",
"\n\n",
"nodes",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServers",
"(",
"req",
".",
"Nodes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"auth",
".",
"UpsertNodes",
"(",
"req",
".",
"Namespace",
",",
"nodes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // upsertNodes is used to bulk insert nodes into the backend. | [
"upsertNodes",
"is",
"used",
"to",
"bulk",
"insert",
"nodes",
"into",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L345-L365 | train |
gravitational/teleport | lib/auth/apiserver.go | getNodes | func (s *APIServer) getNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
skipValidation, _, err := httplib.ParseBool(r.URL.Query(), "skip_validation")
if err != nil {
return nil, trace.Wrap(err)
}
var opts []services.MarshalOption
if skipValidation {
opts = append(opts, services.SkipValidation())
}
servers, err := auth.GetNodes(namespace, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | go | func (s *APIServer) getNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
skipValidation, _, err := httplib.ParseBool(r.URL.Query(), "skip_validation")
if err != nil {
return nil, trace.Wrap(err)
}
var opts []services.MarshalOption
if skipValidation {
opts = append(opts, services.SkipValidation())
}
servers, err := auth.GetNodes(namespace, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getNodes",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"namespace",
":=",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"services",
".",
"IsValidNamespace",
"(",
"namespace",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"skipValidation",
",",
"_",
",",
"err",
":=",
"httplib",
".",
"ParseBool",
"(",
"r",
".",
"URL",
".",
"Query",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"opts",
"[",
"]",
"services",
".",
"MarshalOption",
"\n",
"if",
"skipValidation",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"}",
"\n\n",
"servers",
",",
"err",
":=",
"auth",
".",
"GetNodes",
"(",
"namespace",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"marshalServers",
"(",
"servers",
",",
"version",
")",
"\n",
"}"
] | // getNodes returns registered SSH nodes | [
"getNodes",
"returns",
"registered",
"SSH",
"nodes"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L373-L392 | train |
gravitational/teleport | lib/auth/apiserver.go | deleteProxy | func (s *APIServer) deleteProxy(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
name := p.ByName("name")
if name == "" {
return nil, trace.BadParameter("missing proxy name")
}
err := auth.DeleteProxy(name)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | go | func (s *APIServer) deleteProxy(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
name := p.ByName("name")
if name == "" {
return nil, trace.BadParameter("missing proxy name")
}
err := auth.DeleteProxy(name)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"deleteProxy",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"name",
":=",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"auth",
".",
"DeleteProxy",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // deleteProxy deletes proxy | [
"deleteProxy",
"deletes",
"proxy"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L448-L458 | train |
gravitational/teleport | lib/auth/apiserver.go | upsertAuthServer | func (s *APIServer) upsertAuthServer(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
return s.upsertServer(auth, teleport.RoleAuth, w, r, p, version)
} | go | func (s *APIServer) upsertAuthServer(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
return s.upsertServer(auth, teleport.RoleAuth, w, r, p, version)
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertAuthServer",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"s",
".",
"upsertServer",
"(",
"auth",
",",
"teleport",
".",
"RoleAuth",
",",
"w",
",",
"r",
",",
"p",
",",
"version",
")",
"\n",
"}"
] | // upsertAuthServer is called by remote Auth servers when they ping back into the auth service | [
"upsertAuthServer",
"is",
"called",
"by",
"remote",
"Auth",
"servers",
"when",
"they",
"ping",
"back",
"into",
"the",
"auth",
"service"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L461-L463 | train |
gravitational/teleport | lib/auth/apiserver.go | getAuthServers | func (s *APIServer) getAuthServers(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
servers, err := auth.GetAuthServers()
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | go | func (s *APIServer) getAuthServers(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
servers, err := auth.GetAuthServers()
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getAuthServers",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"servers",
",",
"err",
":=",
"auth",
".",
"GetAuthServers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"marshalServers",
"(",
"servers",
",",
"version",
")",
"\n",
"}"
] | // getAuthServers returns registered auth servers | [
"getAuthServers",
"returns",
"registered",
"auth",
"servers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L466-L472 | train |
gravitational/teleport | lib/auth/apiserver.go | upsertReverseTunnel | func (s *APIServer) upsertReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertReverseTunnelRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
tun, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(req.ReverseTunnel)
if err != nil {
return nil, trace.Wrap(err)
}
if req.TTL != 0 {
tun.SetTTL(s, req.TTL)
}
if err := auth.UpsertReverseTunnel(tun); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | go | func (s *APIServer) upsertReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertReverseTunnelRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
tun, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(req.ReverseTunnel)
if err != nil {
return nil, trace.Wrap(err)
}
if req.TTL != 0 {
tun.SetTTL(s, req.TTL)
}
if err := auth.UpsertReverseTunnel(tun); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertReverseTunnel",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertReverseTunnelRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tun",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"UnmarshalReverseTunnel",
"(",
"req",
".",
"ReverseTunnel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"TTL",
"!=",
"0",
"{",
"tun",
".",
"SetTTL",
"(",
"s",
",",
"req",
".",
"TTL",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"UpsertReverseTunnel",
"(",
"tun",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // upsertReverseTunnel is called by admin to create a reverse tunnel to remote proxy | [
"upsertReverseTunnel",
"is",
"called",
"by",
"admin",
"to",
"create",
"a",
"reverse",
"tunnel",
"to",
"remote",
"proxy"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L492-L508 | train |
gravitational/teleport | lib/auth/apiserver.go | getReverseTunnels | func (s *APIServer) getReverseTunnels(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
reverseTunnels, err := auth.GetReverseTunnels()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(reverseTunnels))
for i, tunnel := range reverseTunnels {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | go | func (s *APIServer) getReverseTunnels(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
reverseTunnels, err := auth.GetReverseTunnels()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(reverseTunnels))
for i, tunnel := range reverseTunnels {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getReverseTunnels",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"reverseTunnels",
",",
"err",
":=",
"auth",
".",
"GetReverseTunnels",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"json",
".",
"RawMessage",
",",
"len",
"(",
"reverseTunnels",
")",
")",
"\n",
"for",
"i",
",",
"tunnel",
":=",
"range",
"reverseTunnels",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"MarshalReverseTunnel",
"(",
"tunnel",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"data",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] | // getReverseTunnels returns a list of reverse tunnels | [
"getReverseTunnels",
"returns",
"a",
"list",
"of",
"reverse",
"tunnels"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L511-L525 | train |
gravitational/teleport | lib/auth/apiserver.go | deleteReverseTunnel | func (s *APIServer) deleteReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
domainName := p.ByName("domain")
err := auth.DeleteReverseTunnel(domainName)
if err != nil {
return nil, trace.Wrap(err)
}
return message(fmt.Sprintf("reverse tunnel %v deleted", domainName)), nil
} | go | func (s *APIServer) deleteReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
domainName := p.ByName("domain")
err := auth.DeleteReverseTunnel(domainName)
if err != nil {
return nil, trace.Wrap(err)
}
return message(fmt.Sprintf("reverse tunnel %v deleted", domainName)), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"deleteReverseTunnel",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"domainName",
":=",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n",
"err",
":=",
"auth",
".",
"DeleteReverseTunnel",
"(",
"domainName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"domainName",
")",
")",
",",
"nil",
"\n",
"}"
] | // deleteReverseTunnel deletes reverse tunnel | [
"deleteReverseTunnel",
"deletes",
"reverse",
"tunnel"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L528-L535 | train |
gravitational/teleport | lib/auth/apiserver.go | getClusterCACert | func (s *APIServer) getClusterCACert(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
localCA, err := auth.GetClusterCACert()
if err != nil {
return nil, trace.Wrap(err)
}
return localCA, nil
} | go | func (s *APIServer) getClusterCACert(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
localCA, err := auth.GetClusterCACert()
if err != nil {
return nil, trace.Wrap(err)
}
return localCA, nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getClusterCACert",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"localCA",
",",
"err",
":=",
"auth",
".",
"GetClusterCACert",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"localCA",
",",
"nil",
"\n",
"}"
] | // getClusterCACert returns the CAs for the local cluster without signing keys. | [
"getClusterCACert",
"returns",
"the",
"CAs",
"for",
"the",
"local",
"cluster",
"without",
"signing",
"keys",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L1075-L1082 | train |
gravitational/teleport | lib/auth/apiserver.go | getU2FAppID | func (s *APIServer) getU2FAppID(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cap, err := auth.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
universalSecondFactor, err := cap.GetU2F()
if err != nil {
return nil, trace.Wrap(err)
}
w.Header().Set("Content-Type", "application/fido.trusted-apps+json")
return universalSecondFactor.AppID, nil
} | go | func (s *APIServer) getU2FAppID(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cap, err := auth.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
universalSecondFactor, err := cap.GetU2F()
if err != nil {
return nil, trace.Wrap(err)
}
w.Header().Set("Content-Type", "application/fido.trusted-apps+json")
return universalSecondFactor.AppID, nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getU2FAppID",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cap",
",",
"err",
":=",
"auth",
".",
"GetAuthPreference",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"universalSecondFactor",
",",
"err",
":=",
"cap",
".",
"GetU2F",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"universalSecondFactor",
".",
"AppID",
",",
"nil",
"\n",
"}"
] | // getU2FAppID returns the U2F AppID in the auth configuration | [
"getU2FAppID",
"returns",
"the",
"U2F",
"AppID",
"in",
"the",
"auth",
"configuration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L1085-L1098 | train |
gravitational/teleport | lib/auth/apiserver.go | getSignupTokenData | func (s *APIServer) getSignupTokenData(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
token := p.ByName("token")
user, otpQRCode, err := auth.GetSignupTokenData(token)
if err != nil {
return nil, trace.Wrap(err)
}
return &getSignupTokenDataResponse{
User: user,
QRImg: otpQRCode,
}, nil
} | go | func (s *APIServer) getSignupTokenData(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
token := p.ByName("token")
user, otpQRCode, err := auth.GetSignupTokenData(token)
if err != nil {
return nil, trace.Wrap(err)
}
return &getSignupTokenDataResponse{
User: user,
QRImg: otpQRCode,
}, nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getSignupTokenData",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"token",
":=",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
"\n\n",
"user",
",",
"otpQRCode",
",",
"err",
":=",
"auth",
".",
"GetSignupTokenData",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"getSignupTokenDataResponse",
"{",
"User",
":",
"user",
",",
"QRImg",
":",
"otpQRCode",
",",
"}",
",",
"nil",
"\n",
"}"
] | // getSignupTokenData returns the signup data for a token. | [
"getSignupTokenData",
"returns",
"the",
"signup",
"data",
"for",
"a",
"token",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L1185-L1197 | train |
gravitational/teleport | lib/auth/apiserver.go | upsertTunnelConnection | func (s *APIServer) upsertTunnelConnection(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertTunnelConnectionRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(req.TunnelConnection)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.UpsertTunnelConnection(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | go | func (s *APIServer) upsertTunnelConnection(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertTunnelConnectionRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(req.TunnelConnection)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.UpsertTunnelConnection(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertTunnelConnection",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertTunnelConnectionRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalTunnelConnection",
"(",
"req",
".",
"TunnelConnection",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"UpsertTunnelConnection",
"(",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // upsertTunnelConnection updates or inserts tunnel connection | [
"upsertTunnelConnection",
"updates",
"or",
"inserts",
"tunnel",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2259-L2272 | train |
gravitational/teleport | lib/auth/apiserver.go | getTunnelConnections | func (s *APIServer) getTunnelConnections(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
conns, err := auth.GetTunnelConnections(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(conns))
for i, conn := range conns {
data, err := services.MarshalTunnelConnection(conn, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | go | func (s *APIServer) getTunnelConnections(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
conns, err := auth.GetTunnelConnections(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(conns))
for i, conn := range conns {
data, err := services.MarshalTunnelConnection(conn, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getTunnelConnections",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"conns",
",",
"err",
":=",
"auth",
".",
"GetTunnelConnections",
"(",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"json",
".",
"RawMessage",
",",
"len",
"(",
"conns",
")",
")",
"\n",
"for",
"i",
",",
"conn",
":=",
"range",
"conns",
"{",
"data",
",",
"err",
":=",
"services",
".",
"MarshalTunnelConnection",
"(",
"conn",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"data",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] | // getTunnelConnections returns a list of tunnel connections from a cluster | [
"getTunnelConnections",
"returns",
"a",
"list",
"of",
"tunnel",
"connections",
"from",
"a",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2275-L2289 | train |
gravitational/teleport | lib/auth/apiserver.go | createRemoteCluster | func (s *APIServer) createRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req createRemoteClusterRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalRemoteCluster(req.RemoteCluster)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.CreateRemoteCluster(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | go | func (s *APIServer) createRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req createRemoteClusterRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalRemoteCluster(req.RemoteCluster)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.CreateRemoteCluster(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"createRemoteCluster",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"createRemoteClusterRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalRemoteCluster",
"(",
"req",
".",
"RemoteCluster",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"CreateRemoteCluster",
"(",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"",
"\"",
")",
",",
"nil",
"\n",
"}"
] | // createRemoteCluster creates remote cluster | [
"createRemoteCluster",
"creates",
"remote",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2341-L2354 | train |
gravitational/teleport | lib/auth/apiserver.go | getRemoteClusters | func (s *APIServer) getRemoteClusters(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
clusters, err := auth.GetRemoteClusters()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(clusters))
for i, cluster := range clusters {
data, err := services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | go | func (s *APIServer) getRemoteClusters(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
clusters, err := auth.GetRemoteClusters()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(clusters))
for i, cluster := range clusters {
data, err := services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getRemoteClusters",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"clusters",
",",
"err",
":=",
"auth",
".",
"GetRemoteClusters",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"json",
".",
"RawMessage",
",",
"len",
"(",
"clusters",
")",
")",
"\n",
"for",
"i",
",",
"cluster",
":=",
"range",
"clusters",
"{",
"data",
",",
"err",
":=",
"services",
".",
"MarshalRemoteCluster",
"(",
"cluster",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"data",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] | // getRemoteClusters returns a list of remote clusters | [
"getRemoteClusters",
"returns",
"a",
"list",
"of",
"remote",
"clusters"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2357-L2371 | train |
gravitational/teleport | lib/auth/apiserver.go | getRemoteCluster | func (s *APIServer) getRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cluster, err := auth.GetRemoteCluster(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
return rawMessage(services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID()))
} | go | func (s *APIServer) getRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cluster, err := auth.GetRemoteCluster(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
return rawMessage(services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID()))
} | [
"func",
"(",
"s",
"*",
"APIServer",
")",
"getRemoteCluster",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cluster",
",",
"err",
":=",
"auth",
".",
"GetRemoteCluster",
"(",
"p",
".",
"ByName",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"rawMessage",
"(",
"services",
".",
"MarshalRemoteCluster",
"(",
"cluster",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
")",
"\n",
"}"
] | // getRemoteCluster returns a remote cluster by name | [
"getRemoteCluster",
"returns",
"a",
"remote",
"cluster",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2374-L2380 | train |
gravitational/teleport | lib/auth/saml.go | buildSAMLRoles | func (a *AuthServer) buildSAMLRoles(connector services.SAMLConnector, assertionInfo saml2.AssertionInfo) ([]string, error) {
roles := connector.MapAttributes(assertionInfo)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map attributes to role for connector: %v", connector.GetName())
}
return roles, nil
} | go | func (a *AuthServer) buildSAMLRoles(connector services.SAMLConnector, assertionInfo saml2.AssertionInfo) ([]string, error) {
roles := connector.MapAttributes(assertionInfo)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map attributes to role for connector: %v", connector.GetName())
}
return roles, nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"buildSAMLRoles",
"(",
"connector",
"services",
".",
"SAMLConnector",
",",
"assertionInfo",
"saml2",
".",
"AssertionInfo",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"roles",
":=",
"connector",
".",
"MapAttributes",
"(",
"assertionInfo",
")",
"\n",
"if",
"len",
"(",
"roles",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
",",
"connector",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"roles",
",",
"nil",
"\n",
"}"
] | // buildSAMLRoles takes a connector and claims and returns a slice of roles. | [
"buildSAMLRoles",
"takes",
"a",
"connector",
"and",
"claims",
"and",
"returns",
"a",
"slice",
"of",
"roles",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/saml.go#L98-L105 | train |
gravitational/teleport | lib/auth/saml.go | assertionsToTraitMap | func assertionsToTraitMap(assertionInfo saml2.AssertionInfo) map[string][]string {
traits := make(map[string][]string)
for _, assr := range assertionInfo.Values {
var vals []string
for _, value := range assr.Values {
vals = append(vals, value.Value)
}
traits[assr.Name] = vals
}
return traits
} | go | func assertionsToTraitMap(assertionInfo saml2.AssertionInfo) map[string][]string {
traits := make(map[string][]string)
for _, assr := range assertionInfo.Values {
var vals []string
for _, value := range assr.Values {
vals = append(vals, value.Value)
}
traits[assr.Name] = vals
}
return traits
} | [
"func",
"assertionsToTraitMap",
"(",
"assertionInfo",
"saml2",
".",
"AssertionInfo",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"traits",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n\n",
"for",
"_",
",",
"assr",
":=",
"range",
"assertionInfo",
".",
"Values",
"{",
"var",
"vals",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"assr",
".",
"Values",
"{",
"vals",
"=",
"append",
"(",
"vals",
",",
"value",
".",
"Value",
")",
"\n",
"}",
"\n",
"traits",
"[",
"assr",
".",
"Name",
"]",
"=",
"vals",
"\n",
"}",
"\n\n",
"return",
"traits",
"\n",
"}"
] | // assertionsToTraitMap extracts all string assertions and creates a map of traits
// that can be used to populate role variables. | [
"assertionsToTraitMap",
"extracts",
"all",
"string",
"assertions",
"and",
"creates",
"a",
"map",
"of",
"traits",
"that",
"can",
"be",
"used",
"to",
"populate",
"role",
"variables",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/saml.go#L109-L121 | train |
gravitational/teleport | lib/auth/saml.go | ValidateSAMLResponse | func (a *AuthServer) ValidateSAMLResponse(samlResponse string) (*SAMLAuthResponse, error) {
re, err := a.validateSAMLResponse(samlResponse)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodSAML,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodSAML,
})
}
return re, err
} | go | func (a *AuthServer) ValidateSAMLResponse(samlResponse string) (*SAMLAuthResponse, error) {
re, err := a.validateSAMLResponse(samlResponse)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodSAML,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodSAML,
})
}
return re, err
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"ValidateSAMLResponse",
"(",
"samlResponse",
"string",
")",
"(",
"*",
"SAMLAuthResponse",
",",
"error",
")",
"{",
"re",
",",
"err",
":=",
"a",
".",
"validateSAMLResponse",
"(",
"samlResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodSAML",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"false",
",",
"events",
".",
"AuthAttemptErr",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLogin",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"re",
".",
"Username",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"true",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodSAML",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"err",
"\n",
"}"
] | // ValidateSAMLResponse consumes attribute statements from SAML identity provider | [
"ValidateSAMLResponse",
"consumes",
"attribute",
"statements",
"from",
"SAML",
"identity",
"provider"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/saml.go#L278-L294 | train |
gravitational/teleport | lib/cache/cache.go | ForAuth | func ForAuth(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: true},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindStaticTokens},
{Kind: services.KindToken},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.AuthQueueSize
return cfg
} | go | func ForAuth(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: true},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindStaticTokens},
{Kind: services.KindToken},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.AuthQueueSize
return cfg
} | [
"func",
"ForAuth",
"(",
"cfg",
"Config",
")",
"Config",
"{",
"cfg",
".",
"Watches",
"=",
"[",
"]",
"services",
".",
"WatchKind",
"{",
"{",
"Kind",
":",
"services",
".",
"KindCertAuthority",
",",
"LoadSecrets",
":",
"true",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindStaticTokens",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindToken",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindUser",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindRole",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNamespace",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNode",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindProxy",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindReverseTunnel",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindTunnelConnection",
"}",
",",
"}",
"\n",
"cfg",
".",
"QueueSize",
"=",
"defaults",
".",
"AuthQueueSize",
"\n",
"return",
"cfg",
"\n",
"}"
] | // ForAuth sets up watch configuration for the auth server | [
"ForAuth",
"sets",
"up",
"watch",
"configuration",
"for",
"the",
"auth",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L37-L54 | train |
gravitational/teleport | lib/cache/cache.go | ForProxy | func ForProxy(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindAuthServer},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.ProxyQueueSize
return cfg
} | go | func ForProxy(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindAuthServer},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.ProxyQueueSize
return cfg
} | [
"func",
"ForProxy",
"(",
"cfg",
"Config",
")",
"Config",
"{",
"cfg",
".",
"Watches",
"=",
"[",
"]",
"services",
".",
"WatchKind",
"{",
"{",
"Kind",
":",
"services",
".",
"KindCertAuthority",
",",
"LoadSecrets",
":",
"false",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindUser",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindRole",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNamespace",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNode",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindProxy",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindAuthServer",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindReverseTunnel",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindTunnelConnection",
"}",
",",
"}",
"\n",
"cfg",
".",
"QueueSize",
"=",
"defaults",
".",
"ProxyQueueSize",
"\n",
"return",
"cfg",
"\n",
"}"
] | // ForProxy sets up watch configuration for proxy | [
"ForProxy",
"sets",
"up",
"watch",
"configuration",
"for",
"proxy"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L57-L73 | train |
gravitational/teleport | lib/cache/cache.go | ForNode | func ForNode(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
// Node only needs to "know" about default
// namespace events to avoid matching too much
// data about other namespaces or node events
{Kind: services.KindNamespace, Name: defaults.Namespace},
}
cfg.QueueSize = defaults.NodeQueueSize
return cfg
} | go | func ForNode(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
// Node only needs to "know" about default
// namespace events to avoid matching too much
// data about other namespaces or node events
{Kind: services.KindNamespace, Name: defaults.Namespace},
}
cfg.QueueSize = defaults.NodeQueueSize
return cfg
} | [
"func",
"ForNode",
"(",
"cfg",
"Config",
")",
"Config",
"{",
"cfg",
".",
"Watches",
"=",
"[",
"]",
"services",
".",
"WatchKind",
"{",
"{",
"Kind",
":",
"services",
".",
"KindCertAuthority",
",",
"LoadSecrets",
":",
"false",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindUser",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindRole",
"}",
",",
"// Node only needs to \"know\" about default",
"// namespace events to avoid matching too much",
"// data about other namespaces or node events",
"{",
"Kind",
":",
"services",
".",
"KindNamespace",
",",
"Name",
":",
"defaults",
".",
"Namespace",
"}",
",",
"}",
"\n",
"cfg",
".",
"QueueSize",
"=",
"defaults",
".",
"NodeQueueSize",
"\n",
"return",
"cfg",
"\n",
"}"
] | // ForNode sets up watch configuration for node | [
"ForNode",
"sets",
"up",
"watch",
"configuration",
"for",
"node"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L76-L90 | train |
gravitational/teleport | lib/cache/cache.go | New | func New(config Config) (*Cache, error) {
if err := config.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
wrapper := backend.NewWrapper(config.Backend)
ctx, cancel := context.WithCancel(config.Context)
cs := &Cache{
wrapper: wrapper,
ctx: ctx,
cancel: cancel,
Config: config,
trustCache: local.NewCAService(wrapper),
clusterConfigCache: local.NewClusterConfigurationService(wrapper),
provisionerCache: local.NewProvisioningService(wrapper),
usersCache: local.NewIdentityService(wrapper),
accessCache: local.NewAccessService(wrapper),
presenceCache: local.NewPresenceService(wrapper),
eventsCache: local.NewEventsService(config.Backend),
Entry: log.WithFields(log.Fields{
trace.Component: config.Component,
}),
}
collections, err := setupCollections(cs, config.Watches)
if err != nil {
return nil, trace.Wrap(err)
}
cs.collections = collections
err = cs.fetch()
if err != nil {
// "only recent" behavior does not tolerate
// stale data, so it has to initialize itself
// with recent data on startup or fail
if cs.OnlyRecent.Enabled {
return nil, trace.Wrap(err)
}
}
go cs.update()
return cs, nil
} | go | func New(config Config) (*Cache, error) {
if err := config.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
wrapper := backend.NewWrapper(config.Backend)
ctx, cancel := context.WithCancel(config.Context)
cs := &Cache{
wrapper: wrapper,
ctx: ctx,
cancel: cancel,
Config: config,
trustCache: local.NewCAService(wrapper),
clusterConfigCache: local.NewClusterConfigurationService(wrapper),
provisionerCache: local.NewProvisioningService(wrapper),
usersCache: local.NewIdentityService(wrapper),
accessCache: local.NewAccessService(wrapper),
presenceCache: local.NewPresenceService(wrapper),
eventsCache: local.NewEventsService(config.Backend),
Entry: log.WithFields(log.Fields{
trace.Component: config.Component,
}),
}
collections, err := setupCollections(cs, config.Watches)
if err != nil {
return nil, trace.Wrap(err)
}
cs.collections = collections
err = cs.fetch()
if err != nil {
// "only recent" behavior does not tolerate
// stale data, so it has to initialize itself
// with recent data on startup or fail
if cs.OnlyRecent.Enabled {
return nil, trace.Wrap(err)
}
}
go cs.update()
return cs, nil
} | [
"func",
"New",
"(",
"config",
"Config",
")",
"(",
"*",
"Cache",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"wrapper",
":=",
"backend",
".",
"NewWrapper",
"(",
"config",
".",
"Backend",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"config",
".",
"Context",
")",
"\n",
"cs",
":=",
"&",
"Cache",
"{",
"wrapper",
":",
"wrapper",
",",
"ctx",
":",
"ctx",
",",
"cancel",
":",
"cancel",
",",
"Config",
":",
"config",
",",
"trustCache",
":",
"local",
".",
"NewCAService",
"(",
"wrapper",
")",
",",
"clusterConfigCache",
":",
"local",
".",
"NewClusterConfigurationService",
"(",
"wrapper",
")",
",",
"provisionerCache",
":",
"local",
".",
"NewProvisioningService",
"(",
"wrapper",
")",
",",
"usersCache",
":",
"local",
".",
"NewIdentityService",
"(",
"wrapper",
")",
",",
"accessCache",
":",
"local",
".",
"NewAccessService",
"(",
"wrapper",
")",
",",
"presenceCache",
":",
"local",
".",
"NewPresenceService",
"(",
"wrapper",
")",
",",
"eventsCache",
":",
"local",
".",
"NewEventsService",
"(",
"config",
".",
"Backend",
")",
",",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"config",
".",
"Component",
",",
"}",
")",
",",
"}",
"\n",
"collections",
",",
"err",
":=",
"setupCollections",
"(",
"cs",
",",
"config",
".",
"Watches",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cs",
".",
"collections",
"=",
"collections",
"\n\n",
"err",
"=",
"cs",
".",
"fetch",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// \"only recent\" behavior does not tolerate",
"// stale data, so it has to initialize itself",
"// with recent data on startup or fail",
"if",
"cs",
".",
"OnlyRecent",
".",
"Enabled",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"cs",
".",
"update",
"(",
")",
"\n",
"return",
"cs",
",",
"nil",
"\n",
"}"
] | // New creates a new instance of Cache | [
"New",
"creates",
"a",
"new",
"instance",
"of",
"Cache"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L261-L300 | train |
gravitational/teleport | lib/cache/cache.go | NewWatcher | func (c *Cache) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return c.eventsCache.NewWatcher(ctx, watch)
} | go | func (c *Cache) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return c.eventsCache.NewWatcher(ctx, watch)
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"NewWatcher",
"(",
"ctx",
"context",
".",
"Context",
",",
"watch",
"services",
".",
"Watch",
")",
"(",
"services",
".",
"Watcher",
",",
"error",
")",
"{",
"return",
"c",
".",
"eventsCache",
".",
"NewWatcher",
"(",
"ctx",
",",
"watch",
")",
"\n",
"}"
] | // NewWatcher returns a new event watcher. In case of a cache
// this watcher will return events as seen by the cache,
// not the backend. This feature allows auth server
// to handle subscribers connected to the in-memory caches
// instead of reading from the backend. | [
"NewWatcher",
"returns",
"a",
"new",
"event",
"watcher",
".",
"In",
"case",
"of",
"a",
"cache",
"this",
"watcher",
"will",
"return",
"events",
"as",
"seen",
"by",
"the",
"cache",
"not",
"the",
"backend",
".",
"This",
"feature",
"allows",
"auth",
"server",
"to",
"handle",
"subscribers",
"connected",
"to",
"the",
"in",
"-",
"memory",
"caches",
"instead",
"of",
"reading",
"from",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L307-L309 | train |
gravitational/teleport | lib/cache/cache.go | setCacheState | func (c *Cache) setCacheState(err error) error {
if !c.OnlyRecent.Enabled {
return err
}
if err := c.eraseAll(); err != nil {
if !c.isClosed() {
c.Warningf("Failed to erase the data: %v.", err)
}
}
c.wrapper.SetReadError(trace.ConnectionProblem(err, "cache is unavailable"))
return err
} | go | func (c *Cache) setCacheState(err error) error {
if !c.OnlyRecent.Enabled {
return err
}
if err := c.eraseAll(); err != nil {
if !c.isClosed() {
c.Warningf("Failed to erase the data: %v.", err)
}
}
c.wrapper.SetReadError(trace.ConnectionProblem(err, "cache is unavailable"))
return err
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"setCacheState",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"!",
"c",
".",
"OnlyRecent",
".",
"Enabled",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"eraseAll",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"!",
"c",
".",
"isClosed",
"(",
")",
"{",
"c",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"c",
".",
"wrapper",
".",
"SetReadError",
"(",
"trace",
".",
"ConnectionProblem",
"(",
"err",
",",
"\"",
"\"",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // setCacheState for "only recent" cache behavior will erase
// the cache and set error mode to refuse to serve stale data,
// otherwise does nothing | [
"setCacheState",
"for",
"only",
"recent",
"cache",
"behavior",
"will",
"erase",
"the",
"cache",
"and",
"set",
"error",
"mode",
"to",
"refuse",
"to",
"serve",
"stale",
"data",
"otherwise",
"does",
"nothing"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L358-L369 | train |
gravitational/teleport | lib/cache/cache.go | eraseAll | func (c *Cache) eraseAll() error {
var errors []error
for _, collection := range c.collections {
errors = append(errors, collection.erase())
}
return trace.NewAggregate(errors...)
} | go | func (c *Cache) eraseAll() error {
var errors []error
for _, collection := range c.collections {
errors = append(errors, collection.erase())
}
return trace.NewAggregate(errors...)
} | [
"func",
"(",
"c",
"*",
"Cache",
")",
"eraseAll",
"(",
")",
"error",
"{",
"var",
"errors",
"[",
"]",
"error",
"\n",
"for",
"_",
",",
"collection",
":=",
"range",
"c",
".",
"collections",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"collection",
".",
"erase",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] | // eraseAll erases all the data from cache collections | [
"eraseAll",
"erases",
"all",
"the",
"data",
"from",
"cache",
"collections"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L501-L507 | train |
gravitational/teleport | lib/reversetunnel/localsite.go | findMatchingConn | func (s *localSite) findMatchingConn(principals []string) (*remoteConn, bool) {
for _, principal := range principals {
rconn, err := s.getConn(principal)
if err == nil {
return rconn, true
}
}
return nil, false
} | go | func (s *localSite) findMatchingConn(principals []string) (*remoteConn, bool) {
for _, principal := range principals {
rconn, err := s.getConn(principal)
if err == nil {
return rconn, true
}
}
return nil, false
} | [
"func",
"(",
"s",
"*",
"localSite",
")",
"findMatchingConn",
"(",
"principals",
"[",
"]",
"string",
")",
"(",
"*",
"remoteConn",
",",
"bool",
")",
"{",
"for",
"_",
",",
"principal",
":=",
"range",
"principals",
"{",
"rconn",
",",
"err",
":=",
"s",
".",
"getConn",
"(",
"principal",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"rconn",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] | // findMatchingConn iterates over passed in principals looking for matching
// remote connections. | [
"findMatchingConn",
"iterates",
"over",
"passed",
"in",
"principals",
"looking",
"for",
"matching",
"remote",
"connections",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/localsite.go#L244-L252 | train |
gravitational/teleport | examples/go-client/main.go | setupClientTLS | func setupClientTLS() (*tls.Config, error) {
storage, err := auth.NewProcessStorage(filepath.Join("/var/lib/teleport", teleport.ComponentProcess))
if err != nil {
return nil, trace.Wrap(err)
}
defer storage.Close()
identity, err := storage.ReadIdentity(auth.IdentityCurrent, teleport.RoleAdmin)
if err != nil {
return nil, trace.Wrap(err)
}
return identity.TLSConfig(nil)
} | go | func setupClientTLS() (*tls.Config, error) {
storage, err := auth.NewProcessStorage(filepath.Join("/var/lib/teleport", teleport.ComponentProcess))
if err != nil {
return nil, trace.Wrap(err)
}
defer storage.Close()
identity, err := storage.ReadIdentity(auth.IdentityCurrent, teleport.RoleAdmin)
if err != nil {
return nil, trace.Wrap(err)
}
return identity.TLSConfig(nil)
} | [
"func",
"setupClientTLS",
"(",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"storage",
",",
"err",
":=",
"auth",
".",
"NewProcessStorage",
"(",
"filepath",
".",
"Join",
"(",
"\"",
"\"",
",",
"teleport",
".",
"ComponentProcess",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"storage",
".",
"Close",
"(",
")",
"\n\n",
"identity",
",",
"err",
":=",
"storage",
".",
"ReadIdentity",
"(",
"auth",
".",
"IdentityCurrent",
",",
"teleport",
".",
"RoleAdmin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"identity",
".",
"TLSConfig",
"(",
"nil",
")",
"\n",
"}"
] | // setupClientTLS sets up client TLS authentiction between TLS client
// and Teleport Auth server. This function uses hardcoded certificate paths,
// assuming program runs alongside auth server, but it can be ran
// on a remote location, assuming client has all the client certificates. | [
"setupClientTLS",
"sets",
"up",
"client",
"TLS",
"authentiction",
"between",
"TLS",
"client",
"and",
"Teleport",
"Auth",
"server",
".",
"This",
"function",
"uses",
"hardcoded",
"certificate",
"paths",
"assuming",
"program",
"runs",
"alongside",
"auth",
"server",
"but",
"it",
"can",
"be",
"ran",
"on",
"a",
"remote",
"location",
"assuming",
"client",
"has",
"all",
"the",
"client",
"certificates",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/examples/go-client/main.go#L64-L77 | train |
gravitational/teleport | lib/services/local/presence.go | NewPresenceService | func NewPresenceService(b backend.Backend) *PresenceService {
return &PresenceService{
log: logrus.WithFields(logrus.Fields{trace.Component: "Presence"}),
Backend: b,
}
} | go | func NewPresenceService(b backend.Backend) *PresenceService {
return &PresenceService{
log: logrus.WithFields(logrus.Fields{trace.Component: "Presence"}),
Backend: b,
}
} | [
"func",
"NewPresenceService",
"(",
"b",
"backend",
".",
"Backend",
")",
"*",
"PresenceService",
"{",
"return",
"&",
"PresenceService",
"{",
"log",
":",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"\"",
"\"",
"}",
")",
",",
"Backend",
":",
"b",
",",
"}",
"\n",
"}"
] | // NewPresenceService returns new presence service instance | [
"NewPresenceService",
"returns",
"new",
"presence",
"service",
"instance"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L41-L46 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertLocalClusterName | func (s *PresenceService) UpsertLocalClusterName(name string) error {
_, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(localClusterPrefix, valPrefix),
Value: []byte(name),
})
return trace.Wrap(err)
} | go | func (s *PresenceService) UpsertLocalClusterName(name string) error {
_, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(localClusterPrefix, valPrefix),
Value: []byte(name),
})
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertLocalClusterName",
"(",
"name",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"localClusterPrefix",
",",
"valPrefix",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"name",
")",
",",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertLocalClusterName upserts local cluster name | [
"UpsertLocalClusterName",
"upserts",
"local",
"cluster",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L53-L59 | train |
gravitational/teleport | lib/services/local/presence.go | GetLocalClusterName | func (s *PresenceService) GetLocalClusterName() (string, error) {
item, err := s.Get(context.TODO(), backend.Key(localClusterPrefix, valPrefix))
if err != nil {
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | go | func (s *PresenceService) GetLocalClusterName() (string, error) {
item, err := s.Get(context.TODO(), backend.Key(localClusterPrefix, valPrefix))
if err != nil {
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetLocalClusterName",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"localClusterPrefix",
",",
"valPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"item",
".",
"Value",
")",
",",
"nil",
"\n",
"}"
] | // GetLocalClusterName upserts local domain | [
"GetLocalClusterName",
"upserts",
"local",
"domain"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L62-L68 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteAllNamespaces | func (s *PresenceService) DeleteAllNamespaces() error {
return s.DeleteRange(context.TODO(), backend.Key(namespacesPrefix), backend.RangeEnd(backend.Key(namespacesPrefix)))
} | go | func (s *PresenceService) DeleteAllNamespaces() error {
return s.DeleteRange(context.TODO(), backend.Key(namespacesPrefix), backend.RangeEnd(backend.Key(namespacesPrefix)))
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllNamespaces",
"(",
")",
"error",
"{",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
")",
",",
"backend",
".",
"RangeEnd",
"(",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
")",
")",
")",
"\n",
"}"
] | // DeleteAllNamespaces deletes all namespaces | [
"DeleteAllNamespaces",
"deletes",
"all",
"namespaces"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L71-L73 | train |
gravitational/teleport | lib/services/local/presence.go | GetNamespace | func (s *PresenceService) GetNamespace(name string) (*services.Namespace, error) {
if name == "" {
return nil, trace.BadParameter("missing namespace name")
}
item, err := s.Get(context.TODO(), backend.Key(namespacesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("namespace %q is not found", name)
}
return nil, trace.Wrap(err)
}
return services.UnmarshalNamespace(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | go | func (s *PresenceService) GetNamespace(name string) (*services.Namespace, error) {
if name == "" {
return nil, trace.BadParameter("missing namespace name")
}
item, err := s.Get(context.TODO(), backend.Key(namespacesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("namespace %q is not found", name)
}
return nil, trace.Wrap(err)
}
return services.UnmarshalNamespace(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetNamespace",
"(",
"name",
"string",
")",
"(",
"*",
"services",
".",
"Namespace",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
",",
"name",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"UnmarshalNamespace",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"}"
] | // GetNamespace returns a namespace by name | [
"GetNamespace",
"returns",
"a",
"namespace",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L121-L134 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteNamespace | func (s *PresenceService) DeleteNamespace(namespace string) error {
if namespace == "" {
return trace.BadParameter("missing namespace name")
}
err := s.Delete(context.TODO(), backend.Key(namespacesPrefix, namespace, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("namespace %q is not found", namespace)
}
}
return trace.Wrap(err)
} | go | func (s *PresenceService) DeleteNamespace(namespace string) error {
if namespace == "" {
return trace.BadParameter("missing namespace name")
}
err := s.Delete(context.TODO(), backend.Key(namespacesPrefix, namespace, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("namespace %q is not found", namespace)
}
}
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteNamespace",
"(",
"namespace",
"string",
")",
"error",
"{",
"if",
"namespace",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
",",
"namespace",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteNamespace deletes a namespace with all the keys from the backend | [
"DeleteNamespace",
"deletes",
"a",
"namespace",
"with",
"all",
"the",
"keys",
"from",
"the",
"backend"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L137-L148 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteAllNodes | func (s *PresenceService) DeleteAllNodes(namespace string) error {
startKey := backend.Key(nodesPrefix, namespace)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | func (s *PresenceService) DeleteAllNodes(namespace string) error {
startKey := backend.Key(nodesPrefix, namespace)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllNodes",
"(",
"namespace",
"string",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"namespace",
")",
"\n",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"}"
] | // DeleteAllNodes deletes all nodes in a namespace | [
"DeleteAllNodes",
"deletes",
"all",
"nodes",
"in",
"a",
"namespace"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L188-L191 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteNode | func (s *PresenceService) DeleteNode(namespace string, name string) error {
key := backend.Key(nodesPrefix, namespace, name)
return s.Delete(context.TODO(), key)
} | go | func (s *PresenceService) DeleteNode(namespace string, name string) error {
key := backend.Key(nodesPrefix, namespace, name)
return s.Delete(context.TODO(), key)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteNode",
"(",
"namespace",
"string",
",",
"name",
"string",
")",
"error",
"{",
"key",
":=",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"namespace",
",",
"name",
")",
"\n",
"return",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"key",
")",
"\n",
"}"
] | // DeleteNode deletes node | [
"DeleteNode",
"deletes",
"node"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L194-L197 | train |
gravitational/teleport | lib/services/local/presence.go | GetNodes | func (s *PresenceService) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter("missing namespace value")
}
// Get all items in the bucket.
startKey := backend.Key(nodesPrefix, namespace)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
// Marshal values into a []services.Server slice.
servers := make([]services.Server, len(result.Items))
for i, item := range result.Items {
server, err := services.GetServerMarshaler().UnmarshalServer(
item.Value,
services.KindNode,
services.AddOptions(opts,
services.WithResourceID(item.ID),
services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
servers[i] = server
}
return servers, nil
} | go | func (s *PresenceService) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter("missing namespace value")
}
// Get all items in the bucket.
startKey := backend.Key(nodesPrefix, namespace)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
// Marshal values into a []services.Server slice.
servers := make([]services.Server, len(result.Items))
for i, item := range result.Items {
server, err := services.GetServerMarshaler().UnmarshalServer(
item.Value,
services.KindNode,
services.AddOptions(opts,
services.WithResourceID(item.ID),
services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
servers[i] = server
}
return servers, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetNodes",
"(",
"namespace",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Get all items in the bucket.",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"namespace",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"// Marshal values into a []services.Server slice.",
"servers",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"server",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServer",
"(",
"item",
".",
"Value",
",",
"services",
".",
"KindNode",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"servers",
"[",
"i",
"]",
"=",
"server",
"\n",
"}",
"\n\n",
"return",
"servers",
",",
"nil",
"\n",
"}"
] | // GetNodes returns a list of registered servers | [
"GetNodes",
"returns",
"a",
"list",
"of",
"registered",
"servers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L200-L227 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertNode | func (s *PresenceService) UpsertNode(server services.Server) (*services.KeepAlive, error) {
if server.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return nil, trace.Wrap(err)
}
lease, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
if server.Expiry().IsZero() {
return &services.KeepAlive{}, nil
}
return &services.KeepAlive{LeaseID: lease.ID, ServerName: server.GetName()}, nil
} | go | func (s *PresenceService) UpsertNode(server services.Server) (*services.KeepAlive, error) {
if server.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return nil, trace.Wrap(err)
}
lease, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
if server.Expiry().IsZero() {
return &services.KeepAlive{}, nil
}
return &services.KeepAlive{LeaseID: lease.ID, ServerName: server.GetName()}, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertNode",
"(",
"server",
"services",
".",
"Server",
")",
"(",
"*",
"services",
".",
"KeepAlive",
",",
"error",
")",
"{",
"if",
"server",
".",
"GetNamespace",
"(",
")",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"MarshalServer",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"lease",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"server",
".",
"GetNamespace",
"(",
")",
",",
"server",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"server",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"server",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"server",
".",
"Expiry",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"return",
"&",
"services",
".",
"KeepAlive",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"services",
".",
"KeepAlive",
"{",
"LeaseID",
":",
"lease",
".",
"ID",
",",
"ServerName",
":",
"server",
".",
"GetName",
"(",
")",
"}",
",",
"nil",
"\n",
"}"
] | // UpsertNode registers node presence, permanently if TTL is 0 or for the
// specified duration with second resolution if it's >= 1 second. | [
"UpsertNode",
"registers",
"node",
"presence",
"permanently",
"if",
"TTL",
"is",
"0",
"or",
"for",
"the",
"specified",
"duration",
"with",
"second",
"resolution",
"if",
"it",
"s",
">",
"=",
"1",
"second",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L231-L252 | train |
gravitational/teleport | lib/services/local/presence.go | KeepAliveNode | func (s *PresenceService) KeepAliveNode(ctx context.Context, h services.KeepAlive) error {
if err := h.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
err := s.KeepAlive(ctx, backend.Lease{
ID: h.LeaseID,
Key: backend.Key(nodesPrefix, h.Namespace, h.ServerName),
}, h.Expires)
return trace.Wrap(err)
} | go | func (s *PresenceService) KeepAliveNode(ctx context.Context, h services.KeepAlive) error {
if err := h.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
err := s.KeepAlive(ctx, backend.Lease{
ID: h.LeaseID,
Key: backend.Key(nodesPrefix, h.Namespace, h.ServerName),
}, h.Expires)
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"KeepAliveNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"h",
"services",
".",
"KeepAlive",
")",
"error",
"{",
"if",
"err",
":=",
"h",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"KeepAlive",
"(",
"ctx",
",",
"backend",
".",
"Lease",
"{",
"ID",
":",
"h",
".",
"LeaseID",
",",
"Key",
":",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"h",
".",
"Namespace",
",",
"h",
".",
"ServerName",
")",
",",
"}",
",",
"h",
".",
"Expires",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // KeepAliveNode updates node expiry | [
"KeepAliveNode",
"updates",
"node",
"expiry"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L255-L264 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertNodes | func (s *PresenceService) UpsertNodes(namespace string, servers []services.Server) error {
batch, ok := s.Backend.(backend.Batch)
if !ok {
return trace.BadParameter("backend does not support batch interface")
}
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
start := time.Now()
items := make([]backend.Item, len(servers))
for i, server := range servers {
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return trace.Wrap(err)
}
items[i] = backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
}
}
err := batch.PutRange(context.TODO(), items)
if err != nil {
return trace.Wrap(err)
}
s.log.Debugf("UpsertNodes(%v) in %v", len(servers), time.Now().Sub(start))
return nil
} | go | func (s *PresenceService) UpsertNodes(namespace string, servers []services.Server) error {
batch, ok := s.Backend.(backend.Batch)
if !ok {
return trace.BadParameter("backend does not support batch interface")
}
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
start := time.Now()
items := make([]backend.Item, len(servers))
for i, server := range servers {
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return trace.Wrap(err)
}
items[i] = backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
}
}
err := batch.PutRange(context.TODO(), items)
if err != nil {
return trace.Wrap(err)
}
s.log.Debugf("UpsertNodes(%v) in %v", len(servers), time.Now().Sub(start))
return nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertNodes",
"(",
"namespace",
"string",
",",
"servers",
"[",
"]",
"services",
".",
"Server",
")",
"error",
"{",
"batch",
",",
"ok",
":=",
"s",
".",
"Backend",
".",
"(",
"backend",
".",
"Batch",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"namespace",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n\n",
"items",
":=",
"make",
"(",
"[",
"]",
"backend",
".",
"Item",
",",
"len",
"(",
"servers",
")",
")",
"\n",
"for",
"i",
",",
"server",
":=",
"range",
"servers",
"{",
"value",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"MarshalServer",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"items",
"[",
"i",
"]",
"=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"server",
".",
"GetNamespace",
"(",
")",
",",
"server",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"server",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"server",
".",
"GetResourceID",
"(",
")",
",",
"}",
"\n",
"}",
"\n\n",
"err",
":=",
"batch",
".",
"PutRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"items",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"len",
"(",
"servers",
")",
",",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"start",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UpsertNodes is used for bulk insertion of nodes. Schema validation is
// always skipped during bulk insertion. | [
"UpsertNodes",
"is",
"used",
"for",
"bulk",
"insertion",
"of",
"nodes",
".",
"Schema",
"validation",
"is",
"always",
"skipped",
"during",
"bulk",
"insertion",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L268-L302 | train |
gravitational/teleport | lib/services/local/presence.go | GetAuthServers | func (s *PresenceService) GetAuthServers() ([]services.Server, error) {
return s.getServers(services.KindAuthServer, authServersPrefix)
} | go | func (s *PresenceService) GetAuthServers() ([]services.Server, error) {
return s.getServers(services.KindAuthServer, authServersPrefix)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetAuthServers",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"return",
"s",
".",
"getServers",
"(",
"services",
".",
"KindAuthServer",
",",
"authServersPrefix",
")",
"\n",
"}"
] | // GetAuthServers returns a list of registered servers | [
"GetAuthServers",
"returns",
"a",
"list",
"of",
"registered",
"servers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L305-L307 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertAuthServer | func (s *PresenceService) UpsertAuthServer(server services.Server) error {
return s.upsertServer(authServersPrefix, server)
} | go | func (s *PresenceService) UpsertAuthServer(server services.Server) error {
return s.upsertServer(authServersPrefix, server)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertAuthServer",
"(",
"server",
"services",
".",
"Server",
")",
"error",
"{",
"return",
"s",
".",
"upsertServer",
"(",
"authServersPrefix",
",",
"server",
")",
"\n",
"}"
] | // UpsertAuthServer registers auth server presence, permanently if ttl is 0 or
// for the specified duration with second resolution if it's >= 1 second | [
"UpsertAuthServer",
"registers",
"auth",
"server",
"presence",
"permanently",
"if",
"ttl",
"is",
"0",
"or",
"for",
"the",
"specified",
"duration",
"with",
"second",
"resolution",
"if",
"it",
"s",
">",
"=",
"1",
"second"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L311-L313 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertProxy | func (s *PresenceService) UpsertProxy(server services.Server) error {
return s.upsertServer(proxiesPrefix, server)
} | go | func (s *PresenceService) UpsertProxy(server services.Server) error {
return s.upsertServer(proxiesPrefix, server)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertProxy",
"(",
"server",
"services",
".",
"Server",
")",
"error",
"{",
"return",
"s",
".",
"upsertServer",
"(",
"proxiesPrefix",
",",
"server",
")",
"\n",
"}"
] | // UpsertProxy registers proxy server presence, permanently if ttl is 0 or
// for the specified duration with second resolution if it's >= 1 second | [
"UpsertProxy",
"registers",
"proxy",
"server",
"presence",
"permanently",
"if",
"ttl",
"is",
"0",
"or",
"for",
"the",
"specified",
"duration",
"with",
"second",
"resolution",
"if",
"it",
"s",
">",
"=",
"1",
"second"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L329-L331 | train |
gravitational/teleport | lib/services/local/presence.go | GetProxies | func (s *PresenceService) GetProxies() ([]services.Server, error) {
return s.getServers(services.KindProxy, proxiesPrefix)
} | go | func (s *PresenceService) GetProxies() ([]services.Server, error) {
return s.getServers(services.KindProxy, proxiesPrefix)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetProxies",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"return",
"s",
".",
"getServers",
"(",
"services",
".",
"KindProxy",
",",
"proxiesPrefix",
")",
"\n",
"}"
] | // GetProxies returns a list of registered proxies | [
"GetProxies",
"returns",
"a",
"list",
"of",
"registered",
"proxies"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L334-L336 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteProxy | func (s *PresenceService) DeleteProxy(name string) error {
key := backend.Key(proxiesPrefix, name)
return s.Delete(context.TODO(), key)
} | go | func (s *PresenceService) DeleteProxy(name string) error {
key := backend.Key(proxiesPrefix, name)
return s.Delete(context.TODO(), key)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteProxy",
"(",
"name",
"string",
")",
"error",
"{",
"key",
":=",
"backend",
".",
"Key",
"(",
"proxiesPrefix",
",",
"name",
")",
"\n",
"return",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"key",
")",
"\n",
"}"
] | // DeleteProxy deletes proxy | [
"DeleteProxy",
"deletes",
"proxy"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L345-L348 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteAllReverseTunnels | func (s *PresenceService) DeleteAllReverseTunnels() error {
startKey := backend.Key(reverseTunnelsPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | func (s *PresenceService) DeleteAllReverseTunnels() error {
startKey := backend.Key(reverseTunnelsPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllReverseTunnels",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
")",
"\n",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"}"
] | // DeleteAllReverseTunnels deletes all reverse tunnels | [
"DeleteAllReverseTunnels",
"deletes",
"all",
"reverse",
"tunnels"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L351-L354 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertReverseTunnel | func (s *PresenceService) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
if err := tunnel.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(reverseTunnelsPrefix, tunnel.GetName()),
Value: value,
Expires: tunnel.Expiry(),
ID: tunnel.GetResourceID(),
})
return trace.Wrap(err)
} | go | func (s *PresenceService) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
if err := tunnel.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(reverseTunnelsPrefix, tunnel.GetName()),
Value: value,
Expires: tunnel.Expiry(),
ID: tunnel.GetResourceID(),
})
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertReverseTunnel",
"(",
"tunnel",
"services",
".",
"ReverseTunnel",
")",
"error",
"{",
"if",
"err",
":=",
"tunnel",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"MarshalReverseTunnel",
"(",
"tunnel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
",",
"tunnel",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"tunnel",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"tunnel",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertReverseTunnel upserts reverse tunnel entry temporarily or permanently | [
"UpsertReverseTunnel",
"upserts",
"reverse",
"tunnel",
"entry",
"temporarily",
"or",
"permanently"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L357-L372 | train |
gravitational/teleport | lib/services/local/presence.go | GetReverseTunnels | func (s *PresenceService) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
startKey := backend.Key(reverseTunnelsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(result.Items))
for i, item := range result.Items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(
item.Value, services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
// sorting helps with tests and makes it all deterministic
sort.Sort(services.SortedReverseTunnels(tunnels))
return tunnels, nil
} | go | func (s *PresenceService) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
startKey := backend.Key(reverseTunnelsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(result.Items))
for i, item := range result.Items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(
item.Value, services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
// sorting helps with tests and makes it all deterministic
sort.Sort(services.SortedReverseTunnels(tunnels))
return tunnels, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetReverseTunnels",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"ReverseTunnel",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tunnels",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"ReverseTunnel",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"tunnel",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"UnmarshalReverseTunnel",
"(",
"item",
".",
"Value",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tunnels",
"[",
"i",
"]",
"=",
"tunnel",
"\n",
"}",
"\n",
"// sorting helps with tests and makes it all deterministic",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedReverseTunnels",
"(",
"tunnels",
")",
")",
"\n",
"return",
"tunnels",
",",
"nil",
"\n",
"}"
] | // GetReverseTunnels returns a list of registered servers | [
"GetReverseTunnels",
"returns",
"a",
"list",
"of",
"registered",
"servers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L385-L403 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteReverseTunnel | func (s *PresenceService) DeleteReverseTunnel(clusterName string) error {
err := s.Delete(context.TODO(), backend.Key(reverseTunnelsPrefix, clusterName))
return trace.Wrap(err)
} | go | func (s *PresenceService) DeleteReverseTunnel(clusterName string) error {
err := s.Delete(context.TODO(), backend.Key(reverseTunnelsPrefix, clusterName))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteReverseTunnel",
"(",
"clusterName",
"string",
")",
"error",
"{",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
",",
"clusterName",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteReverseTunnel deletes reverse tunnel by it's cluster name | [
"DeleteReverseTunnel",
"deletes",
"reverse",
"tunnel",
"by",
"it",
"s",
"cluster",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L406-L409 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertTrustedCluster | func (s *PresenceService) UpsertTrustedCluster(trustedCluster services.TrustedCluster) (services.TrustedCluster, error) {
if err := trustedCluster.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
value, err := services.GetTrustedClusterMarshaler().Marshal(trustedCluster)
if err != nil {
return nil, trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(trustedClustersPrefix, trustedCluster.GetName()),
Value: value,
Expires: trustedCluster.Expiry(),
ID: trustedCluster.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
return trustedCluster, nil
} | go | func (s *PresenceService) UpsertTrustedCluster(trustedCluster services.TrustedCluster) (services.TrustedCluster, error) {
if err := trustedCluster.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
value, err := services.GetTrustedClusterMarshaler().Marshal(trustedCluster)
if err != nil {
return nil, trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(trustedClustersPrefix, trustedCluster.GetName()),
Value: value,
Expires: trustedCluster.Expiry(),
ID: trustedCluster.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
return trustedCluster, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertTrustedCluster",
"(",
"trustedCluster",
"services",
".",
"TrustedCluster",
")",
"(",
"services",
".",
"TrustedCluster",
",",
"error",
")",
"{",
"if",
"err",
":=",
"trustedCluster",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Marshal",
"(",
"trustedCluster",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
",",
"trustedCluster",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"trustedCluster",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"trustedCluster",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"trustedCluster",
",",
"nil",
"\n",
"}"
] | // UpsertTrustedCluster creates or updates a TrustedCluster in the backend. | [
"UpsertTrustedCluster",
"creates",
"or",
"updates",
"a",
"TrustedCluster",
"in",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L412-L430 | train |
gravitational/teleport | lib/services/local/presence.go | GetTrustedCluster | func (s *PresenceService) GetTrustedCluster(name string) (services.TrustedCluster, error) {
if name == "" {
return nil, trace.BadParameter("missing trusted cluster name")
}
item, err := s.Get(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetTrustedClusterMarshaler().Unmarshal(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | go | func (s *PresenceService) GetTrustedCluster(name string) (services.TrustedCluster, error) {
if name == "" {
return nil, trace.BadParameter("missing trusted cluster name")
}
item, err := s.Get(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetTrustedClusterMarshaler().Unmarshal(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTrustedCluster",
"(",
"name",
"string",
")",
"(",
"services",
".",
"TrustedCluster",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"}"
] | // GetTrustedCluster returns a single TrustedCluster by name. | [
"GetTrustedCluster",
"returns",
"a",
"single",
"TrustedCluster",
"by",
"name",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L433-L442 | train |
gravitational/teleport | lib/services/local/presence.go | GetTrustedClusters | func (s *PresenceService) GetTrustedClusters() ([]services.TrustedCluster, error) {
startKey := backend.Key(trustedClustersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.TrustedCluster, len(result.Items))
for i, item := range result.Items {
tc, err := services.GetTrustedClusterMarshaler().Unmarshal(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out[i] = tc
}
sort.Sort(services.SortedTrustedCluster(out))
return out, nil
} | go | func (s *PresenceService) GetTrustedClusters() ([]services.TrustedCluster, error) {
startKey := backend.Key(trustedClustersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.TrustedCluster, len(result.Items))
for i, item := range result.Items {
tc, err := services.GetTrustedClusterMarshaler().Unmarshal(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out[i] = tc
}
sort.Sort(services.SortedTrustedCluster(out))
return out, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTrustedClusters",
"(",
")",
"(",
"[",
"]",
"services",
".",
"TrustedCluster",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"TrustedCluster",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"tc",
",",
"err",
":=",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"[",
"i",
"]",
"=",
"tc",
"\n",
"}",
"\n\n",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedTrustedCluster",
"(",
"out",
")",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // GetTrustedClusters returns all TrustedClusters in the backend. | [
"GetTrustedClusters",
"returns",
"all",
"TrustedClusters",
"in",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L445-L463 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteTrustedCluster | func (s *PresenceService) DeleteTrustedCluster(name string) error {
if name == "" {
return trace.BadParameter("missing trusted cluster name")
}
err := s.Delete(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("trusted cluster %q is not found", name)
}
}
return trace.Wrap(err)
} | go | func (s *PresenceService) DeleteTrustedCluster(name string) error {
if name == "" {
return trace.BadParameter("missing trusted cluster name")
}
err := s.Delete(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("trusted cluster %q is not found", name)
}
}
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteTrustedCluster",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteTrustedCluster removes a TrustedCluster from the backend by name. | [
"DeleteTrustedCluster",
"removes",
"a",
"TrustedCluster",
"from",
"the",
"backend",
"by",
"name",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L466-L477 | train |
gravitational/teleport | lib/services/local/presence.go | UpsertTunnelConnection | func (s *PresenceService) UpsertTunnelConnection(conn services.TunnelConnection) error {
if err := conn.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(tunnelConnectionsPrefix, conn.GetClusterName(), conn.GetName()),
Value: value,
Expires: conn.Expiry(),
ID: conn.GetResourceID(),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *PresenceService) UpsertTunnelConnection(conn services.TunnelConnection) error {
if err := conn.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(tunnelConnectionsPrefix, conn.GetClusterName(), conn.GetName()),
Value: value,
Expires: conn.Expiry(),
ID: conn.GetResourceID(),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertTunnelConnection",
"(",
"conn",
"services",
".",
"TunnelConnection",
")",
"error",
"{",
"if",
"err",
":=",
"conn",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"MarshalTunnelConnection",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"conn",
".",
"GetClusterName",
"(",
")",
",",
"conn",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"conn",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"conn",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertTunnelConnection updates or creates tunnel connection | [
"UpsertTunnelConnection",
"updates",
"or",
"creates",
"tunnel",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L480-L498 | train |
gravitational/teleport | lib/services/local/presence.go | GetTunnelConnection | func (s *PresenceService) GetTunnelConnection(clusterName, connectionName string, opts ...services.MarshalOption) (services.TunnelConnection, error) {
item, err := s.Get(context.TODO(), backend.Key(tunnelConnectionsPrefix, clusterName, connectionName))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("trusted cluster connection %q is not found", connectionName)
}
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | go | func (s *PresenceService) GetTunnelConnection(clusterName, connectionName string, opts ...services.MarshalOption) (services.TunnelConnection, error) {
item, err := s.Get(context.TODO(), backend.Key(tunnelConnectionsPrefix, clusterName, connectionName))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("trusted cluster connection %q is not found", connectionName)
}
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTunnelConnection",
"(",
"clusterName",
",",
"connectionName",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"TunnelConnection",
",",
"error",
")",
"{",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"clusterName",
",",
"connectionName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"connectionName",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalTunnelConnection",
"(",
"item",
".",
"Value",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // GetTunnelConnection returns connection by cluster name and connection name | [
"GetTunnelConnection",
"returns",
"connection",
"by",
"cluster",
"name",
"and",
"connection",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L501-L515 | train |
gravitational/teleport | lib/services/local/presence.go | GetTunnelConnections | func (s *PresenceService) GetTunnelConnections(clusterName string, opts ...services.MarshalOption) ([]services.TunnelConnection, error) {
if clusterName == "" {
return nil, trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
conns := make([]services.TunnelConnection, len(result.Items))
for i, item := range result.Items {
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
conns[i] = conn
}
return conns, nil
} | go | func (s *PresenceService) GetTunnelConnections(clusterName string, opts ...services.MarshalOption) ([]services.TunnelConnection, error) {
if clusterName == "" {
return nil, trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
conns := make([]services.TunnelConnection, len(result.Items))
for i, item := range result.Items {
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
conns[i] = conn
}
return conns, nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTunnelConnections",
"(",
"clusterName",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"TunnelConnection",
",",
"error",
")",
"{",
"if",
"clusterName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"clusterName",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conns",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"TunnelConnection",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalTunnelConnection",
"(",
"item",
".",
"Value",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conns",
"[",
"i",
"]",
"=",
"conn",
"\n",
"}",
"\n\n",
"return",
"conns",
",",
"nil",
"\n",
"}"
] | // GetTunnelConnections returns connections for a trusted cluster | [
"GetTunnelConnections",
"returns",
"connections",
"for",
"a",
"trusted",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L518-L538 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteTunnelConnections | func (s *PresenceService) DeleteTunnelConnections(clusterName string) error {
if clusterName == "" {
return trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | func (s *PresenceService) DeleteTunnelConnections(clusterName string) error {
if clusterName == "" {
return trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteTunnelConnections",
"(",
"clusterName",
"string",
")",
"error",
"{",
"if",
"clusterName",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"clusterName",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteTunnelConnections deletes all tunnel connections for cluster | [
"DeleteTunnelConnections",
"deletes",
"all",
"tunnel",
"connections",
"for",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L575-L582 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteAllTunnelConnections | func (s *PresenceService) DeleteAllTunnelConnections() error {
startKey := backend.Key(tunnelConnectionsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | func (s *PresenceService) DeleteAllTunnelConnections() error {
startKey := backend.Key(tunnelConnectionsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllTunnelConnections",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteAllTunnelConnections deletes all tunnel connections | [
"DeleteAllTunnelConnections",
"deletes",
"all",
"tunnel",
"connections"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L585-L589 | train |
gravitational/teleport | lib/services/local/presence.go | CreateRemoteCluster | func (s *PresenceService) CreateRemoteCluster(rc services.RemoteCluster) error {
value, err := json.Marshal(rc)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(remoteClustersPrefix, rc.GetName()),
Value: value,
Expires: rc.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *PresenceService) CreateRemoteCluster(rc services.RemoteCluster) error {
value, err := json.Marshal(rc)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(remoteClustersPrefix, rc.GetName()),
Value: value,
Expires: rc.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"CreateRemoteCluster",
"(",
"rc",
"services",
".",
"RemoteCluster",
")",
"error",
"{",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"rc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"remoteClustersPrefix",
",",
"rc",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"rc",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateRemoteCluster creates remote cluster | [
"CreateRemoteCluster",
"creates",
"remote",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L592-L607 | train |
gravitational/teleport | lib/services/local/presence.go | DeleteAllRemoteClusters | func (s *PresenceService) DeleteAllRemoteClusters() error {
startKey := backend.Key(remoteClustersPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | func (s *PresenceService) DeleteAllRemoteClusters() error {
startKey := backend.Key(remoteClustersPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllRemoteClusters",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"remoteClustersPrefix",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteAllRemoteClusters deletes all remote clusters | [
"DeleteAllRemoteClusters",
"deletes",
"all",
"remote",
"clusters"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L654-L658 | train |
gravitational/teleport | lib/client/player.go | timestampFrame | func timestampFrame(message string) {
const (
saveCursor = "7"
restoreCursor = "8"
)
sz, err := term.GetWinsize(0)
if err != nil {
return
}
esc := func(s string) {
os.Stdout.Write([]byte("\x1b" + s))
}
esc(saveCursor)
defer esc(restoreCursor)
// move cursor to -10:0
esc(fmt.Sprintf("[%d;%df", 0, int(sz.Width)-len(message)))
os.Stdout.WriteString(message)
} | go | func timestampFrame(message string) {
const (
saveCursor = "7"
restoreCursor = "8"
)
sz, err := term.GetWinsize(0)
if err != nil {
return
}
esc := func(s string) {
os.Stdout.Write([]byte("\x1b" + s))
}
esc(saveCursor)
defer esc(restoreCursor)
// move cursor to -10:0
esc(fmt.Sprintf("[%d;%df", 0, int(sz.Width)-len(message)))
os.Stdout.WriteString(message)
} | [
"func",
"timestampFrame",
"(",
"message",
"string",
")",
"{",
"const",
"(",
"saveCursor",
"=",
"\"",
"\"",
"\n",
"restoreCursor",
"=",
"\"",
"\"",
"\n",
")",
"\n",
"sz",
",",
"err",
":=",
"term",
".",
"GetWinsize",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"esc",
":=",
"func",
"(",
"s",
"string",
")",
"{",
"os",
".",
"Stdout",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\\x1b",
"\"",
"+",
"s",
")",
")",
"\n",
"}",
"\n",
"esc",
"(",
"saveCursor",
")",
"\n",
"defer",
"esc",
"(",
"restoreCursor",
")",
"\n\n",
"// move cursor to -10:0",
"esc",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"0",
",",
"int",
"(",
"sz",
".",
"Width",
")",
"-",
"len",
"(",
"message",
")",
")",
")",
"\n",
"os",
".",
"Stdout",
".",
"WriteString",
"(",
"message",
")",
"\n",
"}"
] | // timestampFrame prints 'event timestamp' in the top right corner of the
// terminal after playing every 'print' event | [
"timestampFrame",
"prints",
"event",
"timestamp",
"in",
"the",
"top",
"right",
"corner",
"of",
"the",
"terminal",
"after",
"playing",
"every",
"print",
"event"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/player.go#L119-L137 | train |
gravitational/teleport | lib/utils/jsontools.go | FastUnmarshal | func FastUnmarshal(data []byte, v interface{}) error {
iter := jsoniter.ConfigFastest.BorrowIterator(data)
defer jsoniter.ConfigFastest.ReturnIterator(iter)
iter.ReadVal(v)
if iter.Error != nil {
return trace.Wrap(iter.Error)
}
return nil
} | go | func FastUnmarshal(data []byte, v interface{}) error {
iter := jsoniter.ConfigFastest.BorrowIterator(data)
defer jsoniter.ConfigFastest.ReturnIterator(iter)
iter.ReadVal(v)
if iter.Error != nil {
return trace.Wrap(iter.Error)
}
return nil
} | [
"func",
"FastUnmarshal",
"(",
"data",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"iter",
":=",
"jsoniter",
".",
"ConfigFastest",
".",
"BorrowIterator",
"(",
"data",
")",
"\n",
"defer",
"jsoniter",
".",
"ConfigFastest",
".",
"ReturnIterator",
"(",
"iter",
")",
"\n\n",
"iter",
".",
"ReadVal",
"(",
"v",
")",
"\n",
"if",
"iter",
".",
"Error",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"iter",
".",
"Error",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // FastUnmarshal uses the json-iterator library for fast JSON unmarshalling.
// Note, this function marshals floats with 6 digits precision. | [
"FastUnmarshal",
"uses",
"the",
"json",
"-",
"iterator",
"library",
"for",
"fast",
"JSON",
"unmarshalling",
".",
"Note",
"this",
"function",
"marshals",
"floats",
"with",
"6",
"digits",
"precision",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L61-L71 | train |
gravitational/teleport | lib/utils/jsontools.go | FastMarshal | func FastMarshal(v interface{}) ([]byte, error) {
data, err := jsoniter.ConfigFastest.Marshal(v)
if err != nil {
return nil, trace.Wrap(err)
}
return data, nil
} | go | func FastMarshal(v interface{}) ([]byte, error) {
data, err := jsoniter.ConfigFastest.Marshal(v)
if err != nil {
return nil, trace.Wrap(err)
}
return data, nil
} | [
"func",
"FastMarshal",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"jsoniter",
".",
"ConfigFastest",
".",
"Marshal",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"data",
",",
"nil",
"\n",
"}"
] | // FastMarshal uses the json-iterator library for fast JSON marshalling.
// Note, this function marshals floats with 6 digits precision. | [
"FastMarshal",
"uses",
"the",
"json",
"-",
"iterator",
"library",
"for",
"fast",
"JSON",
"marshalling",
".",
"Note",
"this",
"function",
"marshals",
"floats",
"with",
"6",
"digits",
"precision",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L75-L82 | train |
gravitational/teleport | lib/utils/jsontools.go | isDoc | func isDoc(val reflect.Value) bool {
iterations := 0
for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
// preventing cycles
iterations++
if iterations > 10 {
return false
}
}
return val.Kind() == reflect.Struct || val.Kind() == reflect.Map
} | go | func isDoc(val reflect.Value) bool {
iterations := 0
for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
// preventing cycles
iterations++
if iterations > 10 {
return false
}
}
return val.Kind() == reflect.Struct || val.Kind() == reflect.Map
} | [
"func",
"isDoc",
"(",
"val",
"reflect",
".",
"Value",
")",
"bool",
"{",
"iterations",
":=",
"0",
"\n",
"for",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Interface",
"||",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"val",
"=",
"val",
".",
"Elem",
"(",
")",
"\n",
"// preventing cycles",
"iterations",
"++",
"\n",
"if",
"iterations",
">",
"10",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"||",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Map",
"\n",
"}"
] | // isDoc detects whether value constitues a document | [
"isDoc",
"detects",
"whether",
"value",
"constitues",
"a",
"document"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L122-L133 | train |
gravitational/teleport | lib/utils/jsontools.go | writeYAML | func writeYAML(w io.Writer, values interface{}) error {
data, err := yaml.Marshal(values)
if err != nil {
return trace.Wrap(err)
}
_, err = w.Write(data)
return trace.Wrap(err)
} | go | func writeYAML(w io.Writer, values interface{}) error {
data, err := yaml.Marshal(values)
if err != nil {
return trace.Wrap(err)
}
_, err = w.Write(data)
return trace.Wrap(err)
} | [
"func",
"writeYAML",
"(",
"w",
"io",
".",
"Writer",
",",
"values",
"interface",
"{",
"}",
")",
"error",
"{",
"data",
",",
"err",
":=",
"yaml",
".",
"Marshal",
"(",
"values",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"data",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // writeYAML writes marshaled YAML to writer | [
"writeYAML",
"writes",
"marshaled",
"YAML",
"to",
"writer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L136-L143 | train |
gravitational/teleport | lib/utils/jsontools.go | ReadYAML | func ReadYAML(reader io.Reader) (interface{}, error) {
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
var values []interface{}
for {
var val interface{}
err := decoder.Decode(&val)
if err != nil {
if err == io.EOF {
if len(values) == 0 {
return nil, trace.BadParameter("no resources found, empty input?")
}
if len(values) == 1 {
return values[0], nil
}
return values, nil
}
return nil, trace.Wrap(err)
}
values = append(values, val)
}
} | go | func ReadYAML(reader io.Reader) (interface{}, error) {
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
var values []interface{}
for {
var val interface{}
err := decoder.Decode(&val)
if err != nil {
if err == io.EOF {
if len(values) == 0 {
return nil, trace.BadParameter("no resources found, empty input?")
}
if len(values) == 1 {
return values[0], nil
}
return values, nil
}
return nil, trace.Wrap(err)
}
values = append(values, val)
}
} | [
"func",
"ReadYAML",
"(",
"reader",
"io",
".",
"Reader",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"decoder",
":=",
"kyaml",
".",
"NewYAMLOrJSONDecoder",
"(",
"reader",
",",
"32",
"*",
"1024",
")",
"\n",
"var",
"values",
"[",
"]",
"interface",
"{",
"}",
"\n",
"for",
"{",
"var",
"val",
"interface",
"{",
"}",
"\n",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"&",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"if",
"len",
"(",
"values",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"values",
")",
"==",
"1",
"{",
"return",
"values",
"[",
"0",
"]",
",",
"nil",
"\n",
"}",
"\n",
"return",
"values",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"values",
"=",
"append",
"(",
"values",
",",
"val",
")",
"\n",
"}",
"\n",
"}"
] | // ReadYAML can unmarshal a stream of documents, used in tests. | [
"ReadYAML",
"can",
"unmarshal",
"a",
"stream",
"of",
"documents",
"used",
"in",
"tests",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L146-L166 | train |
gravitational/teleport | lib/client/redirect.go | NewRedirector | func NewRedirector(login SSHLogin) (*Redirector, error) {
//clt, proxyURL, err := initClient(login.ProxyAddr, login.Insecure, login.Pool)
//if err != nil {
// return nil, trace.Wrap(err)
//}
clt, err := NewCredentialsClient(login.ProxyAddr, login.Insecure, login.Pool)
if err != nil {
return nil, trace.Wrap(err)
}
// Create secret key that will be sent with the request and then used the
// decrypt the response from the server.
key, err := secret.NewKey()
if err != nil {
return nil, trace.Wrap(err)
}
context, cancel := context.WithCancel(login.Context)
rd := &Redirector{
context: context,
cancel: cancel,
proxyClient: clt.clt,
proxyURL: clt.url,
SSHLogin: login,
mux: http.NewServeMux(),
key: key,
shortPath: "/" + uuid.New(),
responseC: make(chan *auth.SSHLoginResponse, 1),
errorC: make(chan error, 1),
}
// callback is a callback URL communicated to the Teleport proxy,
// after SAML/OIDC login, the teleport will redirect user's browser
// to this laptop-local URL
rd.mux.Handle("/callback", rd.wrapCallback(rd.callback))
// short path is a link-shortener style URL
// that will redirect to the Teleport-Proxy supplied address
rd.mux.HandleFunc(rd.shortPath, func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, rd.redirectURL.Value(), http.StatusFound)
})
return rd, nil
} | go | func NewRedirector(login SSHLogin) (*Redirector, error) {
//clt, proxyURL, err := initClient(login.ProxyAddr, login.Insecure, login.Pool)
//if err != nil {
// return nil, trace.Wrap(err)
//}
clt, err := NewCredentialsClient(login.ProxyAddr, login.Insecure, login.Pool)
if err != nil {
return nil, trace.Wrap(err)
}
// Create secret key that will be sent with the request and then used the
// decrypt the response from the server.
key, err := secret.NewKey()
if err != nil {
return nil, trace.Wrap(err)
}
context, cancel := context.WithCancel(login.Context)
rd := &Redirector{
context: context,
cancel: cancel,
proxyClient: clt.clt,
proxyURL: clt.url,
SSHLogin: login,
mux: http.NewServeMux(),
key: key,
shortPath: "/" + uuid.New(),
responseC: make(chan *auth.SSHLoginResponse, 1),
errorC: make(chan error, 1),
}
// callback is a callback URL communicated to the Teleport proxy,
// after SAML/OIDC login, the teleport will redirect user's browser
// to this laptop-local URL
rd.mux.Handle("/callback", rd.wrapCallback(rd.callback))
// short path is a link-shortener style URL
// that will redirect to the Teleport-Proxy supplied address
rd.mux.HandleFunc(rd.shortPath, func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, rd.redirectURL.Value(), http.StatusFound)
})
return rd, nil
} | [
"func",
"NewRedirector",
"(",
"login",
"SSHLogin",
")",
"(",
"*",
"Redirector",
",",
"error",
")",
"{",
"//clt, proxyURL, err := initClient(login.ProxyAddr, login.Insecure, login.Pool)",
"//if err != nil {",
"//\treturn nil, trace.Wrap(err)",
"//}",
"clt",
",",
"err",
":=",
"NewCredentialsClient",
"(",
"login",
".",
"ProxyAddr",
",",
"login",
".",
"Insecure",
",",
"login",
".",
"Pool",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Create secret key that will be sent with the request and then used the",
"// decrypt the response from the server.",
"key",
",",
"err",
":=",
"secret",
".",
"NewKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"context",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"login",
".",
"Context",
")",
"\n",
"rd",
":=",
"&",
"Redirector",
"{",
"context",
":",
"context",
",",
"cancel",
":",
"cancel",
",",
"proxyClient",
":",
"clt",
".",
"clt",
",",
"proxyURL",
":",
"clt",
".",
"url",
",",
"SSHLogin",
":",
"login",
",",
"mux",
":",
"http",
".",
"NewServeMux",
"(",
")",
",",
"key",
":",
"key",
",",
"shortPath",
":",
"\"",
"\"",
"+",
"uuid",
".",
"New",
"(",
")",
",",
"responseC",
":",
"make",
"(",
"chan",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"1",
")",
",",
"errorC",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n\n",
"// callback is a callback URL communicated to the Teleport proxy,",
"// after SAML/OIDC login, the teleport will redirect user's browser",
"// to this laptop-local URL",
"rd",
".",
"mux",
".",
"Handle",
"(",
"\"",
"\"",
",",
"rd",
".",
"wrapCallback",
"(",
"rd",
".",
"callback",
")",
")",
"\n",
"// short path is a link-shortener style URL",
"// that will redirect to the Teleport-Proxy supplied address",
"rd",
".",
"mux",
".",
"HandleFunc",
"(",
"rd",
".",
"shortPath",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"rd",
".",
"redirectURL",
".",
"Value",
"(",
")",
",",
"http",
".",
"StatusFound",
")",
"\n",
"}",
")",
"\n",
"return",
"rd",
",",
"nil",
"\n",
"}"
] | // NewRedirector returns new local web server redirector | [
"NewRedirector",
"returns",
"new",
"local",
"web",
"server",
"redirector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L69-L111 | train |
gravitational/teleport | lib/client/redirect.go | Start | func (rd *Redirector) Start() error {
if rd.BindAddr != "" {
log.Debugf("Binding to %v.", rd.BindAddr)
listener, err := net.Listen("tcp", rd.BindAddr)
if err != nil {
return trace.Wrap(err, "%v: could not bind to %v, make sure the address is host:port format for ipv4 and [ipv6]:port format for ipv6, and the address is not in use", err, rd.BindAddr)
}
rd.server = &httptest.Server{
Listener: listener,
Config: &http.Server{Handler: rd.mux},
}
rd.server.Start()
} else {
rd.server = httptest.NewServer(rd.mux)
}
log.Infof("Waiting for response at: %v.", rd.server.URL)
// communicate callback redirect URL to the Teleport Proxy
u, err := url.Parse(rd.server.URL + "/callback")
if err != nil {
return trace.Wrap(err)
}
query := u.Query()
query.Set("secret_key", rd.key.String())
u.RawQuery = query.Encode()
out, err := rd.proxyClient.PostJSON(rd.Context, rd.proxyClient.Endpoint("webapi", rd.Protocol, "login", "console"), SSOLoginConsoleReq{
RedirectURL: u.String(),
PublicKey: rd.PubKey,
CertTTL: rd.TTL,
ConnectorID: rd.ConnectorID,
Compatibility: rd.Compatibility,
})
if err != nil {
return trace.Wrap(err)
}
var re *SSOLoginConsoleResponse
err = json.Unmarshal(out.Bytes(), &re)
if err != nil {
return trace.Wrap(err)
}
// notice late binding of the redirect URL here, it is referenced
// in the callback handler, but is known only after the request
// is sent to the Teleport Proxy, that's why
// redirectURL is a SyncString
rd.redirectURL.Set(re.RedirectURL)
return nil
} | go | func (rd *Redirector) Start() error {
if rd.BindAddr != "" {
log.Debugf("Binding to %v.", rd.BindAddr)
listener, err := net.Listen("tcp", rd.BindAddr)
if err != nil {
return trace.Wrap(err, "%v: could not bind to %v, make sure the address is host:port format for ipv4 and [ipv6]:port format for ipv6, and the address is not in use", err, rd.BindAddr)
}
rd.server = &httptest.Server{
Listener: listener,
Config: &http.Server{Handler: rd.mux},
}
rd.server.Start()
} else {
rd.server = httptest.NewServer(rd.mux)
}
log.Infof("Waiting for response at: %v.", rd.server.URL)
// communicate callback redirect URL to the Teleport Proxy
u, err := url.Parse(rd.server.URL + "/callback")
if err != nil {
return trace.Wrap(err)
}
query := u.Query()
query.Set("secret_key", rd.key.String())
u.RawQuery = query.Encode()
out, err := rd.proxyClient.PostJSON(rd.Context, rd.proxyClient.Endpoint("webapi", rd.Protocol, "login", "console"), SSOLoginConsoleReq{
RedirectURL: u.String(),
PublicKey: rd.PubKey,
CertTTL: rd.TTL,
ConnectorID: rd.ConnectorID,
Compatibility: rd.Compatibility,
})
if err != nil {
return trace.Wrap(err)
}
var re *SSOLoginConsoleResponse
err = json.Unmarshal(out.Bytes(), &re)
if err != nil {
return trace.Wrap(err)
}
// notice late binding of the redirect URL here, it is referenced
// in the callback handler, but is known only after the request
// is sent to the Teleport Proxy, that's why
// redirectURL is a SyncString
rd.redirectURL.Set(re.RedirectURL)
return nil
} | [
"func",
"(",
"rd",
"*",
"Redirector",
")",
"Start",
"(",
")",
"error",
"{",
"if",
"rd",
".",
"BindAddr",
"!=",
"\"",
"\"",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"rd",
".",
"BindAddr",
")",
"\n",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"rd",
".",
"BindAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
",",
"err",
",",
"rd",
".",
"BindAddr",
")",
"\n",
"}",
"\n",
"rd",
".",
"server",
"=",
"&",
"httptest",
".",
"Server",
"{",
"Listener",
":",
"listener",
",",
"Config",
":",
"&",
"http",
".",
"Server",
"{",
"Handler",
":",
"rd",
".",
"mux",
"}",
",",
"}",
"\n",
"rd",
".",
"server",
".",
"Start",
"(",
")",
"\n",
"}",
"else",
"{",
"rd",
".",
"server",
"=",
"httptest",
".",
"NewServer",
"(",
"rd",
".",
"mux",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"rd",
".",
"server",
".",
"URL",
")",
"\n\n",
"// communicate callback redirect URL to the Teleport Proxy",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"rd",
".",
"server",
".",
"URL",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"query",
":=",
"u",
".",
"Query",
"(",
")",
"\n",
"query",
".",
"Set",
"(",
"\"",
"\"",
",",
"rd",
".",
"key",
".",
"String",
"(",
")",
")",
"\n",
"u",
".",
"RawQuery",
"=",
"query",
".",
"Encode",
"(",
")",
"\n\n",
"out",
",",
"err",
":=",
"rd",
".",
"proxyClient",
".",
"PostJSON",
"(",
"rd",
".",
"Context",
",",
"rd",
".",
"proxyClient",
".",
"Endpoint",
"(",
"\"",
"\"",
",",
"rd",
".",
"Protocol",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"SSOLoginConsoleReq",
"{",
"RedirectURL",
":",
"u",
".",
"String",
"(",
")",
",",
"PublicKey",
":",
"rd",
".",
"PubKey",
",",
"CertTTL",
":",
"rd",
".",
"TTL",
",",
"ConnectorID",
":",
"rd",
".",
"ConnectorID",
",",
"Compatibility",
":",
"rd",
".",
"Compatibility",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"re",
"*",
"SSOLoginConsoleResponse",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"re",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"// notice late binding of the redirect URL here, it is referenced",
"// in the callback handler, but is known only after the request",
"// is sent to the Teleport Proxy, that's why",
"// redirectURL is a SyncString",
"rd",
".",
"redirectURL",
".",
"Set",
"(",
"re",
".",
"RedirectURL",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Start launches local http server on the machine,
// initiates SSO login request sequence with the Teleport Proxy | [
"Start",
"launches",
"local",
"http",
"server",
"on",
"the",
"machine",
"initiates",
"SSO",
"login",
"request",
"sequence",
"with",
"the",
"Teleport",
"Proxy"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L115-L163 | train |
gravitational/teleport | lib/client/redirect.go | ClickableURL | func (rd *Redirector) ClickableURL() string {
if rd.server == nil {
return "<undefined - server is not started>"
}
return utils.ClickableURL(rd.server.URL + rd.shortPath)
} | go | func (rd *Redirector) ClickableURL() string {
if rd.server == nil {
return "<undefined - server is not started>"
}
return utils.ClickableURL(rd.server.URL + rd.shortPath)
} | [
"func",
"(",
"rd",
"*",
"Redirector",
")",
"ClickableURL",
"(",
")",
"string",
"{",
"if",
"rd",
".",
"server",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"utils",
".",
"ClickableURL",
"(",
"rd",
".",
"server",
".",
"URL",
"+",
"rd",
".",
"shortPath",
")",
"\n",
"}"
] | // ClickableURL returns a short clickable redirect URL | [
"ClickableURL",
"returns",
"a",
"short",
"clickable",
"redirect",
"URL"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L172-L177 | train |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.