repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/services/local/users.go | DeleteUser | func (s *IdentityService) DeleteUser(user string) error {
_, err := s.GetUser(user)
if err != nil {
return trace.Wrap(err)
}
startKey := backend.Key(webPrefix, usersPrefix, user)
err = s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteUser(user string) error {
_, err := s.GetUser(user)
if err != nil {
return trace.Wrap(err)
}
startKey := backend.Key(webPrefix, usersPrefix, user)
err = s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteUser",
"(",
"user",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"s",
".",
"GetUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
")",
"\n",
"err",
"=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteUser deletes a user with all the keys from the backend | [
"DeleteUser",
"deletes",
"a",
"user",
"with",
"all",
"the",
"keys",
"from",
"the",
"backend"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L192-L200 | train |
gravitational/teleport | lib/services/local/users.go | UpsertPasswordHash | func (s *IdentityService) UpsertPasswordHash(username string, hash []byte) error {
userPrototype, err := services.NewUser(username)
if err != nil {
return trace.Wrap(err)
}
user, err := services.GetUserMarshaler().GenerateUser(userPrototype)
if err != nil {
return trace.Wrap(err)
}
err = s.CreateUser(user)
if err != nil {
if !trace.IsAlreadyExists(err) {
return trace.Wrap(err)
}
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, username, pwdPrefix),
Value: hash,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertPasswordHash(username string, hash []byte) error {
userPrototype, err := services.NewUser(username)
if err != nil {
return trace.Wrap(err)
}
user, err := services.GetUserMarshaler().GenerateUser(userPrototype)
if err != nil {
return trace.Wrap(err)
}
err = s.CreateUser(user)
if err != nil {
if !trace.IsAlreadyExists(err) {
return trace.Wrap(err)
}
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, username, pwdPrefix),
Value: hash,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertPasswordHash",
"(",
"username",
"string",
",",
"hash",
"[",
"]",
"byte",
")",
"error",
"{",
"userPrototype",
",",
"err",
":=",
"services",
".",
"NewUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"GenerateUser",
"(",
"userPrototype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"CreateUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"username",
",",
"pwdPrefix",
")",
",",
"Value",
":",
"hash",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertPasswordHash upserts user password hash | [
"UpsertPasswordHash",
"upserts",
"user",
"password",
"hash"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L203-L227 | train |
gravitational/teleport | lib/services/local/users.go | UpsertTOTP | func (s *IdentityService) UpsertTOTP(user string, secretKey string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, totpPrefix),
Value: []byte(secretKey),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertTOTP(user string, secretKey string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, totpPrefix),
Value: []byte(secretKey),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertTOTP",
"(",
"user",
"string",
",",
"secretKey",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing user name\"",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"totpPrefix",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"secretKey",
")",
",",
"}",
"\n",
"_",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertTOTP upserts TOTP secret key for a user that can be used to generate and validate tokens. | [
"UpsertTOTP",
"upserts",
"TOTP",
"secret",
"key",
"for",
"a",
"user",
"that",
"can",
"be",
"used",
"to",
"generate",
"and",
"validate",
"tokens",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L292-L308 | train |
gravitational/teleport | lib/services/local/users.go | GetTOTP | func (s *IdentityService) GetTOTP(user string) (string, error) {
if user == "" {
return "", trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, totpPrefix))
if err != nil {
if trace.IsNotFound(err) {
return "", trace.NotFound("user %q is not found", user)
}
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | go | func (s *IdentityService) GetTOTP(user string) (string, error) {
if user == "" {
return "", trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, totpPrefix))
if err != nil {
if trace.IsNotFound(err) {
return "", trace.NotFound("user %q is not found", user)
}
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetTOTP",
"(",
"user",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing user name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"totpPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"\"\"",
",",
"trace",
".",
"NotFound",
"(",
"\"user %q is not found\"",
",",
"user",
")",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"item",
".",
"Value",
")",
",",
"nil",
"\n",
"}"
] | // GetTOTP returns the secret key used by the TOTP algorithm to validate tokens | [
"GetTOTP",
"returns",
"the",
"secret",
"key",
"used",
"by",
"the",
"TOTP",
"algorithm",
"to",
"validate",
"tokens"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L311-L325 | train |
gravitational/teleport | lib/services/local/users.go | UpsertUsedTOTPToken | func (s *IdentityService) UpsertUsedTOTPToken(user string, otpToken string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix),
Value: []byte(otpToken),
Expires: s.Clock().Now().UTC().Add(usedTOTPTTL),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertUsedTOTPToken(user string, otpToken string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix),
Value: []byte(otpToken),
Expires: s.Clock().Now().UTC().Add(usedTOTPTTL),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertUsedTOTPToken",
"(",
"user",
"string",
",",
"otpToken",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing user name\"",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"usedTOTPPrefix",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"otpToken",
")",
",",
"Expires",
":",
"s",
".",
"Clock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"usedTOTPTTL",
")",
",",
"}",
"\n",
"_",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertUsedTOTPToken upserts a TOTP token to the backend so it can't be used again
// during the 30 second window it's valid. | [
"UpsertUsedTOTPToken",
"upserts",
"a",
"TOTP",
"token",
"to",
"the",
"backend",
"so",
"it",
"can",
"t",
"be",
"used",
"again",
"during",
"the",
"30",
"second",
"window",
"it",
"s",
"valid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L329-L343 | train |
gravitational/teleport | lib/services/local/users.go | DeleteUsedTOTPToken | func (s *IdentityService) DeleteUsedTOTPToken(user string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
return s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix))
} | go | func (s *IdentityService) DeleteUsedTOTPToken(user string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
return s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix))
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteUsedTOTPToken",
"(",
"user",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing user name\"",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"usedTOTPPrefix",
")",
")",
"\n",
"}"
] | // DeleteUsedTOTPToken removes the used token from the backend. This should only
// be used during tests. | [
"DeleteUsedTOTPToken",
"removes",
"the",
"used",
"token",
"from",
"the",
"backend",
".",
"This",
"should",
"only",
"be",
"used",
"during",
"tests",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L363-L368 | train |
gravitational/teleport | lib/services/local/users.go | UpsertWebSession | func (s *IdentityService) UpsertWebSession(user, sid string, session services.WebSession) error {
session.SetUser(user)
session.SetName(sid)
value, err := services.GetWebSessionMarshaler().MarshalWebSession(session)
if err != nil {
return trace.Wrap(err)
}
sessionMetadata := session.GetMetadata()
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid),
Value: value,
Expires: backend.EarliestExpiry(session.GetBearerTokenExpiryTime(), sessionMetadata.Expiry()),
}
_, err = s.Put(context.TODO(), item)
return trace.Wrap(err)
} | go | func (s *IdentityService) UpsertWebSession(user, sid string, session services.WebSession) error {
session.SetUser(user)
session.SetName(sid)
value, err := services.GetWebSessionMarshaler().MarshalWebSession(session)
if err != nil {
return trace.Wrap(err)
}
sessionMetadata := session.GetMetadata()
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid),
Value: value,
Expires: backend.EarliestExpiry(session.GetBearerTokenExpiryTime(), sessionMetadata.Expiry()),
}
_, err = s.Put(context.TODO(), item)
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertWebSession",
"(",
"user",
",",
"sid",
"string",
",",
"session",
"services",
".",
"WebSession",
")",
"error",
"{",
"session",
".",
"SetUser",
"(",
"user",
")",
"\n",
"session",
".",
"SetName",
"(",
"sid",
")",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"MarshalWebSession",
"(",
"session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sessionMetadata",
":=",
"session",
".",
"GetMetadata",
"(",
")",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"sessionsPrefix",
",",
"sid",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"backend",
".",
"EarliestExpiry",
"(",
"session",
".",
"GetBearerTokenExpiryTime",
"(",
")",
",",
"sessionMetadata",
".",
"Expiry",
"(",
")",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertWebSession updates or inserts a web session for a user and session id
// the session will be created with bearer token expiry time TTL, because
// it is expected to be extended by the client before then | [
"UpsertWebSession",
"updates",
"or",
"inserts",
"a",
"web",
"session",
"for",
"a",
"user",
"and",
"session",
"id",
"the",
"session",
"will",
"be",
"created",
"with",
"bearer",
"token",
"expiry",
"time",
"TTL",
"because",
"it",
"is",
"expected",
"to",
"be",
"extended",
"by",
"the",
"client",
"before",
"then"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L373-L388 | train |
gravitational/teleport | lib/services/local/users.go | GetUserLoginAttempts | func (s *IdentityService) GetUserLoginAttempts(user string) ([]services.LoginAttempt, error) {
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.LoginAttempt, len(result.Items))
for i, item := range result.Items {
var a services.LoginAttempt
if err := json.Unmarshal(item.Value, &a); err != nil {
return nil, trace.Wrap(err)
}
out[i] = a
}
sort.Sort(services.SortedLoginAttempts(out))
return out, nil
} | go | func (s *IdentityService) GetUserLoginAttempts(user string) ([]services.LoginAttempt, error) {
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.LoginAttempt, len(result.Items))
for i, item := range result.Items {
var a services.LoginAttempt
if err := json.Unmarshal(item.Value, &a); err != nil {
return nil, trace.Wrap(err)
}
out[i] = a
}
sort.Sort(services.SortedLoginAttempts(out))
return out, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetUserLoginAttempts",
"(",
"user",
"string",
")",
"(",
"[",
"]",
"services",
".",
"LoginAttempt",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"attemptsPrefix",
")",
"\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",
".",
"LoginAttempt",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"var",
"a",
"services",
".",
"LoginAttempt",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"a",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"[",
"i",
"]",
"=",
"a",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedLoginAttempts",
"(",
"out",
")",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // GetUserLoginAttempts returns user login attempts | [
"GetUserLoginAttempts",
"returns",
"user",
"login",
"attempts"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L409-L425 | train |
gravitational/teleport | lib/services/local/users.go | DeleteUserLoginAttempts | func (s *IdentityService) DeleteUserLoginAttempts(user string) error {
if user == "" {
return trace.BadParameter("missing username")
}
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) DeleteUserLoginAttempts(user string) error {
if user == "" {
return trace.BadParameter("missing username")
}
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteUserLoginAttempts",
"(",
"user",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing username\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"attemptsPrefix",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteUserLoginAttempts removes all login attempts of a user. Should be
// called after successful login. | [
"DeleteUserLoginAttempts",
"removes",
"all",
"login",
"attempts",
"of",
"a",
"user",
".",
"Should",
"be",
"called",
"after",
"successful",
"login",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L429-L439 | train |
gravitational/teleport | lib/services/local/users.go | GetWebSession | func (s *IdentityService) GetWebSession(user, sid string) (services.WebSession, error) {
if user == "" {
return nil, trace.BadParameter("missing username")
}
if sid == "" {
return nil, trace.BadParameter("missing session id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
if err != nil {
return nil, trace.Wrap(err)
}
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
// this is for backwards compatibility to ensure we
// always have these values
session.SetUser(user)
session.SetName(sid)
return session, nil
} | go | func (s *IdentityService) GetWebSession(user, sid string) (services.WebSession, error) {
if user == "" {
return nil, trace.BadParameter("missing username")
}
if sid == "" {
return nil, trace.BadParameter("missing session id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
if err != nil {
return nil, trace.Wrap(err)
}
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
// this is for backwards compatibility to ensure we
// always have these values
session.SetUser(user)
session.SetName(sid)
return session, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetWebSession",
"(",
"user",
",",
"sid",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing username\"",
")",
"\n",
"}",
"\n",
"if",
"sid",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing session id\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"sessionsPrefix",
",",
"sid",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"item",
".",
"Value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"session",
".",
"SetUser",
"(",
"user",
")",
"\n",
"session",
".",
"SetName",
"(",
"sid",
")",
"\n",
"return",
"session",
",",
"nil",
"\n",
"}"
] | // GetWebSession returns a web session state for a given user and session id | [
"GetWebSession",
"returns",
"a",
"web",
"session",
"state",
"for",
"a",
"given",
"user",
"and",
"session",
"id"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L442-L462 | train |
gravitational/teleport | lib/services/local/users.go | DeleteWebSession | func (s *IdentityService) DeleteWebSession(user, sid string) error {
if user == "" {
return trace.BadParameter("missing username")
}
if sid == "" {
return trace.BadParameter("missing session id")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteWebSession(user, sid string) error {
if user == "" {
return trace.BadParameter("missing username")
}
if sid == "" {
return trace.BadParameter("missing session id")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteWebSession",
"(",
"user",
",",
"sid",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing username\"",
")",
"\n",
"}",
"\n",
"if",
"sid",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing session id\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"sessionsPrefix",
",",
"sid",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteWebSession deletes web session from the storage | [
"DeleteWebSession",
"deletes",
"web",
"session",
"from",
"the",
"storage"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L465-L474 | train |
gravitational/teleport | lib/services/local/users.go | UpsertPassword | func (s *IdentityService) UpsertPassword(user string, password []byte) error {
if user == "" {
return trace.BadParameter("missing username")
}
err := services.VerifyPassword(password)
if err != nil {
return trace.Wrap(err)
}
hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertPasswordHash(user, hash)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertPassword(user string, password []byte) error {
if user == "" {
return trace.BadParameter("missing username")
}
err := services.VerifyPassword(password)
if err != nil {
return trace.Wrap(err)
}
hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertPasswordHash(user, hash)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertPassword",
"(",
"user",
"string",
",",
"password",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing username\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"services",
".",
"VerifyPassword",
"(",
"password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"hash",
",",
"err",
":=",
"bcrypt",
".",
"GenerateFromPassword",
"(",
"password",
",",
"bcrypt",
".",
"DefaultCost",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"UpsertPasswordHash",
"(",
"user",
",",
"hash",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertPassword upserts new password hash into a backend. | [
"UpsertPassword",
"upserts",
"new",
"password",
"hash",
"into",
"a",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L477-L496 | train |
gravitational/teleport | lib/services/local/users.go | UpsertSignupToken | func (s *IdentityService) UpsertSignupToken(token string, tokenData services.SignupToken, ttl time.Duration) error {
if ttl < time.Second || ttl > defaults.MaxSignupTokenTTL {
ttl = defaults.MaxSignupTokenTTL
}
tokenData.Expires = time.Now().UTC().Add(ttl)
value, err := json.Marshal(tokenData)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(userTokensPrefix, token),
Value: value,
Expires: tokenData.Expires,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertSignupToken(token string, tokenData services.SignupToken, ttl time.Duration) error {
if ttl < time.Second || ttl > defaults.MaxSignupTokenTTL {
ttl = defaults.MaxSignupTokenTTL
}
tokenData.Expires = time.Now().UTC().Add(ttl)
value, err := json.Marshal(tokenData)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(userTokensPrefix, token),
Value: value,
Expires: tokenData.Expires,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertSignupToken",
"(",
"token",
"string",
",",
"tokenData",
"services",
".",
"SignupToken",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"ttl",
"<",
"time",
".",
"Second",
"||",
"ttl",
">",
"defaults",
".",
"MaxSignupTokenTTL",
"{",
"ttl",
"=",
"defaults",
".",
"MaxSignupTokenTTL",
"\n",
"}",
"\n",
"tokenData",
".",
"Expires",
"=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"ttl",
")",
"\n",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"tokenData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
",",
"token",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"tokenData",
".",
"Expires",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertSignupToken upserts signup token - one time token that lets user to create a user account | [
"UpsertSignupToken",
"upserts",
"signup",
"token",
"-",
"one",
"time",
"token",
"that",
"lets",
"user",
"to",
"create",
"a",
"user",
"account"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L499-L519 | train |
gravitational/teleport | lib/services/local/users.go | GetSignupToken | func (s *IdentityService) GetSignupToken(token string) (*services.SignupToken, error) {
if token == "" {
return nil, trace.BadParameter("missing token")
}
item, err := s.Get(context.TODO(), backend.Key(userTokensPrefix, token))
if err != nil {
return nil, trace.Wrap(err)
}
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
return &signupToken, nil
} | go | func (s *IdentityService) GetSignupToken(token string) (*services.SignupToken, error) {
if token == "" {
return nil, trace.BadParameter("missing token")
}
item, err := s.Get(context.TODO(), backend.Key(userTokensPrefix, token))
if err != nil {
return nil, trace.Wrap(err)
}
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
return &signupToken, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSignupToken",
"(",
"token",
"string",
")",
"(",
"*",
"services",
".",
"SignupToken",
",",
"error",
")",
"{",
"if",
"token",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing token\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
",",
"token",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"signupToken",
"services",
".",
"SignupToken",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"signupToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"signupToken",
",",
"nil",
"\n",
"}"
] | // GetSignupToken returns signup token data | [
"GetSignupToken",
"returns",
"signup",
"token",
"data"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L522-L536 | train |
gravitational/teleport | lib/services/local/users.go | GetSignupTokens | func (s *IdentityService) GetSignupTokens() ([]services.SignupToken, error) {
startKey := backend.Key(userTokensPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tokens := make([]services.SignupToken, len(result.Items))
for i, item := range result.Items {
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
tokens[i] = signupToken
}
return tokens, nil
} | go | func (s *IdentityService) GetSignupTokens() ([]services.SignupToken, error) {
startKey := backend.Key(userTokensPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tokens := make([]services.SignupToken, len(result.Items))
for i, item := range result.Items {
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
tokens[i] = signupToken
}
return tokens, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSignupTokens",
"(",
")",
"(",
"[",
"]",
"services",
".",
"SignupToken",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tokens",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"SignupToken",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"var",
"signupToken",
"services",
".",
"SignupToken",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"signupToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tokens",
"[",
"i",
"]",
"=",
"signupToken",
"\n",
"}",
"\n",
"return",
"tokens",
",",
"nil",
"\n",
"}"
] | // GetSignupTokens returns all non-expired user tokens | [
"GetSignupTokens",
"returns",
"all",
"non",
"-",
"expired",
"user",
"tokens"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L539-L555 | train |
gravitational/teleport | lib/services/local/users.go | DeleteSignupToken | func (s *IdentityService) DeleteSignupToken(token string) error {
if token == "" {
return trace.BadParameter("missing parameter token")
}
err := s.Delete(context.TODO(), backend.Key(userTokensPrefix, token))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteSignupToken(token string) error {
if token == "" {
return trace.BadParameter("missing parameter token")
}
err := s.Delete(context.TODO(), backend.Key(userTokensPrefix, token))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteSignupToken",
"(",
"token",
"string",
")",
"error",
"{",
"if",
"token",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter token\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
",",
"token",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteSignupToken deletes signup token from the storage | [
"DeleteSignupToken",
"deletes",
"signup",
"token",
"from",
"the",
"storage"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L558-L564 | train |
gravitational/teleport | lib/services/local/users.go | UpsertOIDCConnector | func (s *IdentityService) UpsertOIDCConnector(connector services.OIDCConnector) error {
if err := connector.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
ID: connector.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertOIDCConnector(connector services.OIDCConnector) error {
if err := connector.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
ID: connector.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertOIDCConnector",
"(",
"connector",
"services",
".",
"OIDCConnector",
")",
"error",
"{",
"if",
"err",
":=",
"connector",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"MarshalOIDCConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"connectorsPrefix",
",",
"connector",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"connector",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"connector",
".",
"GetResourceID",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertOIDCConnector upserts OIDC Connector | [
"UpsertOIDCConnector",
"upserts",
"OIDC",
"Connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L746-L765 | train |
gravitational/teleport | lib/services/local/users.go | GetOIDCConnector | func (s *IdentityService) GetOIDCConnector(name string, withSecrets bool) (services.OIDCConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("OpenID connector '%v' is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(item.Value,
services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
return conn, nil
} | go | func (s *IdentityService) GetOIDCConnector(name string, withSecrets bool) (services.OIDCConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("OpenID connector '%v' is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(item.Value,
services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
return conn, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetOIDCConnector",
"(",
"name",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"OIDCConnector",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"OpenID connector '%v' is not configured\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"UnmarshalOIDCConnector",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"conn",
".",
"SetClientSecret",
"(",
"\"\"",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // GetOIDCConnector returns OIDC connector data, parameter 'withSecrets'
// includes or excludes client secret from return results | [
"GetOIDCConnector",
"returns",
"OIDC",
"connector",
"data",
"parameter",
"withSecrets",
"includes",
"or",
"excludes",
"client",
"secret",
"from",
"return",
"results"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L778-L798 | train |
gravitational/teleport | lib/services/local/users.go | GetOIDCConnectors | func (s *IdentityService) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(result.Items))
for i, item := range result.Items {
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
connectors[i] = conn
}
return connectors, nil
} | go | func (s *IdentityService) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(result.Items))
for i, item := range result.Items {
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
connectors[i] = conn
}
return connectors, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetOIDCConnectors",
"(",
"withSecrets",
"bool",
")",
"(",
"[",
"]",
"services",
".",
"OIDCConnector",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"connectorsPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"OIDCConnector",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"conn",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"UnmarshalOIDCConnector",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"conn",
".",
"SetClientSecret",
"(",
"\"\"",
")",
"\n",
"}",
"\n",
"connectors",
"[",
"i",
"]",
"=",
"conn",
"\n",
"}",
"\n",
"return",
"connectors",
",",
"nil",
"\n",
"}"
] | // GetOIDCConnectors returns registered connectors, withSecrets adds or removes client secret from return results | [
"GetOIDCConnectors",
"returns",
"registered",
"connectors",
"withSecrets",
"adds",
"or",
"removes",
"client",
"secret",
"from",
"return",
"results"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L801-L820 | train |
gravitational/teleport | lib/services/local/users.go | CreateOIDCAuthRequest | func (s *IdentityService) CreateOIDCAuthRequest(req services.OIDCAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateOIDCAuthRequest(req services.OIDCAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateOIDCAuthRequest",
"(",
"req",
"services",
".",
"OIDCAuthRequest",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"err",
":=",
"req",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"requestsPrefix",
",",
"req",
".",
"StateToken",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"backend",
".",
"Expiry",
"(",
"s",
".",
"Clock",
"(",
")",
",",
"ttl",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateOIDCAuthRequest creates new auth request | [
"CreateOIDCAuthRequest",
"creates",
"new",
"auth",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L823-L841 | train |
gravitational/teleport | lib/services/local/users.go | CreateSAMLConnector | func (s *IdentityService) CreateSAMLConnector(connector services.SAMLConnector) error {
if err := connector.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateSAMLConnector(connector services.SAMLConnector) error {
if err := connector.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateSAMLConnector",
"(",
"connector",
"services",
".",
"SAMLConnector",
")",
"error",
"{",
"if",
"err",
":=",
"connector",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"MarshalSAMLConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"connectorsPrefix",
",",
"connector",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"connector",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateSAMLConnector creates SAML Connector | [
"CreateSAMLConnector",
"creates",
"SAML",
"Connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L860-L878 | train |
gravitational/teleport | lib/services/local/users.go | DeleteSAMLConnector | func (s *IdentityService) DeleteSAMLConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteSAMLConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteSAMLConnector",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter name\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteSAMLConnector deletes SAML Connector by name | [
"DeleteSAMLConnector",
"deletes",
"SAML",
"Connector",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L902-L908 | train |
gravitational/teleport | lib/services/local/users.go | GetSAMLConnector | func (s *IdentityService) GetSAMLConnector(name string, withSecrets bool) (services.SAMLConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("SAML connector %q is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
keyPair := conn.GetSigningKeyPair()
if keyPair != nil {
keyPair.PrivateKey = ""
conn.SetSigningKeyPair(keyPair)
}
}
return conn, nil
} | go | func (s *IdentityService) GetSAMLConnector(name string, withSecrets bool) (services.SAMLConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("SAML connector %q is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
keyPair := conn.GetSigningKeyPair()
if keyPair != nil {
keyPair.PrivateKey = ""
conn.SetSigningKeyPair(keyPair)
}
}
return conn, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSAMLConnector",
"(",
"name",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"SAMLConnector",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"SAML connector %q is not configured\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"UnmarshalSAMLConnector",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"keyPair",
":=",
"conn",
".",
"GetSigningKeyPair",
"(",
")",
"\n",
"if",
"keyPair",
"!=",
"nil",
"{",
"keyPair",
".",
"PrivateKey",
"=",
"\"\"",
"\n",
"conn",
".",
"SetSigningKeyPair",
"(",
"keyPair",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // GetSAMLConnector returns SAML connector data,
// withSecrets includes or excludes secrets from return results | [
"GetSAMLConnector",
"returns",
"SAML",
"connector",
"data",
"withSecrets",
"includes",
"or",
"excludes",
"secrets",
"from",
"return",
"results"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L912-L936 | train |
gravitational/teleport | lib/services/local/users.go | GetSAMLConnectors | func (s *IdentityService) GetSAMLConnectors(withSecrets bool) ([]services.SAMLConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.SAMLConnector, len(result.Items))
for i, item := range result.Items {
conn, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
keyPair := conn.GetSigningKeyPair()
if keyPair != nil {
keyPair.PrivateKey = ""
conn.SetSigningKeyPair(keyPair)
}
}
connectors[i] = conn
}
return connectors, nil
} | go | func (s *IdentityService) GetSAMLConnectors(withSecrets bool) ([]services.SAMLConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.SAMLConnector, len(result.Items))
for i, item := range result.Items {
conn, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
keyPair := conn.GetSigningKeyPair()
if keyPair != nil {
keyPair.PrivateKey = ""
conn.SetSigningKeyPair(keyPair)
}
}
connectors[i] = conn
}
return connectors, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSAMLConnectors",
"(",
"withSecrets",
"bool",
")",
"(",
"[",
"]",
"services",
".",
"SAMLConnector",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"connectorsPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"SAMLConnector",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"conn",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"UnmarshalSAMLConnector",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"keyPair",
":=",
"conn",
".",
"GetSigningKeyPair",
"(",
")",
"\n",
"if",
"keyPair",
"!=",
"nil",
"{",
"keyPair",
".",
"PrivateKey",
"=",
"\"\"",
"\n",
"conn",
".",
"SetSigningKeyPair",
"(",
"keyPair",
")",
"\n",
"}",
"\n",
"}",
"\n",
"connectors",
"[",
"i",
"]",
"=",
"conn",
"\n",
"}",
"\n",
"return",
"connectors",
",",
"nil",
"\n",
"}"
] | // GetSAMLConnectors returns registered connectors
// withSecrets includes or excludes private key values from return results | [
"GetSAMLConnectors",
"returns",
"registered",
"connectors",
"withSecrets",
"includes",
"or",
"excludes",
"private",
"key",
"values",
"from",
"return",
"results"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L940-L963 | train |
gravitational/teleport | lib/services/local/users.go | CreateSAMLAuthRequest | func (s *IdentityService) CreateSAMLAuthRequest(req services.SAMLAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, requestsPrefix, req.ID),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateSAMLAuthRequest(req services.SAMLAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, requestsPrefix, req.ID),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateSAMLAuthRequest",
"(",
"req",
"services",
".",
"SAMLAuthRequest",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"err",
":=",
"req",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"requestsPrefix",
",",
"req",
".",
"ID",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"backend",
".",
"Expiry",
"(",
"s",
".",
"Clock",
"(",
")",
",",
"ttl",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateSAMLAuthRequest creates new auth request | [
"CreateSAMLAuthRequest",
"creates",
"new",
"auth",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L966-L984 | train |
gravitational/teleport | lib/services/local/users.go | GetSAMLAuthRequest | func (s *IdentityService) GetSAMLAuthRequest(id string) (*services.SAMLAuthRequest, error) {
if id == "" {
return nil, trace.BadParameter("missing parameter id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, requestsPrefix, id))
if err != nil {
return nil, trace.Wrap(err)
}
var req services.SAMLAuthRequest
if err := json.Unmarshal(item.Value, &req); err != nil {
return nil, trace.Wrap(err)
}
return &req, nil
} | go | func (s *IdentityService) GetSAMLAuthRequest(id string) (*services.SAMLAuthRequest, error) {
if id == "" {
return nil, trace.BadParameter("missing parameter id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, requestsPrefix, id))
if err != nil {
return nil, trace.Wrap(err)
}
var req services.SAMLAuthRequest
if err := json.Unmarshal(item.Value, &req); err != nil {
return nil, trace.Wrap(err)
}
return &req, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSAMLAuthRequest",
"(",
"id",
"string",
")",
"(",
"*",
"services",
".",
"SAMLAuthRequest",
",",
"error",
")",
"{",
"if",
"id",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter id\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"requestsPrefix",
",",
"id",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"req",
"services",
".",
"SAMLAuthRequest",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"req",
",",
"nil",
"\n",
"}"
] | // GetSAMLAuthRequest returns SAML auth request if found | [
"GetSAMLAuthRequest",
"returns",
"SAML",
"auth",
"request",
"if",
"found"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L987-L1000 | train |
gravitational/teleport | lib/services/local/users.go | GetGithubConnector | func (s *IdentityService) GetGithubConnector(name string, withSecrets bool) (services.GithubConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("github connector %q is not configured", name)
}
return nil, trace.Wrap(err)
}
connector, err := services.GetGithubConnectorMarshaler().Unmarshal(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
connector.SetClientSecret("")
}
return connector, nil
} | go | func (s *IdentityService) GetGithubConnector(name string, withSecrets bool) (services.GithubConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("github connector %q is not configured", name)
}
return nil, trace.Wrap(err)
}
connector, err := services.GetGithubConnectorMarshaler().Unmarshal(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
connector.SetClientSecret("")
}
return connector, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetGithubConnector",
"(",
"name",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"GithubConnector",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"githubPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"github connector %q is not configured\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connector",
",",
"err",
":=",
"services",
".",
"GetGithubConnectorMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"connector",
".",
"SetClientSecret",
"(",
"\"\"",
")",
"\n",
"}",
"\n",
"return",
"connector",
",",
"nil",
"\n",
"}"
] | // GetGithubConnectot returns a particular Github connector | [
"GetGithubConnectot",
"returns",
"a",
"particular",
"Github",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L1067-L1086 | train |
gravitational/teleport | lib/services/local/users.go | DeleteGithubConnector | func (s *IdentityService) DeleteGithubConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
return trace.Wrap(s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name)))
} | go | func (s *IdentityService) DeleteGithubConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
return trace.Wrap(s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name)))
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteGithubConnector",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter name\"",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"githubPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
")",
"\n",
"}"
] | // DeleteGithubConnector deletes the specified connector | [
"DeleteGithubConnector",
"deletes",
"the",
"specified",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L1089-L1094 | train |
gravitational/teleport | lib/services/local/users.go | CreateGithubAuthRequest | func (s *IdentityService) CreateGithubAuthRequest(req services.GithubAuthRequest) error {
err := req.Check()
if err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: req.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateGithubAuthRequest(req services.GithubAuthRequest) error {
err := req.Check()
if err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: req.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateGithubAuthRequest",
"(",
"req",
"services",
".",
"GithubAuthRequest",
")",
"error",
"{",
"err",
":=",
"req",
".",
"Check",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"githubPrefix",
",",
"requestsPrefix",
",",
"req",
".",
"StateToken",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"req",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateGithubAuthRequest creates a new auth request for Github OAuth2 flow | [
"CreateGithubAuthRequest",
"creates",
"a",
"new",
"auth",
"request",
"for",
"Github",
"OAuth2",
"flow"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L1097-L1116 | train |
gravitational/teleport | lib/services/local/users.go | GetGithubAuthRequest | func (s *IdentityService) GetGithubAuthRequest(stateToken string) (*services.GithubAuthRequest, error) {
if stateToken == "" {
return nil, trace.BadParameter("missing parameter stateToken")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, stateToken))
if err != nil {
return nil, trace.Wrap(err)
}
var req services.GithubAuthRequest
err = json.Unmarshal(item.Value, &req)
if err != nil {
return nil, trace.Wrap(err)
}
return &req, nil
} | go | func (s *IdentityService) GetGithubAuthRequest(stateToken string) (*services.GithubAuthRequest, error) {
if stateToken == "" {
return nil, trace.BadParameter("missing parameter stateToken")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, stateToken))
if err != nil {
return nil, trace.Wrap(err)
}
var req services.GithubAuthRequest
err = json.Unmarshal(item.Value, &req)
if err != nil {
return nil, trace.Wrap(err)
}
return &req, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetGithubAuthRequest",
"(",
"stateToken",
"string",
")",
"(",
"*",
"services",
".",
"GithubAuthRequest",
",",
"error",
")",
"{",
"if",
"stateToken",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter stateToken\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"githubPrefix",
",",
"requestsPrefix",
",",
"stateToken",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"req",
"services",
".",
"GithubAuthRequest",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"req",
",",
"nil",
"\n",
"}"
] | // GetGithubAuthRequest retrieves Github auth request by the token | [
"GetGithubAuthRequest",
"retrieves",
"Github",
"auth",
"request",
"by",
"the",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L1119-L1133 | train |
gravitational/teleport | lib/services/server.go | ServersToV1 | func ServersToV1(in []Server) []ServerV1 {
out := make([]ServerV1, len(in))
for i := range in {
out[i] = *(in[i].V1())
}
return out
} | go | func ServersToV1(in []Server) []ServerV1 {
out := make([]ServerV1, len(in))
for i := range in {
out[i] = *(in[i].V1())
}
return out
} | [
"func",
"ServersToV1",
"(",
"in",
"[",
"]",
"Server",
")",
"[",
"]",
"ServerV1",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"ServerV1",
",",
"len",
"(",
"in",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"in",
"{",
"out",
"[",
"i",
"]",
"=",
"*",
"(",
"in",
"[",
"i",
"]",
".",
"V1",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // ServersToV1 converts list of servers to slice of V1 style ones | [
"ServersToV1",
"converts",
"list",
"of",
"servers",
"to",
"slice",
"of",
"V1",
"style",
"ones"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L81-L87 | train |
gravitational/teleport | lib/services/server.go | GetCmdLabels | func (s *ServerV2) GetCmdLabels() map[string]CommandLabel {
if s.Spec.CmdLabels == nil {
return nil
}
out := make(map[string]CommandLabel, len(s.Spec.CmdLabels))
for key := range s.Spec.CmdLabels {
val := s.Spec.CmdLabels[key]
out[key] = &val
}
return out
} | go | func (s *ServerV2) GetCmdLabels() map[string]CommandLabel {
if s.Spec.CmdLabels == nil {
return nil
}
out := make(map[string]CommandLabel, len(s.Spec.CmdLabels))
for key := range s.Spec.CmdLabels {
val := s.Spec.CmdLabels[key]
out[key] = &val
}
return out
} | [
"func",
"(",
"s",
"*",
"ServerV2",
")",
"GetCmdLabels",
"(",
")",
"map",
"[",
"string",
"]",
"CommandLabel",
"{",
"if",
"s",
".",
"Spec",
".",
"CmdLabels",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"CommandLabel",
",",
"len",
"(",
"s",
".",
"Spec",
".",
"CmdLabels",
")",
")",
"\n",
"for",
"key",
":=",
"range",
"s",
".",
"Spec",
".",
"CmdLabels",
"{",
"val",
":=",
"s",
".",
"Spec",
".",
"CmdLabels",
"[",
"key",
"]",
"\n",
"out",
"[",
"key",
"]",
"=",
"&",
"val",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // GetCmdLabels returns command labels | [
"GetCmdLabels",
"returns",
"command",
"labels"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L232-L242 | train |
gravitational/teleport | lib/services/server.go | MatchAgainst | func (s *ServerV2) MatchAgainst(labels map[string]string) bool {
if labels != nil {
myLabels := s.GetAllLabels()
for key, value := range labels {
if myLabels[key] != value {
return false
}
}
}
return true
} | go | func (s *ServerV2) MatchAgainst(labels map[string]string) bool {
if labels != nil {
myLabels := s.GetAllLabels()
for key, value := range labels {
if myLabels[key] != value {
return false
}
}
}
return true
} | [
"func",
"(",
"s",
"*",
"ServerV2",
")",
"MatchAgainst",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"bool",
"{",
"if",
"labels",
"!=",
"nil",
"{",
"myLabels",
":=",
"s",
".",
"GetAllLabels",
"(",
")",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"labels",
"{",
"if",
"myLabels",
"[",
"key",
"]",
"!=",
"value",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // MatchAgainst takes a map of labels and returns True if this server
// has ALL of them
//
// Any server matches against an empty label set | [
"MatchAgainst",
"takes",
"a",
"map",
"of",
"labels",
"and",
"returns",
"True",
"if",
"this",
"server",
"has",
"ALL",
"of",
"them",
"Any",
"server",
"matches",
"against",
"an",
"empty",
"label",
"set"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L270-L280 | train |
gravitational/teleport | lib/services/server.go | LabelsString | func (s *ServerV2) LabelsString() string {
labels := []string{}
for key, val := range s.Metadata.Labels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val))
}
for key, val := range s.Spec.CmdLabels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val.Result))
}
sort.Strings(labels)
return strings.Join(labels, ",")
} | go | func (s *ServerV2) LabelsString() string {
labels := []string{}
for key, val := range s.Metadata.Labels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val))
}
for key, val := range s.Spec.CmdLabels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val.Result))
}
sort.Strings(labels)
return strings.Join(labels, ",")
} | [
"func",
"(",
"s",
"*",
"ServerV2",
")",
"LabelsString",
"(",
")",
"string",
"{",
"labels",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"key",
",",
"val",
":=",
"range",
"s",
".",
"Metadata",
".",
"Labels",
"{",
"labels",
"=",
"append",
"(",
"labels",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%s=%s\"",
",",
"key",
",",
"val",
")",
")",
"\n",
"}",
"\n",
"for",
"key",
",",
"val",
":=",
"range",
"s",
".",
"Spec",
".",
"CmdLabels",
"{",
"labels",
"=",
"append",
"(",
"labels",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%s=%s\"",
",",
"key",
",",
"val",
".",
"Result",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"labels",
")",
"\n",
"return",
"strings",
".",
"Join",
"(",
"labels",
",",
"\",\"",
")",
"\n",
"}"
] | // LabelsString returns a comma separated string with all node's labels | [
"LabelsString",
"returns",
"a",
"comma",
"separated",
"string",
"with",
"all",
"node",
"s",
"labels"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L283-L293 | train |
gravitational/teleport | lib/services/server.go | CmdLabelMapsEqual | func CmdLabelMapsEqual(a, b map[string]CommandLabel) bool {
if len(a) != len(b) {
return false
}
for key, val := range a {
val2, ok := b[key]
if !ok {
return false
}
if !val.Equals(val2) {
return false
}
}
return true
} | go | func CmdLabelMapsEqual(a, b map[string]CommandLabel) bool {
if len(a) != len(b) {
return false
}
for key, val := range a {
val2, ok := b[key]
if !ok {
return false
}
if !val.Equals(val2) {
return false
}
}
return true
} | [
"func",
"CmdLabelMapsEqual",
"(",
"a",
",",
"b",
"map",
"[",
"string",
"]",
"CommandLabel",
")",
"bool",
"{",
"if",
"len",
"(",
"a",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"key",
",",
"val",
":=",
"range",
"a",
"{",
"val2",
",",
"ok",
":=",
"b",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"val",
".",
"Equals",
"(",
"val2",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // CmdLabelMapsEqual compares two maps with command labels,
// returns true if label sets are equal | [
"CmdLabelMapsEqual",
"compares",
"two",
"maps",
"with",
"command",
"labels",
"returns",
"true",
"if",
"label",
"sets",
"are",
"equal"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L353-L367 | train |
gravitational/teleport | lib/services/server.go | LabelsToV2 | func LabelsToV2(labels map[string]CommandLabel) map[string]CommandLabelV2 {
out := make(map[string]CommandLabelV2, len(labels))
for key, val := range labels {
out[key] = CommandLabelV2{
Period: NewDuration(val.GetPeriod()),
Result: val.GetResult(),
Command: val.GetCommand(),
}
}
return out
} | go | func LabelsToV2(labels map[string]CommandLabel) map[string]CommandLabelV2 {
out := make(map[string]CommandLabelV2, len(labels))
for key, val := range labels {
out[key] = CommandLabelV2{
Period: NewDuration(val.GetPeriod()),
Result: val.GetResult(),
Command: val.GetCommand(),
}
}
return out
} | [
"func",
"LabelsToV2",
"(",
"labels",
"map",
"[",
"string",
"]",
"CommandLabel",
")",
"map",
"[",
"string",
"]",
"CommandLabelV2",
"{",
"out",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"CommandLabelV2",
",",
"len",
"(",
"labels",
")",
")",
"\n",
"for",
"key",
",",
"val",
":=",
"range",
"labels",
"{",
"out",
"[",
"key",
"]",
"=",
"CommandLabelV2",
"{",
"Period",
":",
"NewDuration",
"(",
"val",
".",
"GetPeriod",
"(",
")",
")",
",",
"Result",
":",
"val",
".",
"GetResult",
"(",
")",
",",
"Command",
":",
"val",
".",
"GetCommand",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // LabelsToV2 converts labels from interface to V2 spec | [
"LabelsToV2",
"converts",
"labels",
"from",
"interface",
"to",
"V2",
"spec"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L449-L459 | train |
gravitational/teleport | lib/services/server.go | Equals | func (c *CommandLabelV2) Equals(other CommandLabel) bool {
if c.GetPeriod() != other.GetPeriod() {
return false
}
if c.GetResult() != other.GetResult() {
return false
}
if !utils.StringSlicesEqual(c.GetCommand(), other.GetCommand()) {
return false
}
return true
} | go | func (c *CommandLabelV2) Equals(other CommandLabel) bool {
if c.GetPeriod() != other.GetPeriod() {
return false
}
if c.GetResult() != other.GetResult() {
return false
}
if !utils.StringSlicesEqual(c.GetCommand(), other.GetCommand()) {
return false
}
return true
} | [
"func",
"(",
"c",
"*",
"CommandLabelV2",
")",
"Equals",
"(",
"other",
"CommandLabel",
")",
"bool",
"{",
"if",
"c",
".",
"GetPeriod",
"(",
")",
"!=",
"other",
".",
"GetPeriod",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"GetResult",
"(",
")",
"!=",
"other",
".",
"GetResult",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"utils",
".",
"StringSlicesEqual",
"(",
"c",
".",
"GetCommand",
"(",
")",
",",
"other",
".",
"GetCommand",
"(",
")",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Equals returns true if labels are equal, false otherwise | [
"Equals",
"returns",
"true",
"if",
"labels",
"are",
"equal",
"false",
"otherwise"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L482-L493 | train |
gravitational/teleport | lib/services/server.go | Clone | func (c *CommandLabelV2) Clone() CommandLabel {
command := make([]string, len(c.Command))
copy(command, c.Command)
return &CommandLabelV2{
Command: command,
Period: c.Period,
Result: c.Result,
}
} | go | func (c *CommandLabelV2) Clone() CommandLabel {
command := make([]string, len(c.Command))
copy(command, c.Command)
return &CommandLabelV2{
Command: command,
Period: c.Period,
Result: c.Result,
}
} | [
"func",
"(",
"c",
"*",
"CommandLabelV2",
")",
"Clone",
"(",
")",
"CommandLabel",
"{",
"command",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"c",
".",
"Command",
")",
")",
"\n",
"copy",
"(",
"command",
",",
"c",
".",
"Command",
")",
"\n",
"return",
"&",
"CommandLabelV2",
"{",
"Command",
":",
"command",
",",
"Period",
":",
"c",
".",
"Period",
",",
"Result",
":",
"c",
".",
"Result",
",",
"}",
"\n",
"}"
] | // Clone returns non-shallow copy of the label | [
"Clone",
"returns",
"non",
"-",
"shallow",
"copy",
"of",
"the",
"label"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L496-L504 | train |
gravitational/teleport | lib/services/server.go | SetPeriod | func (c *CommandLabelV2) SetPeriod(p time.Duration) {
c.Period = Duration(p)
} | go | func (c *CommandLabelV2) SetPeriod(p time.Duration) {
c.Period = Duration(p)
} | [
"func",
"(",
"c",
"*",
"CommandLabelV2",
")",
"SetPeriod",
"(",
"p",
"time",
".",
"Duration",
")",
"{",
"c",
".",
"Period",
"=",
"Duration",
"(",
"p",
")",
"\n",
"}"
] | // SetPeriod sets label period | [
"SetPeriod",
"sets",
"label",
"period"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L512-L514 | train |
gravitational/teleport | lib/services/server.go | Clone | func (c *CommandLabels) Clone() CommandLabels {
out := make(CommandLabels, len(*c))
for name, label := range *c {
out[name] = label.Clone()
}
return out
} | go | func (c *CommandLabels) Clone() CommandLabels {
out := make(CommandLabels, len(*c))
for name, label := range *c {
out[name] = label.Clone()
}
return out
} | [
"func",
"(",
"c",
"*",
"CommandLabels",
")",
"Clone",
"(",
")",
"CommandLabels",
"{",
"out",
":=",
"make",
"(",
"CommandLabels",
",",
"len",
"(",
"*",
"c",
")",
")",
"\n",
"for",
"name",
",",
"label",
":=",
"range",
"*",
"c",
"{",
"out",
"[",
"name",
"]",
"=",
"label",
".",
"Clone",
"(",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // Clone returns copy of the set | [
"Clone",
"returns",
"copy",
"of",
"the",
"set"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L546-L552 | train |
gravitational/teleport | lib/services/server.go | SetEnv | func (c *CommandLabels) SetEnv(v string) error {
if err := json.Unmarshal([]byte(v), c); err != nil {
return trace.Wrap(err, "can not parse Command Labels")
}
return nil
} | go | func (c *CommandLabels) SetEnv(v string) error {
if err := json.Unmarshal([]byte(v), c); err != nil {
return trace.Wrap(err, "can not parse Command Labels")
}
return nil
} | [
"func",
"(",
"c",
"*",
"CommandLabels",
")",
"SetEnv",
"(",
"v",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"v",
")",
",",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"can not parse Command Labels\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetEnv sets the value of the label from environment variable | [
"SetEnv",
"sets",
"the",
"value",
"of",
"the",
"label",
"from",
"environment",
"variable"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L555-L560 | train |
gravitational/teleport | lib/services/server.go | GetServerSchema | func GetServerSchema() string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(ServerSpecV2Schema, RotationSchema), DefaultDefinitions)
} | go | func GetServerSchema() string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(ServerSpecV2Schema, RotationSchema), DefaultDefinitions)
} | [
"func",
"GetServerSchema",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"fmt",
".",
"Sprintf",
"(",
"ServerSpecV2Schema",
",",
"RotationSchema",
")",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] | // GetServerSchema returns role schema with optionally injected
// schema for extensions | [
"GetServerSchema",
"returns",
"role",
"schema",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L564-L566 | train |
gravitational/teleport | lib/services/server.go | UnmarshalServerResource | func UnmarshalServerResource(data []byte, kind string, cfg *MarshalConfig) (Server, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing server data")
}
var h ResourceHeader
err := utils.FastUnmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var s ServerV1
err := utils.FastUnmarshal(data, &s)
if err != nil {
return nil, trace.Wrap(err)
}
s.Kind = kind
v2 := s.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
v2.SetExpiry(cfg.Expires)
}
return v2, nil
case V2:
var s ServerV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &s); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetServerSchema(), &s, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
s.Kind = kind
if err := s.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
s.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
s.SetExpiry(cfg.Expires)
}
return &s, nil
}
return nil, trace.BadParameter("server resource version %q is not supported", h.Version)
} | go | func UnmarshalServerResource(data []byte, kind string, cfg *MarshalConfig) (Server, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing server data")
}
var h ResourceHeader
err := utils.FastUnmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var s ServerV1
err := utils.FastUnmarshal(data, &s)
if err != nil {
return nil, trace.Wrap(err)
}
s.Kind = kind
v2 := s.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
v2.SetExpiry(cfg.Expires)
}
return v2, nil
case V2:
var s ServerV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &s); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetServerSchema(), &s, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
s.Kind = kind
if err := s.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
s.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
s.SetExpiry(cfg.Expires)
}
return &s, nil
}
return nil, trace.BadParameter("server resource version %q is not supported", h.Version)
} | [
"func",
"UnmarshalServerResource",
"(",
"data",
"[",
"]",
"byte",
",",
"kind",
"string",
",",
"cfg",
"*",
"MarshalConfig",
")",
"(",
"Server",
",",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing server data\"",
")",
"\n",
"}",
"\n",
"var",
"h",
"ResourceHeader",
"\n",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"s",
"ServerV1",
"\n",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"Kind",
"=",
"kind",
"\n",
"v2",
":=",
"s",
".",
"V2",
"(",
")",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"v2",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"v2",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"v2",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"s",
"ServerV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"s",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetServerSchema",
"(",
")",
",",
"&",
"s",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"s",
".",
"Kind",
"=",
"kind",
"\n",
"if",
"err",
":=",
"s",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"s",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"s",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"s",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"server resource version %q is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalServerResource unmarshals role from JSON or YAML,
// sets defaults and checks the schema | [
"UnmarshalServerResource",
"unmarshals",
"role",
"from",
"JSON",
"or",
"YAML",
"sets",
"defaults",
"and",
"checks",
"the",
"schema"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L570-L622 | train |
gravitational/teleport | lib/services/server.go | UnmarshalServer | func (*TeleportServerMarshaler) UnmarshalServer(bytes []byte, kind string, opts ...MarshalOption) (Server, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
return UnmarshalServerResource(bytes, kind, cfg)
} | go | func (*TeleportServerMarshaler) UnmarshalServer(bytes []byte, kind string, opts ...MarshalOption) (Server, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
return UnmarshalServerResource(bytes, kind, cfg)
} | [
"func",
"(",
"*",
"TeleportServerMarshaler",
")",
"UnmarshalServer",
"(",
"bytes",
"[",
"]",
"byte",
",",
"kind",
"string",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"Server",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"UnmarshalServerResource",
"(",
"bytes",
",",
"kind",
",",
"cfg",
")",
"\n",
"}"
] | // UnmarshalServer unmarshals server from JSON | [
"UnmarshalServer",
"unmarshals",
"server",
"from",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L659-L666 | train |
gravitational/teleport | lib/services/server.go | MarshalServer | func (*TeleportServerMarshaler) MarshalServer(s Server, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type serverv1 interface {
V1() *ServerV1
}
type serverv2 interface {
V2() *ServerV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := s.(serverv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return utils.FastMarshal(v.V1())
case V2:
v, ok := s.(serverv2)
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 (*TeleportServerMarshaler) MarshalServer(s Server, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type serverv1 interface {
V1() *ServerV1
}
type serverv2 interface {
V2() *ServerV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := s.(serverv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return utils.FastMarshal(v.V1())
case V2:
v, ok := s.(serverv2)
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",
"(",
"*",
"TeleportServerMarshaler",
")",
"MarshalServer",
"(",
"s",
"Server",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"serverv1",
"interface",
"{",
"V1",
"(",
")",
"*",
"ServerV1",
"\n",
"}",
"\n",
"type",
"serverv2",
"interface",
"{",
"V2",
"(",
")",
"*",
"ServerV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"s",
".",
"(",
"serverv1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"s",
".",
"(",
"serverv2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"version %v is not supported\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] | // MarshalServer marshals server into JSON. | [
"MarshalServer",
"marshals",
"server",
"into",
"JSON",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L669-L705 | train |
gravitational/teleport | lib/services/server.go | UnmarshalServers | func (*TeleportServerMarshaler) UnmarshalServers(bytes []byte) ([]Server, error) {
var servers []ServerV2
err := utils.FastUnmarshal(bytes, &servers)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]Server, len(servers))
for i, v := range servers {
out[i] = Server(&v)
}
return out, nil
} | go | func (*TeleportServerMarshaler) UnmarshalServers(bytes []byte) ([]Server, error) {
var servers []ServerV2
err := utils.FastUnmarshal(bytes, &servers)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]Server, len(servers))
for i, v := range servers {
out[i] = Server(&v)
}
return out, nil
} | [
"func",
"(",
"*",
"TeleportServerMarshaler",
")",
"UnmarshalServers",
"(",
"bytes",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"Server",
",",
"error",
")",
"{",
"var",
"servers",
"[",
"]",
"ServerV2",
"\n",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"servers",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"Server",
",",
"len",
"(",
"servers",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"servers",
"{",
"out",
"[",
"i",
"]",
"=",
"Server",
"(",
"&",
"v",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // UnmarshalServers is used to unmarshal multiple servers from their
// binary representation. | [
"UnmarshalServers",
"is",
"used",
"to",
"unmarshal",
"multiple",
"servers",
"from",
"their",
"binary",
"representation",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L709-L722 | train |
gravitational/teleport | lib/services/server.go | MarshalServers | func (*TeleportServerMarshaler) MarshalServers(s []Server) ([]byte, error) {
bytes, err := utils.FastMarshal(s)
if err != nil {
return nil, trace.Wrap(err)
}
return bytes, nil
} | go | func (*TeleportServerMarshaler) MarshalServers(s []Server) ([]byte, error) {
bytes, err := utils.FastMarshal(s)
if err != nil {
return nil, trace.Wrap(err)
}
return bytes, nil
} | [
"func",
"(",
"*",
"TeleportServerMarshaler",
")",
"MarshalServers",
"(",
"s",
"[",
"]",
"Server",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"bytes",
",",
"err",
":=",
"utils",
".",
"FastMarshal",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"bytes",
",",
"nil",
"\n",
"}"
] | // MarshalServers is used to marshal multiple servers to their binary
// representation. | [
"MarshalServers",
"is",
"used",
"to",
"marshal",
"multiple",
"servers",
"to",
"their",
"binary",
"representation",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/server.go#L726-L733 | train |
gravitational/teleport | lib/web/ui/cluster.go | NewAvailableClusters | func NewAvailableClusters(currentClusterName string, remoteClusters []reversetunnel.RemoteSite) *AvailableClusters {
out := AvailableClusters{}
for _, item := range remoteClusters {
cluster := Cluster{
Name: item.GetName(),
LastConnected: item.GetLastConnected(),
Status: item.GetStatus(),
}
if item.GetName() == currentClusterName {
out.Current = cluster
} else {
out.Trusted = append(out.Trusted, cluster)
}
}
sort.Slice(out.Trusted, func(i, j int) bool {
return out.Trusted[i].Name < out.Trusted[j].Name
})
return &out
} | go | func NewAvailableClusters(currentClusterName string, remoteClusters []reversetunnel.RemoteSite) *AvailableClusters {
out := AvailableClusters{}
for _, item := range remoteClusters {
cluster := Cluster{
Name: item.GetName(),
LastConnected: item.GetLastConnected(),
Status: item.GetStatus(),
}
if item.GetName() == currentClusterName {
out.Current = cluster
} else {
out.Trusted = append(out.Trusted, cluster)
}
}
sort.Slice(out.Trusted, func(i, j int) bool {
return out.Trusted[i].Name < out.Trusted[j].Name
})
return &out
} | [
"func",
"NewAvailableClusters",
"(",
"currentClusterName",
"string",
",",
"remoteClusters",
"[",
"]",
"reversetunnel",
".",
"RemoteSite",
")",
"*",
"AvailableClusters",
"{",
"out",
":=",
"AvailableClusters",
"{",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"remoteClusters",
"{",
"cluster",
":=",
"Cluster",
"{",
"Name",
":",
"item",
".",
"GetName",
"(",
")",
",",
"LastConnected",
":",
"item",
".",
"GetLastConnected",
"(",
")",
",",
"Status",
":",
"item",
".",
"GetStatus",
"(",
")",
",",
"}",
"\n",
"if",
"item",
".",
"GetName",
"(",
")",
"==",
"currentClusterName",
"{",
"out",
".",
"Current",
"=",
"cluster",
"\n",
"}",
"else",
"{",
"out",
".",
"Trusted",
"=",
"append",
"(",
"out",
".",
"Trusted",
",",
"cluster",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sort",
".",
"Slice",
"(",
"out",
".",
"Trusted",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"out",
".",
"Trusted",
"[",
"i",
"]",
".",
"Name",
"<",
"out",
".",
"Trusted",
"[",
"j",
"]",
".",
"Name",
"\n",
"}",
")",
"\n",
"return",
"&",
"out",
"\n",
"}"
] | // NewAvailableClusters returns all available clusters | [
"NewAvailableClusters",
"returns",
"all",
"available",
"clusters"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/ui/cluster.go#L45-L66 | train |
gravitational/teleport | lib/backend/legacy/import.go | Import | func Import(ctx context.Context, importer Importer, newExporter NewExporterFunc) error {
log := logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentMigrate),
})
err := func() error {
imported, err := importer.Imported(ctx)
if err != nil {
return trace.Wrap(err)
}
if imported {
log.Debugf("Detected legacy backend, data has already been imported.")
return nil
}
log.Infof("Importing data from legacy backend.")
exporter, err := newExporter()
if err != nil {
return trace.Wrap(err)
}
defer exporter.Close()
items, err := exporter.Export()
if err != nil {
return trace.Wrap(err)
}
if err := importer.Import(ctx, items); err != nil {
return trace.Wrap(err)
}
log.Infof("Successfully imported %v items.", len(items))
return nil
}()
if err != nil {
if err := importer.Close(); err != nil {
log.Errorf("Failed to close backend: %v.", err)
}
}
return trace.Wrap(err)
} | go | func Import(ctx context.Context, importer Importer, newExporter NewExporterFunc) error {
log := logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentMigrate),
})
err := func() error {
imported, err := importer.Imported(ctx)
if err != nil {
return trace.Wrap(err)
}
if imported {
log.Debugf("Detected legacy backend, data has already been imported.")
return nil
}
log.Infof("Importing data from legacy backend.")
exporter, err := newExporter()
if err != nil {
return trace.Wrap(err)
}
defer exporter.Close()
items, err := exporter.Export()
if err != nil {
return trace.Wrap(err)
}
if err := importer.Import(ctx, items); err != nil {
return trace.Wrap(err)
}
log.Infof("Successfully imported %v items.", len(items))
return nil
}()
if err != nil {
if err := importer.Close(); err != nil {
log.Errorf("Failed to close backend: %v.", err)
}
}
return trace.Wrap(err)
} | [
"func",
"Import",
"(",
"ctx",
"context",
".",
"Context",
",",
"importer",
"Importer",
",",
"newExporter",
"NewExporterFunc",
")",
"error",
"{",
"log",
":=",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentMigrate",
")",
",",
"}",
")",
"\n",
"err",
":=",
"func",
"(",
")",
"error",
"{",
"imported",
",",
"err",
":=",
"importer",
".",
"Imported",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"imported",
"{",
"log",
".",
"Debugf",
"(",
"\"Detected legacy backend, data has already been imported.\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"Importing data from legacy backend.\"",
")",
"\n",
"exporter",
",",
"err",
":=",
"newExporter",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"exporter",
".",
"Close",
"(",
")",
"\n",
"items",
",",
"err",
":=",
"exporter",
".",
"Export",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"importer",
".",
"Import",
"(",
"ctx",
",",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"Successfully imported %v items.\"",
",",
"len",
"(",
"items",
")",
")",
"\n",
"return",
"nil",
"\n",
"}",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
":=",
"importer",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to close backend: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // Import imports backend data into importer unless importer has already
// imported data. If Importer has no imported data yet, exporter will
// not be initialized. This function can be called many times on the
// same importer. Importer will be closed if import has failed. | [
"Import",
"imports",
"backend",
"data",
"into",
"importer",
"unless",
"importer",
"has",
"already",
"imported",
"data",
".",
"If",
"Importer",
"has",
"no",
"imported",
"data",
"yet",
"exporter",
"will",
"not",
"be",
"initialized",
".",
"This",
"function",
"can",
"be",
"called",
"many",
"times",
"on",
"the",
"same",
"importer",
".",
"Importer",
"will",
"be",
"closed",
"if",
"import",
"has",
"failed",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/import.go#L39-L74 | train |
gravitational/teleport | lib/service/info.go | writeDebugInfo | func writeDebugInfo(w io.Writer) {
fmt.Fprintf(w, "Runtime stats\n")
runtimeStats(w)
fmt.Fprintf(w, "Memory stats\n")
memStats(w)
fmt.Fprintf(w, "Goroutines\n")
goroutineDump(w)
} | go | func writeDebugInfo(w io.Writer) {
fmt.Fprintf(w, "Runtime stats\n")
runtimeStats(w)
fmt.Fprintf(w, "Memory stats\n")
memStats(w)
fmt.Fprintf(w, "Goroutines\n")
goroutineDump(w)
} | [
"func",
"writeDebugInfo",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"Runtime stats\\n\"",
")",
"\n",
"\\n",
"\n",
"runtimeStats",
"(",
"w",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"Memory stats\\n\"",
")",
"\n",
"\\n",
"\n",
"memStats",
"(",
"w",
")",
"\n",
"}"
] | // writeDebugInfo writes debugging information
// about this process | [
"writeDebugInfo",
"writes",
"debugging",
"information",
"about",
"this",
"process"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/info.go#L33-L42 | train |
gravitational/teleport | lib/multiplexer/wrappers.go | Read | func (c *Conn) Read(p []byte) (int, error) {
return c.reader.Read(p)
} | go | func (c *Conn) Read(p []byte) (int, error) {
return c.reader.Read(p)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"c",
".",
"reader",
".",
"Read",
"(",
"p",
")",
"\n",
"}"
] | // Read reads from connection | [
"Read",
"reads",
"from",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/wrappers.go#L39-L41 | train |
gravitational/teleport | lib/multiplexer/wrappers.go | LocalAddr | func (c *Conn) LocalAddr() net.Addr {
if c.proxyLine != nil {
return &c.proxyLine.Destination
}
return c.Conn.LocalAddr()
} | go | func (c *Conn) LocalAddr() net.Addr {
if c.proxyLine != nil {
return &c.proxyLine.Destination
}
return c.Conn.LocalAddr()
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"LocalAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"if",
"c",
".",
"proxyLine",
"!=",
"nil",
"{",
"return",
"&",
"c",
".",
"proxyLine",
".",
"Destination",
"\n",
"}",
"\n",
"return",
"c",
".",
"Conn",
".",
"LocalAddr",
"(",
")",
"\n",
"}"
] | // LocalAddr returns local address of the connection | [
"LocalAddr",
"returns",
"local",
"address",
"of",
"the",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/wrappers.go#L44-L49 | train |
gravitational/teleport | lib/multiplexer/wrappers.go | RemoteAddr | func (c *Conn) RemoteAddr() net.Addr {
if c.proxyLine != nil {
return &c.proxyLine.Source
}
return c.Conn.RemoteAddr()
} | go | func (c *Conn) RemoteAddr() net.Addr {
if c.proxyLine != nil {
return &c.proxyLine.Source
}
return c.Conn.RemoteAddr()
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"RemoteAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"if",
"c",
".",
"proxyLine",
"!=",
"nil",
"{",
"return",
"&",
"c",
".",
"proxyLine",
".",
"Source",
"\n",
"}",
"\n",
"return",
"c",
".",
"Conn",
".",
"RemoteAddr",
"(",
")",
"\n",
"}"
] | // RemoteAddr returns remote address of the connection | [
"RemoteAddr",
"returns",
"remote",
"address",
"of",
"the",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/wrappers.go#L52-L57 | train |
gravitational/teleport | lib/multiplexer/wrappers.go | Accept | func (l *Listener) Accept() (net.Conn, error) {
select {
case <-l.context.Done():
return nil, trace.ConnectionProblem(nil, "listener is closed")
case conn := <-l.connC:
if conn == nil {
return nil, trace.ConnectionProblem(nil, "listener is closed")
}
return conn, nil
}
} | go | func (l *Listener) Accept() (net.Conn, error) {
select {
case <-l.context.Done():
return nil, trace.ConnectionProblem(nil, "listener is closed")
case conn := <-l.connC:
if conn == nil {
return nil, trace.ConnectionProblem(nil, "listener is closed")
}
return conn, nil
}
} | [
"func",
"(",
"l",
"*",
"Listener",
")",
"Accept",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"select",
"{",
"case",
"<-",
"l",
".",
"context",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"listener is closed\"",
")",
"\n",
"case",
"conn",
":=",
"<-",
"l",
".",
"connC",
":",
"if",
"conn",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"listener is closed\"",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Accept accepts connections from parent multiplexer listener | [
"Accept",
"accepts",
"connections",
"from",
"parent",
"multiplexer",
"listener"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/wrappers.go#L84-L94 | train |
gravitational/teleport | lib/services/identity.go | Equals | func (i *ExternalIdentity) Equals(other *ExternalIdentity) bool {
return i.ConnectorID == other.ConnectorID && i.Username == other.Username
} | go | func (i *ExternalIdentity) Equals(other *ExternalIdentity) bool {
return i.ConnectorID == other.ConnectorID && i.Username == other.Username
} | [
"func",
"(",
"i",
"*",
"ExternalIdentity",
")",
"Equals",
"(",
"other",
"*",
"ExternalIdentity",
")",
"bool",
"{",
"return",
"i",
".",
"ConnectorID",
"==",
"other",
".",
"ConnectorID",
"&&",
"i",
".",
"Username",
"==",
"other",
".",
"Username",
"\n",
"}"
] | // Equals returns true if this identity equals to passed one | [
"Equals",
"returns",
"true",
"if",
"this",
"identity",
"equals",
"to",
"passed",
"one"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/identity.go#L257-L259 | train |
gravitational/teleport | lib/services/identity.go | Check | func (r *GithubAuthRequest) Check() error {
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
if r.StateToken == "" {
return trace.BadParameter("missing StateToken")
}
if len(r.PublicKey) != 0 {
_, _, _, _, err := ssh.ParseAuthorizedKey(r.PublicKey)
if err != nil {
return trace.BadParameter("bad PublicKey: %v", err)
}
if (r.CertTTL > defaults.MaxCertDuration) || (r.CertTTL < defaults.MinCertDuration) {
return trace.BadParameter("wrong CertTTL")
}
}
return nil
} | go | func (r *GithubAuthRequest) Check() error {
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
if r.StateToken == "" {
return trace.BadParameter("missing StateToken")
}
if len(r.PublicKey) != 0 {
_, _, _, _, err := ssh.ParseAuthorizedKey(r.PublicKey)
if err != nil {
return trace.BadParameter("bad PublicKey: %v", err)
}
if (r.CertTTL > defaults.MaxCertDuration) || (r.CertTTL < defaults.MinCertDuration) {
return trace.BadParameter("wrong CertTTL")
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"GithubAuthRequest",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"r",
".",
"ConnectorID",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing ConnectorID\"",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"StateToken",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing StateToken\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"r",
".",
"PublicKey",
")",
"!=",
"0",
"{",
"_",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"r",
".",
"PublicKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"bad PublicKey: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"(",
"r",
".",
"CertTTL",
">",
"defaults",
".",
"MaxCertDuration",
")",
"||",
"(",
"r",
".",
"CertTTL",
"<",
"defaults",
".",
"MinCertDuration",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"wrong CertTTL\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check makes sure the request is valid | [
"Check",
"makes",
"sure",
"the",
"request",
"is",
"valid"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/identity.go#L320-L337 | train |
gravitational/teleport | lib/services/identity.go | Swap | func (s SortedLoginAttempts) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | func (s SortedLoginAttempts) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | [
"func",
"(",
"s",
"SortedLoginAttempts",
")",
"Swap",
"(",
"i",
",",
"j",
"int",
")",
"{",
"s",
"[",
"i",
"]",
",",
"s",
"[",
"j",
"]",
"=",
"s",
"[",
"j",
"]",
",",
"s",
"[",
"i",
"]",
"\n",
"}"
] | // Swap swaps two attempts | [
"Swap",
"swaps",
"two",
"attempts"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/identity.go#L491-L493 | train |
gravitational/teleport | lib/services/identity.go | LastFailed | func LastFailed(x int, attempts []LoginAttempt) bool {
var failed int
for i := len(attempts) - 1; i >= 0; i-- {
if !attempts[i].Success {
failed++
} else {
return false
}
if failed >= x {
return true
}
}
return false
} | go | func LastFailed(x int, attempts []LoginAttempt) bool {
var failed int
for i := len(attempts) - 1; i >= 0; i-- {
if !attempts[i].Success {
failed++
} else {
return false
}
if failed >= x {
return true
}
}
return false
} | [
"func",
"LastFailed",
"(",
"x",
"int",
",",
"attempts",
"[",
"]",
"LoginAttempt",
")",
"bool",
"{",
"var",
"failed",
"int",
"\n",
"for",
"i",
":=",
"len",
"(",
"attempts",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"if",
"!",
"attempts",
"[",
"i",
"]",
".",
"Success",
"{",
"failed",
"++",
"\n",
"}",
"else",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"failed",
">=",
"x",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // LastFailed calculates last x successive attempts are failed | [
"LastFailed",
"calculates",
"last",
"x",
"successive",
"attempts",
"are",
"failed"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/identity.go#L496-L509 | train |
gravitational/teleport | lib/web/terminal.go | NewTerminal | func NewTerminal(req TerminalRequest, authProvider AuthProvider, ctx *SessionContext) (*TerminalHandler, error) {
// Make sure whatever session is requested is a valid session.
_, err := session.ParseID(string(req.SessionID))
if err != nil {
return nil, trace.BadParameter("sid: invalid session id")
}
if req.Login == "" {
return nil, trace.BadParameter("login: missing login")
}
if req.Term.W <= 0 || req.Term.H <= 0 {
return nil, trace.BadParameter("term: bad term dimensions")
}
servers, err := authProvider.GetNodes(req.Namespace, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
hostName, hostPort, err := resolveServerHostPort(req.Server, servers)
if err != nil {
return nil, trace.BadParameter("invalid server name %q: %v", req.Server, err)
}
return &TerminalHandler{
log: logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentWebsocket,
}),
params: req,
ctx: ctx,
hostName: hostName,
hostPort: hostPort,
authProvider: authProvider,
encoder: unicode.UTF8.NewEncoder(),
decoder: unicode.UTF8.NewDecoder(),
}, nil
} | go | func NewTerminal(req TerminalRequest, authProvider AuthProvider, ctx *SessionContext) (*TerminalHandler, error) {
// Make sure whatever session is requested is a valid session.
_, err := session.ParseID(string(req.SessionID))
if err != nil {
return nil, trace.BadParameter("sid: invalid session id")
}
if req.Login == "" {
return nil, trace.BadParameter("login: missing login")
}
if req.Term.W <= 0 || req.Term.H <= 0 {
return nil, trace.BadParameter("term: bad term dimensions")
}
servers, err := authProvider.GetNodes(req.Namespace, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
hostName, hostPort, err := resolveServerHostPort(req.Server, servers)
if err != nil {
return nil, trace.BadParameter("invalid server name %q: %v", req.Server, err)
}
return &TerminalHandler{
log: logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentWebsocket,
}),
params: req,
ctx: ctx,
hostName: hostName,
hostPort: hostPort,
authProvider: authProvider,
encoder: unicode.UTF8.NewEncoder(),
decoder: unicode.UTF8.NewDecoder(),
}, nil
} | [
"func",
"NewTerminal",
"(",
"req",
"TerminalRequest",
",",
"authProvider",
"AuthProvider",
",",
"ctx",
"*",
"SessionContext",
")",
"(",
"*",
"TerminalHandler",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"session",
".",
"ParseID",
"(",
"string",
"(",
"req",
".",
"SessionID",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"sid: invalid session id\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Login",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"login: missing login\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"Term",
".",
"W",
"<=",
"0",
"||",
"req",
".",
"Term",
".",
"H",
"<=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"term: bad term dimensions\"",
")",
"\n",
"}",
"\n",
"servers",
",",
"err",
":=",
"authProvider",
".",
"GetNodes",
"(",
"req",
".",
"Namespace",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"hostName",
",",
"hostPort",
",",
"err",
":=",
"resolveServerHostPort",
"(",
"req",
".",
"Server",
",",
"servers",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid server name %q: %v\"",
",",
"req",
".",
"Server",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"TerminalHandler",
"{",
"log",
":",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentWebsocket",
",",
"}",
")",
",",
"params",
":",
"req",
",",
"ctx",
":",
"ctx",
",",
"hostName",
":",
"hostName",
",",
"hostPort",
":",
"hostPort",
",",
"authProvider",
":",
"authProvider",
",",
"encoder",
":",
"unicode",
".",
"UTF8",
".",
"NewEncoder",
"(",
")",
",",
"decoder",
":",
"unicode",
".",
"UTF8",
".",
"NewDecoder",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewTerminal creates a web-based terminal based on WebSockets and returns a
// new TerminalHandler. | [
"NewTerminal",
"creates",
"a",
"web",
"-",
"based",
"terminal",
"based",
"on",
"WebSockets",
"and",
"returns",
"a",
"new",
"TerminalHandler",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L84-L121 | train |
gravitational/teleport | lib/web/terminal.go | Close | func (t *TerminalHandler) Close() error {
// Close the websocket connection to the client web browser.
if t.ws != nil {
t.ws.Close()
}
// Close the SSH connection to the remote node.
if t.sshSession != nil {
t.sshSession.Close()
}
// If the terminal handler was closed (most likely due to the *SessionContext
// closing) then the stream should be closed as well.
t.terminalCancel()
return nil
} | go | func (t *TerminalHandler) Close() error {
// Close the websocket connection to the client web browser.
if t.ws != nil {
t.ws.Close()
}
// Close the SSH connection to the remote node.
if t.sshSession != nil {
t.sshSession.Close()
}
// If the terminal handler was closed (most likely due to the *SessionContext
// closing) then the stream should be closed as well.
t.terminalCancel()
return nil
} | [
"func",
"(",
"t",
"*",
"TerminalHandler",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"t",
".",
"ws",
"!=",
"nil",
"{",
"t",
".",
"ws",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"sshSession",
"!=",
"nil",
"{",
"t",
".",
"sshSession",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"t",
".",
"terminalCancel",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close the websocket stream. | [
"Close",
"the",
"websocket",
"stream",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L191-L207 | train |
gravitational/teleport | lib/web/terminal.go | handler | func (t *TerminalHandler) handler(ws *websocket.Conn) {
// Create a Teleport client, if not able to, show the reason to the user in
// the terminal.
tc, err := t.makeClient(ws)
if err != nil {
er := t.writeError(err, ws)
if er != nil {
t.log.Warnf("Unable to send error to terminal: %v: %v.", err, er)
}
return
}
// Create a context for signaling when the terminal session is over.
t.terminalContext, t.terminalCancel = context.WithCancel(context.Background())
t.log.Debugf("Creating websocket stream for %v.", t.params.SessionID)
// Pump raw terminal in/out and audit events into the websocket.
go t.streamTerminal(ws, tc)
go t.streamEvents(ws, tc)
// Block until the terminal session is complete.
<-t.terminalContext.Done()
t.log.Debugf("Closing websocket stream for %v.", t.params.SessionID)
} | go | func (t *TerminalHandler) handler(ws *websocket.Conn) {
// Create a Teleport client, if not able to, show the reason to the user in
// the terminal.
tc, err := t.makeClient(ws)
if err != nil {
er := t.writeError(err, ws)
if er != nil {
t.log.Warnf("Unable to send error to terminal: %v: %v.", err, er)
}
return
}
// Create a context for signaling when the terminal session is over.
t.terminalContext, t.terminalCancel = context.WithCancel(context.Background())
t.log.Debugf("Creating websocket stream for %v.", t.params.SessionID)
// Pump raw terminal in/out and audit events into the websocket.
go t.streamTerminal(ws, tc)
go t.streamEvents(ws, tc)
// Block until the terminal session is complete.
<-t.terminalContext.Done()
t.log.Debugf("Closing websocket stream for %v.", t.params.SessionID)
} | [
"func",
"(",
"t",
"*",
"TerminalHandler",
")",
"handler",
"(",
"ws",
"*",
"websocket",
".",
"Conn",
")",
"{",
"tc",
",",
"err",
":=",
"t",
".",
"makeClient",
"(",
"ws",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"er",
":=",
"t",
".",
"writeError",
"(",
"err",
",",
"ws",
")",
"\n",
"if",
"er",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to send error to terminal: %v: %v.\"",
",",
"err",
",",
"er",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"t",
".",
"terminalContext",
",",
"t",
".",
"terminalCancel",
"=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Creating websocket stream for %v.\"",
",",
"t",
".",
"params",
".",
"SessionID",
")",
"\n",
"go",
"t",
".",
"streamTerminal",
"(",
"ws",
",",
"tc",
")",
"\n",
"go",
"t",
".",
"streamEvents",
"(",
"ws",
",",
"tc",
")",
"\n",
"<-",
"t",
".",
"terminalContext",
".",
"Done",
"(",
")",
"\n",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Closing websocket stream for %v.\"",
",",
"t",
".",
"params",
".",
"SessionID",
")",
"\n",
"}"
] | // handler is the main websocket loop. It creates a Teleport client and then
// pumps raw events and audit events back to the client until the SSH session
// is complete. | [
"handler",
"is",
"the",
"main",
"websocket",
"loop",
".",
"It",
"creates",
"a",
"Teleport",
"client",
"and",
"then",
"pumps",
"raw",
"events",
"and",
"audit",
"events",
"back",
"to",
"the",
"client",
"until",
"the",
"SSH",
"session",
"is",
"complete",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L212-L236 | train |
gravitational/teleport | lib/web/terminal.go | streamTerminal | func (t *TerminalHandler) streamTerminal(ws *websocket.Conn, tc *client.TeleportClient) {
defer t.terminalCancel()
// Establish SSH connection to the server. This function will block until
// either an error occurs or it completes successfully.
err := tc.SSH(t.terminalContext, t.params.InteractiveCommand, false)
if err != nil {
t.log.Warnf("Unable to stream terminal: %v.", err)
er := t.writeError(err, ws)
if er != nil {
t.log.Warnf("Unable to send error to terminal: %v: %v.", err, er)
}
return
}
// Send close envelope to web terminal upon exit without an error.
envelope := &Envelope{
Version: defaults.WebsocketVersion,
Type: defaults.WebsocketClose,
Payload: "",
}
envelopeBytes, err := proto.Marshal(envelope)
if err != nil {
t.log.Errorf("Unable to marshal close event for web client.")
return
}
err = websocket.Message.Send(ws, envelopeBytes)
if err != nil {
t.log.Errorf("Unable to send close event to web client.")
return
}
t.log.Debugf("Sent close event to web client.")
} | go | func (t *TerminalHandler) streamTerminal(ws *websocket.Conn, tc *client.TeleportClient) {
defer t.terminalCancel()
// Establish SSH connection to the server. This function will block until
// either an error occurs or it completes successfully.
err := tc.SSH(t.terminalContext, t.params.InteractiveCommand, false)
if err != nil {
t.log.Warnf("Unable to stream terminal: %v.", err)
er := t.writeError(err, ws)
if er != nil {
t.log.Warnf("Unable to send error to terminal: %v: %v.", err, er)
}
return
}
// Send close envelope to web terminal upon exit without an error.
envelope := &Envelope{
Version: defaults.WebsocketVersion,
Type: defaults.WebsocketClose,
Payload: "",
}
envelopeBytes, err := proto.Marshal(envelope)
if err != nil {
t.log.Errorf("Unable to marshal close event for web client.")
return
}
err = websocket.Message.Send(ws, envelopeBytes)
if err != nil {
t.log.Errorf("Unable to send close event to web client.")
return
}
t.log.Debugf("Sent close event to web client.")
} | [
"func",
"(",
"t",
"*",
"TerminalHandler",
")",
"streamTerminal",
"(",
"ws",
"*",
"websocket",
".",
"Conn",
",",
"tc",
"*",
"client",
".",
"TeleportClient",
")",
"{",
"defer",
"t",
".",
"terminalCancel",
"(",
")",
"\n",
"err",
":=",
"tc",
".",
"SSH",
"(",
"t",
".",
"terminalContext",
",",
"t",
".",
"params",
".",
"InteractiveCommand",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to stream terminal: %v.\"",
",",
"err",
")",
"\n",
"er",
":=",
"t",
".",
"writeError",
"(",
"err",
",",
"ws",
")",
"\n",
"if",
"er",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to send error to terminal: %v: %v.\"",
",",
"err",
",",
"er",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"envelope",
":=",
"&",
"Envelope",
"{",
"Version",
":",
"defaults",
".",
"WebsocketVersion",
",",
"Type",
":",
"defaults",
".",
"WebsocketClose",
",",
"Payload",
":",
"\"\"",
",",
"}",
"\n",
"envelopeBytes",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"envelope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Errorf",
"(",
"\"Unable to marshal close event for web client.\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"err",
"=",
"websocket",
".",
"Message",
".",
"Send",
"(",
"ws",
",",
"envelopeBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Errorf",
"(",
"\"Unable to send close event to web client.\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Sent close event to web client.\"",
")",
"\n",
"}"
] | // streamTerminal opens a SSH connection to the remote host and streams
// events back to the web client. | [
"streamTerminal",
"opens",
"a",
"SSH",
"connection",
"to",
"the",
"remote",
"host",
"and",
"streams",
"events",
"back",
"to",
"the",
"web",
"client",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L288-L320 | train |
gravitational/teleport | lib/web/terminal.go | streamEvents | func (t *TerminalHandler) streamEvents(ws *websocket.Conn, tc *client.TeleportClient) {
for {
select {
// Send push events that come over the events channel to the web client.
case event := <-tc.EventsChannel():
data, err := json.Marshal(event)
if err != nil {
t.log.Errorf("Unable to marshal audit event %v: %v.", event.GetType(), err)
continue
}
t.log.Debugf("Sending audit event %v to web client.", event.GetType())
// UTF-8 encode the error message and then wrap it in a raw envelope.
encodedPayload, err := t.encoder.String(string(data))
if err != nil {
t.log.Debugf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
envelope := &Envelope{
Version: defaults.WebsocketVersion,
Type: defaults.WebsocketAudit,
Payload: encodedPayload,
}
envelopeBytes, err := proto.Marshal(envelope)
if err != nil {
t.log.Debugf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
// Send bytes over the websocket to the web client.
err = websocket.Message.Send(ws, envelopeBytes)
if err != nil {
t.log.Errorf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
// Once the terminal stream is over (and the close envelope has been sent),
// close stop streaming envelopes.
case <-t.terminalContext.Done():
return
}
}
} | go | func (t *TerminalHandler) streamEvents(ws *websocket.Conn, tc *client.TeleportClient) {
for {
select {
// Send push events that come over the events channel to the web client.
case event := <-tc.EventsChannel():
data, err := json.Marshal(event)
if err != nil {
t.log.Errorf("Unable to marshal audit event %v: %v.", event.GetType(), err)
continue
}
t.log.Debugf("Sending audit event %v to web client.", event.GetType())
// UTF-8 encode the error message and then wrap it in a raw envelope.
encodedPayload, err := t.encoder.String(string(data))
if err != nil {
t.log.Debugf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
envelope := &Envelope{
Version: defaults.WebsocketVersion,
Type: defaults.WebsocketAudit,
Payload: encodedPayload,
}
envelopeBytes, err := proto.Marshal(envelope)
if err != nil {
t.log.Debugf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
// Send bytes over the websocket to the web client.
err = websocket.Message.Send(ws, envelopeBytes)
if err != nil {
t.log.Errorf("Unable to send audit event %v to web client: %v.", event.GetType(), err)
continue
}
// Once the terminal stream is over (and the close envelope has been sent),
// close stop streaming envelopes.
case <-t.terminalContext.Done():
return
}
}
} | [
"func",
"(",
"t",
"*",
"TerminalHandler",
")",
"streamEvents",
"(",
"ws",
"*",
"websocket",
".",
"Conn",
",",
"tc",
"*",
"client",
".",
"TeleportClient",
")",
"{",
"for",
"{",
"select",
"{",
"case",
"event",
":=",
"<-",
"tc",
".",
"EventsChannel",
"(",
")",
":",
"data",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"event",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Errorf",
"(",
"\"Unable to marshal audit event %v: %v.\"",
",",
"event",
".",
"GetType",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Sending audit event %v to web client.\"",
",",
"event",
".",
"GetType",
"(",
")",
")",
"\n",
"encodedPayload",
",",
"err",
":=",
"t",
".",
"encoder",
".",
"String",
"(",
"string",
"(",
"data",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Unable to send audit event %v to web client: %v.\"",
",",
"event",
".",
"GetType",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"envelope",
":=",
"&",
"Envelope",
"{",
"Version",
":",
"defaults",
".",
"WebsocketVersion",
",",
"Type",
":",
"defaults",
".",
"WebsocketAudit",
",",
"Payload",
":",
"encodedPayload",
",",
"}",
"\n",
"envelopeBytes",
",",
"err",
":=",
"proto",
".",
"Marshal",
"(",
"envelope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Unable to send audit event %v to web client: %v.\"",
",",
"event",
".",
"GetType",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"websocket",
".",
"Message",
".",
"Send",
"(",
"ws",
",",
"envelopeBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Errorf",
"(",
"\"Unable to send audit event %v to web client: %v.\"",
",",
"event",
".",
"GetType",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"case",
"<-",
"t",
".",
"terminalContext",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // streamEvents receives events over the SSH connection and forwards them to
// the web client. | [
"streamEvents",
"receives",
"events",
"over",
"the",
"SSH",
"connection",
"and",
"forwards",
"them",
"to",
"the",
"web",
"client",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L324-L366 | train |
gravitational/teleport | lib/web/terminal.go | windowChange | func (t *TerminalHandler) windowChange(params *session.TerminalParams) error {
if t.sshSession == nil {
return nil
}
_, err := t.sshSession.SendRequest(
sshutils.WindowChangeRequest,
false,
ssh.Marshal(sshutils.WinChangeReqParams{
W: uint32(params.W),
H: uint32(params.H),
}))
if err != nil {
t.log.Error(err)
}
return trace.Wrap(err)
} | go | func (t *TerminalHandler) windowChange(params *session.TerminalParams) error {
if t.sshSession == nil {
return nil
}
_, err := t.sshSession.SendRequest(
sshutils.WindowChangeRequest,
false,
ssh.Marshal(sshutils.WinChangeReqParams{
W: uint32(params.W),
H: uint32(params.H),
}))
if err != nil {
t.log.Error(err)
}
return trace.Wrap(err)
} | [
"func",
"(",
"t",
"*",
"TerminalHandler",
")",
"windowChange",
"(",
"params",
"*",
"session",
".",
"TerminalParams",
")",
"error",
"{",
"if",
"t",
".",
"sshSession",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"t",
".",
"sshSession",
".",
"SendRequest",
"(",
"sshutils",
".",
"WindowChangeRequest",
",",
"false",
",",
"ssh",
".",
"Marshal",
"(",
"sshutils",
".",
"WinChangeReqParams",
"{",
"W",
":",
"uint32",
"(",
"params",
".",
"W",
")",
",",
"H",
":",
"uint32",
"(",
"params",
".",
"H",
")",
",",
"}",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // windowChange is called when the browser window is resized. It sends a
// "window-change" channel request to the server. | [
"windowChange",
"is",
"called",
"when",
"the",
"browser",
"window",
"is",
"resized",
".",
"It",
"sends",
"a",
"window",
"-",
"change",
"channel",
"request",
"to",
"the",
"server",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L370-L387 | train |
gravitational/teleport | lib/web/terminal.go | writeError | func (t *TerminalHandler) writeError(err error, ws *websocket.Conn) error {
// Replace \n with \r\n so the message correctly aligned.
r := strings.NewReplacer("\r\n", "\r\n", "\n", "\r\n")
errMessage := r.Replace(err.Error())
_, err = t.write([]byte(errMessage), ws)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (t *TerminalHandler) writeError(err error, ws *websocket.Conn) error {
// Replace \n with \r\n so the message correctly aligned.
r := strings.NewReplacer("\r\n", "\r\n", "\n", "\r\n")
errMessage := r.Replace(err.Error())
_, err = t.write([]byte(errMessage), ws)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"t",
"*",
"TerminalHandler",
")",
"writeError",
"(",
"err",
"error",
",",
"ws",
"*",
"websocket",
".",
"Conn",
")",
"error",
"{",
"r",
":=",
"strings",
".",
"NewReplacer",
"(",
"\"\\r\\n\"",
",",
"\\r",
",",
"\\n",
",",
"\"\\r\\n\"",
")",
"\n",
"\\r",
"\n",
"\\n",
"\n",
"\"\\n\"",
"\n",
"\\n",
"\n",
"}"
] | // writeError displays an error in the terminal window. | [
"writeError",
"displays",
"an",
"error",
"in",
"the",
"terminal",
"window",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L390-L400 | train |
gravitational/teleport | lib/web/terminal.go | resolveServerHostPort | func resolveServerHostPort(servername string, existingServers []services.Server) (string, int, error) {
// If port is 0, client wants us to figure out which port to use.
var defaultPort = 0
if servername == "" {
return "", defaultPort, trace.BadParameter("empty server name")
}
// Check if servername is UUID.
for i := range existingServers {
node := existingServers[i]
if node.GetName() == servername {
return node.GetHostname(), defaultPort, nil
}
}
if !strings.Contains(servername, ":") {
return servername, defaultPort, nil
}
// Check for explicitly specified port.
host, portString, err := utils.SplitHostPort(servername)
if err != nil {
return "", defaultPort, trace.Wrap(err)
}
port, err := strconv.Atoi(portString)
if err != nil {
return "", defaultPort, trace.BadParameter("invalid port: %v", err)
}
return host, port, nil
} | go | func resolveServerHostPort(servername string, existingServers []services.Server) (string, int, error) {
// If port is 0, client wants us to figure out which port to use.
var defaultPort = 0
if servername == "" {
return "", defaultPort, trace.BadParameter("empty server name")
}
// Check if servername is UUID.
for i := range existingServers {
node := existingServers[i]
if node.GetName() == servername {
return node.GetHostname(), defaultPort, nil
}
}
if !strings.Contains(servername, ":") {
return servername, defaultPort, nil
}
// Check for explicitly specified port.
host, portString, err := utils.SplitHostPort(servername)
if err != nil {
return "", defaultPort, trace.Wrap(err)
}
port, err := strconv.Atoi(portString)
if err != nil {
return "", defaultPort, trace.BadParameter("invalid port: %v", err)
}
return host, port, nil
} | [
"func",
"resolveServerHostPort",
"(",
"servername",
"string",
",",
"existingServers",
"[",
"]",
"services",
".",
"Server",
")",
"(",
"string",
",",
"int",
",",
"error",
")",
"{",
"var",
"defaultPort",
"=",
"0",
"\n",
"if",
"servername",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"defaultPort",
",",
"trace",
".",
"BadParameter",
"(",
"\"empty server name\"",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"existingServers",
"{",
"node",
":=",
"existingServers",
"[",
"i",
"]",
"\n",
"if",
"node",
".",
"GetName",
"(",
")",
"==",
"servername",
"{",
"return",
"node",
".",
"GetHostname",
"(",
")",
",",
"defaultPort",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"servername",
",",
"\":\"",
")",
"{",
"return",
"servername",
",",
"defaultPort",
",",
"nil",
"\n",
"}",
"\n",
"host",
",",
"portString",
",",
"err",
":=",
"utils",
".",
"SplitHostPort",
"(",
"servername",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"defaultPort",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"port",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"portString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"defaultPort",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid port: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"host",
",",
"port",
",",
"nil",
"\n",
"}"
] | // resolveServerHostPort parses server name and attempts to resolve hostname
// and port. | [
"resolveServerHostPort",
"parses",
"server",
"name",
"and",
"attempts",
"to",
"resolve",
"hostname",
"and",
"port",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L404-L436 | train |
gravitational/teleport | lib/web/terminal.go | Write | func (w *terminalStream) Write(data []byte) (n int, err error) {
return w.terminal.write(data, w.ws)
} | go | func (w *terminalStream) Write(data []byte) (n int, err error) {
return w.terminal.write(data, w.ws)
} | [
"func",
"(",
"w",
"*",
"terminalStream",
")",
"Write",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"return",
"w",
".",
"terminal",
".",
"write",
"(",
"data",
",",
"w",
".",
"ws",
")",
"\n",
"}"
] | // Write wraps the data bytes in a raw envelope and sends. | [
"Write",
"wraps",
"the",
"data",
"bytes",
"in",
"a",
"raw",
"envelope",
"and",
"sends",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L544-L546 | train |
gravitational/teleport | lib/web/terminal.go | SetReadDeadline | func (w *terminalStream) SetReadDeadline(t time.Time) error {
return w.ws.SetReadDeadline(t)
} | go | func (w *terminalStream) SetReadDeadline(t time.Time) error {
return w.ws.SetReadDeadline(t)
} | [
"func",
"(",
"w",
"*",
"terminalStream",
")",
"SetReadDeadline",
"(",
"t",
"time",
".",
"Time",
")",
"error",
"{",
"return",
"w",
".",
"ws",
".",
"SetReadDeadline",
"(",
"t",
")",
"\n",
"}"
] | // SetReadDeadline sets the network read deadline on the underlying websocket. | [
"SetReadDeadline",
"sets",
"the",
"network",
"read",
"deadline",
"on",
"the",
"underlying",
"websocket",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/terminal.go#L555-L557 | train |
gravitational/teleport | lib/kube/proxy/forwarder.go | NewForwarder | func NewForwarder(cfg ForwarderConfig) (*Forwarder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
creds, err := getKubeCreds(cfg.KubeconfigPath)
if err != nil {
return nil, trace.Wrap(err)
}
clusterSessions, err := ttlmap.New(defaults.ClientCacheSize)
if err != nil {
return nil, trace.Wrap(err)
}
closeCtx, close := context.WithCancel(cfg.Context)
fwd := &Forwarder{
creds: *creds,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component(teleport.ComponentKube),
}),
Router: *httprouter.New(),
ForwarderConfig: cfg,
clusterSessions: clusterSessions,
activeRequests: make(map[string]context.Context),
ctx: closeCtx,
close: close,
}
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/exec", fwd.withAuth(fwd.exec))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/exec", fwd.withAuth(fwd.exec))
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/attach", fwd.withAuth(fwd.exec))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/attach", fwd.withAuth(fwd.exec))
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/portforward", fwd.withAuth(fwd.portForward))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/portforward", fwd.withAuth(fwd.portForward))
fwd.NotFound = fwd.withAuthStd(fwd.catchAll)
if cfg.ClusterOverride != "" {
fwd.Debugf("Cluster override is set, forwarder will send all requests to remote cluster %v.", cfg.ClusterOverride)
}
return fwd, nil
} | go | func NewForwarder(cfg ForwarderConfig) (*Forwarder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
creds, err := getKubeCreds(cfg.KubeconfigPath)
if err != nil {
return nil, trace.Wrap(err)
}
clusterSessions, err := ttlmap.New(defaults.ClientCacheSize)
if err != nil {
return nil, trace.Wrap(err)
}
closeCtx, close := context.WithCancel(cfg.Context)
fwd := &Forwarder{
creds: *creds,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component(teleport.ComponentKube),
}),
Router: *httprouter.New(),
ForwarderConfig: cfg,
clusterSessions: clusterSessions,
activeRequests: make(map[string]context.Context),
ctx: closeCtx,
close: close,
}
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/exec", fwd.withAuth(fwd.exec))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/exec", fwd.withAuth(fwd.exec))
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/attach", fwd.withAuth(fwd.exec))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/attach", fwd.withAuth(fwd.exec))
fwd.POST("/api/:ver/namespaces/:podNamespace/pods/:podName/portforward", fwd.withAuth(fwd.portForward))
fwd.GET("/api/:ver/namespaces/:podNamespace/pods/:podName/portforward", fwd.withAuth(fwd.portForward))
fwd.NotFound = fwd.withAuthStd(fwd.catchAll)
if cfg.ClusterOverride != "" {
fwd.Debugf("Cluster override is set, forwarder will send all requests to remote cluster %v.", cfg.ClusterOverride)
}
return fwd, nil
} | [
"func",
"NewForwarder",
"(",
"cfg",
"ForwarderConfig",
")",
"(",
"*",
"Forwarder",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"creds",
",",
"err",
":=",
"getKubeCreds",
"(",
"cfg",
".",
"KubeconfigPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"clusterSessions",
",",
"err",
":=",
"ttlmap",
".",
"New",
"(",
"defaults",
".",
"ClientCacheSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"closeCtx",
",",
"close",
":=",
"context",
".",
"WithCancel",
"(",
"cfg",
".",
"Context",
")",
"\n",
"fwd",
":=",
"&",
"Forwarder",
"{",
"creds",
":",
"*",
"creds",
",",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentKube",
")",
",",
"}",
")",
",",
"Router",
":",
"*",
"httprouter",
".",
"New",
"(",
")",
",",
"ForwarderConfig",
":",
"cfg",
",",
"clusterSessions",
":",
"clusterSessions",
",",
"activeRequests",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"context",
".",
"Context",
")",
",",
"ctx",
":",
"closeCtx",
",",
"close",
":",
"close",
",",
"}",
"\n",
"fwd",
".",
"POST",
"(",
"\"/api/:ver/namespaces/:podNamespace/pods/:podName/exec\"",
",",
"fwd",
".",
"withAuth",
"(",
"fwd",
".",
"exec",
")",
")",
"\n",
"fwd",
".",
"GET",
"(",
"\"/api/:ver/namespaces/:podNamespace/pods/:podName/exec\"",
",",
"fwd",
".",
"withAuth",
"(",
"fwd",
".",
"exec",
")",
")",
"\n",
"fwd",
".",
"POST",
"(",
"\"/api/:ver/namespaces/:podNamespace/pods/:podName/attach\"",
",",
"fwd",
".",
"withAuth",
"(",
"fwd",
".",
"exec",
")",
")",
"\n",
"fwd",
".",
"GET",
"(",
"\"/api/:ver/namespaces/:podNamespace/pods/:podName/attach\"",
",",
"fwd",
".",
"withAuth",
"(",
"fwd",
".",
"exec",
")",
")",
"\n",
"fwd",
".",
"POST",
"(",
"\"/api/:ver/namespaces/:podNamespace/pods/:podName/portforward\"",
",",
"fwd",
".",
"withAuth",
"(",
"fwd",
".",
"portForward",
")",
")",
"\n",
"fwd",
".",
"GET",
"(",
"\"/api/:ver/namespaces/:podNamespace/pods/:podName/portforward\"",
",",
"fwd",
".",
"withAuth",
"(",
"fwd",
".",
"portForward",
")",
")",
"\n",
"fwd",
".",
"NotFound",
"=",
"fwd",
".",
"withAuthStd",
"(",
"fwd",
".",
"catchAll",
")",
"\n",
"if",
"cfg",
".",
"ClusterOverride",
"!=",
"\"\"",
"{",
"fwd",
".",
"Debugf",
"(",
"\"Cluster override is set, forwarder will send all requests to remote cluster %v.\"",
",",
"cfg",
".",
"ClusterOverride",
")",
"\n",
"}",
"\n",
"return",
"fwd",
",",
"nil",
"\n",
"}"
] | // NewForwarder returns new instance of Kubernetes request
// forwarding proxy. | [
"NewForwarder",
"returns",
"new",
"instance",
"of",
"Kubernetes",
"request",
"forwarding",
"proxy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/proxy/forwarder.go#L144-L187 | train |
gravitational/teleport | lib/kube/proxy/forwarder.go | authenticate | func (f *Forwarder) authenticate(req *http.Request) (*authContext, error) {
const accessDeniedMsg = "[00] access denied"
var isRemoteUser bool
userTypeI := req.Context().Value(auth.ContextUser)
switch userTypeI.(type) {
case auth.LocalUser:
case auth.RemoteUser:
isRemoteUser = true
default:
f.Warningf("Denying proxy access to unsupported user type: %T.", userTypeI)
return nil, trace.AccessDenied(accessDeniedMsg)
}
userContext, err := f.Auth.Authorize(req.Context())
if err != nil {
switch {
// propagate connection problem error so we can differentiate
// between connection failed and access denied
case trace.IsConnectionProblem(err):
return nil, trace.ConnectionProblem(err, "[07] failed to connect to the database")
case trace.IsAccessDenied(err):
// don't print stack trace, just log the warning
f.Warn(err)
return nil, trace.AccessDenied(accessDeniedMsg)
default:
f.Warn(trace.DebugReport(err))
return nil, trace.AccessDenied(accessDeniedMsg)
}
}
peers := req.TLS.PeerCertificates
if len(peers) > 1 {
// when turning intermediaries on, don't forget to verify
// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59
return nil, trace.AccessDenied("access denied: intermediaries are not supported")
}
if len(peers) == 0 {
return nil, trace.AccessDenied("access denied: only mutual TLS authentication is supported")
}
clientCert := peers[0]
authContext, err := f.setupContext(*userContext, req, isRemoteUser, clientCert.NotAfter)
if err != nil {
f.Warn(err.Error())
return nil, trace.AccessDenied(accessDeniedMsg)
}
return authContext, nil
} | go | func (f *Forwarder) authenticate(req *http.Request) (*authContext, error) {
const accessDeniedMsg = "[00] access denied"
var isRemoteUser bool
userTypeI := req.Context().Value(auth.ContextUser)
switch userTypeI.(type) {
case auth.LocalUser:
case auth.RemoteUser:
isRemoteUser = true
default:
f.Warningf("Denying proxy access to unsupported user type: %T.", userTypeI)
return nil, trace.AccessDenied(accessDeniedMsg)
}
userContext, err := f.Auth.Authorize(req.Context())
if err != nil {
switch {
// propagate connection problem error so we can differentiate
// between connection failed and access denied
case trace.IsConnectionProblem(err):
return nil, trace.ConnectionProblem(err, "[07] failed to connect to the database")
case trace.IsAccessDenied(err):
// don't print stack trace, just log the warning
f.Warn(err)
return nil, trace.AccessDenied(accessDeniedMsg)
default:
f.Warn(trace.DebugReport(err))
return nil, trace.AccessDenied(accessDeniedMsg)
}
}
peers := req.TLS.PeerCertificates
if len(peers) > 1 {
// when turning intermediaries on, don't forget to verify
// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59
return nil, trace.AccessDenied("access denied: intermediaries are not supported")
}
if len(peers) == 0 {
return nil, trace.AccessDenied("access denied: only mutual TLS authentication is supported")
}
clientCert := peers[0]
authContext, err := f.setupContext(*userContext, req, isRemoteUser, clientCert.NotAfter)
if err != nil {
f.Warn(err.Error())
return nil, trace.AccessDenied(accessDeniedMsg)
}
return authContext, nil
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"authenticate",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"authContext",
",",
"error",
")",
"{",
"const",
"accessDeniedMsg",
"=",
"\"[00] access denied\"",
"\n",
"var",
"isRemoteUser",
"bool",
"\n",
"userTypeI",
":=",
"req",
".",
"Context",
"(",
")",
".",
"Value",
"(",
"auth",
".",
"ContextUser",
")",
"\n",
"switch",
"userTypeI",
".",
"(",
"type",
")",
"{",
"case",
"auth",
".",
"LocalUser",
":",
"case",
"auth",
".",
"RemoteUser",
":",
"isRemoteUser",
"=",
"true",
"\n",
"default",
":",
"f",
".",
"Warningf",
"(",
"\"Denying proxy access to unsupported user type: %T.\"",
",",
"userTypeI",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"accessDeniedMsg",
")",
"\n",
"}",
"\n",
"userContext",
",",
"err",
":=",
"f",
".",
"Auth",
".",
"Authorize",
"(",
"req",
".",
"Context",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"switch",
"{",
"case",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
":",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"err",
",",
"\"[07] failed to connect to the database\"",
")",
"\n",
"case",
"trace",
".",
"IsAccessDenied",
"(",
"err",
")",
":",
"f",
".",
"Warn",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"accessDeniedMsg",
")",
"\n",
"default",
":",
"f",
".",
"Warn",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"accessDeniedMsg",
")",
"\n",
"}",
"\n",
"}",
"\n",
"peers",
":=",
"req",
".",
"TLS",
".",
"PeerCertificates",
"\n",
"if",
"len",
"(",
"peers",
")",
">",
"1",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"access denied: intermediaries are not supported\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"peers",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"access denied: only mutual TLS authentication is supported\"",
")",
"\n",
"}",
"\n",
"clientCert",
":=",
"peers",
"[",
"0",
"]",
"\n",
"authContext",
",",
"err",
":=",
"f",
".",
"setupContext",
"(",
"*",
"userContext",
",",
"req",
",",
"isRemoteUser",
",",
"clientCert",
".",
"NotAfter",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"f",
".",
"Warn",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"accessDeniedMsg",
")",
"\n",
"}",
"\n",
"return",
"authContext",
",",
"nil",
"\n",
"}"
] | // authenticate function authenticates request | [
"authenticate",
"function",
"authenticates",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/proxy/forwarder.go#L274-L321 | train |
gravitational/teleport | lib/kube/proxy/forwarder.go | portForward | func (f *Forwarder) portForward(ctx *authContext, w http.ResponseWriter, req *http.Request, p httprouter.Params) (interface{}, error) {
f.Debugf("Port forward: %v. req headers: %v", req.URL.String(), req.Header)
sess, err := f.getOrCreateClusterSession(*ctx)
if err != nil {
return nil, trace.Wrap(err)
}
if err := f.setupForwardingHeaders(ctx, sess, req); err != nil {
f.Debugf("DENIED Port forward: %v.", req.URL.String())
return nil, trace.Wrap(err)
}
dialer, err := f.getDialer(*ctx, sess, req)
if err != nil {
return nil, trace.Wrap(err)
}
onPortForward := func(addr string, success bool) {
event := events.PortForward
if !success {
event = events.PortForwardFailure
}
f.AuditLog.EmitAuditEvent(event, events.EventFields{
events.EventProtocol: events.EventProtocolKube,
events.PortForwardAddr: addr,
events.PortForwardSuccess: success,
events.EventLogin: ctx.User.GetName(),
events.EventUser: ctx.User.GetName(),
events.LocalAddr: sess.cluster.targetAddr,
events.RemoteAddr: req.RemoteAddr,
})
}
q := req.URL.Query()
request := portForwardRequest{
podNamespace: p.ByName("podNamespace"),
podName: p.ByName("podName"),
ports: q["ports"],
context: req.Context(),
httpRequest: req,
httpResponseWriter: w,
onPortForward: onPortForward,
targetDialer: dialer,
}
f.Debugf("Starting %v.", request)
err = runPortForwarding(request)
if err != nil {
return nil, trace.Wrap(err)
}
f.Debugf("Done %v.", request)
return nil, nil
} | go | func (f *Forwarder) portForward(ctx *authContext, w http.ResponseWriter, req *http.Request, p httprouter.Params) (interface{}, error) {
f.Debugf("Port forward: %v. req headers: %v", req.URL.String(), req.Header)
sess, err := f.getOrCreateClusterSession(*ctx)
if err != nil {
return nil, trace.Wrap(err)
}
if err := f.setupForwardingHeaders(ctx, sess, req); err != nil {
f.Debugf("DENIED Port forward: %v.", req.URL.String())
return nil, trace.Wrap(err)
}
dialer, err := f.getDialer(*ctx, sess, req)
if err != nil {
return nil, trace.Wrap(err)
}
onPortForward := func(addr string, success bool) {
event := events.PortForward
if !success {
event = events.PortForwardFailure
}
f.AuditLog.EmitAuditEvent(event, events.EventFields{
events.EventProtocol: events.EventProtocolKube,
events.PortForwardAddr: addr,
events.PortForwardSuccess: success,
events.EventLogin: ctx.User.GetName(),
events.EventUser: ctx.User.GetName(),
events.LocalAddr: sess.cluster.targetAddr,
events.RemoteAddr: req.RemoteAddr,
})
}
q := req.URL.Query()
request := portForwardRequest{
podNamespace: p.ByName("podNamespace"),
podName: p.ByName("podName"),
ports: q["ports"],
context: req.Context(),
httpRequest: req,
httpResponseWriter: w,
onPortForward: onPortForward,
targetDialer: dialer,
}
f.Debugf("Starting %v.", request)
err = runPortForwarding(request)
if err != nil {
return nil, trace.Wrap(err)
}
f.Debugf("Done %v.", request)
return nil, nil
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"portForward",
"(",
"ctx",
"*",
"authContext",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"f",
".",
"Debugf",
"(",
"\"Port forward: %v. req headers: %v\"",
",",
"req",
".",
"URL",
".",
"String",
"(",
")",
",",
"req",
".",
"Header",
")",
"\n",
"sess",
",",
"err",
":=",
"f",
".",
"getOrCreateClusterSession",
"(",
"*",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"setupForwardingHeaders",
"(",
"ctx",
",",
"sess",
",",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"f",
".",
"Debugf",
"(",
"\"DENIED Port forward: %v.\"",
",",
"req",
".",
"URL",
".",
"String",
"(",
")",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"dialer",
",",
"err",
":=",
"f",
".",
"getDialer",
"(",
"*",
"ctx",
",",
"sess",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"onPortForward",
":=",
"func",
"(",
"addr",
"string",
",",
"success",
"bool",
")",
"{",
"event",
":=",
"events",
".",
"PortForward",
"\n",
"if",
"!",
"success",
"{",
"event",
"=",
"events",
".",
"PortForwardFailure",
"\n",
"}",
"\n",
"f",
".",
"AuditLog",
".",
"EmitAuditEvent",
"(",
"event",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventProtocol",
":",
"events",
".",
"EventProtocolKube",
",",
"events",
".",
"PortForwardAddr",
":",
"addr",
",",
"events",
".",
"PortForwardSuccess",
":",
"success",
",",
"events",
".",
"EventLogin",
":",
"ctx",
".",
"User",
".",
"GetName",
"(",
")",
",",
"events",
".",
"EventUser",
":",
"ctx",
".",
"User",
".",
"GetName",
"(",
")",
",",
"events",
".",
"LocalAddr",
":",
"sess",
".",
"cluster",
".",
"targetAddr",
",",
"events",
".",
"RemoteAddr",
":",
"req",
".",
"RemoteAddr",
",",
"}",
")",
"\n",
"}",
"\n",
"q",
":=",
"req",
".",
"URL",
".",
"Query",
"(",
")",
"\n",
"request",
":=",
"portForwardRequest",
"{",
"podNamespace",
":",
"p",
".",
"ByName",
"(",
"\"podNamespace\"",
")",
",",
"podName",
":",
"p",
".",
"ByName",
"(",
"\"podName\"",
")",
",",
"ports",
":",
"q",
"[",
"\"ports\"",
"]",
",",
"context",
":",
"req",
".",
"Context",
"(",
")",
",",
"httpRequest",
":",
"req",
",",
"httpResponseWriter",
":",
"w",
",",
"onPortForward",
":",
"onPortForward",
",",
"targetDialer",
":",
"dialer",
",",
"}",
"\n",
"f",
".",
"Debugf",
"(",
"\"Starting %v.\"",
",",
"request",
")",
"\n",
"err",
"=",
"runPortForwarding",
"(",
"request",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"f",
".",
"Debugf",
"(",
"\"Done %v.\"",
",",
"request",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // portForward starts port forwarding to the remote cluster | [
"portForward",
"starts",
"port",
"forwarding",
"to",
"the",
"remote",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/proxy/forwarder.go#L568-L619 | train |
gravitational/teleport | lib/kube/proxy/forwarder.go | catchAll | func (f *Forwarder) catchAll(ctx *authContext, w http.ResponseWriter, req *http.Request) (interface{}, error) {
sess, err := f.getOrCreateClusterSession(*ctx)
if err != nil {
return nil, trace.Wrap(err)
}
if err := f.setupForwardingHeaders(ctx, sess, req); err != nil {
return nil, trace.Wrap(err)
}
sess.forwarder.ServeHTTP(w, req)
return nil, nil
} | go | func (f *Forwarder) catchAll(ctx *authContext, w http.ResponseWriter, req *http.Request) (interface{}, error) {
sess, err := f.getOrCreateClusterSession(*ctx)
if err != nil {
return nil, trace.Wrap(err)
}
if err := f.setupForwardingHeaders(ctx, sess, req); err != nil {
return nil, trace.Wrap(err)
}
sess.forwarder.ServeHTTP(w, req)
return nil, nil
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"catchAll",
"(",
"ctx",
"*",
"authContext",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"sess",
",",
"err",
":=",
"f",
".",
"getOrCreateClusterSession",
"(",
"*",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"f",
".",
"setupForwardingHeaders",
"(",
"ctx",
",",
"sess",
",",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
".",
"forwarder",
".",
"ServeHTTP",
"(",
"w",
",",
"req",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // catchAll forwards all HTTP requests to the target k8s API server | [
"catchAll",
"forwards",
"all",
"HTTP",
"requests",
"to",
"the",
"target",
"k8s",
"API",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/proxy/forwarder.go#L655-L665 | train |
gravitational/teleport | lib/kube/proxy/forwarder.go | UpdateClientActivity | func (t *trackingConn) UpdateClientActivity() {
t.Lock()
defer t.Unlock()
t.lastActive = t.clock.Now().UTC()
} | go | func (t *trackingConn) UpdateClientActivity() {
t.Lock()
defer t.Unlock()
t.lastActive = t.clock.Now().UTC()
} | [
"func",
"(",
"t",
"*",
"trackingConn",
")",
"UpdateClientActivity",
"(",
")",
"{",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n",
"t",
".",
"lastActive",
"=",
"t",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] | // UpdateClientActivity sets last recorded client activity | [
"UpdateClientActivity",
"sets",
"last",
"recorded",
"client",
"activity"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/proxy/forwarder.go#L778-L782 | train |
gravitational/teleport | lib/kube/proxy/forwarder.go | getOrCreateRequestContext | func (f *Forwarder) getOrCreateRequestContext(key string) (context.Context, context.CancelFunc) {
f.Lock()
defer f.Unlock()
ctx, ok := f.activeRequests[key]
if ok {
return ctx, nil
}
ctx, cancel := context.WithCancel(context.TODO())
f.activeRequests[key] = ctx
return ctx, func() {
cancel()
f.Lock()
defer f.Unlock()
delete(f.activeRequests, key)
}
} | go | func (f *Forwarder) getOrCreateRequestContext(key string) (context.Context, context.CancelFunc) {
f.Lock()
defer f.Unlock()
ctx, ok := f.activeRequests[key]
if ok {
return ctx, nil
}
ctx, cancel := context.WithCancel(context.TODO())
f.activeRequests[key] = ctx
return ctx, func() {
cancel()
f.Lock()
defer f.Unlock()
delete(f.activeRequests, key)
}
} | [
"func",
"(",
"f",
"*",
"Forwarder",
")",
"getOrCreateRequestContext",
"(",
"key",
"string",
")",
"(",
"context",
".",
"Context",
",",
"context",
".",
"CancelFunc",
")",
"{",
"f",
".",
"Lock",
"(",
")",
"\n",
"defer",
"f",
".",
"Unlock",
"(",
")",
"\n",
"ctx",
",",
"ok",
":=",
"f",
".",
"activeRequests",
"[",
"key",
"]",
"\n",
"if",
"ok",
"{",
"return",
"ctx",
",",
"nil",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"f",
".",
"activeRequests",
"[",
"key",
"]",
"=",
"ctx",
"\n",
"return",
"ctx",
",",
"func",
"(",
")",
"{",
"cancel",
"(",
")",
"\n",
"f",
".",
"Lock",
"(",
")",
"\n",
"defer",
"f",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"f",
".",
"activeRequests",
",",
"key",
")",
"\n",
"}",
"\n",
"}"
] | // getOrCreateRequestContext creates a new certificate request for a given context,
// if there is no active CSR request in progress, or returns an existing one.
// if the new context has been created, cancel function is returned as a
// second argument. Caller should call this function to signal that CSR has been
// completed or failed. | [
"getOrCreateRequestContext",
"creates",
"a",
"new",
"certificate",
"request",
"for",
"a",
"given",
"context",
"if",
"there",
"is",
"no",
"active",
"CSR",
"request",
"in",
"progress",
"or",
"returns",
"an",
"existing",
"one",
".",
"if",
"the",
"new",
"context",
"has",
"been",
"created",
"cancel",
"function",
"is",
"returned",
"as",
"a",
"second",
"argument",
".",
"Caller",
"should",
"call",
"this",
"function",
"to",
"signal",
"that",
"CSR",
"has",
"been",
"completed",
"or",
"failed",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/proxy/forwarder.go#L936-L951 | train |
gravitational/teleport | lib/multiplexer/proxyline.go | String | func (p *ProxyLine) String() string {
return fmt.Sprintf("PROXY %s %s %s %d %d\r\n", p.Protocol, p.Source.IP.String(), p.Destination.IP.String(), p.Source.Port, p.Destination.Port)
} | go | func (p *ProxyLine) String() string {
return fmt.Sprintf("PROXY %s %s %s %d %d\r\n", p.Protocol, p.Source.IP.String(), p.Destination.IP.String(), p.Source.Port, p.Destination.Port)
} | [
"func",
"(",
"p",
"*",
"ProxyLine",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"PROXY %s %s %s %d %d\\r\\n\"",
",",
"\\r",
",",
"\\n",
",",
"p",
".",
"Protocol",
",",
"p",
".",
"Source",
".",
"IP",
".",
"String",
"(",
")",
",",
"p",
".",
"Destination",
".",
"IP",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // String returns on-the wire string representation of the proxy line | [
"String",
"returns",
"on",
"-",
"the",
"wire",
"string",
"representation",
"of",
"the",
"proxy",
"line"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/proxyline.go#L55-L57 | train |
gravitational/teleport | lib/multiplexer/proxyline.go | ReadProxyLine | func ReadProxyLine(reader *bufio.Reader) (*ProxyLine, error) {
line, err := reader.ReadString('\n')
if err != nil {
return nil, trace.Wrap(err)
}
if !strings.HasSuffix(line, proxyCRLF) {
return nil, trace.BadParameter("expected CRLF in proxy protocol, got something else")
}
tokens := strings.Split(line[:len(line)-2], proxySep)
ret := ProxyLine{}
if len(tokens) < 6 {
return nil, trace.BadParameter("malformed PROXY line protocol string")
}
switch tokens[1] {
case TCP4:
ret.Protocol = TCP4
case TCP6:
ret.Protocol = TCP6
default:
ret.Protocol = UNKNOWN
}
sourceIP, err := parseIP(ret.Protocol, tokens[2])
if err != nil {
return nil, trace.Wrap(err)
}
destIP, err := parseIP(ret.Protocol, tokens[3])
if err != nil {
return nil, trace.Wrap(err)
}
sourcePort, err := parsePortNumber(tokens[4])
if err != nil {
return nil, trace.Wrap(err)
}
destPort, err := parsePortNumber(tokens[5])
if err != nil {
return nil, err
}
ret.Source = net.TCPAddr{IP: sourceIP, Port: sourcePort}
ret.Destination = net.TCPAddr{IP: destIP, Port: destPort}
return &ret, nil
} | go | func ReadProxyLine(reader *bufio.Reader) (*ProxyLine, error) {
line, err := reader.ReadString('\n')
if err != nil {
return nil, trace.Wrap(err)
}
if !strings.HasSuffix(line, proxyCRLF) {
return nil, trace.BadParameter("expected CRLF in proxy protocol, got something else")
}
tokens := strings.Split(line[:len(line)-2], proxySep)
ret := ProxyLine{}
if len(tokens) < 6 {
return nil, trace.BadParameter("malformed PROXY line protocol string")
}
switch tokens[1] {
case TCP4:
ret.Protocol = TCP4
case TCP6:
ret.Protocol = TCP6
default:
ret.Protocol = UNKNOWN
}
sourceIP, err := parseIP(ret.Protocol, tokens[2])
if err != nil {
return nil, trace.Wrap(err)
}
destIP, err := parseIP(ret.Protocol, tokens[3])
if err != nil {
return nil, trace.Wrap(err)
}
sourcePort, err := parsePortNumber(tokens[4])
if err != nil {
return nil, trace.Wrap(err)
}
destPort, err := parsePortNumber(tokens[5])
if err != nil {
return nil, err
}
ret.Source = net.TCPAddr{IP: sourceIP, Port: sourcePort}
ret.Destination = net.TCPAddr{IP: destIP, Port: destPort}
return &ret, nil
} | [
"func",
"ReadProxyLine",
"(",
"reader",
"*",
"bufio",
".",
"Reader",
")",
"(",
"*",
"ProxyLine",
",",
"error",
")",
"{",
"line",
",",
"err",
":=",
"reader",
".",
"ReadString",
"(",
"'\\n'",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"line",
",",
"proxyCRLF",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"expected CRLF in proxy protocol, got something else\"",
")",
"\n",
"}",
"\n",
"tokens",
":=",
"strings",
".",
"Split",
"(",
"line",
"[",
":",
"len",
"(",
"line",
")",
"-",
"2",
"]",
",",
"proxySep",
")",
"\n",
"ret",
":=",
"ProxyLine",
"{",
"}",
"\n",
"if",
"len",
"(",
"tokens",
")",
"<",
"6",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"malformed PROXY line protocol string\"",
")",
"\n",
"}",
"\n",
"switch",
"tokens",
"[",
"1",
"]",
"{",
"case",
"TCP4",
":",
"ret",
".",
"Protocol",
"=",
"TCP4",
"\n",
"case",
"TCP6",
":",
"ret",
".",
"Protocol",
"=",
"TCP6",
"\n",
"default",
":",
"ret",
".",
"Protocol",
"=",
"UNKNOWN",
"\n",
"}",
"\n",
"sourceIP",
",",
"err",
":=",
"parseIP",
"(",
"ret",
".",
"Protocol",
",",
"tokens",
"[",
"2",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"destIP",
",",
"err",
":=",
"parseIP",
"(",
"ret",
".",
"Protocol",
",",
"tokens",
"[",
"3",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sourcePort",
",",
"err",
":=",
"parsePortNumber",
"(",
"tokens",
"[",
"4",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"destPort",
",",
"err",
":=",
"parsePortNumber",
"(",
"tokens",
"[",
"5",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"ret",
".",
"Source",
"=",
"net",
".",
"TCPAddr",
"{",
"IP",
":",
"sourceIP",
",",
"Port",
":",
"sourcePort",
"}",
"\n",
"ret",
".",
"Destination",
"=",
"net",
".",
"TCPAddr",
"{",
"IP",
":",
"destIP",
",",
"Port",
":",
"destPort",
"}",
"\n",
"return",
"&",
"ret",
",",
"nil",
"\n",
"}"
] | // ReadProxyLine reads proxy line protocol from the reader | [
"ReadProxyLine",
"reads",
"proxy",
"line",
"protocol",
"from",
"the",
"reader"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/proxyline.go#L60-L100 | train |
gravitational/teleport | lib/service/state.go | newProcessState | func newProcessState(process *TeleportProcess) *processState {
return &processState{
process: process,
recoveryTime: process.Clock.Now(),
currentState: stateOK,
}
} | go | func newProcessState(process *TeleportProcess) *processState {
return &processState{
process: process,
recoveryTime: process.Clock.Now(),
currentState: stateOK,
}
} | [
"func",
"newProcessState",
"(",
"process",
"*",
"TeleportProcess",
")",
"*",
"processState",
"{",
"return",
"&",
"processState",
"{",
"process",
":",
"process",
",",
"recoveryTime",
":",
"process",
".",
"Clock",
".",
"Now",
"(",
")",
",",
"currentState",
":",
"stateOK",
",",
"}",
"\n",
"}"
] | // newProcessState returns a new FSM that tracks the state of the Teleport process. | [
"newProcessState",
"returns",
"a",
"new",
"FSM",
"that",
"tracks",
"the",
"state",
"of",
"the",
"Teleport",
"process",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/state.go#L46-L52 | train |
gravitational/teleport | lib/service/state.go | Process | func (f *processState) Process(event Event) {
switch event.Name {
// Ready event means Teleport has started successfully.
case TeleportReadyEvent:
atomic.StoreInt64(&f.currentState, stateOK)
f.process.Infof("Detected that service started and joined the cluster successfully.")
// If a degraded event was received, always change the state to degraded.
case TeleportDegradedEvent:
atomic.StoreInt64(&f.currentState, stateDegraded)
f.process.Infof("Detected Teleport is running in a degraded state.")
// If the current state is degraded, and a OK event has been
// received, change the state to recovering. If the current state is
// recovering and a OK events is received, if it's been longer
// than the recovery time (2 time the server keep alive ttl), change
// state to OK.
case TeleportOKEvent:
switch atomic.LoadInt64(&f.currentState) {
case stateDegraded:
atomic.StoreInt64(&f.currentState, stateRecovering)
f.recoveryTime = f.process.Clock.Now()
f.process.Infof("Teleport is recovering from a degraded state.")
case stateRecovering:
if f.process.Clock.Now().Sub(f.recoveryTime) > defaults.ServerKeepAliveTTL*2 {
atomic.StoreInt64(&f.currentState, stateOK)
f.process.Infof("Teleport has recovered from a degraded state.")
}
}
}
} | go | func (f *processState) Process(event Event) {
switch event.Name {
// Ready event means Teleport has started successfully.
case TeleportReadyEvent:
atomic.StoreInt64(&f.currentState, stateOK)
f.process.Infof("Detected that service started and joined the cluster successfully.")
// If a degraded event was received, always change the state to degraded.
case TeleportDegradedEvent:
atomic.StoreInt64(&f.currentState, stateDegraded)
f.process.Infof("Detected Teleport is running in a degraded state.")
// If the current state is degraded, and a OK event has been
// received, change the state to recovering. If the current state is
// recovering and a OK events is received, if it's been longer
// than the recovery time (2 time the server keep alive ttl), change
// state to OK.
case TeleportOKEvent:
switch atomic.LoadInt64(&f.currentState) {
case stateDegraded:
atomic.StoreInt64(&f.currentState, stateRecovering)
f.recoveryTime = f.process.Clock.Now()
f.process.Infof("Teleport is recovering from a degraded state.")
case stateRecovering:
if f.process.Clock.Now().Sub(f.recoveryTime) > defaults.ServerKeepAliveTTL*2 {
atomic.StoreInt64(&f.currentState, stateOK)
f.process.Infof("Teleport has recovered from a degraded state.")
}
}
}
} | [
"func",
"(",
"f",
"*",
"processState",
")",
"Process",
"(",
"event",
"Event",
")",
"{",
"switch",
"event",
".",
"Name",
"{",
"case",
"TeleportReadyEvent",
":",
"atomic",
".",
"StoreInt64",
"(",
"&",
"f",
".",
"currentState",
",",
"stateOK",
")",
"\n",
"f",
".",
"process",
".",
"Infof",
"(",
"\"Detected that service started and joined the cluster successfully.\"",
")",
"\n",
"case",
"TeleportDegradedEvent",
":",
"atomic",
".",
"StoreInt64",
"(",
"&",
"f",
".",
"currentState",
",",
"stateDegraded",
")",
"\n",
"f",
".",
"process",
".",
"Infof",
"(",
"\"Detected Teleport is running in a degraded state.\"",
")",
"\n",
"case",
"TeleportOKEvent",
":",
"switch",
"atomic",
".",
"LoadInt64",
"(",
"&",
"f",
".",
"currentState",
")",
"{",
"case",
"stateDegraded",
":",
"atomic",
".",
"StoreInt64",
"(",
"&",
"f",
".",
"currentState",
",",
"stateRecovering",
")",
"\n",
"f",
".",
"recoveryTime",
"=",
"f",
".",
"process",
".",
"Clock",
".",
"Now",
"(",
")",
"\n",
"f",
".",
"process",
".",
"Infof",
"(",
"\"Teleport is recovering from a degraded state.\"",
")",
"\n",
"case",
"stateRecovering",
":",
"if",
"f",
".",
"process",
".",
"Clock",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"f",
".",
"recoveryTime",
")",
">",
"defaults",
".",
"ServerKeepAliveTTL",
"*",
"2",
"{",
"atomic",
".",
"StoreInt64",
"(",
"&",
"f",
".",
"currentState",
",",
"stateOK",
")",
"\n",
"f",
".",
"process",
".",
"Infof",
"(",
"\"Teleport has recovered from a degraded state.\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Process updates the state of Teleport. | [
"Process",
"updates",
"the",
"state",
"of",
"Teleport",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/state.go#L55-L83 | train |
gravitational/teleport | lib/utils/addr.go | Host | func (a *NetAddr) Host() string {
host, _, err := net.SplitHostPort(a.Addr)
if err != nil {
return a.Addr
}
return host
} | go | func (a *NetAddr) Host() string {
host, _, err := net.SplitHostPort(a.Addr)
if err != nil {
return a.Addr
}
return host
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"Host",
"(",
")",
"string",
"{",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"a",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"a",
".",
"Addr",
"\n",
"}",
"\n",
"return",
"host",
"\n",
"}"
] | // Host returns host part of address without port | [
"Host",
"returns",
"host",
"part",
"of",
"address",
"without",
"port"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L42-L48 | train |
gravitational/teleport | lib/utils/addr.go | Port | func (a *NetAddr) Port(defaultPort int) int {
_, port, err := net.SplitHostPort(a.Addr)
if err != nil {
return defaultPort
}
porti, err := strconv.Atoi(port)
if err != nil {
return defaultPort
}
return porti
} | go | func (a *NetAddr) Port(defaultPort int) int {
_, port, err := net.SplitHostPort(a.Addr)
if err != nil {
return defaultPort
}
porti, err := strconv.Atoi(port)
if err != nil {
return defaultPort
}
return porti
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"Port",
"(",
"defaultPort",
"int",
")",
"int",
"{",
"_",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"a",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"defaultPort",
"\n",
"}",
"\n",
"porti",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"defaultPort",
"\n",
"}",
"\n",
"return",
"porti",
"\n",
"}"
] | // Port returns defaultPort if no port is set or is invalid,
// the real port otherwise | [
"Port",
"returns",
"defaultPort",
"if",
"no",
"port",
"is",
"set",
"or",
"is",
"invalid",
"the",
"real",
"port",
"otherwise"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L52-L62 | train |
gravitational/teleport | lib/utils/addr.go | Equals | func (a *NetAddr) Equals(other NetAddr) bool {
return a.Addr == other.Addr && a.AddrNetwork == other.AddrNetwork && a.Path == other.Path
} | go | func (a *NetAddr) Equals(other NetAddr) bool {
return a.Addr == other.Addr && a.AddrNetwork == other.AddrNetwork && a.Path == other.Path
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"Equals",
"(",
"other",
"NetAddr",
")",
"bool",
"{",
"return",
"a",
".",
"Addr",
"==",
"other",
".",
"Addr",
"&&",
"a",
".",
"AddrNetwork",
"==",
"other",
".",
"AddrNetwork",
"&&",
"a",
".",
"Path",
"==",
"other",
".",
"Path",
"\n",
"}"
] | // Equals returns true if address is equal to other | [
"Equals",
"returns",
"true",
"if",
"address",
"is",
"equal",
"to",
"other"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L65-L67 | train |
gravitational/teleport | lib/utils/addr.go | IsLocal | func (a *NetAddr) IsLocal() bool {
host, _, err := net.SplitHostPort(a.Addr)
if err != nil {
return false
}
return IsLocalhost(host)
} | go | func (a *NetAddr) IsLocal() bool {
host, _, err := net.SplitHostPort(a.Addr)
if err != nil {
return false
}
return IsLocalhost(host)
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"IsLocal",
"(",
")",
"bool",
"{",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"a",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"IsLocalhost",
"(",
"host",
")",
"\n",
"}"
] | // IsLocal returns true if this is a local address | [
"IsLocal",
"returns",
"true",
"if",
"this",
"is",
"a",
"local",
"address"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L70-L76 | train |
gravitational/teleport | lib/utils/addr.go | IsEmpty | func (a *NetAddr) IsEmpty() bool {
return a.Addr == "" && a.AddrNetwork == "" && a.Path == ""
} | go | func (a *NetAddr) IsEmpty() bool {
return a.Addr == "" && a.AddrNetwork == "" && a.Path == ""
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"IsEmpty",
"(",
")",
"bool",
"{",
"return",
"a",
".",
"Addr",
"==",
"\"\"",
"&&",
"a",
".",
"AddrNetwork",
"==",
"\"\"",
"&&",
"a",
".",
"Path",
"==",
"\"\"",
"\n",
"}"
] | // IsEmpty returns true if address is empty | [
"IsEmpty",
"returns",
"true",
"if",
"address",
"is",
"empty"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L84-L86 | train |
gravitational/teleport | lib/utils/addr.go | MarshalYAML | func (a *NetAddr) MarshalYAML() (interface{}, error) {
url := url.URL{Scheme: a.AddrNetwork, Host: a.Addr, Path: a.Path}
return strings.TrimLeft(url.String(), "/"), nil
} | go | func (a *NetAddr) MarshalYAML() (interface{}, error) {
url := url.URL{Scheme: a.AddrNetwork, Host: a.Addr, Path: a.Path}
return strings.TrimLeft(url.String(), "/"), nil
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"MarshalYAML",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"url",
":=",
"url",
".",
"URL",
"{",
"Scheme",
":",
"a",
".",
"AddrNetwork",
",",
"Host",
":",
"a",
".",
"Addr",
",",
"Path",
":",
"a",
".",
"Path",
"}",
"\n",
"return",
"strings",
".",
"TrimLeft",
"(",
"url",
".",
"String",
"(",
")",
",",
"\"/\"",
")",
",",
"nil",
"\n",
"}"
] | // MarshalYAML defines how a network address should be marshalled to a string | [
"MarshalYAML",
"defines",
"how",
"a",
"network",
"address",
"should",
"be",
"marshalled",
"to",
"a",
"string"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L104-L107 | train |
gravitational/teleport | lib/utils/addr.go | UnmarshalYAML | func (a *NetAddr) UnmarshalYAML(unmarshal func(interface{}) error) error {
var addr string
err := unmarshal(&addr)
if err != nil {
return err
}
parsedAddr, err := ParseAddr(addr)
if err != nil {
return err
}
*a = *parsedAddr
return nil
} | go | func (a *NetAddr) UnmarshalYAML(unmarshal func(interface{}) error) error {
var addr string
err := unmarshal(&addr)
if err != nil {
return err
}
parsedAddr, err := ParseAddr(addr)
if err != nil {
return err
}
*a = *parsedAddr
return nil
} | [
"func",
"(",
"a",
"*",
"NetAddr",
")",
"UnmarshalYAML",
"(",
"unmarshal",
"func",
"(",
"interface",
"{",
"}",
")",
"error",
")",
"error",
"{",
"var",
"addr",
"string",
"\n",
"err",
":=",
"unmarshal",
"(",
"&",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"parsedAddr",
",",
"err",
":=",
"ParseAddr",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"a",
"=",
"*",
"parsedAddr",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalYAML defines how a string can be unmarshalled into a network address | [
"UnmarshalYAML",
"defines",
"how",
"a",
"string",
"can",
"be",
"unmarshalled",
"into",
"a",
"network",
"address"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L110-L124 | train |
gravitational/teleport | lib/utils/addr.go | MustParseAddr | func MustParseAddr(a string) *NetAddr {
addr, err := ParseAddr(a)
if err != nil {
panic(fmt.Sprintf("failed to parse %v: %v", a, err))
}
return addr
} | go | func MustParseAddr(a string) *NetAddr {
addr, err := ParseAddr(a)
if err != nil {
panic(fmt.Sprintf("failed to parse %v: %v", a, err))
}
return addr
} | [
"func",
"MustParseAddr",
"(",
"a",
"string",
")",
"*",
"NetAddr",
"{",
"addr",
",",
"err",
":=",
"ParseAddr",
"(",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"failed to parse %v: %v\"",
",",
"a",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"addr",
"\n",
"}"
] | // MustParseAddr parses the provided string into NetAddr or panics on an error | [
"MustParseAddr",
"parses",
"the",
"provided",
"string",
"into",
"NetAddr",
"or",
"panics",
"on",
"an",
"error"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L162-L168 | train |
gravitational/teleport | lib/utils/addr.go | FromAddr | func FromAddr(a net.Addr) NetAddr {
return NetAddr{AddrNetwork: a.Network(), Addr: a.String()}
} | go | func FromAddr(a net.Addr) NetAddr {
return NetAddr{AddrNetwork: a.Network(), Addr: a.String()}
} | [
"func",
"FromAddr",
"(",
"a",
"net",
".",
"Addr",
")",
"NetAddr",
"{",
"return",
"NetAddr",
"{",
"AddrNetwork",
":",
"a",
".",
"Network",
"(",
")",
",",
"Addr",
":",
"a",
".",
"String",
"(",
")",
"}",
"\n",
"}"
] | // FromAddr returns NetAddr from golang standard net.Addr | [
"FromAddr",
"returns",
"NetAddr",
"from",
"golang",
"standard",
"net",
".",
"Addr"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L171-L173 | train |
gravitational/teleport | lib/utils/addr.go | JoinAddrSlices | func JoinAddrSlices(a []NetAddr, b []NetAddr) []NetAddr {
if len(a)+len(b) == 0 {
return nil
}
out := make([]NetAddr, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | go | func JoinAddrSlices(a []NetAddr, b []NetAddr) []NetAddr {
if len(a)+len(b) == 0 {
return nil
}
out := make([]NetAddr, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | [
"func",
"JoinAddrSlices",
"(",
"a",
"[",
"]",
"NetAddr",
",",
"b",
"[",
"]",
"NetAddr",
")",
"[",
"]",
"NetAddr",
"{",
"if",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"NetAddr",
",",
"0",
",",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
")",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"a",
"...",
")",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"b",
"...",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // JoinAddrSlices joins two addr slices and returns a resulting slice | [
"JoinAddrSlices",
"joins",
"two",
"addr",
"slices",
"and",
"returns",
"a",
"resulting",
"slice"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L176-L184 | train |
gravitational/teleport | lib/utils/addr.go | DialAddrFromListenAddr | func DialAddrFromListenAddr(listenAddr NetAddr) NetAddr {
if listenAddr.IsEmpty() {
return listenAddr
}
return NetAddr{Addr: ReplaceLocalhost(listenAddr.Addr, "127.0.0.1")}
} | go | func DialAddrFromListenAddr(listenAddr NetAddr) NetAddr {
if listenAddr.IsEmpty() {
return listenAddr
}
return NetAddr{Addr: ReplaceLocalhost(listenAddr.Addr, "127.0.0.1")}
} | [
"func",
"DialAddrFromListenAddr",
"(",
"listenAddr",
"NetAddr",
")",
"NetAddr",
"{",
"if",
"listenAddr",
".",
"IsEmpty",
"(",
")",
"{",
"return",
"listenAddr",
"\n",
"}",
"\n",
"return",
"NetAddr",
"{",
"Addr",
":",
"ReplaceLocalhost",
"(",
"listenAddr",
".",
"Addr",
",",
"\"127.0.0.1\"",
")",
"}",
"\n",
"}"
] | // DialAddrFromListenAddr returns dial address from listen address | [
"DialAddrFromListenAddr",
"returns",
"dial",
"address",
"from",
"listen",
"address"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L204-L209 | train |
gravitational/teleport | lib/utils/addr.go | Addresses | func (nl *NetAddrList) Addresses() []string {
var ns []string
for _, n := range *nl {
ns = append(ns, n.FullAddress())
}
return ns
} | go | func (nl *NetAddrList) Addresses() []string {
var ns []string
for _, n := range *nl {
ns = append(ns, n.FullAddress())
}
return ns
} | [
"func",
"(",
"nl",
"*",
"NetAddrList",
")",
"Addresses",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"ns",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"*",
"nl",
"{",
"ns",
"=",
"append",
"(",
"ns",
",",
"n",
".",
"FullAddress",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"ns",
"\n",
"}"
] | // Addresses returns a slice of strings converted from the addresses | [
"Addresses",
"returns",
"a",
"slice",
"of",
"strings",
"converted",
"from",
"the",
"addresses"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L242-L248 | train |
gravitational/teleport | lib/utils/addr.go | Set | func (nl *NetAddrList) Set(s string) error {
v, err := ParseAddr(s)
if err != nil {
return err
}
*nl = append(*nl, *v)
return nil
} | go | func (nl *NetAddrList) Set(s string) error {
v, err := ParseAddr(s)
if err != nil {
return err
}
*nl = append(*nl, *v)
return nil
} | [
"func",
"(",
"nl",
"*",
"NetAddrList",
")",
"Set",
"(",
"s",
"string",
")",
"error",
"{",
"v",
",",
"err",
":=",
"ParseAddr",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"nl",
"=",
"append",
"(",
"*",
"nl",
",",
"*",
"v",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Set is called by CLI tools | [
"Set",
"is",
"called",
"by",
"CLI",
"tools"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L251-L259 | train |
gravitational/teleport | lib/utils/addr.go | String | func (nl *NetAddrList) String() string {
var ns []string
for _, n := range *nl {
ns = append(ns, n.FullAddress())
}
return strings.Join(ns, " ")
} | go | func (nl *NetAddrList) String() string {
var ns []string
for _, n := range *nl {
ns = append(ns, n.FullAddress())
}
return strings.Join(ns, " ")
} | [
"func",
"(",
"nl",
"*",
"NetAddrList",
")",
"String",
"(",
")",
"string",
"{",
"var",
"ns",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"*",
"nl",
"{",
"ns",
"=",
"append",
"(",
"ns",
",",
"n",
".",
"FullAddress",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"ns",
",",
"\" \"",
")",
"\n",
"}"
] | // String returns debug-friendly representation of the tool | [
"String",
"returns",
"debug",
"-",
"friendly",
"representation",
"of",
"the",
"tool"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L262-L268 | train |
gravitational/teleport | lib/utils/addr.go | IsLocalhost | func IsLocalhost(host string) bool {
if host == "localhost" {
return true
}
ip := net.ParseIP(host)
return ip.IsLoopback() || ip.IsUnspecified()
} | go | func IsLocalhost(host string) bool {
if host == "localhost" {
return true
}
ip := net.ParseIP(host)
return ip.IsLoopback() || ip.IsUnspecified()
} | [
"func",
"IsLocalhost",
"(",
"host",
"string",
")",
"bool",
"{",
"if",
"host",
"==",
"\"localhost\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"host",
")",
"\n",
"return",
"ip",
".",
"IsLoopback",
"(",
")",
"||",
"ip",
".",
"IsUnspecified",
"(",
")",
"\n",
"}"
] | // IsLocalhost returns true if this is a local hostname or ip | [
"IsLocalhost",
"returns",
"true",
"if",
"this",
"is",
"a",
"local",
"hostname",
"or",
"ip"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L291-L297 | train |
gravitational/teleport | lib/utils/addr.go | IsLoopback | func IsLoopback(host string) bool {
if strings.Contains(host, ":") {
var err error
host, _, err = net.SplitHostPort(host)
if err != nil {
return false
}
}
ips, err := net.LookupIP(host)
if err != nil {
return false
}
for _, ip := range ips {
if ip.IsLoopback() {
return true
}
}
return false
} | go | func IsLoopback(host string) bool {
if strings.Contains(host, ":") {
var err error
host, _, err = net.SplitHostPort(host)
if err != nil {
return false
}
}
ips, err := net.LookupIP(host)
if err != nil {
return false
}
for _, ip := range ips {
if ip.IsLoopback() {
return true
}
}
return false
} | [
"func",
"IsLoopback",
"(",
"host",
"string",
")",
"bool",
"{",
"if",
"strings",
".",
"Contains",
"(",
"host",
",",
"\":\"",
")",
"{",
"var",
"err",
"error",
"\n",
"host",
",",
"_",
",",
"err",
"=",
"net",
".",
"SplitHostPort",
"(",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"ips",
",",
"err",
":=",
"net",
".",
"LookupIP",
"(",
"host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"ips",
"{",
"if",
"ip",
".",
"IsLoopback",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsLoopback returns 'true' if a given hostname resolves to local
// host's loopback interface | [
"IsLoopback",
"returns",
"true",
"if",
"a",
"given",
"hostname",
"resolves",
"to",
"local",
"host",
"s",
"loopback",
"interface"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L301-L319 | train |
gravitational/teleport | lib/utils/addr.go | GuessHostIP | func GuessHostIP() (ip net.IP, err error) {
ifaces, err := net.Interfaces()
if err != nil {
return nil, trace.Wrap(err)
}
adrs := make([]net.Addr, 0)
for _, iface := range ifaces {
ifadrs, err := iface.Addrs()
if err != nil {
log.Warn(err)
} else {
adrs = append(adrs, ifadrs...)
}
}
return guessHostIP(adrs), nil
} | go | func GuessHostIP() (ip net.IP, err error) {
ifaces, err := net.Interfaces()
if err != nil {
return nil, trace.Wrap(err)
}
adrs := make([]net.Addr, 0)
for _, iface := range ifaces {
ifadrs, err := iface.Addrs()
if err != nil {
log.Warn(err)
} else {
adrs = append(adrs, ifadrs...)
}
}
return guessHostIP(adrs), nil
} | [
"func",
"GuessHostIP",
"(",
")",
"(",
"ip",
"net",
".",
"IP",
",",
"err",
"error",
")",
"{",
"ifaces",
",",
"err",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"adrs",
":=",
"make",
"(",
"[",
"]",
"net",
".",
"Addr",
",",
"0",
")",
"\n",
"for",
"_",
",",
"iface",
":=",
"range",
"ifaces",
"{",
"ifadrs",
",",
"err",
":=",
"iface",
".",
"Addrs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warn",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"adrs",
"=",
"append",
"(",
"adrs",
",",
"ifadrs",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"guessHostIP",
"(",
"adrs",
")",
",",
"nil",
"\n",
"}"
] | // GuessIP tries to guess an IP address this machine is reachable at on the
// internal network, always picking IPv4 from the internal address space
//
// If no internal IPs are found, it returns 127.0.0.1 but it never returns
// an address from the public IP space | [
"GuessIP",
"tries",
"to",
"guess",
"an",
"IP",
"address",
"this",
"machine",
"is",
"reachable",
"at",
"on",
"the",
"internal",
"network",
"always",
"picking",
"IPv4",
"from",
"the",
"internal",
"address",
"space",
"If",
"no",
"internal",
"IPs",
"are",
"found",
"it",
"returns",
"127",
".",
"0",
".",
"0",
".",
"1",
"but",
"it",
"never",
"returns",
"an",
"address",
"from",
"the",
"public",
"IP",
"space"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/addr.go#L326-L341 | train |
gravitational/teleport | lib/auth/mocku2f/mocku2f.go | decodeBase64 | func decodeBase64(s string) ([]byte, error) {
for i := 0; i < len(s)%4; i++ {
s += "="
}
return base64.URLEncoding.DecodeString(s)
} | go | func decodeBase64(s string) ([]byte, error) {
for i := 0; i < len(s)%4; i++ {
s += "="
}
return base64.URLEncoding.DecodeString(s)
} | [
"func",
"decodeBase64",
"(",
"s",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"s",
")",
"%",
"4",
";",
"i",
"++",
"{",
"s",
"+=",
"\"=\"",
"\n",
"}",
"\n",
"return",
"base64",
".",
"URLEncoding",
".",
"DecodeString",
"(",
"s",
")",
"\n",
"}"
] | // The "websafe-base64 encoding" in the U2F specifications removes the padding | [
"The",
"websafe",
"-",
"base64",
"encoding",
"in",
"the",
"U2F",
"specifications",
"removes",
"the",
"padding"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/mocku2f/mocku2f.go#L52-L57 | train |
gravitational/teleport | lib/reversetunnel/peer.go | newClusterPeer | func newClusterPeer(srv *server, connInfo services.TunnelConnection) (*clusterPeer, error) {
clusterPeer := &clusterPeer{
srv: srv,
connInfo: connInfo,
log: log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelServer,
trace.ComponentFields: map[string]string{
"cluster": connInfo.GetClusterName(),
},
}),
}
return clusterPeer, nil
} | go | func newClusterPeer(srv *server, connInfo services.TunnelConnection) (*clusterPeer, error) {
clusterPeer := &clusterPeer{
srv: srv,
connInfo: connInfo,
log: log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelServer,
trace.ComponentFields: map[string]string{
"cluster": connInfo.GetClusterName(),
},
}),
}
return clusterPeer, nil
} | [
"func",
"newClusterPeer",
"(",
"srv",
"*",
"server",
",",
"connInfo",
"services",
".",
"TunnelConnection",
")",
"(",
"*",
"clusterPeer",
",",
"error",
")",
"{",
"clusterPeer",
":=",
"&",
"clusterPeer",
"{",
"srv",
":",
"srv",
",",
"connInfo",
":",
"connInfo",
",",
"log",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentReverseTunnelServer",
",",
"trace",
".",
"ComponentFields",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"cluster\"",
":",
"connInfo",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"}",
")",
",",
"}",
"\n",
"return",
"clusterPeer",
",",
"nil",
"\n",
"}"
] | // newClusterPeer returns new cluster peer | [
"newClusterPeer",
"returns",
"new",
"cluster",
"peer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/peer.go#L136-L149 | train |
gravitational/teleport | lib/utils/otp.go | GenerateQRCode | func GenerateQRCode(u string) ([]byte, error) {
otpKey, err := otp.NewKeyFromURL(u)
if err != nil {
return nil, trace.Wrap(err)
}
otpImage, err := otpKey.Image(450, 450)
if err != nil {
return nil, trace.Wrap(err)
}
var otpQR bytes.Buffer
err = png.Encode(&otpQR, otpImage)
if err != nil {
return nil, trace.Wrap(err)
}
return otpQR.Bytes(), nil
} | go | func GenerateQRCode(u string) ([]byte, error) {
otpKey, err := otp.NewKeyFromURL(u)
if err != nil {
return nil, trace.Wrap(err)
}
otpImage, err := otpKey.Image(450, 450)
if err != nil {
return nil, trace.Wrap(err)
}
var otpQR bytes.Buffer
err = png.Encode(&otpQR, otpImage)
if err != nil {
return nil, trace.Wrap(err)
}
return otpQR.Bytes(), nil
} | [
"func",
"GenerateQRCode",
"(",
"u",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"otpKey",
",",
"err",
":=",
"otp",
".",
"NewKeyFromURL",
"(",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"otpImage",
",",
"err",
":=",
"otpKey",
".",
"Image",
"(",
"450",
",",
"450",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"otpQR",
"bytes",
".",
"Buffer",
"\n",
"err",
"=",
"png",
".",
"Encode",
"(",
"&",
"otpQR",
",",
"otpImage",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"otpQR",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] | // GenerateQRCode takes in a OTP Key URL and returns a PNG-encoded QR code. | [
"GenerateQRCode",
"takes",
"in",
"a",
"OTP",
"Key",
"URL",
"and",
"returns",
"a",
"PNG",
"-",
"encoded",
"QR",
"code",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/otp.go#L15-L33 | train |
gravitational/teleport | lib/web/password.go | changePassword | func (h *Handler) changePassword(w http.ResponseWriter, r *http.Request, p httprouter.Params, ctx *SessionContext) (interface{}, error) {
var req *changePasswordReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
clt, err := ctx.GetClient()
if err != nil {
return nil, trace.Wrap(err)
}
servicedReq := services.ChangePasswordReq{
User: ctx.GetUser(),
OldPassword: req.OldPassword,
NewPassword: req.NewPassword,
SecondFactorToken: req.SecondFactorToken,
U2FSignResponse: req.U2FSignResponse,
}
err = clt.ChangePassword(servicedReq)
if err != nil {
return nil, trace.Wrap(err)
}
return ok(), nil
} | go | func (h *Handler) changePassword(w http.ResponseWriter, r *http.Request, p httprouter.Params, ctx *SessionContext) (interface{}, error) {
var req *changePasswordReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
clt, err := ctx.GetClient()
if err != nil {
return nil, trace.Wrap(err)
}
servicedReq := services.ChangePasswordReq{
User: ctx.GetUser(),
OldPassword: req.OldPassword,
NewPassword: req.NewPassword,
SecondFactorToken: req.SecondFactorToken,
U2FSignResponse: req.U2FSignResponse,
}
err = clt.ChangePassword(servicedReq)
if err != nil {
return nil, trace.Wrap(err)
}
return ok(), nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"changePassword",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"ctx",
"*",
"SessionContext",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"*",
"changePasswordReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"clt",
",",
"err",
":=",
"ctx",
".",
"GetClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"servicedReq",
":=",
"services",
".",
"ChangePasswordReq",
"{",
"User",
":",
"ctx",
".",
"GetUser",
"(",
")",
",",
"OldPassword",
":",
"req",
".",
"OldPassword",
",",
"NewPassword",
":",
"req",
".",
"NewPassword",
",",
"SecondFactorToken",
":",
"req",
".",
"SecondFactorToken",
",",
"U2FSignResponse",
":",
"req",
".",
"U2FSignResponse",
",",
"}",
"\n",
"err",
"=",
"clt",
".",
"ChangePassword",
"(",
"servicedReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ok",
"(",
")",
",",
"nil",
"\n",
"}"
] | // changePassword updates users password based on the old password | [
"changePassword",
"updates",
"users",
"password",
"based",
"on",
"the",
"old",
"password"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/password.go#L45-L70 | train |
gravitational/teleport | lib/web/password.go | u2fChangePasswordRequest | func (h *Handler) u2fChangePasswordRequest(w http.ResponseWriter, r *http.Request, _ httprouter.Params, ctx *SessionContext) (interface{}, error) {
var req *client.U2fSignRequestReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
clt, err := ctx.GetClient()
if err != nil {
return nil, trace.Wrap(err)
}
u2fReq, err := clt.GetU2FSignRequest(ctx.GetUser(), []byte(req.Pass))
if err != nil && trace.IsAccessDenied(err) {
// logout in case of access denied
logoutErr := h.logout(w, ctx)
if logoutErr != nil {
return nil, trace.Wrap(logoutErr)
}
}
if err != nil {
return nil, trace.Wrap(err)
}
return u2fReq, nil
} | go | func (h *Handler) u2fChangePasswordRequest(w http.ResponseWriter, r *http.Request, _ httprouter.Params, ctx *SessionContext) (interface{}, error) {
var req *client.U2fSignRequestReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
clt, err := ctx.GetClient()
if err != nil {
return nil, trace.Wrap(err)
}
u2fReq, err := clt.GetU2FSignRequest(ctx.GetUser(), []byte(req.Pass))
if err != nil && trace.IsAccessDenied(err) {
// logout in case of access denied
logoutErr := h.logout(w, ctx)
if logoutErr != nil {
return nil, trace.Wrap(logoutErr)
}
}
if err != nil {
return nil, trace.Wrap(err)
}
return u2fReq, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"u2fChangePasswordRequest",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"_",
"httprouter",
".",
"Params",
",",
"ctx",
"*",
"SessionContext",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"*",
"client",
".",
"U2fSignRequestReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"clt",
",",
"err",
":=",
"ctx",
".",
"GetClient",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"u2fReq",
",",
"err",
":=",
"clt",
".",
"GetU2FSignRequest",
"(",
"ctx",
".",
"GetUser",
"(",
")",
",",
"[",
"]",
"byte",
"(",
"req",
".",
"Pass",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"trace",
".",
"IsAccessDenied",
"(",
"err",
")",
"{",
"logoutErr",
":=",
"h",
".",
"logout",
"(",
"w",
",",
"ctx",
")",
"\n",
"if",
"logoutErr",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"logoutErr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"u2fReq",
",",
"nil",
"\n",
"}"
] | // u2fChangePasswordRequest is called to get U2F challedge for changing a user password | [
"u2fChangePasswordRequest",
"is",
"called",
"to",
"get",
"U2F",
"challedge",
"for",
"changing",
"a",
"user",
"password"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/password.go#L73-L98 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.