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/auth/clt.go | DeleteWebSession | func (c *Client) DeleteWebSession(user string, sid string) error {
_, err := c.Delete(c.Endpoint("users", user, "web", "sessions", sid))
return trace.Wrap(err)
} | go | func (c *Client) DeleteWebSession(user string, sid string) error {
_, err := c.Delete(c.Endpoint("users", user, "web", "sessions", sid))
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteWebSession",
"(",
"user",
"string",
",",
"sid",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"user",
",",
"\"web\"",
",",
"\"sessions\"",
",",
"sid",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteWebSession deletes a web session for this user by id | [
"DeleteWebSession",
"deletes",
"a",
"web",
"session",
"for",
"this",
"user",
"by",
"id"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1405-L1408 | train |
gravitational/teleport | lib/auth/clt.go | GetUser | func (c *Client) GetUser(name string) (services.User, error) {
if name == "" {
return nil, trace.BadParameter("missing username")
}
out, err := c.Get(c.Endpoint("users", name), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
user, err := services.GetUserMarshaler().UnmarshalUser(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return user, nil
} | go | func (c *Client) GetUser(name string) (services.User, error) {
if name == "" {
return nil, trace.BadParameter("missing username")
}
out, err := c.Get(c.Endpoint("users", name), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
user, err := services.GetUserMarshaler().UnmarshalUser(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return user, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetUser",
"(",
"name",
"string",
")",
"(",
"services",
".",
"User",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing username\"",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"name",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"UnmarshalUser",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"user",
",",
"nil",
"\n",
"}"
] | // GetUser returns a list of usernames registered in the system | [
"GetUser",
"returns",
"a",
"list",
"of",
"usernames",
"registered",
"in",
"the",
"system"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1411-L1424 | train |
gravitational/teleport | lib/auth/clt.go | GetUsers | func (c *Client) GetUsers() ([]services.User, error) {
out, err := c.Get(c.Endpoint("users"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
users := make([]services.User, len(items))
for i, userBytes := range items {
user, err := services.GetUserMarshaler().UnmarshalUser(userBytes, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
users[i] = user
}
return users, nil
} | go | func (c *Client) GetUsers() ([]services.User, error) {
out, err := c.Get(c.Endpoint("users"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
users := make([]services.User, len(items))
for i, userBytes := range items {
user, err := services.GetUserMarshaler().UnmarshalUser(userBytes, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
users[i] = user
}
return users, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetUsers",
"(",
")",
"(",
"[",
"]",
"services",
".",
"User",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"users",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"User",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"userBytes",
":=",
"range",
"items",
"{",
"user",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"UnmarshalUser",
"(",
"userBytes",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"users",
"[",
"i",
"]",
"=",
"user",
"\n",
"}",
"\n",
"return",
"users",
",",
"nil",
"\n",
"}"
] | // GetUsers returns a list of usernames registered in the system | [
"GetUsers",
"returns",
"a",
"list",
"of",
"usernames",
"registered",
"in",
"the",
"system"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1427-L1445 | train |
gravitational/teleport | lib/auth/clt.go | DeleteUser | func (c *Client) DeleteUser(user string) error {
_, err := c.Delete(c.Endpoint("users", user))
return trace.Wrap(err)
} | go | func (c *Client) DeleteUser(user string) error {
_, err := c.Delete(c.Endpoint("users", user))
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteUser",
"(",
"user",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"user",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteUser deletes a user by username | [
"DeleteUser",
"deletes",
"a",
"user",
"by",
"username"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1448-L1451 | train |
gravitational/teleport | lib/auth/clt.go | GenerateHostCert | func (c *Client) GenerateHostCert(
key []byte, hostID, nodeName string, principals []string, clusterName string, roles teleport.Roles, ttl time.Duration) ([]byte, error) {
out, err := c.PostJSON(c.Endpoint("ca", "host", "certs"),
generateHostCertReq{
Key: key,
HostID: hostID,
NodeName: nodeName,
Principals: principals,
ClusterName: clusterName,
Roles: roles,
TTL: ttl,
})
if err != nil {
return nil, trace.Wrap(err)
}
var cert string
if err := json.Unmarshal(out.Bytes(), &cert); err != nil {
return nil, err
}
return []byte(cert), nil
} | go | func (c *Client) GenerateHostCert(
key []byte, hostID, nodeName string, principals []string, clusterName string, roles teleport.Roles, ttl time.Duration) ([]byte, error) {
out, err := c.PostJSON(c.Endpoint("ca", "host", "certs"),
generateHostCertReq{
Key: key,
HostID: hostID,
NodeName: nodeName,
Principals: principals,
ClusterName: clusterName,
Roles: roles,
TTL: ttl,
})
if err != nil {
return nil, trace.Wrap(err)
}
var cert string
if err := json.Unmarshal(out.Bytes(), &cert); err != nil {
return nil, err
}
return []byte(cert), nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GenerateHostCert",
"(",
"key",
"[",
"]",
"byte",
",",
"hostID",
",",
"nodeName",
"string",
",",
"principals",
"[",
"]",
"string",
",",
"clusterName",
"string",
",",
"roles",
"teleport",
".",
"Roles",
",",
"ttl",
"time",
".",
"Duration",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"ca\"",
",",
"\"host\"",
",",
"\"certs\"",
")",
",",
"generateHostCertReq",
"{",
"Key",
":",
"key",
",",
"HostID",
":",
"hostID",
",",
"NodeName",
":",
"nodeName",
",",
"Principals",
":",
"principals",
",",
"ClusterName",
":",
"clusterName",
",",
"Roles",
":",
"roles",
",",
"TTL",
":",
"ttl",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"cert",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"cert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"[",
"]",
"byte",
"(",
"cert",
")",
",",
"nil",
"\n",
"}"
] | // GenerateHostCert takes the public key in the Open SSH ``authorized_keys``
// plain text format, signs it using Host Certificate Authority private key and returns the
// resulting certificate. | [
"GenerateHostCert",
"takes",
"the",
"public",
"key",
"in",
"the",
"Open",
"SSH",
"authorized_keys",
"plain",
"text",
"format",
"signs",
"it",
"using",
"Host",
"Certificate",
"Authority",
"private",
"key",
"and",
"returns",
"the",
"resulting",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1471-L1494 | train |
gravitational/teleport | lib/auth/clt.go | GetSignupTokenData | func (c *Client) GetSignupTokenData(token string) (user string, otpQRCode []byte, e error) {
out, err := c.Get(c.Endpoint("signuptokens", token), url.Values{})
if err != nil {
return "", nil, err
}
var tokenData getSignupTokenDataResponse
if err := json.Unmarshal(out.Bytes(), &tokenData); err != nil {
return "", nil, err
}
return tokenData.User, tokenData.QRImg, nil
} | go | func (c *Client) GetSignupTokenData(token string) (user string, otpQRCode []byte, e error) {
out, err := c.Get(c.Endpoint("signuptokens", token), url.Values{})
if err != nil {
return "", nil, err
}
var tokenData getSignupTokenDataResponse
if err := json.Unmarshal(out.Bytes(), &tokenData); err != nil {
return "", nil, err
}
return tokenData.User, tokenData.QRImg, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetSignupTokenData",
"(",
"token",
"string",
")",
"(",
"user",
"string",
",",
"otpQRCode",
"[",
"]",
"byte",
",",
"e",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"signuptokens\"",
",",
"token",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"tokenData",
"getSignupTokenDataResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"tokenData",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"tokenData",
".",
"User",
",",
"tokenData",
".",
"QRImg",
",",
"nil",
"\n",
"}"
] | // GetSignupTokenData returns token data for a valid token | [
"GetSignupTokenData",
"returns",
"token",
"data",
"for",
"a",
"valid",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1517-L1529 | train |
gravitational/teleport | lib/auth/clt.go | GenerateUserCert | func (c *Client) GenerateUserCert(key []byte, user string, ttl time.Duration, compatibility string) ([]byte, error) {
out, err := c.PostJSON(c.Endpoint("ca", "user", "certs"),
generateUserCertReq{
Key: key,
User: user,
TTL: ttl,
Compatibility: compatibility,
})
if err != nil {
return nil, trace.Wrap(err)
}
var cert string
if err := json.Unmarshal(out.Bytes(), &cert); err != nil {
return nil, trace.Wrap(err)
}
return []byte(cert), nil
} | go | func (c *Client) GenerateUserCert(key []byte, user string, ttl time.Duration, compatibility string) ([]byte, error) {
out, err := c.PostJSON(c.Endpoint("ca", "user", "certs"),
generateUserCertReq{
Key: key,
User: user,
TTL: ttl,
Compatibility: compatibility,
})
if err != nil {
return nil, trace.Wrap(err)
}
var cert string
if err := json.Unmarshal(out.Bytes(), &cert); err != nil {
return nil, trace.Wrap(err)
}
return []byte(cert), nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GenerateUserCert",
"(",
"key",
"[",
"]",
"byte",
",",
"user",
"string",
",",
"ttl",
"time",
".",
"Duration",
",",
"compatibility",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"ca\"",
",",
"\"user\"",
",",
"\"certs\"",
")",
",",
"generateUserCertReq",
"{",
"Key",
":",
"key",
",",
"User",
":",
"user",
",",
"TTL",
":",
"ttl",
",",
"Compatibility",
":",
"compatibility",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"cert",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"cert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"[",
"]",
"byte",
"(",
"cert",
")",
",",
"nil",
"\n",
"}"
] | // GenerateUserCert takes the public key in the OpenSSH `authorized_keys` plain
// text format, signs it using User Certificate Authority signing key and
// returns the resulting certificate. | [
"GenerateUserCert",
"takes",
"the",
"public",
"key",
"in",
"the",
"OpenSSH",
"authorized_keys",
"plain",
"text",
"format",
"signs",
"it",
"using",
"User",
"Certificate",
"Authority",
"signing",
"key",
"and",
"returns",
"the",
"resulting",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1534-L1550 | train |
gravitational/teleport | lib/auth/clt.go | GetSignupU2FRegisterRequest | func (c *Client) GetSignupU2FRegisterRequest(token string) (u2fRegisterRequest *u2f.RegisterRequest, e error) {
out, err := c.Get(c.Endpoint("u2f", "signuptokens", token), url.Values{})
if err != nil {
return nil, err
}
var u2fRegReq u2f.RegisterRequest
if err := json.Unmarshal(out.Bytes(), &u2fRegReq); err != nil {
return nil, err
}
return &u2fRegReq, nil
} | go | func (c *Client) GetSignupU2FRegisterRequest(token string) (u2fRegisterRequest *u2f.RegisterRequest, e error) {
out, err := c.Get(c.Endpoint("u2f", "signuptokens", token), url.Values{})
if err != nil {
return nil, err
}
var u2fRegReq u2f.RegisterRequest
if err := json.Unmarshal(out.Bytes(), &u2fRegReq); err != nil {
return nil, err
}
return &u2fRegReq, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetSignupU2FRegisterRequest",
"(",
"token",
"string",
")",
"(",
"u2fRegisterRequest",
"*",
"u2f",
".",
"RegisterRequest",
",",
"e",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"u2f\"",
",",
"\"signuptokens\"",
",",
"token",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"u2fRegReq",
"u2f",
".",
"RegisterRequest",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"u2fRegReq",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"u2fRegReq",
",",
"nil",
"\n",
"}"
] | // GetSignupU2FRegisterRequest generates sign request for user trying to sign up with invite tokenx | [
"GetSignupU2FRegisterRequest",
"generates",
"sign",
"request",
"for",
"user",
"trying",
"to",
"sign",
"up",
"with",
"invite",
"tokenx"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1553-L1563 | train |
gravitational/teleport | lib/auth/clt.go | CreateUserWithOTP | func (c *Client) CreateUserWithOTP(token, password, otpToken string) (services.WebSession, error) {
out, err := c.PostJSON(c.Endpoint("signuptokens", "users"), createUserWithTokenReq{
Token: token,
Password: password,
OTPToken: otpToken,
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | go | func (c *Client) CreateUserWithOTP(token, password, otpToken string) (services.WebSession, error) {
out, err := c.PostJSON(c.Endpoint("signuptokens", "users"), createUserWithTokenReq{
Token: token,
Password: password,
OTPToken: otpToken,
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateUserWithOTP",
"(",
"token",
",",
"password",
",",
"otpToken",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"signuptokens\"",
",",
"\"users\"",
")",
",",
"createUserWithTokenReq",
"{",
"Token",
":",
"token",
",",
"Password",
":",
"password",
",",
"OTPToken",
":",
"otpToken",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"out",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // CreateUserWithOTP creates account with provided token and password.
// Account username and OTP key are taken from token data.
// Deletes token after account creation. | [
"CreateUserWithOTP",
"creates",
"account",
"with",
"provided",
"token",
"and",
"password",
".",
"Account",
"username",
"and",
"OTP",
"key",
"are",
"taken",
"from",
"token",
"data",
".",
"Deletes",
"token",
"after",
"account",
"creation",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1568-L1578 | train |
gravitational/teleport | lib/auth/clt.go | CreateUserWithU2FToken | func (c *Client) CreateUserWithU2FToken(token string, password string, u2fRegisterResponse u2f.RegisterResponse) (services.WebSession, error) {
out, err := c.PostJSON(c.Endpoint("u2f", "users"), createUserWithU2FTokenReq{
Token: token,
Password: password,
U2FRegisterResponse: u2fRegisterResponse,
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | go | func (c *Client) CreateUserWithU2FToken(token string, password string, u2fRegisterResponse u2f.RegisterResponse) (services.WebSession, error) {
out, err := c.PostJSON(c.Endpoint("u2f", "users"), createUserWithU2FTokenReq{
Token: token,
Password: password,
U2FRegisterResponse: u2fRegisterResponse,
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateUserWithU2FToken",
"(",
"token",
"string",
",",
"password",
"string",
",",
"u2fRegisterResponse",
"u2f",
".",
"RegisterResponse",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"u2f\"",
",",
"\"users\"",
")",
",",
"createUserWithU2FTokenReq",
"{",
"Token",
":",
"token",
",",
"Password",
":",
"password",
",",
"U2FRegisterResponse",
":",
"u2fRegisterResponse",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"out",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // CreateUserWithU2FToken creates user account with provided token and U2F sign response | [
"CreateUserWithU2FToken",
"creates",
"user",
"account",
"with",
"provided",
"token",
"and",
"U2F",
"sign",
"response"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1594-L1604 | train |
gravitational/teleport | lib/auth/clt.go | UpsertOIDCConnector | func (c *Client) UpsertOIDCConnector(connector services.OIDCConnector) error {
data, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("oidc", "connectors"), &upsertOIDCConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) UpsertOIDCConnector(connector services.OIDCConnector) error {
data, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("oidc", "connectors"), &upsertOIDCConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertOIDCConnector",
"(",
"connector",
"services",
".",
"OIDCConnector",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"MarshalOIDCConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"oidc\"",
",",
"\"connectors\"",
")",
",",
"&",
"upsertOIDCConnectorRawReq",
"{",
"Connector",
":",
"data",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertOIDCConnector updates or creates OIDC connector | [
"UpsertOIDCConnector",
"updates",
"or",
"creates",
"OIDC",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1607-L1619 | train |
gravitational/teleport | lib/auth/clt.go | GetOIDCConnector | func (c *Client) GetOIDCConnector(id string, withSecrets bool) (services.OIDCConnector, error) {
if id == "" {
return nil, trace.BadParameter("missing connector id")
}
out, err := c.Get(c.Endpoint("oidc", "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
return services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(out.Bytes(), services.SkipValidation())
} | go | func (c *Client) GetOIDCConnector(id string, withSecrets bool) (services.OIDCConnector, error) {
if id == "" {
return nil, trace.BadParameter("missing connector id")
}
out, err := c.Get(c.Endpoint("oidc", "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
return services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(out.Bytes(), services.SkipValidation())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetOIDCConnector",
"(",
"id",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"OIDCConnector",
",",
"error",
")",
"{",
"if",
"id",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing connector id\"",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"oidc\"",
",",
"\"connectors\"",
",",
"id",
")",
",",
"url",
".",
"Values",
"{",
"\"with_secrets\"",
":",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%t\"",
",",
"withSecrets",
")",
"}",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"UnmarshalOIDCConnector",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"}"
] | // GetOIDCConnector returns OIDC connector information by id | [
"GetOIDCConnector",
"returns",
"OIDC",
"connector",
"information",
"by",
"id"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1622-L1632 | train |
gravitational/teleport | lib/auth/clt.go | GetOIDCConnectors | func (c *Client) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
out, err := c.Get(c.Endpoint("oidc", "connectors"),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(items))
for i, raw := range items {
connector, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
connectors[i] = connector
}
return connectors, nil
} | go | func (c *Client) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
out, err := c.Get(c.Endpoint("oidc", "connectors"),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(items))
for i, raw := range items {
connector, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
connectors[i] = connector
}
return connectors, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetOIDCConnectors",
"(",
"withSecrets",
"bool",
")",
"(",
"[",
"]",
"services",
".",
"OIDCConnector",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"oidc\"",
",",
"\"connectors\"",
")",
",",
"url",
".",
"Values",
"{",
"\"with_secrets\"",
":",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%t\"",
",",
"withSecrets",
")",
"}",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"OIDCConnector",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"items",
"{",
"connector",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"UnmarshalOIDCConnector",
"(",
"raw",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
"[",
"i",
"]",
"=",
"connector",
"\n",
"}",
"\n",
"return",
"connectors",
",",
"nil",
"\n",
"}"
] | // GetOIDCConnector gets OIDC connectors list | [
"GetOIDCConnector",
"gets",
"OIDC",
"connectors",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1635-L1654 | train |
gravitational/teleport | lib/auth/clt.go | CreateOIDCAuthRequest | func (c *Client) CreateOIDCAuthRequest(req services.OIDCAuthRequest) (*services.OIDCAuthRequest, error) {
out, err := c.PostJSON(c.Endpoint("oidc", "requests", "create"), createOIDCAuthRequestReq{
Req: req,
})
if err != nil {
return nil, trace.Wrap(err)
}
var response *services.OIDCAuthRequest
if err := json.Unmarshal(out.Bytes(), &response); err != nil {
return nil, trace.Wrap(err)
}
return response, nil
} | go | func (c *Client) CreateOIDCAuthRequest(req services.OIDCAuthRequest) (*services.OIDCAuthRequest, error) {
out, err := c.PostJSON(c.Endpoint("oidc", "requests", "create"), createOIDCAuthRequestReq{
Req: req,
})
if err != nil {
return nil, trace.Wrap(err)
}
var response *services.OIDCAuthRequest
if err := json.Unmarshal(out.Bytes(), &response); err != nil {
return nil, trace.Wrap(err)
}
return response, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateOIDCAuthRequest",
"(",
"req",
"services",
".",
"OIDCAuthRequest",
")",
"(",
"*",
"services",
".",
"OIDCAuthRequest",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"oidc\"",
",",
"\"requests\"",
",",
"\"create\"",
")",
",",
"createOIDCAuthRequestReq",
"{",
"Req",
":",
"req",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"response",
"*",
"services",
".",
"OIDCAuthRequest",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"response",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | // CreateOIDCAuthRequest creates OIDCAuthRequest | [
"CreateOIDCAuthRequest",
"creates",
"OIDCAuthRequest"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1666-L1678 | train |
gravitational/teleport | lib/auth/clt.go | CreateSAMLConnector | func (c *Client) CreateSAMLConnector(connector services.SAMLConnector) error {
data, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("saml", "connectors"), &createSAMLConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) CreateSAMLConnector(connector services.SAMLConnector) error {
data, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("saml", "connectors"), &createSAMLConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateSAMLConnector",
"(",
"connector",
"services",
".",
"SAMLConnector",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"MarshalSAMLConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"connectors\"",
")",
",",
"&",
"createSAMLConnectorRawReq",
"{",
"Connector",
":",
"data",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateOIDCConnector creates SAML connector | [
"CreateOIDCConnector",
"creates",
"SAML",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1718-L1730 | train |
gravitational/teleport | lib/auth/clt.go | UpsertSAMLConnector | func (c *Client) UpsertSAMLConnector(connector services.SAMLConnector) error {
data, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("saml", "connectors"), &upsertSAMLConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) UpsertSAMLConnector(connector services.SAMLConnector) error {
data, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("saml", "connectors"), &upsertSAMLConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertSAMLConnector",
"(",
"connector",
"services",
".",
"SAMLConnector",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"MarshalSAMLConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PutJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"connectors\"",
")",
",",
"&",
"upsertSAMLConnectorRawReq",
"{",
"Connector",
":",
"data",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertSAMLConnector updates or creates OIDC connector | [
"UpsertSAMLConnector",
"updates",
"or",
"creates",
"OIDC",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1733-L1745 | train |
gravitational/teleport | lib/auth/clt.go | GetSAMLConnector | func (c *Client) GetSAMLConnector(id string, withSecrets bool) (services.SAMLConnector, error) {
if id == "" {
return nil, trace.BadParameter("missing connector id")
}
out, err := c.Get(c.Endpoint("saml", "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(out.Bytes(), services.SkipValidation())
} | go | func (c *Client) GetSAMLConnector(id string, withSecrets bool) (services.SAMLConnector, error) {
if id == "" {
return nil, trace.BadParameter("missing connector id")
}
out, err := c.Get(c.Endpoint("saml", "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(out.Bytes(), services.SkipValidation())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetSAMLConnector",
"(",
"id",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"SAMLConnector",
",",
"error",
")",
"{",
"if",
"id",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing connector id\"",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"connectors\"",
",",
"id",
")",
",",
"url",
".",
"Values",
"{",
"\"with_secrets\"",
":",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%t\"",
",",
"withSecrets",
")",
"}",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"UnmarshalSAMLConnector",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"}"
] | // GetOIDCConnector returns SAML connector information by id | [
"GetOIDCConnector",
"returns",
"SAML",
"connector",
"information",
"by",
"id"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1748-L1758 | train |
gravitational/teleport | lib/auth/clt.go | GetSAMLConnectors | func (c *Client) GetSAMLConnectors(withSecrets bool) ([]services.SAMLConnector, error) {
out, err := c.Get(c.Endpoint("saml", "connectors"),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.SAMLConnector, len(items))
for i, raw := range items {
connector, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
connectors[i] = connector
}
return connectors, nil
} | go | func (c *Client) GetSAMLConnectors(withSecrets bool) ([]services.SAMLConnector, error) {
out, err := c.Get(c.Endpoint("saml", "connectors"),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.SAMLConnector, len(items))
for i, raw := range items {
connector, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
connectors[i] = connector
}
return connectors, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetSAMLConnectors",
"(",
"withSecrets",
"bool",
")",
"(",
"[",
"]",
"services",
".",
"SAMLConnector",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"connectors\"",
")",
",",
"url",
".",
"Values",
"{",
"\"with_secrets\"",
":",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%t\"",
",",
"withSecrets",
")",
"}",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"SAMLConnector",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"items",
"{",
"connector",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"UnmarshalSAMLConnector",
"(",
"raw",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
"[",
"i",
"]",
"=",
"connector",
"\n",
"}",
"\n",
"return",
"connectors",
",",
"nil",
"\n",
"}"
] | // GetSAMLConnectors gets SAML connectors list | [
"GetSAMLConnectors",
"gets",
"SAML",
"connectors",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1761-L1780 | train |
gravitational/teleport | lib/auth/clt.go | DeleteSAMLConnector | func (c *Client) DeleteSAMLConnector(connectorID string) error {
if connectorID == "" {
return trace.BadParameter("missing connector id")
}
_, err := c.Delete(c.Endpoint("saml", "connectors", connectorID))
return trace.Wrap(err)
} | go | func (c *Client) DeleteSAMLConnector(connectorID string) error {
if connectorID == "" {
return trace.BadParameter("missing connector id")
}
_, err := c.Delete(c.Endpoint("saml", "connectors", connectorID))
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteSAMLConnector",
"(",
"connectorID",
"string",
")",
"error",
"{",
"if",
"connectorID",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing connector id\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"connectors\"",
",",
"connectorID",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteSAMLConnector deletes SAML connector by ID | [
"DeleteSAMLConnector",
"deletes",
"SAML",
"connector",
"by",
"ID"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1783-L1789 | train |
gravitational/teleport | lib/auth/clt.go | CreateSAMLAuthRequest | func (c *Client) CreateSAMLAuthRequest(req services.SAMLAuthRequest) (*services.SAMLAuthRequest, error) {
out, err := c.PostJSON(c.Endpoint("saml", "requests", "create"), createSAMLAuthRequestReq{
Req: req,
})
if err != nil {
return nil, trace.Wrap(err)
}
var response *services.SAMLAuthRequest
if err := json.Unmarshal(out.Bytes(), &response); err != nil {
return nil, trace.Wrap(err)
}
return response, nil
} | go | func (c *Client) CreateSAMLAuthRequest(req services.SAMLAuthRequest) (*services.SAMLAuthRequest, error) {
out, err := c.PostJSON(c.Endpoint("saml", "requests", "create"), createSAMLAuthRequestReq{
Req: req,
})
if err != nil {
return nil, trace.Wrap(err)
}
var response *services.SAMLAuthRequest
if err := json.Unmarshal(out.Bytes(), &response); err != nil {
return nil, trace.Wrap(err)
}
return response, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateSAMLAuthRequest",
"(",
"req",
"services",
".",
"SAMLAuthRequest",
")",
"(",
"*",
"services",
".",
"SAMLAuthRequest",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"requests\"",
",",
"\"create\"",
")",
",",
"createSAMLAuthRequestReq",
"{",
"Req",
":",
"req",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"response",
"*",
"services",
".",
"SAMLAuthRequest",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"response",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | // CreateSAMLAuthRequest creates SAML AuthnRequest | [
"CreateSAMLAuthRequest",
"creates",
"SAML",
"AuthnRequest"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1792-L1804 | train |
gravitational/teleport | lib/auth/clt.go | ValidateSAMLResponse | func (c *Client) ValidateSAMLResponse(re string) (*SAMLAuthResponse, error) {
out, err := c.PostJSON(c.Endpoint("saml", "requests", "validate"), validateSAMLResponseReq{
Response: re,
})
if err != nil {
return nil, trace.Wrap(err)
}
var rawResponse *samlAuthRawResponse
if err := json.Unmarshal(out.Bytes(), &rawResponse); err != nil {
return nil, trace.Wrap(err)
}
response := SAMLAuthResponse{
Username: rawResponse.Username,
Identity: rawResponse.Identity,
Cert: rawResponse.Cert,
Req: rawResponse.Req,
TLSCert: rawResponse.TLSCert,
}
if len(rawResponse.Session) != 0 {
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(rawResponse.Session)
if err != nil {
return nil, trace.Wrap(err)
}
response.Session = session
}
response.HostSigners = make([]services.CertAuthority, len(rawResponse.HostSigners))
for i, raw := range rawResponse.HostSigners {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw)
if err != nil {
return nil, trace.Wrap(err)
}
response.HostSigners[i] = ca
}
return &response, nil
} | go | func (c *Client) ValidateSAMLResponse(re string) (*SAMLAuthResponse, error) {
out, err := c.PostJSON(c.Endpoint("saml", "requests", "validate"), validateSAMLResponseReq{
Response: re,
})
if err != nil {
return nil, trace.Wrap(err)
}
var rawResponse *samlAuthRawResponse
if err := json.Unmarshal(out.Bytes(), &rawResponse); err != nil {
return nil, trace.Wrap(err)
}
response := SAMLAuthResponse{
Username: rawResponse.Username,
Identity: rawResponse.Identity,
Cert: rawResponse.Cert,
Req: rawResponse.Req,
TLSCert: rawResponse.TLSCert,
}
if len(rawResponse.Session) != 0 {
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(rawResponse.Session)
if err != nil {
return nil, trace.Wrap(err)
}
response.Session = session
}
response.HostSigners = make([]services.CertAuthority, len(rawResponse.HostSigners))
for i, raw := range rawResponse.HostSigners {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw)
if err != nil {
return nil, trace.Wrap(err)
}
response.HostSigners[i] = ca
}
return &response, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ValidateSAMLResponse",
"(",
"re",
"string",
")",
"(",
"*",
"SAMLAuthResponse",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"saml\"",
",",
"\"requests\"",
",",
"\"validate\"",
")",
",",
"validateSAMLResponseReq",
"{",
"Response",
":",
"re",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"rawResponse",
"*",
"samlAuthRawResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"rawResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
":=",
"SAMLAuthResponse",
"{",
"Username",
":",
"rawResponse",
".",
"Username",
",",
"Identity",
":",
"rawResponse",
".",
"Identity",
",",
"Cert",
":",
"rawResponse",
".",
"Cert",
",",
"Req",
":",
"rawResponse",
".",
"Req",
",",
"TLSCert",
":",
"rawResponse",
".",
"TLSCert",
",",
"}",
"\n",
"if",
"len",
"(",
"rawResponse",
".",
"Session",
")",
"!=",
"0",
"{",
"session",
",",
"err",
":=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"rawResponse",
".",
"Session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
".",
"Session",
"=",
"session",
"\n",
"}",
"\n",
"response",
".",
"HostSigners",
"=",
"make",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
",",
"len",
"(",
"rawResponse",
".",
"HostSigners",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"rawResponse",
".",
"HostSigners",
"{",
"ca",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"UnmarshalCertAuthority",
"(",
"raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
".",
"HostSigners",
"[",
"i",
"]",
"=",
"ca",
"\n",
"}",
"\n",
"return",
"&",
"response",
",",
"nil",
"\n",
"}"
] | // ValidateSAMLResponse validates response returned by SAML identity provider | [
"ValidateSAMLResponse",
"validates",
"response",
"returned",
"by",
"SAML",
"identity",
"provider"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1807-L1841 | train |
gravitational/teleport | lib/auth/clt.go | UpsertGithubConnector | func (c *Client) UpsertGithubConnector(connector services.GithubConnector) error {
bytes, err := services.GetGithubConnectorMarshaler().Marshal(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("github", "connectors"), &upsertGithubConnectorRawReq{
Connector: bytes,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) UpsertGithubConnector(connector services.GithubConnector) error {
bytes, err := services.GetGithubConnectorMarshaler().Marshal(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("github", "connectors"), &upsertGithubConnectorRawReq{
Connector: bytes,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertGithubConnector",
"(",
"connector",
"services",
".",
"GithubConnector",
")",
"error",
"{",
"bytes",
",",
"err",
":=",
"services",
".",
"GetGithubConnectorMarshaler",
"(",
")",
".",
"Marshal",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PutJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"github\"",
",",
"\"connectors\"",
")",
",",
"&",
"upsertGithubConnectorRawReq",
"{",
"Connector",
":",
"bytes",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertGithubConnector creates or updates a Github connector | [
"UpsertGithubConnector",
"creates",
"or",
"updates",
"a",
"Github",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1859-L1871 | train |
gravitational/teleport | lib/auth/clt.go | GetGithubConnector | func (c *Client) GetGithubConnector(id string, withSecrets bool) (services.GithubConnector, error) {
out, err := c.Get(c.Endpoint("github", "connectors", id), url.Values{
"with_secrets": []string{strconv.FormatBool(withSecrets)},
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetGithubConnectorMarshaler().Unmarshal(out.Bytes())
} | go | func (c *Client) GetGithubConnector(id string, withSecrets bool) (services.GithubConnector, error) {
out, err := c.Get(c.Endpoint("github", "connectors", id), url.Values{
"with_secrets": []string{strconv.FormatBool(withSecrets)},
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetGithubConnectorMarshaler().Unmarshal(out.Bytes())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetGithubConnector",
"(",
"id",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"GithubConnector",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"github\"",
",",
"\"connectors\"",
",",
"id",
")",
",",
"url",
".",
"Values",
"{",
"\"with_secrets\"",
":",
"[",
"]",
"string",
"{",
"strconv",
".",
"FormatBool",
"(",
"withSecrets",
")",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetGithubConnectorMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // GetGithubConnector returns the specified Github connector | [
"GetGithubConnector",
"returns",
"the",
"specified",
"Github",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1897-L1905 | train |
gravitational/teleport | lib/auth/clt.go | DeleteGithubConnector | func (c *Client) DeleteGithubConnector(id string) error {
_, err := c.Delete(c.Endpoint("github", "connectors", id))
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) DeleteGithubConnector(id string) error {
_, err := c.Delete(c.Endpoint("github", "connectors", id))
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteGithubConnector",
"(",
"id",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"github\"",
",",
"\"connectors\"",
",",
"id",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteGithubConnector deletes the specified Github connector | [
"DeleteGithubConnector",
"deletes",
"the",
"specified",
"Github",
"connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1908-L1914 | train |
gravitational/teleport | lib/auth/clt.go | ValidateGithubAuthCallback | func (c *Client) ValidateGithubAuthCallback(q url.Values) (*GithubAuthResponse, error) {
out, err := c.PostJSON(c.Endpoint("github", "requests", "validate"),
validateGithubAuthCallbackReq{Query: q})
if err != nil {
return nil, trace.Wrap(err)
}
var rawResponse githubAuthRawResponse
if err := json.Unmarshal(out.Bytes(), &rawResponse); err != nil {
return nil, trace.Wrap(err)
}
response := GithubAuthResponse{
Username: rawResponse.Username,
Identity: rawResponse.Identity,
Cert: rawResponse.Cert,
Req: rawResponse.Req,
TLSCert: rawResponse.TLSCert,
}
if len(rawResponse.Session) != 0 {
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(
rawResponse.Session)
if err != nil {
return nil, trace.Wrap(err)
}
response.Session = session
}
response.HostSigners = make([]services.CertAuthority, len(rawResponse.HostSigners))
for i, raw := range rawResponse.HostSigners {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw)
if err != nil {
return nil, trace.Wrap(err)
}
response.HostSigners[i] = ca
}
return &response, nil
} | go | func (c *Client) ValidateGithubAuthCallback(q url.Values) (*GithubAuthResponse, error) {
out, err := c.PostJSON(c.Endpoint("github", "requests", "validate"),
validateGithubAuthCallbackReq{Query: q})
if err != nil {
return nil, trace.Wrap(err)
}
var rawResponse githubAuthRawResponse
if err := json.Unmarshal(out.Bytes(), &rawResponse); err != nil {
return nil, trace.Wrap(err)
}
response := GithubAuthResponse{
Username: rawResponse.Username,
Identity: rawResponse.Identity,
Cert: rawResponse.Cert,
Req: rawResponse.Req,
TLSCert: rawResponse.TLSCert,
}
if len(rawResponse.Session) != 0 {
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(
rawResponse.Session)
if err != nil {
return nil, trace.Wrap(err)
}
response.Session = session
}
response.HostSigners = make([]services.CertAuthority, len(rawResponse.HostSigners))
for i, raw := range rawResponse.HostSigners {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw)
if err != nil {
return nil, trace.Wrap(err)
}
response.HostSigners[i] = ca
}
return &response, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ValidateGithubAuthCallback",
"(",
"q",
"url",
".",
"Values",
")",
"(",
"*",
"GithubAuthResponse",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"github\"",
",",
"\"requests\"",
",",
"\"validate\"",
")",
",",
"validateGithubAuthCallbackReq",
"{",
"Query",
":",
"q",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"rawResponse",
"githubAuthRawResponse",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"rawResponse",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
":=",
"GithubAuthResponse",
"{",
"Username",
":",
"rawResponse",
".",
"Username",
",",
"Identity",
":",
"rawResponse",
".",
"Identity",
",",
"Cert",
":",
"rawResponse",
".",
"Cert",
",",
"Req",
":",
"rawResponse",
".",
"Req",
",",
"TLSCert",
":",
"rawResponse",
".",
"TLSCert",
",",
"}",
"\n",
"if",
"len",
"(",
"rawResponse",
".",
"Session",
")",
"!=",
"0",
"{",
"session",
",",
"err",
":=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"rawResponse",
".",
"Session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
".",
"Session",
"=",
"session",
"\n",
"}",
"\n",
"response",
".",
"HostSigners",
"=",
"make",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
",",
"len",
"(",
"rawResponse",
".",
"HostSigners",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"rawResponse",
".",
"HostSigners",
"{",
"ca",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"UnmarshalCertAuthority",
"(",
"raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
".",
"HostSigners",
"[",
"i",
"]",
"=",
"ca",
"\n",
"}",
"\n",
"return",
"&",
"response",
",",
"nil",
"\n",
"}"
] | // ValidateGithubAuthCallback validates Github auth callback returned from redirect | [
"ValidateGithubAuthCallback",
"validates",
"Github",
"auth",
"callback",
"returned",
"from",
"redirect"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1931-L1965 | train |
gravitational/teleport | lib/auth/clt.go | SearchEvents | func (c *Client) SearchEvents(from, to time.Time, query string, limit int) ([]events.EventFields, error) {
q, err := url.ParseQuery(query)
if err != nil {
return nil, trace.BadParameter("query")
}
q.Set("from", from.Format(time.RFC3339))
q.Set("to", to.Format(time.RFC3339))
q.Set("limit", fmt.Sprintf("%v", limit))
response, err := c.Get(c.Endpoint("events"), q)
if err != nil {
return nil, trace.Wrap(err)
}
retval := make([]events.EventFields, 0)
if err := json.Unmarshal(response.Bytes(), &retval); err != nil {
return nil, trace.Wrap(err)
}
return retval, nil
} | go | func (c *Client) SearchEvents(from, to time.Time, query string, limit int) ([]events.EventFields, error) {
q, err := url.ParseQuery(query)
if err != nil {
return nil, trace.BadParameter("query")
}
q.Set("from", from.Format(time.RFC3339))
q.Set("to", to.Format(time.RFC3339))
q.Set("limit", fmt.Sprintf("%v", limit))
response, err := c.Get(c.Endpoint("events"), q)
if err != nil {
return nil, trace.Wrap(err)
}
retval := make([]events.EventFields, 0)
if err := json.Unmarshal(response.Bytes(), &retval); err != nil {
return nil, trace.Wrap(err)
}
return retval, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SearchEvents",
"(",
"from",
",",
"to",
"time",
".",
"Time",
",",
"query",
"string",
",",
"limit",
"int",
")",
"(",
"[",
"]",
"events",
".",
"EventFields",
",",
"error",
")",
"{",
"q",
",",
"err",
":=",
"url",
".",
"ParseQuery",
"(",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"query\"",
")",
"\n",
"}",
"\n",
"q",
".",
"Set",
"(",
"\"from\"",
",",
"from",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"q",
".",
"Set",
"(",
"\"to\"",
",",
"to",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"q",
".",
"Set",
"(",
"\"limit\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"limit",
")",
")",
"\n",
"response",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"events\"",
")",
",",
"q",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"retval",
":=",
"make",
"(",
"[",
"]",
"events",
".",
"EventFields",
",",
"0",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"response",
".",
"Bytes",
"(",
")",
",",
"&",
"retval",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"retval",
",",
"nil",
"\n",
"}"
] | // SearchEvents returns events that fit the criteria | [
"SearchEvents",
"returns",
"events",
"that",
"fit",
"the",
"criteria"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2075-L2092 | train |
gravitational/teleport | lib/auth/clt.go | GetClusterConfig | func (c *Client) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
out, err := c.Get(c.Endpoint("configuration"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
cc, err := services.GetClusterConfigMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return cc, err
} | go | func (c *Client) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
out, err := c.Get(c.Endpoint("configuration"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
cc, err := services.GetClusterConfigMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return cc, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetClusterConfig",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"ClusterConfig",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"configuration\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cc",
",",
"err",
":=",
"services",
".",
"GetClusterConfigMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cc",
",",
"err",
"\n",
"}"
] | // GetClusterConfig returns cluster level configuration information. | [
"GetClusterConfig",
"returns",
"cluster",
"level",
"configuration",
"information",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2211-L2223 | train |
gravitational/teleport | lib/auth/clt.go | SetClusterConfig | func (c *Client) SetClusterConfig(cc services.ClusterConfig) error {
data, err := services.GetClusterConfigMarshaler().Marshal(cc)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration"), &setClusterConfigReq{ClusterConfig: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) SetClusterConfig(cc services.ClusterConfig) error {
data, err := services.GetClusterConfigMarshaler().Marshal(cc)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration"), &setClusterConfigReq{ClusterConfig: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetClusterConfig",
"(",
"cc",
"services",
".",
"ClusterConfig",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetClusterConfigMarshaler",
"(",
")",
".",
"Marshal",
"(",
"cc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"configuration\"",
")",
",",
"&",
"setClusterConfigReq",
"{",
"ClusterConfig",
":",
"data",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetClusterConfig sets cluster level configuration information. | [
"SetClusterConfig",
"sets",
"cluster",
"level",
"configuration",
"information",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2226-L2238 | train |
gravitational/teleport | lib/auth/clt.go | GetClusterName | func (c *Client) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
out, err := c.Get(c.Endpoint("configuration", "name"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
cn, err := services.GetClusterNameMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return cn, err
} | go | func (c *Client) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
out, err := c.Get(c.Endpoint("configuration", "name"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
cn, err := services.GetClusterNameMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return cn, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetClusterName",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"ClusterName",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"configuration\"",
",",
"\"name\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cn",
",",
"err",
":=",
"services",
".",
"GetClusterNameMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cn",
",",
"err",
"\n",
"}"
] | // GetClusterName returns a cluster name | [
"GetClusterName",
"returns",
"a",
"cluster",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2241-L2253 | train |
gravitational/teleport | lib/auth/clt.go | SetClusterName | func (c *Client) SetClusterName(cn services.ClusterName) error {
data, err := services.GetClusterNameMarshaler().Marshal(cn)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "name"), &setClusterNameReq{ClusterName: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) SetClusterName(cn services.ClusterName) error {
data, err := services.GetClusterNameMarshaler().Marshal(cn)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "name"), &setClusterNameReq{ClusterName: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetClusterName",
"(",
"cn",
"services",
".",
"ClusterName",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetClusterNameMarshaler",
"(",
")",
".",
"Marshal",
"(",
"cn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"configuration\"",
",",
"\"name\"",
")",
",",
"&",
"setClusterNameReq",
"{",
"ClusterName",
":",
"data",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetClusterName sets cluster name once, will
// return Already Exists error if the name is already set | [
"SetClusterName",
"sets",
"cluster",
"name",
"once",
"will",
"return",
"Already",
"Exists",
"error",
"if",
"the",
"name",
"is",
"already",
"set"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2257-L2269 | train |
gravitational/teleport | lib/auth/clt.go | GetStaticTokens | func (c *Client) GetStaticTokens() (services.StaticTokens, error) {
out, err := c.Get(c.Endpoint("configuration", "static_tokens"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
st, err := services.GetStaticTokensMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return st, err
} | go | func (c *Client) GetStaticTokens() (services.StaticTokens, error) {
out, err := c.Get(c.Endpoint("configuration", "static_tokens"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
st, err := services.GetStaticTokensMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return st, err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetStaticTokens",
"(",
")",
"(",
"services",
".",
"StaticTokens",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"configuration\"",
",",
"\"static_tokens\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"st",
",",
"err",
":=",
"services",
".",
"GetStaticTokensMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"st",
",",
"err",
"\n",
"}"
] | // GetStaticTokens returns a list of static register tokens | [
"GetStaticTokens",
"returns",
"a",
"list",
"of",
"static",
"register",
"tokens"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2283-L2295 | train |
gravitational/teleport | lib/auth/clt.go | SetStaticTokens | func (c *Client) SetStaticTokens(st services.StaticTokens) error {
data, err := services.GetStaticTokensMarshaler().Marshal(st)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "static_tokens"), &setStaticTokensReq{StaticTokens: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) SetStaticTokens(st services.StaticTokens) error {
data, err := services.GetStaticTokensMarshaler().Marshal(st)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "static_tokens"), &setStaticTokensReq{StaticTokens: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetStaticTokens",
"(",
"st",
"services",
".",
"StaticTokens",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetStaticTokensMarshaler",
"(",
")",
".",
"Marshal",
"(",
"st",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"configuration\"",
",",
"\"static_tokens\"",
")",
",",
"&",
"setStaticTokensReq",
"{",
"StaticTokens",
":",
"data",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetStaticTokens sets a list of static register tokens | [
"SetStaticTokens",
"sets",
"a",
"list",
"of",
"static",
"register",
"tokens"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L2298-L2310 | train |
gravitational/teleport | lib/srv/forward/subsystem.go | Start | func (r *remoteSubsystem) Start(channel ssh.Channel) error {
session := r.serverContext.RemoteSession
stdout, err := session.StdoutPipe()
if err != nil {
return trace.Wrap(err)
}
stderr, err := session.StderrPipe()
if err != nil {
return trace.Wrap(err)
}
stdin, err := session.StdinPipe()
if err != nil {
return trace.Wrap(err)
}
// request the subsystem from the remote node. if successful, the user can
// interact with the remote subsystem with stdin, stdout, and stderr.
err = session.RequestSubsystem(r.subsytemName)
if err != nil {
// emit an event to the audit log with the reason remote execution failed
r.emitAuditEvent(err)
return trace.Wrap(err)
}
// copy back and forth between stdin, stdout, and stderr and the SSH channel.
go func() {
defer session.Close()
_, err := io.Copy(channel, stdout)
r.errorCh <- err
}()
go func() {
defer session.Close()
_, err := io.Copy(channel.Stderr(), stderr)
r.errorCh <- err
}()
go func() {
defer session.Close()
_, err := io.Copy(stdin, channel)
r.errorCh <- err
}()
return nil
} | go | func (r *remoteSubsystem) Start(channel ssh.Channel) error {
session := r.serverContext.RemoteSession
stdout, err := session.StdoutPipe()
if err != nil {
return trace.Wrap(err)
}
stderr, err := session.StderrPipe()
if err != nil {
return trace.Wrap(err)
}
stdin, err := session.StdinPipe()
if err != nil {
return trace.Wrap(err)
}
// request the subsystem from the remote node. if successful, the user can
// interact with the remote subsystem with stdin, stdout, and stderr.
err = session.RequestSubsystem(r.subsytemName)
if err != nil {
// emit an event to the audit log with the reason remote execution failed
r.emitAuditEvent(err)
return trace.Wrap(err)
}
// copy back and forth between stdin, stdout, and stderr and the SSH channel.
go func() {
defer session.Close()
_, err := io.Copy(channel, stdout)
r.errorCh <- err
}()
go func() {
defer session.Close()
_, err := io.Copy(channel.Stderr(), stderr)
r.errorCh <- err
}()
go func() {
defer session.Close()
_, err := io.Copy(stdin, channel)
r.errorCh <- err
}()
return nil
} | [
"func",
"(",
"r",
"*",
"remoteSubsystem",
")",
"Start",
"(",
"channel",
"ssh",
".",
"Channel",
")",
"error",
"{",
"session",
":=",
"r",
".",
"serverContext",
".",
"RemoteSession",
"\n",
"stdout",
",",
"err",
":=",
"session",
".",
"StdoutPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"stderr",
",",
"err",
":=",
"session",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"stdin",
",",
"err",
":=",
"session",
".",
"StdinPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"session",
".",
"RequestSubsystem",
"(",
"r",
".",
"subsytemName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r",
".",
"emitAuditEvent",
"(",
"err",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"channel",
",",
"stdout",
")",
"\n",
"r",
".",
"errorCh",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"channel",
".",
"Stderr",
"(",
")",
",",
"stderr",
")",
"\n",
"r",
".",
"errorCh",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"stdin",
",",
"channel",
")",
"\n",
"r",
".",
"errorCh",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Start will begin execution of the remote subsytem on the passed in channel. | [
"Start",
"will",
"begin",
"execution",
"of",
"the",
"remote",
"subsytem",
"on",
"the",
"passed",
"in",
"channel",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/forward/subsystem.go#L61-L108 | train |
gravitational/teleport | lib/srv/forward/subsystem.go | Wait | func (r *remoteSubsystem) Wait() error {
var lastErr error
for i := 0; i < 3; i++ {
select {
case err := <-r.errorCh:
if err != nil && err != io.EOF {
r.log.Warnf("Connection problem: %v %T", trace.DebugReport(err), err)
lastErr = err
}
case <-r.ctx.Done():
lastErr = trace.ConnectionProblem(nil, "context is closing")
}
}
// emit an event to the audit log with the result of execution
r.emitAuditEvent(lastErr)
return lastErr
} | go | func (r *remoteSubsystem) Wait() error {
var lastErr error
for i := 0; i < 3; i++ {
select {
case err := <-r.errorCh:
if err != nil && err != io.EOF {
r.log.Warnf("Connection problem: %v %T", trace.DebugReport(err), err)
lastErr = err
}
case <-r.ctx.Done():
lastErr = trace.ConnectionProblem(nil, "context is closing")
}
}
// emit an event to the audit log with the result of execution
r.emitAuditEvent(lastErr)
return lastErr
} | [
"func",
"(",
"r",
"*",
"remoteSubsystem",
")",
"Wait",
"(",
")",
"error",
"{",
"var",
"lastErr",
"error",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"3",
";",
"i",
"++",
"{",
"select",
"{",
"case",
"err",
":=",
"<-",
"r",
".",
"errorCh",
":",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"r",
".",
"log",
".",
"Warnf",
"(",
"\"Connection problem: %v %T\"",
",",
"trace",
".",
"DebugReport",
"(",
"err",
")",
",",
"err",
")",
"\n",
"lastErr",
"=",
"err",
"\n",
"}",
"\n",
"case",
"<-",
"r",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"lastErr",
"=",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"context is closing\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"emitAuditEvent",
"(",
"lastErr",
")",
"\n",
"return",
"lastErr",
"\n",
"}"
] | // Wait until the remote subsystem has finished execution and then return the last error. | [
"Wait",
"until",
"the",
"remote",
"subsystem",
"has",
"finished",
"execution",
"and",
"then",
"return",
"the",
"last",
"error",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/forward/subsystem.go#L111-L130 | train |
gravitational/teleport | lib/services/session.go | NewWebSession | func NewWebSession(name string, spec WebSessionSpecV2) WebSession {
return &WebSessionV2{
Kind: KindWebSession,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | go | func NewWebSession(name string, spec WebSessionSpecV2) WebSession {
return &WebSessionV2{
Kind: KindWebSession,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | [
"func",
"NewWebSession",
"(",
"name",
"string",
",",
"spec",
"WebSessionSpecV2",
")",
"WebSession",
"{",
"return",
"&",
"WebSessionV2",
"{",
"Kind",
":",
"KindWebSession",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"}"
] | // NewWebSession returns new instance of the web session based on the V2 spec | [
"NewWebSession",
"returns",
"new",
"instance",
"of",
"the",
"web",
"session",
"based",
"on",
"the",
"V2",
"spec"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L74-L84 | train |
gravitational/teleport | lib/services/session.go | WithoutSecrets | func (ws *WebSessionV2) WithoutSecrets() WebSession {
v2 := ws.V2()
v2.Spec.Priv = nil
return v2
} | go | func (ws *WebSessionV2) WithoutSecrets() WebSession {
v2 := ws.V2()
v2.Spec.Priv = nil
return v2
} | [
"func",
"(",
"ws",
"*",
"WebSessionV2",
")",
"WithoutSecrets",
"(",
")",
"WebSession",
"{",
"v2",
":=",
"ws",
".",
"V2",
"(",
")",
"\n",
"v2",
".",
"Spec",
".",
"Priv",
"=",
"nil",
"\n",
"return",
"v2",
"\n",
"}"
] | // WithoutSecrets returns copy of the object but without secrets | [
"WithoutSecrets",
"returns",
"copy",
"of",
"the",
"object",
"but",
"without",
"secrets"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L123-L127 | train |
gravitational/teleport | lib/services/session.go | GetShortName | func (ws *WebSessionV2) GetShortName() string {
if len(ws.Metadata.Name) < 4 {
return "<undefined>"
}
return ws.Metadata.Name[:4]
} | go | func (ws *WebSessionV2) GetShortName() string {
if len(ws.Metadata.Name) < 4 {
return "<undefined>"
}
return ws.Metadata.Name[:4]
} | [
"func",
"(",
"ws",
"*",
"WebSessionV2",
")",
"GetShortName",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"ws",
".",
"Metadata",
".",
"Name",
")",
"<",
"4",
"{",
"return",
"\"<undefined>\"",
"\n",
"}",
"\n",
"return",
"ws",
".",
"Metadata",
".",
"Name",
"[",
":",
"4",
"]",
"\n",
"}"
] | // GetShortName returns visible short name used in logging | [
"GetShortName",
"returns",
"visible",
"short",
"name",
"used",
"in",
"logging"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L155-L160 | train |
gravitational/teleport | lib/services/session.go | SetBearerTokenExpiryTime | func (ws *WebSessionV2) SetBearerTokenExpiryTime(tm time.Time) {
ws.Spec.BearerTokenExpires = tm
} | go | func (ws *WebSessionV2) SetBearerTokenExpiryTime(tm time.Time) {
ws.Spec.BearerTokenExpires = tm
} | [
"func",
"(",
"ws",
"*",
"WebSessionV2",
")",
"SetBearerTokenExpiryTime",
"(",
"tm",
"time",
".",
"Time",
")",
"{",
"ws",
".",
"Spec",
".",
"BearerTokenExpires",
"=",
"tm",
"\n",
"}"
] | // SetBearerTokenExpiryTime sets bearer token expiry time | [
"SetBearerTokenExpiryTime",
"sets",
"bearer",
"token",
"expiry",
"time"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L194-L196 | train |
gravitational/teleport | lib/services/session.go | SetExpiryTime | func (ws *WebSessionV2) SetExpiryTime(tm time.Time) {
ws.Spec.Expires = tm
} | go | func (ws *WebSessionV2) SetExpiryTime(tm time.Time) {
ws.Spec.Expires = tm
} | [
"func",
"(",
"ws",
"*",
"WebSessionV2",
")",
"SetExpiryTime",
"(",
"tm",
"time",
".",
"Time",
")",
"{",
"ws",
".",
"Spec",
".",
"Expires",
"=",
"tm",
"\n",
"}"
] | // SetExpiryTime sets session expiry time | [
"SetExpiryTime",
"sets",
"session",
"expiry",
"time"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L199-L201 | train |
gravitational/teleport | lib/services/session.go | GetWebSessionSchemaWithExtensions | func GetWebSessionSchemaWithExtensions(extension string) string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(WebSessionSpecV2Schema, extension), DefaultDefinitions)
} | go | func GetWebSessionSchemaWithExtensions(extension string) string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(WebSessionSpecV2Schema, extension), DefaultDefinitions)
} | [
"func",
"GetWebSessionSchemaWithExtensions",
"(",
"extension",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"fmt",
".",
"Sprintf",
"(",
"WebSessionSpecV2Schema",
",",
"extension",
")",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] | // GetWebSessionSchemaWithExtensions returns JSON Schema for web session with user-supplied extensions | [
"GetWebSessionSchemaWithExtensions",
"returns",
"JSON",
"Schema",
"for",
"web",
"session",
"with",
"user",
"-",
"supplied",
"extensions"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L395-L397 | train |
gravitational/teleport | lib/services/session.go | UnmarshalWebSession | func (*TeleportWebSessionMarshaler) UnmarshalWebSession(bytes []byte) (WebSession, error) {
var h ResourceHeader
err := json.Unmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var ws WebSessionV1
err := json.Unmarshal(bytes, &ws)
if err != nil {
return nil, trace.Wrap(err)
}
utils.UTC(&ws.Expires)
return ws.V2(), nil
case V2:
var ws WebSessionV2
if err := utils.UnmarshalWithSchema(GetWebSessionSchema(), &ws, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
utils.UTC(&ws.Spec.BearerTokenExpires)
utils.UTC(&ws.Spec.Expires)
if err := ws.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &ws, nil
}
return nil, trace.BadParameter("web session resource version %v is not supported", h.Version)
} | go | func (*TeleportWebSessionMarshaler) UnmarshalWebSession(bytes []byte) (WebSession, error) {
var h ResourceHeader
err := json.Unmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var ws WebSessionV1
err := json.Unmarshal(bytes, &ws)
if err != nil {
return nil, trace.Wrap(err)
}
utils.UTC(&ws.Expires)
return ws.V2(), nil
case V2:
var ws WebSessionV2
if err := utils.UnmarshalWithSchema(GetWebSessionSchema(), &ws, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
utils.UTC(&ws.Spec.BearerTokenExpires)
utils.UTC(&ws.Spec.Expires)
if err := ws.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &ws, nil
}
return nil, trace.BadParameter("web session resource version %v is not supported", h.Version)
} | [
"func",
"(",
"*",
"TeleportWebSessionMarshaler",
")",
"UnmarshalWebSession",
"(",
"bytes",
"[",
"]",
"byte",
")",
"(",
"WebSession",
",",
"error",
")",
"{",
"var",
"h",
"ResourceHeader",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"ws",
"WebSessionV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"ws",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"utils",
".",
"UTC",
"(",
"&",
"ws",
".",
"Expires",
")",
"\n",
"return",
"ws",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"ws",
"WebSessionV2",
"\n",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetWebSessionSchema",
"(",
")",
",",
"&",
"ws",
",",
"bytes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"utils",
".",
"UTC",
"(",
"&",
"ws",
".",
"Spec",
".",
"BearerTokenExpires",
")",
"\n",
"utils",
".",
"UTC",
"(",
"&",
"ws",
".",
"Spec",
".",
"Expires",
")",
"\n",
"if",
"err",
":=",
"ws",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"ws",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"web session resource version %v is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalWebSession unmarshals web session from on-disk byte format | [
"UnmarshalWebSession",
"unmarshals",
"web",
"session",
"from",
"on",
"-",
"disk",
"byte",
"format"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L414-L445 | train |
gravitational/teleport | lib/services/session.go | MarshalWebSession | func (*TeleportWebSessionMarshaler) MarshalWebSession(ws WebSession, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type ws1 interface {
V1() *WebSessionV1
}
type ws2 interface {
V2() *WebSessionV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := ws.(ws1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal session %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := ws.(ws2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal session %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.Metadata.ID = 0
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | go | func (*TeleportWebSessionMarshaler) MarshalWebSession(ws WebSession, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type ws1 interface {
V1() *WebSessionV1
}
type ws2 interface {
V2() *WebSessionV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := ws.(ws1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal session %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := ws.(ws2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal session %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.Metadata.ID = 0
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | [
"func",
"(",
"*",
"TeleportWebSessionMarshaler",
")",
"MarshalWebSession",
"(",
"ws",
"WebSession",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"ws1",
"interface",
"{",
"V1",
"(",
")",
"*",
"WebSessionV1",
"\n",
"}",
"\n",
"type",
"ws2",
"interface",
"{",
"V2",
"(",
")",
"*",
"WebSessionV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"ws",
".",
"(",
"ws1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal session %v\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"ws",
".",
"(",
"ws2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal session %v\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"Metadata",
".",
"ID",
"=",
"0",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"version %v is not supported\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] | // MarshalWebSession marshals web session into on-disk representation | [
"MarshalWebSession",
"marshals",
"web",
"session",
"into",
"on",
"-",
"disk",
"representation"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/session.go#L448-L484 | train |
gravitational/teleport | lib/srv/sess.go | emitSessionJoinEvent | func (s *SessionRegistry) emitSessionJoinEvent(ctx *ServerContext) {
sessionJoinEvent := events.EventFields{
events.EventType: events.SessionJoinEvent,
events.SessionEventID: string(ctx.session.id),
events.EventNamespace: s.srv.GetNamespace(),
events.EventLogin: ctx.Identity.Login,
events.EventUser: ctx.Identity.TeleportUser,
events.LocalAddr: ctx.Conn.LocalAddr().String(),
events.RemoteAddr: ctx.Conn.RemoteAddr().String(),
events.SessionServerID: ctx.srv.ID(),
}
// Emit session join event to Audit Log.
ctx.session.recorder.GetAuditLog().EmitAuditEvent(events.SessionJoin, sessionJoinEvent)
// Notify all members of the party that a new member has joined over the
// "x-teleport-event" channel.
for _, p := range s.getParties(ctx.session) {
eventPayload, err := json.Marshal(sessionJoinEvent)
if err != nil {
s.log.Warnf("Unable to marshal %v for %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to send %v to %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
s.log.Debugf("Sent %v to %v.", events.SessionJoinEvent, p.sconn.RemoteAddr())
}
} | go | func (s *SessionRegistry) emitSessionJoinEvent(ctx *ServerContext) {
sessionJoinEvent := events.EventFields{
events.EventType: events.SessionJoinEvent,
events.SessionEventID: string(ctx.session.id),
events.EventNamespace: s.srv.GetNamespace(),
events.EventLogin: ctx.Identity.Login,
events.EventUser: ctx.Identity.TeleportUser,
events.LocalAddr: ctx.Conn.LocalAddr().String(),
events.RemoteAddr: ctx.Conn.RemoteAddr().String(),
events.SessionServerID: ctx.srv.ID(),
}
// Emit session join event to Audit Log.
ctx.session.recorder.GetAuditLog().EmitAuditEvent(events.SessionJoin, sessionJoinEvent)
// Notify all members of the party that a new member has joined over the
// "x-teleport-event" channel.
for _, p := range s.getParties(ctx.session) {
eventPayload, err := json.Marshal(sessionJoinEvent)
if err != nil {
s.log.Warnf("Unable to marshal %v for %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to send %v to %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
s.log.Debugf("Sent %v to %v.", events.SessionJoinEvent, p.sconn.RemoteAddr())
}
} | [
"func",
"(",
"s",
"*",
"SessionRegistry",
")",
"emitSessionJoinEvent",
"(",
"ctx",
"*",
"ServerContext",
")",
"{",
"sessionJoinEvent",
":=",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventType",
":",
"events",
".",
"SessionJoinEvent",
",",
"events",
".",
"SessionEventID",
":",
"string",
"(",
"ctx",
".",
"session",
".",
"id",
")",
",",
"events",
".",
"EventNamespace",
":",
"s",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"events",
".",
"EventLogin",
":",
"ctx",
".",
"Identity",
".",
"Login",
",",
"events",
".",
"EventUser",
":",
"ctx",
".",
"Identity",
".",
"TeleportUser",
",",
"events",
".",
"LocalAddr",
":",
"ctx",
".",
"Conn",
".",
"LocalAddr",
"(",
")",
".",
"String",
"(",
")",
",",
"events",
".",
"RemoteAddr",
":",
"ctx",
".",
"Conn",
".",
"RemoteAddr",
"(",
")",
".",
"String",
"(",
")",
",",
"events",
".",
"SessionServerID",
":",
"ctx",
".",
"srv",
".",
"ID",
"(",
")",
",",
"}",
"\n",
"ctx",
".",
"session",
".",
"recorder",
".",
"GetAuditLog",
"(",
")",
".",
"EmitAuditEvent",
"(",
"events",
".",
"SessionJoin",
",",
"sessionJoinEvent",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"s",
".",
"getParties",
"(",
"ctx",
".",
"session",
")",
"{",
"eventPayload",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"sessionJoinEvent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to marshal %v for %v: %v.\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
"=",
"p",
".",
"sconn",
".",
"SendRequest",
"(",
"teleport",
".",
"SessionEvent",
",",
"false",
",",
"eventPayload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to send %v to %v: %v.\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"Sent %v to %v.\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // emitSessionJoinEvent emits a session join event to both the Audit Log as
// well as sending a "x-teleport-event" global request on the SSH connection. | [
"emitSessionJoinEvent",
"emits",
"a",
"session",
"join",
"event",
"to",
"both",
"the",
"Audit",
"Log",
"as",
"well",
"as",
"sending",
"a",
"x",
"-",
"teleport",
"-",
"event",
"global",
"request",
"on",
"the",
"SSH",
"connection",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L115-L145 | train |
gravitational/teleport | lib/srv/sess.go | OpenSession | func (s *SessionRegistry) OpenSession(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
if ctx.session != nil {
ctx.Infof("Joining existing session %v.", ctx.session.id)
// Update the in-memory data structure that a party member has joined.
_, err := ctx.session.join(ch, req, ctx)
if err != nil {
return trace.Wrap(err)
}
// Emit session join event to both the Audit Log as well as over the
// "x-teleport-event" channel in the SSH connection.
s.emitSessionJoinEvent(ctx)
return nil
}
// session not found? need to create one. start by getting/generating an ID for it
sid, found := ctx.GetEnv(sshutils.SessionEnvVar)
if !found {
sid = string(rsession.NewID())
ctx.SetEnv(sshutils.SessionEnvVar, sid)
}
// This logic allows concurrent request to create a new session
// to fail, what is ok because we should never have this condition
sess, err := newSession(rsession.ID(sid), s, ctx)
if err != nil {
return trace.Wrap(err)
}
ctx.session = sess
s.addSession(sess)
ctx.Infof("Creating session %v.", sid)
if err := sess.start(ch, ctx); err != nil {
sess.Close()
return trace.Wrap(err)
}
return nil
} | go | func (s *SessionRegistry) OpenSession(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
if ctx.session != nil {
ctx.Infof("Joining existing session %v.", ctx.session.id)
// Update the in-memory data structure that a party member has joined.
_, err := ctx.session.join(ch, req, ctx)
if err != nil {
return trace.Wrap(err)
}
// Emit session join event to both the Audit Log as well as over the
// "x-teleport-event" channel in the SSH connection.
s.emitSessionJoinEvent(ctx)
return nil
}
// session not found? need to create one. start by getting/generating an ID for it
sid, found := ctx.GetEnv(sshutils.SessionEnvVar)
if !found {
sid = string(rsession.NewID())
ctx.SetEnv(sshutils.SessionEnvVar, sid)
}
// This logic allows concurrent request to create a new session
// to fail, what is ok because we should never have this condition
sess, err := newSession(rsession.ID(sid), s, ctx)
if err != nil {
return trace.Wrap(err)
}
ctx.session = sess
s.addSession(sess)
ctx.Infof("Creating session %v.", sid)
if err := sess.start(ch, ctx); err != nil {
sess.Close()
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"SessionRegistry",
")",
"OpenSession",
"(",
"ch",
"ssh",
".",
"Channel",
",",
"req",
"*",
"ssh",
".",
"Request",
",",
"ctx",
"*",
"ServerContext",
")",
"error",
"{",
"if",
"ctx",
".",
"session",
"!=",
"nil",
"{",
"ctx",
".",
"Infof",
"(",
"\"Joining existing session %v.\"",
",",
"ctx",
".",
"session",
".",
"id",
")",
"\n",
"_",
",",
"err",
":=",
"ctx",
".",
"session",
".",
"join",
"(",
"ch",
",",
"req",
",",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"emitSessionJoinEvent",
"(",
"ctx",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"sid",
",",
"found",
":=",
"ctx",
".",
"GetEnv",
"(",
"sshutils",
".",
"SessionEnvVar",
")",
"\n",
"if",
"!",
"found",
"{",
"sid",
"=",
"string",
"(",
"rsession",
".",
"NewID",
"(",
")",
")",
"\n",
"ctx",
".",
"SetEnv",
"(",
"sshutils",
".",
"SessionEnvVar",
",",
"sid",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
":=",
"newSession",
"(",
"rsession",
".",
"ID",
"(",
"sid",
")",
",",
"s",
",",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
".",
"session",
"=",
"sess",
"\n",
"s",
".",
"addSession",
"(",
"sess",
")",
"\n",
"ctx",
".",
"Infof",
"(",
"\"Creating session %v.\"",
",",
"sid",
")",
"\n",
"if",
"err",
":=",
"sess",
".",
"start",
"(",
"ch",
",",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"sess",
".",
"Close",
"(",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // OpenSession either joins an existing session or starts a new session. | [
"OpenSession",
"either",
"joins",
"an",
"existing",
"session",
"or",
"starts",
"a",
"new",
"session",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L148-L185 | train |
gravitational/teleport | lib/srv/sess.go | emitSessionLeaveEvent | func (s *SessionRegistry) emitSessionLeaveEvent(party *party) {
sessionLeaveEvent := events.EventFields{
events.EventType: events.SessionLeaveEvent,
events.SessionEventID: party.id.String(),
events.EventUser: party.user,
events.SessionServerID: party.serverID,
events.EventNamespace: s.srv.GetNamespace(),
}
// Emit session leave event to Audit Log.
party.s.recorder.GetAuditLog().EmitAuditEvent(events.SessionLeave, sessionLeaveEvent)
// Notify all members of the party that a new member has left over the
// "x-teleport-event" channel.
for _, p := range s.getParties(party.s) {
eventPayload, err := json.Marshal(sessionLeaveEvent)
if err != nil {
s.log.Warnf("Unable to marshal %v for %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to send %v to %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
s.log.Debugf("Sent %v to %v.", events.SessionJoinEvent, p.sconn.RemoteAddr())
}
} | go | func (s *SessionRegistry) emitSessionLeaveEvent(party *party) {
sessionLeaveEvent := events.EventFields{
events.EventType: events.SessionLeaveEvent,
events.SessionEventID: party.id.String(),
events.EventUser: party.user,
events.SessionServerID: party.serverID,
events.EventNamespace: s.srv.GetNamespace(),
}
// Emit session leave event to Audit Log.
party.s.recorder.GetAuditLog().EmitAuditEvent(events.SessionLeave, sessionLeaveEvent)
// Notify all members of the party that a new member has left over the
// "x-teleport-event" channel.
for _, p := range s.getParties(party.s) {
eventPayload, err := json.Marshal(sessionLeaveEvent)
if err != nil {
s.log.Warnf("Unable to marshal %v for %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to send %v to %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
s.log.Debugf("Sent %v to %v.", events.SessionJoinEvent, p.sconn.RemoteAddr())
}
} | [
"func",
"(",
"s",
"*",
"SessionRegistry",
")",
"emitSessionLeaveEvent",
"(",
"party",
"*",
"party",
")",
"{",
"sessionLeaveEvent",
":=",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventType",
":",
"events",
".",
"SessionLeaveEvent",
",",
"events",
".",
"SessionEventID",
":",
"party",
".",
"id",
".",
"String",
"(",
")",
",",
"events",
".",
"EventUser",
":",
"party",
".",
"user",
",",
"events",
".",
"SessionServerID",
":",
"party",
".",
"serverID",
",",
"events",
".",
"EventNamespace",
":",
"s",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"}",
"\n",
"party",
".",
"s",
".",
"recorder",
".",
"GetAuditLog",
"(",
")",
".",
"EmitAuditEvent",
"(",
"events",
".",
"SessionLeave",
",",
"sessionLeaveEvent",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"s",
".",
"getParties",
"(",
"party",
".",
"s",
")",
"{",
"eventPayload",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"sessionLeaveEvent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to marshal %v for %v: %v.\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
"=",
"p",
".",
"sconn",
".",
"SendRequest",
"(",
"teleport",
".",
"SessionEvent",
",",
"false",
",",
"eventPayload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to send %v to %v: %v.\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"Sent %v to %v.\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // emitSessionLeaveEvent emits a session leave event to both the Audit Log as
// well as sending a "x-teleport-event" global request on the SSH connection. | [
"emitSessionLeaveEvent",
"emits",
"a",
"session",
"leave",
"event",
"to",
"both",
"the",
"Audit",
"Log",
"as",
"well",
"as",
"sending",
"a",
"x",
"-",
"teleport",
"-",
"event",
"global",
"request",
"on",
"the",
"SSH",
"connection",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L189-L216 | train |
gravitational/teleport | lib/srv/sess.go | leaveSession | func (s *SessionRegistry) leaveSession(party *party) error {
sess := party.s
s.Lock()
defer s.Unlock()
// Emit session leave event to both the Audit Log as well as over the
// "x-teleport-event" channel in the SSH connection.
s.emitSessionLeaveEvent(party)
// Remove member from in-members representation of party.
if err := sess.removeParty(party); err != nil {
return trace.Wrap(err)
}
// this goroutine runs for a short amount of time only after a session
// becomes empty (no parties). It allows session to "linger" for a bit
// allowing parties to reconnect if they lost connection momentarily
lingerAndDie := func() {
lingerTTL := sess.GetLingerTTL()
if lingerTTL > 0 {
time.Sleep(lingerTTL)
}
// not lingering anymore? someone reconnected? cool then... no need
// to die...
if !sess.isLingering() {
s.log.Infof("Session %v has become active again.", sess.id)
return
}
s.log.Infof("Session %v will be garbage collected.", sess.id)
// no more people left? Need to end the session!
s.Lock()
delete(s.sessions, sess.id)
s.Unlock()
// send an event indicating that this session has ended
sess.recorder.GetAuditLog().EmitAuditEvent(events.SessionEnd, events.EventFields{
events.SessionEventID: string(sess.id),
events.EventUser: party.user,
events.EventNamespace: s.srv.GetNamespace(),
})
// close recorder to free up associated resources
// and flush data
sess.recorder.Close()
if err := sess.Close(); err != nil {
s.log.Errorf("Unable to close session %v: %v", sess.id, err)
}
// mark it as inactive in the DB
if s.srv.GetSessionServer() != nil {
False := false
s.srv.GetSessionServer().UpdateSession(rsession.UpdateRequest{
ID: sess.id,
Active: &False,
Namespace: s.srv.GetNamespace(),
})
}
}
go lingerAndDie()
return nil
} | go | func (s *SessionRegistry) leaveSession(party *party) error {
sess := party.s
s.Lock()
defer s.Unlock()
// Emit session leave event to both the Audit Log as well as over the
// "x-teleport-event" channel in the SSH connection.
s.emitSessionLeaveEvent(party)
// Remove member from in-members representation of party.
if err := sess.removeParty(party); err != nil {
return trace.Wrap(err)
}
// this goroutine runs for a short amount of time only after a session
// becomes empty (no parties). It allows session to "linger" for a bit
// allowing parties to reconnect if they lost connection momentarily
lingerAndDie := func() {
lingerTTL := sess.GetLingerTTL()
if lingerTTL > 0 {
time.Sleep(lingerTTL)
}
// not lingering anymore? someone reconnected? cool then... no need
// to die...
if !sess.isLingering() {
s.log.Infof("Session %v has become active again.", sess.id)
return
}
s.log.Infof("Session %v will be garbage collected.", sess.id)
// no more people left? Need to end the session!
s.Lock()
delete(s.sessions, sess.id)
s.Unlock()
// send an event indicating that this session has ended
sess.recorder.GetAuditLog().EmitAuditEvent(events.SessionEnd, events.EventFields{
events.SessionEventID: string(sess.id),
events.EventUser: party.user,
events.EventNamespace: s.srv.GetNamespace(),
})
// close recorder to free up associated resources
// and flush data
sess.recorder.Close()
if err := sess.Close(); err != nil {
s.log.Errorf("Unable to close session %v: %v", sess.id, err)
}
// mark it as inactive in the DB
if s.srv.GetSessionServer() != nil {
False := false
s.srv.GetSessionServer().UpdateSession(rsession.UpdateRequest{
ID: sess.id,
Active: &False,
Namespace: s.srv.GetNamespace(),
})
}
}
go lingerAndDie()
return nil
} | [
"func",
"(",
"s",
"*",
"SessionRegistry",
")",
"leaveSession",
"(",
"party",
"*",
"party",
")",
"error",
"{",
"sess",
":=",
"party",
".",
"s",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"emitSessionLeaveEvent",
"(",
"party",
")",
"\n",
"if",
"err",
":=",
"sess",
".",
"removeParty",
"(",
"party",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"lingerAndDie",
":=",
"func",
"(",
")",
"{",
"lingerTTL",
":=",
"sess",
".",
"GetLingerTTL",
"(",
")",
"\n",
"if",
"lingerTTL",
">",
"0",
"{",
"time",
".",
"Sleep",
"(",
"lingerTTL",
")",
"\n",
"}",
"\n",
"if",
"!",
"sess",
".",
"isLingering",
"(",
")",
"{",
"s",
".",
"log",
".",
"Infof",
"(",
"\"Session %v has become active again.\"",
",",
"sess",
".",
"id",
")",
"\n",
"return",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Infof",
"(",
"\"Session %v will be garbage collected.\"",
",",
"sess",
".",
"id",
")",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"s",
".",
"sessions",
",",
"sess",
".",
"id",
")",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n",
"sess",
".",
"recorder",
".",
"GetAuditLog",
"(",
")",
".",
"EmitAuditEvent",
"(",
"events",
".",
"SessionEnd",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"SessionEventID",
":",
"string",
"(",
"sess",
".",
"id",
")",
",",
"events",
".",
"EventUser",
":",
"party",
".",
"user",
",",
"events",
".",
"EventNamespace",
":",
"s",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"}",
")",
"\n",
"sess",
".",
"recorder",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
":=",
"sess",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Errorf",
"(",
"\"Unable to close session %v: %v\"",
",",
"sess",
".",
"id",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"srv",
".",
"GetSessionServer",
"(",
")",
"!=",
"nil",
"{",
"False",
":=",
"false",
"\n",
"s",
".",
"srv",
".",
"GetSessionServer",
"(",
")",
".",
"UpdateSession",
"(",
"rsession",
".",
"UpdateRequest",
"{",
"ID",
":",
"sess",
".",
"id",
",",
"Active",
":",
"&",
"False",
",",
"Namespace",
":",
"s",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"lingerAndDie",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // leaveSession removes the given party from this session. | [
"leaveSession",
"removes",
"the",
"given",
"party",
"from",
"this",
"session",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L219-L281 | train |
gravitational/teleport | lib/srv/sess.go | NotifyWinChange | func (s *SessionRegistry) NotifyWinChange(params rsession.TerminalParams, ctx *ServerContext) error {
if ctx.session == nil {
s.log.Debugf("Unable to update window size, no session found in context.")
return nil
}
sid := ctx.session.id
// Build the resize event.
resizeEvent := events.EventFields{
events.EventType: events.ResizeEvent,
events.EventNamespace: s.srv.GetNamespace(),
events.SessionEventID: sid,
events.EventLogin: ctx.Identity.Login,
events.EventUser: ctx.Identity.TeleportUser,
events.TerminalSize: params.Serialize(),
}
// Report the updated window size to the event log (this is so the sessions
// can be replayed correctly).
ctx.session.recorder.GetAuditLog().EmitAuditEvent(events.TerminalResize, resizeEvent)
// Update the size of the server side PTY.
err := ctx.session.term.SetWinSize(params)
if err != nil {
return trace.Wrap(err)
}
// If sessions are being recorded at the proxy, sessions can not be shared.
// In that situation, PTY size information does not need to be propagated
// back to all clients and we can return right away.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy {
return nil
}
// Notify all members of the party (except originator) that the size of the
// window has changed so the client can update it's own local PTY. Note that
// OpenSSH clients will ignore this and not update their own local PTY.
for _, p := range s.getParties(ctx.session) {
// Don't send the window change notification back to the originator.
if p.ctx.ID() == ctx.ID() {
continue
}
eventPayload, err := json.Marshal(resizeEvent)
if err != nil {
s.log.Warnf("Unable to marshal resize event for %v: %v.", p.sconn.RemoteAddr(), err)
continue
}
// Send the message as a global request.
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to resize event to %v: %v.", p.sconn.RemoteAddr(), err)
continue
}
s.log.Debugf("Sent resize event %v to %v.", params, p.sconn.RemoteAddr())
}
return nil
} | go | func (s *SessionRegistry) NotifyWinChange(params rsession.TerminalParams, ctx *ServerContext) error {
if ctx.session == nil {
s.log.Debugf("Unable to update window size, no session found in context.")
return nil
}
sid := ctx.session.id
// Build the resize event.
resizeEvent := events.EventFields{
events.EventType: events.ResizeEvent,
events.EventNamespace: s.srv.GetNamespace(),
events.SessionEventID: sid,
events.EventLogin: ctx.Identity.Login,
events.EventUser: ctx.Identity.TeleportUser,
events.TerminalSize: params.Serialize(),
}
// Report the updated window size to the event log (this is so the sessions
// can be replayed correctly).
ctx.session.recorder.GetAuditLog().EmitAuditEvent(events.TerminalResize, resizeEvent)
// Update the size of the server side PTY.
err := ctx.session.term.SetWinSize(params)
if err != nil {
return trace.Wrap(err)
}
// If sessions are being recorded at the proxy, sessions can not be shared.
// In that situation, PTY size information does not need to be propagated
// back to all clients and we can return right away.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy {
return nil
}
// Notify all members of the party (except originator) that the size of the
// window has changed so the client can update it's own local PTY. Note that
// OpenSSH clients will ignore this and not update their own local PTY.
for _, p := range s.getParties(ctx.session) {
// Don't send the window change notification back to the originator.
if p.ctx.ID() == ctx.ID() {
continue
}
eventPayload, err := json.Marshal(resizeEvent)
if err != nil {
s.log.Warnf("Unable to marshal resize event for %v: %v.", p.sconn.RemoteAddr(), err)
continue
}
// Send the message as a global request.
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to resize event to %v: %v.", p.sconn.RemoteAddr(), err)
continue
}
s.log.Debugf("Sent resize event %v to %v.", params, p.sconn.RemoteAddr())
}
return nil
} | [
"func",
"(",
"s",
"*",
"SessionRegistry",
")",
"NotifyWinChange",
"(",
"params",
"rsession",
".",
"TerminalParams",
",",
"ctx",
"*",
"ServerContext",
")",
"error",
"{",
"if",
"ctx",
".",
"session",
"==",
"nil",
"{",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"Unable to update window size, no session found in context.\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"sid",
":=",
"ctx",
".",
"session",
".",
"id",
"\n",
"resizeEvent",
":=",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventType",
":",
"events",
".",
"ResizeEvent",
",",
"events",
".",
"EventNamespace",
":",
"s",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"events",
".",
"SessionEventID",
":",
"sid",
",",
"events",
".",
"EventLogin",
":",
"ctx",
".",
"Identity",
".",
"Login",
",",
"events",
".",
"EventUser",
":",
"ctx",
".",
"Identity",
".",
"TeleportUser",
",",
"events",
".",
"TerminalSize",
":",
"params",
".",
"Serialize",
"(",
")",
",",
"}",
"\n",
"ctx",
".",
"session",
".",
"recorder",
".",
"GetAuditLog",
"(",
")",
".",
"EmitAuditEvent",
"(",
"events",
".",
"TerminalResize",
",",
"resizeEvent",
")",
"\n",
"err",
":=",
"ctx",
".",
"session",
".",
"term",
".",
"SetWinSize",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ctx",
".",
"ClusterConfig",
".",
"GetSessionRecording",
"(",
")",
"==",
"services",
".",
"RecordAtProxy",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"s",
".",
"getParties",
"(",
"ctx",
".",
"session",
")",
"{",
"if",
"p",
".",
"ctx",
".",
"ID",
"(",
")",
"==",
"ctx",
".",
"ID",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"eventPayload",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"resizeEvent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to marshal resize event for %v: %v.\"",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"_",
",",
"_",
",",
"err",
"=",
"p",
".",
"sconn",
".",
"SendRequest",
"(",
"teleport",
".",
"SessionEvent",
",",
"false",
",",
"eventPayload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to resize event to %v: %v.\"",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"Sent resize event %v to %v.\"",
",",
"params",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // NotifyWinChange is called to notify all members in the party that the PTY
// size has changed. The notification is sent as a global SSH request and it
// is the responsibility of the client to update it's window size upon receipt. | [
"NotifyWinChange",
"is",
"called",
"to",
"notify",
"all",
"members",
"in",
"the",
"party",
"that",
"the",
"PTY",
"size",
"has",
"changed",
".",
"The",
"notification",
"is",
"sent",
"as",
"a",
"global",
"SSH",
"request",
"and",
"it",
"is",
"the",
"responsibility",
"of",
"the",
"client",
"to",
"update",
"it",
"s",
"window",
"size",
"upon",
"receipt",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L305-L364 | train |
gravitational/teleport | lib/srv/sess.go | newSession | func newSession(id rsession.ID, r *SessionRegistry, ctx *ServerContext) (*session, error) {
serverSessions.Inc()
rsess := rsession.Session{
ID: id,
TerminalParams: rsession.TerminalParams{
W: teleport.DefaultTerminalWidth,
H: teleport.DefaultTerminalHeight,
},
Login: ctx.Identity.Login,
Created: time.Now().UTC(),
LastActive: time.Now().UTC(),
ServerID: ctx.srv.ID(),
Namespace: r.srv.GetNamespace(),
}
term := ctx.GetTerm()
if term != nil {
winsize, err := term.GetWinSize()
if err != nil {
return nil, trace.Wrap(err)
}
rsess.TerminalParams.W = int(winsize.Width)
rsess.TerminalParams.H = int(winsize.Height)
}
// get the session server where session information lives. if the recording
// proxy is being used and this is a node, then a discard session server will
// be returned here.
sessionServer := r.srv.GetSessionServer()
err := sessionServer.CreateSession(rsess)
if err != nil {
if trace.IsAlreadyExists(err) {
// if session already exists, make sure they are compatible
// Login matches existing login
existing, err := sessionServer.GetSession(r.srv.GetNamespace(), id)
if err != nil {
return nil, trace.Wrap(err)
}
if existing.Login != rsess.Login {
return nil, trace.AccessDenied(
"can't switch users from %v to %v for session %v",
rsess.Login, existing.Login, id)
}
}
// return nil, trace.Wrap(err)
// No need to abort. Perhaps the auth server is down?
// Log the error and continue:
r.log.Errorf("Failed to create new session: %v.", err)
}
sess := &session{
log: logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentSession, r.srv.Component()),
}),
id: id,
registry: r,
parties: make(map[rsession.ID]*party),
writer: newMultiWriter(),
login: ctx.Identity.Login,
closeC: make(chan bool),
lingerTTL: defaults.SessionIdlePeriod,
}
return sess, nil
} | go | func newSession(id rsession.ID, r *SessionRegistry, ctx *ServerContext) (*session, error) {
serverSessions.Inc()
rsess := rsession.Session{
ID: id,
TerminalParams: rsession.TerminalParams{
W: teleport.DefaultTerminalWidth,
H: teleport.DefaultTerminalHeight,
},
Login: ctx.Identity.Login,
Created: time.Now().UTC(),
LastActive: time.Now().UTC(),
ServerID: ctx.srv.ID(),
Namespace: r.srv.GetNamespace(),
}
term := ctx.GetTerm()
if term != nil {
winsize, err := term.GetWinSize()
if err != nil {
return nil, trace.Wrap(err)
}
rsess.TerminalParams.W = int(winsize.Width)
rsess.TerminalParams.H = int(winsize.Height)
}
// get the session server where session information lives. if the recording
// proxy is being used and this is a node, then a discard session server will
// be returned here.
sessionServer := r.srv.GetSessionServer()
err := sessionServer.CreateSession(rsess)
if err != nil {
if trace.IsAlreadyExists(err) {
// if session already exists, make sure they are compatible
// Login matches existing login
existing, err := sessionServer.GetSession(r.srv.GetNamespace(), id)
if err != nil {
return nil, trace.Wrap(err)
}
if existing.Login != rsess.Login {
return nil, trace.AccessDenied(
"can't switch users from %v to %v for session %v",
rsess.Login, existing.Login, id)
}
}
// return nil, trace.Wrap(err)
// No need to abort. Perhaps the auth server is down?
// Log the error and continue:
r.log.Errorf("Failed to create new session: %v.", err)
}
sess := &session{
log: logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentSession, r.srv.Component()),
}),
id: id,
registry: r,
parties: make(map[rsession.ID]*party),
writer: newMultiWriter(),
login: ctx.Identity.Login,
closeC: make(chan bool),
lingerTTL: defaults.SessionIdlePeriod,
}
return sess, nil
} | [
"func",
"newSession",
"(",
"id",
"rsession",
".",
"ID",
",",
"r",
"*",
"SessionRegistry",
",",
"ctx",
"*",
"ServerContext",
")",
"(",
"*",
"session",
",",
"error",
")",
"{",
"serverSessions",
".",
"Inc",
"(",
")",
"\n",
"rsess",
":=",
"rsession",
".",
"Session",
"{",
"ID",
":",
"id",
",",
"TerminalParams",
":",
"rsession",
".",
"TerminalParams",
"{",
"W",
":",
"teleport",
".",
"DefaultTerminalWidth",
",",
"H",
":",
"teleport",
".",
"DefaultTerminalHeight",
",",
"}",
",",
"Login",
":",
"ctx",
".",
"Identity",
".",
"Login",
",",
"Created",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"LastActive",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"ServerID",
":",
"ctx",
".",
"srv",
".",
"ID",
"(",
")",
",",
"Namespace",
":",
"r",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"}",
"\n",
"term",
":=",
"ctx",
".",
"GetTerm",
"(",
")",
"\n",
"if",
"term",
"!=",
"nil",
"{",
"winsize",
",",
"err",
":=",
"term",
".",
"GetWinSize",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"rsess",
".",
"TerminalParams",
".",
"W",
"=",
"int",
"(",
"winsize",
".",
"Width",
")",
"\n",
"rsess",
".",
"TerminalParams",
".",
"H",
"=",
"int",
"(",
"winsize",
".",
"Height",
")",
"\n",
"}",
"\n",
"sessionServer",
":=",
"r",
".",
"srv",
".",
"GetSessionServer",
"(",
")",
"\n",
"err",
":=",
"sessionServer",
".",
"CreateSession",
"(",
"rsess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"existing",
",",
"err",
":=",
"sessionServer",
".",
"GetSession",
"(",
"r",
".",
"srv",
".",
"GetNamespace",
"(",
")",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"existing",
".",
"Login",
"!=",
"rsess",
".",
"Login",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"can't switch users from %v to %v for session %v\"",
",",
"rsess",
".",
"Login",
",",
"existing",
".",
"Login",
",",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"log",
".",
"Errorf",
"(",
"\"Failed to create new session: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"sess",
":=",
"&",
"session",
"{",
"log",
":",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentSession",
",",
"r",
".",
"srv",
".",
"Component",
"(",
")",
")",
",",
"}",
")",
",",
"id",
":",
"id",
",",
"registry",
":",
"r",
",",
"parties",
":",
"make",
"(",
"map",
"[",
"rsession",
".",
"ID",
"]",
"*",
"party",
")",
",",
"writer",
":",
"newMultiWriter",
"(",
")",
",",
"login",
":",
"ctx",
".",
"Identity",
".",
"Login",
",",
"closeC",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"lingerTTL",
":",
"defaults",
".",
"SessionIdlePeriod",
",",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] | // newSession creates a new session with a given ID within a given context. | [
"newSession",
"creates",
"a",
"new",
"session",
"with",
"a",
"given",
"ID",
"within",
"a",
"given",
"context",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L428-L491 | train |
gravitational/teleport | lib/srv/sess.go | isLingering | func (s *session) isLingering() bool {
s.Lock()
defer s.Unlock()
return len(s.parties) == 0
} | go | func (s *session) isLingering() bool {
s.Lock()
defer s.Unlock()
return len(s.parties) == 0
} | [
"func",
"(",
"s",
"*",
"session",
")",
"isLingering",
"(",
")",
"bool",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"return",
"len",
"(",
"s",
".",
"parties",
")",
"==",
"0",
"\n",
"}"
] | // isLingering returns true if every party has left this session. Occurs
// under a lock. | [
"isLingering",
"returns",
"true",
"if",
"every",
"party",
"has",
"left",
"this",
"session",
".",
"Occurs",
"under",
"a",
"lock",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L495-L500 | train |
gravitational/teleport | lib/srv/sess.go | Close | func (s *session) Close() error {
serverSessions.Dec()
s.closeOnce.Do(func() {
// closing needs to happen asynchronously because the last client
// (session writer) will try to close this session, causing a deadlock
// because of closeOnce
go func() {
s.log.Infof("Closing session %v", s.id)
if s.term != nil {
s.term.Close()
}
close(s.closeC)
// close all writers in our multi-writer
s.writer.Lock()
defer s.writer.Unlock()
for writerName, writer := range s.writer.writers {
s.log.Infof("Closing session writer: %v", writerName)
closer, ok := io.Writer(writer).(io.WriteCloser)
if ok {
closer.Close()
}
}
}()
})
return nil
} | go | func (s *session) Close() error {
serverSessions.Dec()
s.closeOnce.Do(func() {
// closing needs to happen asynchronously because the last client
// (session writer) will try to close this session, causing a deadlock
// because of closeOnce
go func() {
s.log.Infof("Closing session %v", s.id)
if s.term != nil {
s.term.Close()
}
close(s.closeC)
// close all writers in our multi-writer
s.writer.Lock()
defer s.writer.Unlock()
for writerName, writer := range s.writer.writers {
s.log.Infof("Closing session writer: %v", writerName)
closer, ok := io.Writer(writer).(io.WriteCloser)
if ok {
closer.Close()
}
}
}()
})
return nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"Close",
"(",
")",
"error",
"{",
"serverSessions",
".",
"Dec",
"(",
")",
"\n",
"s",
".",
"closeOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"go",
"func",
"(",
")",
"{",
"s",
".",
"log",
".",
"Infof",
"(",
"\"Closing session %v\"",
",",
"s",
".",
"id",
")",
"\n",
"if",
"s",
".",
"term",
"!=",
"nil",
"{",
"s",
".",
"term",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"close",
"(",
"s",
".",
"closeC",
")",
"\n",
"s",
".",
"writer",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"writer",
".",
"Unlock",
"(",
")",
"\n",
"for",
"writerName",
",",
"writer",
":=",
"range",
"s",
".",
"writer",
".",
"writers",
"{",
"s",
".",
"log",
".",
"Infof",
"(",
"\"Closing session writer: %v\"",
",",
"writerName",
")",
"\n",
"closer",
",",
"ok",
":=",
"io",
".",
"Writer",
"(",
"writer",
")",
".",
"(",
"io",
".",
"WriteCloser",
")",
"\n",
"if",
"ok",
"{",
"closer",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close ends the active session forcing all clients to disconnect and freeing all resources | [
"Close",
"ends",
"the",
"active",
"session",
"forcing",
"all",
"clients",
"to",
"disconnect",
"and",
"freeing",
"all",
"resources"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L503-L529 | train |
gravitational/teleport | lib/srv/sess.go | removePartyMember | func (s *session) removePartyMember(party *party) {
s.Lock()
defer s.Unlock()
delete(s.parties, party.id)
} | go | func (s *session) removePartyMember(party *party) {
s.Lock()
defer s.Unlock()
delete(s.parties, party.id)
} | [
"func",
"(",
"s",
"*",
"session",
")",
"removePartyMember",
"(",
"party",
"*",
"party",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"s",
".",
"parties",
",",
"party",
".",
"id",
")",
"\n",
"}"
] | // removePartyMember removes participant from in-memory representation of
// party members. Occurs under a lock. | [
"removePartyMember",
"removes",
"participant",
"from",
"in",
"-",
"memory",
"representation",
"of",
"party",
"members",
".",
"Occurs",
"under",
"a",
"lock",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L712-L717 | train |
gravitational/teleport | lib/srv/sess.go | removeParty | func (s *session) removeParty(p *party) error {
p.ctx.Infof("Removing party %v from session %v", p, s.id)
// Removes participant from in-memory map of party members.
s.removePartyMember(p)
s.writer.deleteWriter(string(p.id))
return nil
} | go | func (s *session) removeParty(p *party) error {
p.ctx.Infof("Removing party %v from session %v", p, s.id)
// Removes participant from in-memory map of party members.
s.removePartyMember(p)
s.writer.deleteWriter(string(p.id))
return nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"removeParty",
"(",
"p",
"*",
"party",
")",
"error",
"{",
"p",
".",
"ctx",
".",
"Infof",
"(",
"\"Removing party %v from session %v\"",
",",
"p",
",",
"s",
".",
"id",
")",
"\n",
"s",
".",
"removePartyMember",
"(",
"p",
")",
"\n",
"s",
".",
"writer",
".",
"deleteWriter",
"(",
"string",
"(",
"p",
".",
"id",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // removeParty removes the party from the in-memory map that holds all party
// members. | [
"removeParty",
"removes",
"the",
"party",
"from",
"the",
"in",
"-",
"memory",
"map",
"that",
"holds",
"all",
"party",
"members",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L721-L730 | train |
gravitational/teleport | lib/srv/sess.go | exportPartyMembers | func (s *session) exportPartyMembers() []rsession.Party {
s.Lock()
defer s.Unlock()
var partyList []rsession.Party
for _, p := range s.parties {
partyList = append(partyList, rsession.Party{
ID: p.id,
User: p.user,
ServerID: p.serverID,
RemoteAddr: p.site,
LastActive: p.getLastActive(),
})
}
return partyList
} | go | func (s *session) exportPartyMembers() []rsession.Party {
s.Lock()
defer s.Unlock()
var partyList []rsession.Party
for _, p := range s.parties {
partyList = append(partyList, rsession.Party{
ID: p.id,
User: p.user,
ServerID: p.serverID,
RemoteAddr: p.site,
LastActive: p.getLastActive(),
})
}
return partyList
} | [
"func",
"(",
"s",
"*",
"session",
")",
"exportPartyMembers",
"(",
")",
"[",
"]",
"rsession",
".",
"Party",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"var",
"partyList",
"[",
"]",
"rsession",
".",
"Party",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"s",
".",
"parties",
"{",
"partyList",
"=",
"append",
"(",
"partyList",
",",
"rsession",
".",
"Party",
"{",
"ID",
":",
"p",
".",
"id",
",",
"User",
":",
"p",
".",
"user",
",",
"ServerID",
":",
"p",
".",
"serverID",
",",
"RemoteAddr",
":",
"p",
".",
"site",
",",
"LastActive",
":",
"p",
".",
"getLastActive",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"partyList",
"\n",
"}"
] | // exportPartyMembers exports participants in the in-memory map of party
// members. Occurs under a lock. | [
"exportPartyMembers",
"exports",
"participants",
"in",
"the",
"in",
"-",
"memory",
"map",
"of",
"party",
"members",
".",
"Occurs",
"under",
"a",
"lock",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L750-L766 | train |
gravitational/teleport | lib/srv/sess.go | heartbeat | func (s *session) heartbeat(ctx *ServerContext) {
// If sessions are being recorded at the proxy, an identical version of this
// goroutine is running in the proxy, which means it does not need to run here.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy &&
s.registry.srv.Component() == teleport.ComponentNode {
return
}
// If no session server (endpoint interface for active sessions) is passed in
// (for example Teleconsole does this) then nothing to sync.
sessionServer := s.registry.srv.GetSessionServer()
if sessionServer == nil {
return
}
s.log.Debugf("Starting poll and sync of terminal size to all parties.")
defer s.log.Debugf("Stopping poll and sync of terminal size to all parties.")
tickerCh := time.NewTicker(defaults.SessionRefreshPeriod)
defer tickerCh.Stop()
// Loop as long as the session is active, updating the session in the backend.
for {
select {
case <-tickerCh.C:
partyList := s.exportPartyMembers()
var active = true
err := sessionServer.UpdateSession(rsession.UpdateRequest{
Namespace: s.getNamespace(),
ID: s.id,
Active: &active,
Parties: &partyList,
})
if err != nil {
s.log.Warnf("Unable to update session %v as active: %v", s.id, err)
}
case <-s.closeC:
return
}
}
} | go | func (s *session) heartbeat(ctx *ServerContext) {
// If sessions are being recorded at the proxy, an identical version of this
// goroutine is running in the proxy, which means it does not need to run here.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy &&
s.registry.srv.Component() == teleport.ComponentNode {
return
}
// If no session server (endpoint interface for active sessions) is passed in
// (for example Teleconsole does this) then nothing to sync.
sessionServer := s.registry.srv.GetSessionServer()
if sessionServer == nil {
return
}
s.log.Debugf("Starting poll and sync of terminal size to all parties.")
defer s.log.Debugf("Stopping poll and sync of terminal size to all parties.")
tickerCh := time.NewTicker(defaults.SessionRefreshPeriod)
defer tickerCh.Stop()
// Loop as long as the session is active, updating the session in the backend.
for {
select {
case <-tickerCh.C:
partyList := s.exportPartyMembers()
var active = true
err := sessionServer.UpdateSession(rsession.UpdateRequest{
Namespace: s.getNamespace(),
ID: s.id,
Active: &active,
Parties: &partyList,
})
if err != nil {
s.log.Warnf("Unable to update session %v as active: %v", s.id, err)
}
case <-s.closeC:
return
}
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"heartbeat",
"(",
"ctx",
"*",
"ServerContext",
")",
"{",
"if",
"ctx",
".",
"ClusterConfig",
".",
"GetSessionRecording",
"(",
")",
"==",
"services",
".",
"RecordAtProxy",
"&&",
"s",
".",
"registry",
".",
"srv",
".",
"Component",
"(",
")",
"==",
"teleport",
".",
"ComponentNode",
"{",
"return",
"\n",
"}",
"\n",
"sessionServer",
":=",
"s",
".",
"registry",
".",
"srv",
".",
"GetSessionServer",
"(",
")",
"\n",
"if",
"sessionServer",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"Starting poll and sync of terminal size to all parties.\"",
")",
"\n",
"defer",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"Stopping poll and sync of terminal size to all parties.\"",
")",
"\n",
"tickerCh",
":=",
"time",
".",
"NewTicker",
"(",
"defaults",
".",
"SessionRefreshPeriod",
")",
"\n",
"defer",
"tickerCh",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"tickerCh",
".",
"C",
":",
"partyList",
":=",
"s",
".",
"exportPartyMembers",
"(",
")",
"\n",
"var",
"active",
"=",
"true",
"\n",
"err",
":=",
"sessionServer",
".",
"UpdateSession",
"(",
"rsession",
".",
"UpdateRequest",
"{",
"Namespace",
":",
"s",
".",
"getNamespace",
"(",
")",
",",
"ID",
":",
"s",
".",
"id",
",",
"Active",
":",
"&",
"active",
",",
"Parties",
":",
"&",
"partyList",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to update session %v as active: %v\"",
",",
"s",
".",
"id",
",",
"err",
")",
"\n",
"}",
"\n",
"case",
"<-",
"s",
".",
"closeC",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // heartbeat will loop as long as the session is not closed and mark it as
// active and update the list of party members. If the session are recorded at
// the proxy, then this function does nothing as it's counterpart
// in the proxy will do this work. | [
"heartbeat",
"will",
"loop",
"as",
"long",
"as",
"the",
"session",
"is",
"not",
"closed",
"and",
"mark",
"it",
"as",
"active",
"and",
"update",
"the",
"list",
"of",
"party",
"members",
".",
"If",
"the",
"session",
"are",
"recorded",
"at",
"the",
"proxy",
"then",
"this",
"function",
"does",
"nothing",
"as",
"it",
"s",
"counterpart",
"in",
"the",
"proxy",
"will",
"do",
"this",
"work",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L772-L813 | train |
gravitational/teleport | lib/srv/sess.go | addPartyMember | func (s *session) addPartyMember(p *party) {
s.Lock()
defer s.Unlock()
s.parties[p.id] = p
} | go | func (s *session) addPartyMember(p *party) {
s.Lock()
defer s.Unlock()
s.parties[p.id] = p
} | [
"func",
"(",
"s",
"*",
"session",
")",
"addPartyMember",
"(",
"p",
"*",
"party",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"parties",
"[",
"p",
".",
"id",
"]",
"=",
"p",
"\n",
"}"
] | // addPartyMember adds participant to in-memory map of party members. Occurs
// under a lock. | [
"addPartyMember",
"adds",
"participant",
"to",
"in",
"-",
"memory",
"map",
"of",
"party",
"members",
".",
"Occurs",
"under",
"a",
"lock",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L817-L822 | train |
gravitational/teleport | lib/srv/sess.go | addParty | func (s *session) addParty(p *party) error {
if s.login != p.login {
return trace.AccessDenied(
"can't switch users from %v to %v for session %v",
s.login, p.login, s.id)
}
// Adds participant to in-memory map of party members.
s.addPartyMember(p)
// Write last chunk (so the newly joined parties won't stare at a blank
// screen).
getRecentWrite := func() []byte {
s.writer.Lock()
defer s.writer.Unlock()
data := make([]byte, 0, 1024)
for i := range s.writer.recentWrites {
data = append(data, s.writer.recentWrites[i]...)
}
return data
}
p.Write(getRecentWrite())
// Register this party as one of the session writers (output will go to it).
s.writer.addWriter(string(p.id), p, true)
p.ctx.AddCloser(p)
s.term.AddParty(1)
s.log.Infof("New party %v joined session: %v", p.String(), s.id)
// This goroutine keeps pumping party's input into the session.
go func() {
defer s.term.AddParty(-1)
_, err := io.Copy(s.term.PTY(), p)
if err != nil {
s.log.Errorf("Party member %v left session %v due an error: %v", p.id, s.id, err)
}
s.log.Infof("Party member %v left session %v.", p.id, s.id)
}()
return nil
} | go | func (s *session) addParty(p *party) error {
if s.login != p.login {
return trace.AccessDenied(
"can't switch users from %v to %v for session %v",
s.login, p.login, s.id)
}
// Adds participant to in-memory map of party members.
s.addPartyMember(p)
// Write last chunk (so the newly joined parties won't stare at a blank
// screen).
getRecentWrite := func() []byte {
s.writer.Lock()
defer s.writer.Unlock()
data := make([]byte, 0, 1024)
for i := range s.writer.recentWrites {
data = append(data, s.writer.recentWrites[i]...)
}
return data
}
p.Write(getRecentWrite())
// Register this party as one of the session writers (output will go to it).
s.writer.addWriter(string(p.id), p, true)
p.ctx.AddCloser(p)
s.term.AddParty(1)
s.log.Infof("New party %v joined session: %v", p.String(), s.id)
// This goroutine keeps pumping party's input into the session.
go func() {
defer s.term.AddParty(-1)
_, err := io.Copy(s.term.PTY(), p)
if err != nil {
s.log.Errorf("Party member %v left session %v due an error: %v", p.id, s.id, err)
}
s.log.Infof("Party member %v left session %v.", p.id, s.id)
}()
return nil
} | [
"func",
"(",
"s",
"*",
"session",
")",
"addParty",
"(",
"p",
"*",
"party",
")",
"error",
"{",
"if",
"s",
".",
"login",
"!=",
"p",
".",
"login",
"{",
"return",
"trace",
".",
"AccessDenied",
"(",
"\"can't switch users from %v to %v for session %v\"",
",",
"s",
".",
"login",
",",
"p",
".",
"login",
",",
"s",
".",
"id",
")",
"\n",
"}",
"\n",
"s",
".",
"addPartyMember",
"(",
"p",
")",
"\n",
"getRecentWrite",
":=",
"func",
"(",
")",
"[",
"]",
"byte",
"{",
"s",
".",
"writer",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"writer",
".",
"Unlock",
"(",
")",
"\n",
"data",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"1024",
")",
"\n",
"for",
"i",
":=",
"range",
"s",
".",
"writer",
".",
"recentWrites",
"{",
"data",
"=",
"append",
"(",
"data",
",",
"s",
".",
"writer",
".",
"recentWrites",
"[",
"i",
"]",
"...",
")",
"\n",
"}",
"\n",
"return",
"data",
"\n",
"}",
"\n",
"p",
".",
"Write",
"(",
"getRecentWrite",
"(",
")",
")",
"\n",
"s",
".",
"writer",
".",
"addWriter",
"(",
"string",
"(",
"p",
".",
"id",
")",
",",
"p",
",",
"true",
")",
"\n",
"p",
".",
"ctx",
".",
"AddCloser",
"(",
"p",
")",
"\n",
"s",
".",
"term",
".",
"AddParty",
"(",
"1",
")",
"\n",
"s",
".",
"log",
".",
"Infof",
"(",
"\"New party %v joined session: %v\"",
",",
"p",
".",
"String",
"(",
")",
",",
"s",
".",
"id",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"s",
".",
"term",
".",
"AddParty",
"(",
"-",
"1",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"s",
".",
"term",
".",
"PTY",
"(",
")",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Errorf",
"(",
"\"Party member %v left session %v due an error: %v\"",
",",
"p",
".",
"id",
",",
"s",
".",
"id",
",",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Infof",
"(",
"\"Party member %v left session %v.\"",
",",
"p",
".",
"id",
",",
"s",
".",
"id",
")",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // addParty is called when a new party joins the session. | [
"addParty",
"is",
"called",
"when",
"a",
"new",
"party",
"joins",
"the",
"session",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L825-L865 | train |
gravitational/teleport | lib/srv/sess.go | Write | func (m *multiWriter) Write(p []byte) (n int, err error) {
// lock and make a local copy of available writers:
getWriters := func() (writers []writerWrapper) {
m.RLock()
defer m.RUnlock()
writers = make([]writerWrapper, 0, len(m.writers))
for _, w := range m.writers {
writers = append(writers, w)
}
// add the recent write chunk to the "instant replay" buffer
// of the session, to be replayed to newly joining parties:
m.lockedAddRecentWrite(p)
return writers
}
// unlock and multiplex the write to all writers:
for _, w := range getWriters() {
n, err = w.Write(p)
if err != nil {
if w.closeOnError {
return
}
continue
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
} | go | func (m *multiWriter) Write(p []byte) (n int, err error) {
// lock and make a local copy of available writers:
getWriters := func() (writers []writerWrapper) {
m.RLock()
defer m.RUnlock()
writers = make([]writerWrapper, 0, len(m.writers))
for _, w := range m.writers {
writers = append(writers, w)
}
// add the recent write chunk to the "instant replay" buffer
// of the session, to be replayed to newly joining parties:
m.lockedAddRecentWrite(p)
return writers
}
// unlock and multiplex the write to all writers:
for _, w := range getWriters() {
n, err = w.Write(p)
if err != nil {
if w.closeOnError {
return
}
continue
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
} | [
"func",
"(",
"m",
"*",
"multiWriter",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"getWriters",
":=",
"func",
"(",
")",
"(",
"writers",
"[",
"]",
"writerWrapper",
")",
"{",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"writers",
"=",
"make",
"(",
"[",
"]",
"writerWrapper",
",",
"0",
",",
"len",
"(",
"m",
".",
"writers",
")",
")",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"m",
".",
"writers",
"{",
"writers",
"=",
"append",
"(",
"writers",
",",
"w",
")",
"\n",
"}",
"\n",
"m",
".",
"lockedAddRecentWrite",
"(",
"p",
")",
"\n",
"return",
"writers",
"\n",
"}",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"getWriters",
"(",
")",
"{",
"n",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"w",
".",
"closeOnError",
"{",
"return",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"n",
"!=",
"len",
"(",
"p",
")",
"{",
"err",
"=",
"io",
".",
"ErrShortWrite",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"len",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] | // Write multiplexes the input to multiple sub-writers. The entire point
// of multiWriter is to do this | [
"Write",
"multiplexes",
"the",
"input",
"to",
"multiple",
"sub",
"-",
"writers",
".",
"The",
"entire",
"point",
"of",
"multiWriter",
"is",
"to",
"do",
"this"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/sess.go#L915-L946 | train |
gravitational/teleport | lib/service/supervisor.go | String | func (e EventMapping) String() string {
return fmt.Sprintf("EventMapping(in=%v, out=%v)", e.In, e.Out)
} | go | func (e EventMapping) String() string {
return fmt.Sprintf("EventMapping(in=%v, out=%v)", e.In, e.Out)
} | [
"func",
"(",
"e",
"EventMapping",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"EventMapping(in=%v, out=%v)\"",
",",
"e",
".",
"In",
",",
"e",
".",
"Out",
")",
"\n",
"}"
] | // String returns user-friendly representation of the mapping. | [
"String",
"returns",
"user",
"-",
"friendly",
"representation",
"of",
"the",
"mapping",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L96-L98 | train |
gravitational/teleport | lib/service/supervisor.go | NewSupervisor | func NewSupervisor(id string) Supervisor {
closeContext, cancel := context.WithCancel(context.TODO())
exitContext, signalExit := context.WithCancel(context.TODO())
reloadContext, signalReload := context.WithCancel(context.TODO())
srv := &LocalSupervisor{
id: id,
services: []Service{},
wg: &sync.WaitGroup{},
events: map[string]Event{},
eventsC: make(chan Event, 1024),
eventWaiters: make(map[string][]*waiter),
closeContext: closeContext,
signalClose: cancel,
exitContext: exitContext,
signalExit: signalExit,
reloadContext: reloadContext,
signalReload: signalReload,
}
go srv.fanOut()
return srv
} | go | func NewSupervisor(id string) Supervisor {
closeContext, cancel := context.WithCancel(context.TODO())
exitContext, signalExit := context.WithCancel(context.TODO())
reloadContext, signalReload := context.WithCancel(context.TODO())
srv := &LocalSupervisor{
id: id,
services: []Service{},
wg: &sync.WaitGroup{},
events: map[string]Event{},
eventsC: make(chan Event, 1024),
eventWaiters: make(map[string][]*waiter),
closeContext: closeContext,
signalClose: cancel,
exitContext: exitContext,
signalExit: signalExit,
reloadContext: reloadContext,
signalReload: signalReload,
}
go srv.fanOut()
return srv
} | [
"func",
"NewSupervisor",
"(",
"id",
"string",
")",
"Supervisor",
"{",
"closeContext",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"exitContext",
",",
"signalExit",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"reloadContext",
",",
"signalReload",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"srv",
":=",
"&",
"LocalSupervisor",
"{",
"id",
":",
"id",
",",
"services",
":",
"[",
"]",
"Service",
"{",
"}",
",",
"wg",
":",
"&",
"sync",
".",
"WaitGroup",
"{",
"}",
",",
"events",
":",
"map",
"[",
"string",
"]",
"Event",
"{",
"}",
",",
"eventsC",
":",
"make",
"(",
"chan",
"Event",
",",
"1024",
")",
",",
"eventWaiters",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"waiter",
")",
",",
"closeContext",
":",
"closeContext",
",",
"signalClose",
":",
"cancel",
",",
"exitContext",
":",
"exitContext",
",",
"signalExit",
":",
"signalExit",
",",
"reloadContext",
":",
"reloadContext",
",",
"signalReload",
":",
"signalReload",
",",
"}",
"\n",
"go",
"srv",
".",
"fanOut",
"(",
")",
"\n",
"return",
"srv",
"\n",
"}"
] | // NewSupervisor returns new instance of initialized supervisor | [
"NewSupervisor",
"returns",
"new",
"instance",
"of",
"initialized",
"supervisor"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L142-L166 | train |
gravitational/teleport | lib/service/supervisor.go | ServiceCount | func (s *LocalSupervisor) ServiceCount() int {
s.Lock()
defer s.Unlock()
return len(s.services)
} | go | func (s *LocalSupervisor) ServiceCount() int {
s.Lock()
defer s.Unlock()
return len(s.services)
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"ServiceCount",
"(",
")",
"int",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"return",
"len",
"(",
"s",
".",
"services",
")",
"\n",
"}"
] | // ServiceCount returns the number of registered and actively running services | [
"ServiceCount",
"returns",
"the",
"number",
"of",
"registered",
"and",
"actively",
"running",
"services"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L191-L195 | train |
gravitational/teleport | lib/service/supervisor.go | RegisterFunc | func (s *LocalSupervisor) RegisterFunc(name string, fn ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name})
} | go | func (s *LocalSupervisor) RegisterFunc(name string, fn ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name})
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"RegisterFunc",
"(",
"name",
"string",
",",
"fn",
"ServiceFunc",
")",
"{",
"s",
".",
"Register",
"(",
"&",
"LocalService",
"{",
"Function",
":",
"fn",
",",
"ServiceName",
":",
"name",
"}",
")",
"\n",
"}"
] | // RegisterFunc creates a service from function spec and registers
// it within the system | [
"RegisterFunc",
"creates",
"a",
"service",
"from",
"function",
"spec",
"and",
"registers",
"it",
"within",
"the",
"system"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L199-L201 | train |
gravitational/teleport | lib/service/supervisor.go | RegisterCriticalFunc | func (s *LocalSupervisor) RegisterCriticalFunc(name string, fn ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name, Critical: true})
} | go | func (s *LocalSupervisor) RegisterCriticalFunc(name string, fn ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name, Critical: true})
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"RegisterCriticalFunc",
"(",
"name",
"string",
",",
"fn",
"ServiceFunc",
")",
"{",
"s",
".",
"Register",
"(",
"&",
"LocalService",
"{",
"Function",
":",
"fn",
",",
"ServiceName",
":",
"name",
",",
"Critical",
":",
"true",
"}",
")",
"\n",
"}"
] | // RegisterCriticalFunc creates a critical service from function spec and registers
// it within the system, if this service exits with error,
// the process shuts down. | [
"RegisterCriticalFunc",
"creates",
"a",
"critical",
"service",
"from",
"function",
"spec",
"and",
"registers",
"it",
"within",
"the",
"system",
"if",
"this",
"service",
"exits",
"with",
"error",
"the",
"process",
"shuts",
"down",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L206-L208 | train |
gravitational/teleport | lib/service/supervisor.go | RemoveService | func (s *LocalSupervisor) RemoveService(srv Service) error {
l := logrus.WithFields(logrus.Fields{"service": srv.Name(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)})
s.Lock()
defer s.Unlock()
for i, el := range s.services {
if el == srv {
s.services = append(s.services[:i], s.services[i+1:]...)
l.Debugf("Service is completed and removed.")
return nil
}
}
l.Warningf("Service is completed but not found.")
return trace.NotFound("service %v is not found", srv)
} | go | func (s *LocalSupervisor) RemoveService(srv Service) error {
l := logrus.WithFields(logrus.Fields{"service": srv.Name(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)})
s.Lock()
defer s.Unlock()
for i, el := range s.services {
if el == srv {
s.services = append(s.services[:i], s.services[i+1:]...)
l.Debugf("Service is completed and removed.")
return nil
}
}
l.Warningf("Service is completed but not found.")
return trace.NotFound("service %v is not found", srv)
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"RemoveService",
"(",
"srv",
"Service",
")",
"error",
"{",
"l",
":=",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"service\"",
":",
"srv",
".",
"Name",
"(",
")",
",",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentProcess",
",",
"s",
".",
"id",
")",
"}",
")",
"\n",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"for",
"i",
",",
"el",
":=",
"range",
"s",
".",
"services",
"{",
"if",
"el",
"==",
"srv",
"{",
"s",
".",
"services",
"=",
"append",
"(",
"s",
".",
"services",
"[",
":",
"i",
"]",
",",
"s",
".",
"services",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"l",
".",
"Debugf",
"(",
"\"Service is completed and removed.\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"l",
".",
"Warningf",
"(",
"\"Service is completed but not found.\"",
")",
"\n",
"return",
"trace",
".",
"NotFound",
"(",
"\"service %v is not found\"",
",",
"srv",
")",
"\n",
"}"
] | // RemoveService removes service from supervisor tracking list | [
"RemoveService",
"removes",
"service",
"from",
"supervisor",
"tracking",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L211-L224 | train |
gravitational/teleport | lib/service/supervisor.go | BroadcastEvent | func (s *LocalSupervisor) BroadcastEvent(event Event) {
s.Lock()
defer s.Unlock()
switch event.Name {
case TeleportExitEvent:
s.signalExit()
case TeleportReloadEvent:
s.signalReload()
}
s.events[event.Name] = event
// Log all events other than recovered events to prevent the logs from
// being flooded.
if event.String() != TeleportOKEvent {
log.WithFields(logrus.Fields{"event": event.String(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)}).Debugf("Broadcasting event.")
}
go func() {
select {
case s.eventsC <- event:
case <-s.closeContext.Done():
return
}
}()
for _, m := range s.eventMappings {
if m.matches(event.Name, s.events) {
mappedEvent := Event{Name: m.Out}
s.events[mappedEvent.Name] = mappedEvent
go func(e Event) {
select {
case s.eventsC <- e:
case <-s.closeContext.Done():
return
}
}(mappedEvent)
log.WithFields(logrus.Fields{"in": event.String(), "out": m.String(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)}).Debugf("Broadcasting mapped event.")
}
}
} | go | func (s *LocalSupervisor) BroadcastEvent(event Event) {
s.Lock()
defer s.Unlock()
switch event.Name {
case TeleportExitEvent:
s.signalExit()
case TeleportReloadEvent:
s.signalReload()
}
s.events[event.Name] = event
// Log all events other than recovered events to prevent the logs from
// being flooded.
if event.String() != TeleportOKEvent {
log.WithFields(logrus.Fields{"event": event.String(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)}).Debugf("Broadcasting event.")
}
go func() {
select {
case s.eventsC <- event:
case <-s.closeContext.Done():
return
}
}()
for _, m := range s.eventMappings {
if m.matches(event.Name, s.events) {
mappedEvent := Event{Name: m.Out}
s.events[mappedEvent.Name] = mappedEvent
go func(e Event) {
select {
case s.eventsC <- e:
case <-s.closeContext.Done():
return
}
}(mappedEvent)
log.WithFields(logrus.Fields{"in": event.String(), "out": m.String(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)}).Debugf("Broadcasting mapped event.")
}
}
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"BroadcastEvent",
"(",
"event",
"Event",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"switch",
"event",
".",
"Name",
"{",
"case",
"TeleportExitEvent",
":",
"s",
".",
"signalExit",
"(",
")",
"\n",
"case",
"TeleportReloadEvent",
":",
"s",
".",
"signalReload",
"(",
")",
"\n",
"}",
"\n",
"s",
".",
"events",
"[",
"event",
".",
"Name",
"]",
"=",
"event",
"\n",
"if",
"event",
".",
"String",
"(",
")",
"!=",
"TeleportOKEvent",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"event\"",
":",
"event",
".",
"String",
"(",
")",
",",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentProcess",
",",
"s",
".",
"id",
")",
"}",
")",
".",
"Debugf",
"(",
"\"Broadcasting event.\"",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"select",
"{",
"case",
"s",
".",
"eventsC",
"<-",
"event",
":",
"case",
"<-",
"s",
".",
"closeContext",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"s",
".",
"eventMappings",
"{",
"if",
"m",
".",
"matches",
"(",
"event",
".",
"Name",
",",
"s",
".",
"events",
")",
"{",
"mappedEvent",
":=",
"Event",
"{",
"Name",
":",
"m",
".",
"Out",
"}",
"\n",
"s",
".",
"events",
"[",
"mappedEvent",
".",
"Name",
"]",
"=",
"mappedEvent",
"\n",
"go",
"func",
"(",
"e",
"Event",
")",
"{",
"select",
"{",
"case",
"s",
".",
"eventsC",
"<-",
"e",
":",
"case",
"<-",
"s",
".",
"closeContext",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"(",
"mappedEvent",
")",
"\n",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"in\"",
":",
"event",
".",
"String",
"(",
")",
",",
"\"out\"",
":",
"m",
".",
"String",
"(",
")",
",",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentProcess",
",",
"s",
".",
"id",
")",
"}",
")",
".",
"Debugf",
"(",
"\"Broadcasting mapped event.\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // BroadcastEvent generates event and broadcasts it to all
// subscribed parties. | [
"BroadcastEvent",
"generates",
"event",
"and",
"broadcasts",
"it",
"to",
"all",
"subscribed",
"parties",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L313-L354 | train |
gravitational/teleport | lib/service/supervisor.go | RegisterEventMapping | func (s *LocalSupervisor) RegisterEventMapping(m EventMapping) {
s.Lock()
defer s.Unlock()
s.eventMappings = append(s.eventMappings, m)
} | go | func (s *LocalSupervisor) RegisterEventMapping(m EventMapping) {
s.Lock()
defer s.Unlock()
s.eventMappings = append(s.eventMappings, m)
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"RegisterEventMapping",
"(",
"m",
"EventMapping",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"eventMappings",
"=",
"append",
"(",
"s",
".",
"eventMappings",
",",
"m",
")",
"\n",
"}"
] | // RegisterEventMapping registers event mapping -
// when the sequence in the event mapping triggers, the
// outbound event will be generated. | [
"RegisterEventMapping",
"registers",
"event",
"mapping",
"-",
"when",
"the",
"sequence",
"in",
"the",
"event",
"mapping",
"triggers",
"the",
"outbound",
"event",
"will",
"be",
"generated",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L359-L364 | train |
gravitational/teleport | lib/service/supervisor.go | WaitForEvent | func (s *LocalSupervisor) WaitForEvent(ctx context.Context, name string, eventC chan Event) {
s.Lock()
defer s.Unlock()
waiter := &waiter{eventC: eventC, context: ctx}
event, ok := s.events[name]
if ok {
go s.notifyWaiter(waiter, event)
return
}
s.eventWaiters[name] = append(s.eventWaiters[name], waiter)
} | go | func (s *LocalSupervisor) WaitForEvent(ctx context.Context, name string, eventC chan Event) {
s.Lock()
defer s.Unlock()
waiter := &waiter{eventC: eventC, context: ctx}
event, ok := s.events[name]
if ok {
go s.notifyWaiter(waiter, event)
return
}
s.eventWaiters[name] = append(s.eventWaiters[name], waiter)
} | [
"func",
"(",
"s",
"*",
"LocalSupervisor",
")",
"WaitForEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"name",
"string",
",",
"eventC",
"chan",
"Event",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"waiter",
":=",
"&",
"waiter",
"{",
"eventC",
":",
"eventC",
",",
"context",
":",
"ctx",
"}",
"\n",
"event",
",",
"ok",
":=",
"s",
".",
"events",
"[",
"name",
"]",
"\n",
"if",
"ok",
"{",
"go",
"s",
".",
"notifyWaiter",
"(",
"waiter",
",",
"event",
")",
"\n",
"return",
"\n",
"}",
"\n",
"s",
".",
"eventWaiters",
"[",
"name",
"]",
"=",
"append",
"(",
"s",
".",
"eventWaiters",
"[",
"name",
"]",
",",
"waiter",
")",
"\n",
"}"
] | // WaitForEvent waits for event to be broadcasted, if the event
// was already broadcasted, eventC will receive current event immediately. | [
"WaitForEvent",
"waits",
"for",
"event",
"to",
"be",
"broadcasted",
"if",
"the",
"event",
"was",
"already",
"broadcasted",
"eventC",
"will",
"receive",
"current",
"event",
"immediately",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/supervisor.go#L368-L379 | train |
gravitational/teleport | tool/tsh/tsh.go | onPlay | func onPlay(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
if err := tc.Play(context.TODO(), cf.Namespace, cf.SessionID); err != nil {
utils.FatalError(err)
}
} | go | func onPlay(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
if err := tc.Play(context.TODO(), cf.Namespace, cf.SessionID); err != nil {
utils.FatalError(err)
}
} | [
"func",
"onPlay",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"tc",
".",
"Play",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"cf",
".",
"Namespace",
",",
"cf",
".",
"SessionID",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // onPlay replays a session with a given ID | [
"onPlay",
"replays",
"a",
"session",
"with",
"a",
"given",
"ID"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L351-L359 | train |
gravitational/teleport | tool/tsh/tsh.go | onLogin | func onLogin(cf *CLIConf) {
var (
err error
tc *client.TeleportClient
key *client.Key
)
if cf.IdentityFileIn != "" {
utils.FatalError(trace.BadParameter("-i flag cannot be used here"))
}
if cf.IdentityFormat != client.IdentityFormatOpenSSH && cf.IdentityFormat != client.IdentityFormatFile {
utils.FatalError(trace.BadParameter("invalid identity format: %s", cf.IdentityFormat))
}
// Get the status of the active profile ~/.tsh/profile as well as the status
// of any other proxies the user is logged into.
profile, profiles, err := client.Status("", cf.Proxy)
if err != nil {
if !trace.IsNotFound(err) {
utils.FatalError(err)
}
}
// make the teleport client and retrieve the certificate from the proxy:
tc, err = makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
// client is already logged in and profile is not expired
if profile != nil && !profile.IsExpired(clockwork.NewRealClock()) {
switch {
// in case if nothing is specified, print current status
case cf.Proxy == "" && cf.SiteName == "":
printProfiles(profile, profiles)
return
// in case if parameters match, print current status
case host(cf.Proxy) == host(profile.ProxyURL.Host) && cf.SiteName == profile.Cluster:
printProfiles(profile, profiles)
return
// proxy is unspecified or the same as the currently provided proxy,
// but cluster is specified, treat this as selecting a new cluster
// for the same proxy
case (cf.Proxy == "" || host(cf.Proxy) == host(profile.ProxyURL.Host)) && cf.SiteName != "":
tc.SaveProfile("", "")
if err := kubeclient.UpdateKubeconfig(tc); err != nil {
utils.FatalError(err)
}
onStatus(cf)
return
// otherwise just passthrough to standard login
default:
}
}
if cf.Username == "" {
cf.Username = tc.Username
}
// -i flag specified? save the retreived cert into an identity file
makeIdentityFile := (cf.IdentityFileOut != "")
activateKey := !makeIdentityFile
key, err = tc.Login(cf.Context, activateKey)
if err != nil {
utils.FatalError(err)
}
if makeIdentityFile {
if err := setupNoninteractiveClient(tc, key); err != nil {
utils.FatalError(err)
}
authorities, err := tc.GetTrustedCA(cf.Context, key.ClusterName)
if err != nil {
utils.FatalError(err)
}
client.MakeIdentityFile(cf.IdentityFileOut, key, cf.IdentityFormat, authorities)
fmt.Printf("\nThe certificate has been written to %s\n", cf.IdentityFileOut)
return
}
// If the proxy is advertising that it supports Kubernetes, update kubeconfig.
if tc.KubeProxyAddr != "" {
if err := kubeclient.UpdateKubeconfig(tc); err != nil {
utils.FatalError(err)
}
}
// Regular login without -i flag.
tc.SaveProfile(key.ProxyHost, "")
// Print status to show information of the logged in user. Update the
// command line flag (used to print status) for the proxy to make sure any
// advertised settings are picked up.
webProxyHost, _ := tc.WebProxyHostPort()
cf.Proxy = webProxyHost
onStatus(cf)
} | go | func onLogin(cf *CLIConf) {
var (
err error
tc *client.TeleportClient
key *client.Key
)
if cf.IdentityFileIn != "" {
utils.FatalError(trace.BadParameter("-i flag cannot be used here"))
}
if cf.IdentityFormat != client.IdentityFormatOpenSSH && cf.IdentityFormat != client.IdentityFormatFile {
utils.FatalError(trace.BadParameter("invalid identity format: %s", cf.IdentityFormat))
}
// Get the status of the active profile ~/.tsh/profile as well as the status
// of any other proxies the user is logged into.
profile, profiles, err := client.Status("", cf.Proxy)
if err != nil {
if !trace.IsNotFound(err) {
utils.FatalError(err)
}
}
// make the teleport client and retrieve the certificate from the proxy:
tc, err = makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
// client is already logged in and profile is not expired
if profile != nil && !profile.IsExpired(clockwork.NewRealClock()) {
switch {
// in case if nothing is specified, print current status
case cf.Proxy == "" && cf.SiteName == "":
printProfiles(profile, profiles)
return
// in case if parameters match, print current status
case host(cf.Proxy) == host(profile.ProxyURL.Host) && cf.SiteName == profile.Cluster:
printProfiles(profile, profiles)
return
// proxy is unspecified or the same as the currently provided proxy,
// but cluster is specified, treat this as selecting a new cluster
// for the same proxy
case (cf.Proxy == "" || host(cf.Proxy) == host(profile.ProxyURL.Host)) && cf.SiteName != "":
tc.SaveProfile("", "")
if err := kubeclient.UpdateKubeconfig(tc); err != nil {
utils.FatalError(err)
}
onStatus(cf)
return
// otherwise just passthrough to standard login
default:
}
}
if cf.Username == "" {
cf.Username = tc.Username
}
// -i flag specified? save the retreived cert into an identity file
makeIdentityFile := (cf.IdentityFileOut != "")
activateKey := !makeIdentityFile
key, err = tc.Login(cf.Context, activateKey)
if err != nil {
utils.FatalError(err)
}
if makeIdentityFile {
if err := setupNoninteractiveClient(tc, key); err != nil {
utils.FatalError(err)
}
authorities, err := tc.GetTrustedCA(cf.Context, key.ClusterName)
if err != nil {
utils.FatalError(err)
}
client.MakeIdentityFile(cf.IdentityFileOut, key, cf.IdentityFormat, authorities)
fmt.Printf("\nThe certificate has been written to %s\n", cf.IdentityFileOut)
return
}
// If the proxy is advertising that it supports Kubernetes, update kubeconfig.
if tc.KubeProxyAddr != "" {
if err := kubeclient.UpdateKubeconfig(tc); err != nil {
utils.FatalError(err)
}
}
// Regular login without -i flag.
tc.SaveProfile(key.ProxyHost, "")
// Print status to show information of the logged in user. Update the
// command line flag (used to print status) for the proxy to make sure any
// advertised settings are picked up.
webProxyHost, _ := tc.WebProxyHostPort()
cf.Proxy = webProxyHost
onStatus(cf)
} | [
"func",
"onLogin",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"var",
"(",
"err",
"error",
"\n",
"tc",
"*",
"client",
".",
"TeleportClient",
"\n",
"key",
"*",
"client",
".",
"Key",
"\n",
")",
"\n",
"if",
"cf",
".",
"IdentityFileIn",
"!=",
"\"\"",
"{",
"utils",
".",
"FatalError",
"(",
"trace",
".",
"BadParameter",
"(",
"\"-i flag cannot be used here\"",
")",
")",
"\n",
"}",
"\n",
"if",
"cf",
".",
"IdentityFormat",
"!=",
"client",
".",
"IdentityFormatOpenSSH",
"&&",
"cf",
".",
"IdentityFormat",
"!=",
"client",
".",
"IdentityFormatFile",
"{",
"utils",
".",
"FatalError",
"(",
"trace",
".",
"BadParameter",
"(",
"\"invalid identity format: %s\"",
",",
"cf",
".",
"IdentityFormat",
")",
")",
"\n",
"}",
"\n",
"profile",
",",
"profiles",
",",
"err",
":=",
"client",
".",
"Status",
"(",
"\"\"",
",",
"cf",
".",
"Proxy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"tc",
",",
"err",
"=",
"makeClient",
"(",
"cf",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"profile",
"!=",
"nil",
"&&",
"!",
"profile",
".",
"IsExpired",
"(",
"clockwork",
".",
"NewRealClock",
"(",
")",
")",
"{",
"switch",
"{",
"case",
"cf",
".",
"Proxy",
"==",
"\"\"",
"&&",
"cf",
".",
"SiteName",
"==",
"\"\"",
":",
"printProfiles",
"(",
"profile",
",",
"profiles",
")",
"\n",
"return",
"\n",
"case",
"host",
"(",
"cf",
".",
"Proxy",
")",
"==",
"host",
"(",
"profile",
".",
"ProxyURL",
".",
"Host",
")",
"&&",
"cf",
".",
"SiteName",
"==",
"profile",
".",
"Cluster",
":",
"printProfiles",
"(",
"profile",
",",
"profiles",
")",
"\n",
"return",
"\n",
"case",
"(",
"cf",
".",
"Proxy",
"==",
"\"\"",
"||",
"host",
"(",
"cf",
".",
"Proxy",
")",
"==",
"host",
"(",
"profile",
".",
"ProxyURL",
".",
"Host",
")",
")",
"&&",
"cf",
".",
"SiteName",
"!=",
"\"\"",
":",
"tc",
".",
"SaveProfile",
"(",
"\"\"",
",",
"\"\"",
")",
"\n",
"if",
"err",
":=",
"kubeclient",
".",
"UpdateKubeconfig",
"(",
"tc",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"onStatus",
"(",
"cf",
")",
"\n",
"return",
"\n",
"default",
":",
"}",
"\n",
"}",
"\n",
"if",
"cf",
".",
"Username",
"==",
"\"\"",
"{",
"cf",
".",
"Username",
"=",
"tc",
".",
"Username",
"\n",
"}",
"\n",
"makeIdentityFile",
":=",
"(",
"cf",
".",
"IdentityFileOut",
"!=",
"\"\"",
")",
"\n",
"activateKey",
":=",
"!",
"makeIdentityFile",
"\n",
"key",
",",
"err",
"=",
"tc",
".",
"Login",
"(",
"cf",
".",
"Context",
",",
"activateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"makeIdentityFile",
"{",
"if",
"err",
":=",
"setupNoninteractiveClient",
"(",
"tc",
",",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"authorities",
",",
"err",
":=",
"tc",
".",
"GetTrustedCA",
"(",
"cf",
".",
"Context",
",",
"key",
".",
"ClusterName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"client",
".",
"MakeIdentityFile",
"(",
"cf",
".",
"IdentityFileOut",
",",
"key",
",",
"cf",
".",
"IdentityFormat",
",",
"authorities",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"\\nThe certificate has been written to %s\\n\"",
",",
"\\n",
")",
"\n",
"\\n",
"\n",
"}",
"\n",
"cf",
".",
"IdentityFileOut",
"\n",
"return",
"\n",
"if",
"tc",
".",
"KubeProxyAddr",
"!=",
"\"\"",
"{",
"if",
"err",
":=",
"kubeclient",
".",
"UpdateKubeconfig",
"(",
"tc",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"tc",
".",
"SaveProfile",
"(",
"key",
".",
"ProxyHost",
",",
"\"\"",
")",
"\n",
"webProxyHost",
",",
"_",
":=",
"tc",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"}"
] | // onLogin logs in with remote proxy and gets signed certificates | [
"onLogin",
"logs",
"in",
"with",
"remote",
"proxy",
"and",
"gets",
"signed",
"certificates"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L362-L460 | train |
gravitational/teleport | tool/tsh/tsh.go | setupNoninteractiveClient | func setupNoninteractiveClient(tc *client.TeleportClient, key *client.Key) error {
certUsername, err := key.CertUsername()
if err != nil {
return trace.Wrap(err)
}
tc.Username = certUsername
// Extract and set the HostLogin to be the first principal. It doesn't
// matter what the value is, but some valid principal has to be set
// otherwise the certificate won't be validated.
certPrincipals, err := key.CertPrincipals()
if err != nil {
return trace.Wrap(err)
}
if len(certPrincipals) == 0 {
return trace.BadParameter("no principals found")
}
tc.HostLogin = certPrincipals[0]
identityAuth, err := authFromIdentity(key)
if err != nil {
return trace.Wrap(err)
}
tc.TLS, err = key.ClientTLSConfig()
if err != nil {
return trace.Wrap(err)
}
tc.AuthMethods = []ssh.AuthMethod{identityAuth}
tc.Interactive = false
tc.SkipLocalAuth = true
return nil
} | go | func setupNoninteractiveClient(tc *client.TeleportClient, key *client.Key) error {
certUsername, err := key.CertUsername()
if err != nil {
return trace.Wrap(err)
}
tc.Username = certUsername
// Extract and set the HostLogin to be the first principal. It doesn't
// matter what the value is, but some valid principal has to be set
// otherwise the certificate won't be validated.
certPrincipals, err := key.CertPrincipals()
if err != nil {
return trace.Wrap(err)
}
if len(certPrincipals) == 0 {
return trace.BadParameter("no principals found")
}
tc.HostLogin = certPrincipals[0]
identityAuth, err := authFromIdentity(key)
if err != nil {
return trace.Wrap(err)
}
tc.TLS, err = key.ClientTLSConfig()
if err != nil {
return trace.Wrap(err)
}
tc.AuthMethods = []ssh.AuthMethod{identityAuth}
tc.Interactive = false
tc.SkipLocalAuth = true
return nil
} | [
"func",
"setupNoninteractiveClient",
"(",
"tc",
"*",
"client",
".",
"TeleportClient",
",",
"key",
"*",
"client",
".",
"Key",
")",
"error",
"{",
"certUsername",
",",
"err",
":=",
"key",
".",
"CertUsername",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tc",
".",
"Username",
"=",
"certUsername",
"\n",
"certPrincipals",
",",
"err",
":=",
"key",
".",
"CertPrincipals",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"certPrincipals",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"no principals found\"",
")",
"\n",
"}",
"\n",
"tc",
".",
"HostLogin",
"=",
"certPrincipals",
"[",
"0",
"]",
"\n",
"identityAuth",
",",
"err",
":=",
"authFromIdentity",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tc",
".",
"TLS",
",",
"err",
"=",
"key",
".",
"ClientTLSConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tc",
".",
"AuthMethods",
"=",
"[",
"]",
"ssh",
".",
"AuthMethod",
"{",
"identityAuth",
"}",
"\n",
"tc",
".",
"Interactive",
"=",
"false",
"\n",
"tc",
".",
"SkipLocalAuth",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] | // setupNoninteractiveClient sets up existing client to use
// non-interactive authentication methods | [
"setupNoninteractiveClient",
"sets",
"up",
"existing",
"client",
"to",
"use",
"non",
"-",
"interactive",
"authentication",
"methods"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L464-L495 | train |
gravitational/teleport | tool/tsh/tsh.go | onListNodes | func onListNodes(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
// Get list of all nodes in backend and sort by "Node Name".
var nodes []services.Server
err = client.RetryWithRelogin(cf.Context, tc, func() error {
nodes, err = tc.ListNodes(cf.Context)
return err
})
if err != nil {
utils.FatalError(err)
}
sort.Slice(nodes, func(i, j int) bool {
return nodes[i].GetHostname() < nodes[j].GetHostname()
})
switch cf.Verbose {
// In verbose mode, print everything on a single line and include the Node
// ID (UUID). Useful for machines that need to parse the output of "tsh ls".
case true:
t := asciitable.MakeTable([]string{"Node Name", "Node ID", "Address", "Labels"})
for _, n := range nodes {
t.AddRow([]string{
n.GetHostname(), n.GetName(), n.GetAddr(), n.LabelsString(),
})
}
fmt.Println(t.AsBuffer().String())
// In normal mode chunk the labels and print two per line and allow multiple
// lines per node.
case false:
t := asciitable.MakeTable([]string{"Node Name", "Address", "Labels"})
for _, n := range nodes {
labelChunks := chunkLabels(n.GetAllLabels(), 2)
for i, v := range labelChunks {
var hostname string
var addr string
if i == 0 {
hostname = n.GetHostname()
addr = n.GetAddr()
}
t.AddRow([]string{hostname, addr, strings.Join(v, ", ")})
}
}
fmt.Println(t.AsBuffer().String())
}
} | go | func onListNodes(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
// Get list of all nodes in backend and sort by "Node Name".
var nodes []services.Server
err = client.RetryWithRelogin(cf.Context, tc, func() error {
nodes, err = tc.ListNodes(cf.Context)
return err
})
if err != nil {
utils.FatalError(err)
}
sort.Slice(nodes, func(i, j int) bool {
return nodes[i].GetHostname() < nodes[j].GetHostname()
})
switch cf.Verbose {
// In verbose mode, print everything on a single line and include the Node
// ID (UUID). Useful for machines that need to parse the output of "tsh ls".
case true:
t := asciitable.MakeTable([]string{"Node Name", "Node ID", "Address", "Labels"})
for _, n := range nodes {
t.AddRow([]string{
n.GetHostname(), n.GetName(), n.GetAddr(), n.LabelsString(),
})
}
fmt.Println(t.AsBuffer().String())
// In normal mode chunk the labels and print two per line and allow multiple
// lines per node.
case false:
t := asciitable.MakeTable([]string{"Node Name", "Address", "Labels"})
for _, n := range nodes {
labelChunks := chunkLabels(n.GetAllLabels(), 2)
for i, v := range labelChunks {
var hostname string
var addr string
if i == 0 {
hostname = n.GetHostname()
addr = n.GetAddr()
}
t.AddRow([]string{hostname, addr, strings.Join(v, ", ")})
}
}
fmt.Println(t.AsBuffer().String())
}
} | [
"func",
"onListNodes",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"nodes",
"[",
"]",
"services",
".",
"Server",
"\n",
"err",
"=",
"client",
".",
"RetryWithRelogin",
"(",
"cf",
".",
"Context",
",",
"tc",
",",
"func",
"(",
")",
"error",
"{",
"nodes",
",",
"err",
"=",
"tc",
".",
"ListNodes",
"(",
"cf",
".",
"Context",
")",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"sort",
".",
"Slice",
"(",
"nodes",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"nodes",
"[",
"i",
"]",
".",
"GetHostname",
"(",
")",
"<",
"nodes",
"[",
"j",
"]",
".",
"GetHostname",
"(",
")",
"\n",
"}",
")",
"\n",
"switch",
"cf",
".",
"Verbose",
"{",
"case",
"true",
":",
"t",
":=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"Node Name\"",
",",
"\"Node ID\"",
",",
"\"Address\"",
",",
"\"Labels\"",
"}",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"nodes",
"{",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"n",
".",
"GetHostname",
"(",
")",
",",
"n",
".",
"GetName",
"(",
")",
",",
"n",
".",
"GetAddr",
"(",
")",
",",
"n",
".",
"LabelsString",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"t",
".",
"AsBuffer",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"case",
"false",
":",
"t",
":=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"Node Name\"",
",",
"\"Address\"",
",",
"\"Labels\"",
"}",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"nodes",
"{",
"labelChunks",
":=",
"chunkLabels",
"(",
"n",
".",
"GetAllLabels",
"(",
")",
",",
"2",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"labelChunks",
"{",
"var",
"hostname",
"string",
"\n",
"var",
"addr",
"string",
"\n",
"if",
"i",
"==",
"0",
"{",
"hostname",
"=",
"n",
".",
"GetHostname",
"(",
")",
"\n",
"addr",
"=",
"n",
".",
"GetAddr",
"(",
")",
"\n",
"}",
"\n",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"hostname",
",",
"addr",
",",
"strings",
".",
"Join",
"(",
"v",
",",
"\", \"",
")",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"t",
".",
"AsBuffer",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // onListNodes executes 'tsh ls' command. | [
"onListNodes",
"executes",
"tsh",
"ls",
"command",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L589-L637 | train |
gravitational/teleport | tool/tsh/tsh.go | chunkLabels | func chunkLabels(labels map[string]string, chunkSize int) [][]string {
// First sort labels so they always occur in the same order.
sorted := make([]string, 0, len(labels))
for k, v := range labels {
sorted = append(sorted, fmt.Sprintf("%v=%v", k, v))
}
sort.Slice(sorted, func(i, j int) bool { return sorted[i] < sorted[j] })
// Then chunk labels into sized chunks.
var chunks [][]string
for chunkSize < len(sorted) {
sorted, chunks = sorted[chunkSize:], append(chunks, sorted[0:chunkSize:chunkSize])
}
chunks = append(chunks, sorted)
return chunks
} | go | func chunkLabels(labels map[string]string, chunkSize int) [][]string {
// First sort labels so they always occur in the same order.
sorted := make([]string, 0, len(labels))
for k, v := range labels {
sorted = append(sorted, fmt.Sprintf("%v=%v", k, v))
}
sort.Slice(sorted, func(i, j int) bool { return sorted[i] < sorted[j] })
// Then chunk labels into sized chunks.
var chunks [][]string
for chunkSize < len(sorted) {
sorted, chunks = sorted[chunkSize:], append(chunks, sorted[0:chunkSize:chunkSize])
}
chunks = append(chunks, sorted)
return chunks
} | [
"func",
"chunkLabels",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"chunkSize",
"int",
")",
"[",
"]",
"[",
"]",
"string",
"{",
"sorted",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"labels",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"labels",
"{",
"sorted",
"=",
"append",
"(",
"sorted",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v=%v\"",
",",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Slice",
"(",
"sorted",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"sorted",
"[",
"i",
"]",
"<",
"sorted",
"[",
"j",
"]",
"}",
")",
"\n",
"var",
"chunks",
"[",
"]",
"[",
"]",
"string",
"\n",
"for",
"chunkSize",
"<",
"len",
"(",
"sorted",
")",
"{",
"sorted",
",",
"chunks",
"=",
"sorted",
"[",
"chunkSize",
":",
"]",
",",
"append",
"(",
"chunks",
",",
"sorted",
"[",
"0",
":",
"chunkSize",
":",
"chunkSize",
"]",
")",
"\n",
"}",
"\n",
"chunks",
"=",
"append",
"(",
"chunks",
",",
"sorted",
")",
"\n",
"return",
"chunks",
"\n",
"}"
] | // chunkLabels breaks labels into sized chunks. Used to improve readability
// of "tsh ls". | [
"chunkLabels",
"breaks",
"labels",
"into",
"sized",
"chunks",
".",
"Used",
"to",
"improve",
"readability",
"of",
"tsh",
"ls",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L641-L657 | train |
gravitational/teleport | tool/tsh/tsh.go | onListClusters | func onListClusters(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
proxyClient, err := tc.ConnectToProxy(cf.Context)
if err != nil {
utils.FatalError(err)
}
defer proxyClient.Close()
var sites []services.Site
err = client.RetryWithRelogin(cf.Context, tc, func() error {
sites, err = proxyClient.GetSites()
return err
})
if err != nil {
utils.FatalError(err)
}
var t asciitable.Table
if cf.Quiet {
t = asciitable.MakeHeadlessTable(2)
} else {
t = asciitable.MakeTable([]string{"Cluster Name", "Status"})
}
if len(sites) == 0 {
return
}
for _, site := range sites {
t.AddRow([]string{site.Name, site.Status})
}
fmt.Println(t.AsBuffer().String())
} | go | func onListClusters(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
proxyClient, err := tc.ConnectToProxy(cf.Context)
if err != nil {
utils.FatalError(err)
}
defer proxyClient.Close()
var sites []services.Site
err = client.RetryWithRelogin(cf.Context, tc, func() error {
sites, err = proxyClient.GetSites()
return err
})
if err != nil {
utils.FatalError(err)
}
var t asciitable.Table
if cf.Quiet {
t = asciitable.MakeHeadlessTable(2)
} else {
t = asciitable.MakeTable([]string{"Cluster Name", "Status"})
}
if len(sites) == 0 {
return
}
for _, site := range sites {
t.AddRow([]string{site.Name, site.Status})
}
fmt.Println(t.AsBuffer().String())
} | [
"func",
"onListClusters",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"proxyClient",
",",
"err",
":=",
"tc",
".",
"ConnectToProxy",
"(",
"cf",
".",
"Context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"proxyClient",
".",
"Close",
"(",
")",
"\n",
"var",
"sites",
"[",
"]",
"services",
".",
"Site",
"\n",
"err",
"=",
"client",
".",
"RetryWithRelogin",
"(",
"cf",
".",
"Context",
",",
"tc",
",",
"func",
"(",
")",
"error",
"{",
"sites",
",",
"err",
"=",
"proxyClient",
".",
"GetSites",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"t",
"asciitable",
".",
"Table",
"\n",
"if",
"cf",
".",
"Quiet",
"{",
"t",
"=",
"asciitable",
".",
"MakeHeadlessTable",
"(",
"2",
")",
"\n",
"}",
"else",
"{",
"t",
"=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"Cluster Name\"",
",",
"\"Status\"",
"}",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"sites",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"for",
"_",
",",
"site",
":=",
"range",
"sites",
"{",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"site",
".",
"Name",
",",
"site",
".",
"Status",
"}",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"t",
".",
"AsBuffer",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"}"
] | // onListClusters executes 'tsh clusters' command | [
"onListClusters",
"executes",
"tsh",
"clusters",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L660-L692 | train |
gravitational/teleport | tool/tsh/tsh.go | onSSH | func onSSH(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
tc.Stdin = os.Stdin
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.SSH(cf.Context, cf.RemoteCommand, cf.LocalExec)
})
if err != nil {
// exit with the same exit status as the failed command:
if tc.ExitStatus != 0 {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(tc.ExitStatus)
} else {
utils.FatalError(err)
}
}
} | go | func onSSH(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
tc.Stdin = os.Stdin
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.SSH(cf.Context, cf.RemoteCommand, cf.LocalExec)
})
if err != nil {
// exit with the same exit status as the failed command:
if tc.ExitStatus != 0 {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(tc.ExitStatus)
} else {
utils.FatalError(err)
}
}
} | [
"func",
"onSSH",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"tc",
".",
"Stdin",
"=",
"os",
".",
"Stdin",
"\n",
"err",
"=",
"client",
".",
"RetryWithRelogin",
"(",
"cf",
".",
"Context",
",",
"tc",
",",
"func",
"(",
")",
"error",
"{",
"return",
"tc",
".",
"SSH",
"(",
"cf",
".",
"Context",
",",
"cf",
".",
"RemoteCommand",
",",
"cf",
".",
"LocalExec",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"tc",
".",
"ExitStatus",
"!=",
"0",
"{",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
",",
"utils",
".",
"UserMessageFromError",
"(",
"err",
")",
")",
"\n",
"os",
".",
"Exit",
"(",
"tc",
".",
"ExitStatus",
")",
"\n",
"}",
"else",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // onSSH executes 'tsh ssh' command | [
"onSSH",
"executes",
"tsh",
"ssh",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L695-L714 | train |
gravitational/teleport | tool/tsh/tsh.go | onBenchmark | func onBenchmark(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
result, err := tc.Benchmark(cf.Context, client.Benchmark{
Command: cf.RemoteCommand,
Threads: cf.BenchThreads,
Duration: cf.BenchDuration,
Rate: cf.BenchRate,
})
if err != nil {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(255)
}
fmt.Printf("\n")
fmt.Printf("* Requests originated: %v\n", result.RequestsOriginated)
fmt.Printf("* Requests failed: %v\n", result.RequestsFailed)
if result.LastError != nil {
fmt.Printf("* Last error: %v\n", result.LastError)
}
fmt.Printf("\nHistogram\n\n")
t := asciitable.MakeTable([]string{"Percentile", "Duration"})
for _, quantile := range []float64{25, 50, 75, 90, 95, 99, 100} {
t.AddRow([]string{fmt.Sprintf("%v", quantile),
fmt.Sprintf("%v ms", result.Histogram.ValueAtQuantile(quantile)),
})
}
io.Copy(os.Stdout, t.AsBuffer())
fmt.Printf("\n")
} | go | func onBenchmark(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
result, err := tc.Benchmark(cf.Context, client.Benchmark{
Command: cf.RemoteCommand,
Threads: cf.BenchThreads,
Duration: cf.BenchDuration,
Rate: cf.BenchRate,
})
if err != nil {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(255)
}
fmt.Printf("\n")
fmt.Printf("* Requests originated: %v\n", result.RequestsOriginated)
fmt.Printf("* Requests failed: %v\n", result.RequestsFailed)
if result.LastError != nil {
fmt.Printf("* Last error: %v\n", result.LastError)
}
fmt.Printf("\nHistogram\n\n")
t := asciitable.MakeTable([]string{"Percentile", "Duration"})
for _, quantile := range []float64{25, 50, 75, 90, 95, 99, 100} {
t.AddRow([]string{fmt.Sprintf("%v", quantile),
fmt.Sprintf("%v ms", result.Histogram.ValueAtQuantile(quantile)),
})
}
io.Copy(os.Stdout, t.AsBuffer())
fmt.Printf("\n")
} | [
"func",
"onBenchmark",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"result",
",",
"err",
":=",
"tc",
".",
"Benchmark",
"(",
"cf",
".",
"Context",
",",
"client",
".",
"Benchmark",
"{",
"Command",
":",
"cf",
".",
"RemoteCommand",
",",
"Threads",
":",
"cf",
".",
"BenchThreads",
",",
"Duration",
":",
"cf",
".",
"BenchDuration",
",",
"Rate",
":",
"cf",
".",
"BenchRate",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
",",
"utils",
".",
"UserMessageFromError",
"(",
"err",
")",
")",
"\n",
"os",
".",
"Exit",
"(",
"255",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"\\n\"",
")",
"\n",
"\\n",
"\n",
"fmt",
".",
"Printf",
"(",
"\"* Requests originated: %v\\n\"",
",",
"\\n",
")",
"\n",
"result",
".",
"RequestsOriginated",
"\n",
"fmt",
".",
"Printf",
"(",
"\"* Requests failed: %v\\n\"",
",",
"\\n",
")",
"\n",
"result",
".",
"RequestsFailed",
"\n",
"if",
"result",
".",
"LastError",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"* Last error: %v\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"result",
".",
"LastError",
"\n",
"fmt",
".",
"Printf",
"(",
"\"\\nHistogram\\n\\n\"",
")",
"\n",
"}"
] | // onBenchmark executes benchmark | [
"onBenchmark",
"executes",
"benchmark"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L717-L747 | train |
gravitational/teleport | tool/tsh/tsh.go | onJoin | func onJoin(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
sid, err := session.ParseID(cf.SessionID)
if err != nil {
utils.FatalError(fmt.Errorf("'%v' is not a valid session ID (must be GUID)", cf.SessionID))
}
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.Join(context.TODO(), cf.Namespace, *sid, nil)
})
if err != nil {
utils.FatalError(err)
}
} | go | func onJoin(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
sid, err := session.ParseID(cf.SessionID)
if err != nil {
utils.FatalError(fmt.Errorf("'%v' is not a valid session ID (must be GUID)", cf.SessionID))
}
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.Join(context.TODO(), cf.Namespace, *sid, nil)
})
if err != nil {
utils.FatalError(err)
}
} | [
"func",
"onJoin",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"sid",
",",
"err",
":=",
"session",
".",
"ParseID",
"(",
"cf",
".",
"SessionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"fmt",
".",
"Errorf",
"(",
"\"'%v' is not a valid session ID (must be GUID)\"",
",",
"cf",
".",
"SessionID",
")",
")",
"\n",
"}",
"\n",
"err",
"=",
"client",
".",
"RetryWithRelogin",
"(",
"cf",
".",
"Context",
",",
"tc",
",",
"func",
"(",
")",
"error",
"{",
"return",
"tc",
".",
"Join",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"cf",
".",
"Namespace",
",",
"*",
"sid",
",",
"nil",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // onJoin executes 'ssh join' command | [
"onJoin",
"executes",
"ssh",
"join",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L750-L765 | train |
gravitational/teleport | tool/tsh/tsh.go | onSCP | func onSCP(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.SCP(context.TODO(), cf.CopySpec, int(cf.NodePort), cf.RecursiveCopy, cf.Quiet)
})
if err != nil {
// exit with the same exit status as the failed command:
if tc.ExitStatus != 0 {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(tc.ExitStatus)
} else {
utils.FatalError(err)
}
}
} | go | func onSCP(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.SCP(context.TODO(), cf.CopySpec, int(cf.NodePort), cf.RecursiveCopy, cf.Quiet)
})
if err != nil {
// exit with the same exit status as the failed command:
if tc.ExitStatus != 0 {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(tc.ExitStatus)
} else {
utils.FatalError(err)
}
}
} | [
"func",
"onSCP",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"tc",
",",
"err",
":=",
"makeClient",
"(",
"cf",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"client",
".",
"RetryWithRelogin",
"(",
"cf",
".",
"Context",
",",
"tc",
",",
"func",
"(",
")",
"error",
"{",
"return",
"tc",
".",
"SCP",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"cf",
".",
"CopySpec",
",",
"int",
"(",
"cf",
".",
"NodePort",
")",
",",
"cf",
".",
"RecursiveCopy",
",",
"cf",
".",
"Quiet",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"tc",
".",
"ExitStatus",
"!=",
"0",
"{",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
",",
"utils",
".",
"UserMessageFromError",
"(",
"err",
")",
")",
"\n",
"os",
".",
"Exit",
"(",
"tc",
".",
"ExitStatus",
")",
"\n",
"}",
"else",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // onSCP executes 'tsh scp' command | [
"onSCP",
"executes",
"tsh",
"scp",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L768-L785 | train |
gravitational/teleport | tool/tsh/tsh.go | authFromIdentity | func authFromIdentity(k *client.Key) (ssh.AuthMethod, error) {
signer, err := sshutils.NewSigner(k.Priv, k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
return client.NewAuthMethodForCert(signer), nil
} | go | func authFromIdentity(k *client.Key) (ssh.AuthMethod, error) {
signer, err := sshutils.NewSigner(k.Priv, k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
return client.NewAuthMethodForCert(signer), nil
} | [
"func",
"authFromIdentity",
"(",
"k",
"*",
"client",
".",
"Key",
")",
"(",
"ssh",
".",
"AuthMethod",
",",
"error",
")",
"{",
"signer",
",",
"err",
":=",
"sshutils",
".",
"NewSigner",
"(",
"k",
".",
"Priv",
",",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"client",
".",
"NewAuthMethodForCert",
"(",
"signer",
")",
",",
"nil",
"\n",
"}"
] | // authFromIdentity returns a standard ssh.Authmethod for a given identity file | [
"authFromIdentity",
"returns",
"a",
"standard",
"ssh",
".",
"Authmethod",
"for",
"a",
"given",
"identity",
"file"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L1091-L1097 | train |
gravitational/teleport | tool/tsh/tsh.go | printStatus | func printStatus(p *client.ProfileStatus, isActive bool) {
var prefix string
if isActive {
prefix = "> "
} else {
prefix = " "
}
duration := p.ValidUntil.Sub(time.Now())
humanDuration := "EXPIRED"
if duration.Nanoseconds() > 0 {
humanDuration = fmt.Sprintf("valid for %v", duration.Round(time.Minute))
}
fmt.Printf("%vProfile URL: %v\n", prefix, p.ProxyURL.String())
fmt.Printf(" Logged in as: %v\n", p.Username)
if p.Cluster != "" {
fmt.Printf(" Cluster: %v\n", p.Cluster)
}
fmt.Printf(" Roles: %v*\n", strings.Join(p.Roles, ", "))
fmt.Printf(" Logins: %v\n", strings.Join(p.Logins, ", "))
fmt.Printf(" Valid until: %v [%v]\n", p.ValidUntil, humanDuration)
fmt.Printf(" Extensions: %v\n\n", strings.Join(p.Extensions, ", "))
} | go | func printStatus(p *client.ProfileStatus, isActive bool) {
var prefix string
if isActive {
prefix = "> "
} else {
prefix = " "
}
duration := p.ValidUntil.Sub(time.Now())
humanDuration := "EXPIRED"
if duration.Nanoseconds() > 0 {
humanDuration = fmt.Sprintf("valid for %v", duration.Round(time.Minute))
}
fmt.Printf("%vProfile URL: %v\n", prefix, p.ProxyURL.String())
fmt.Printf(" Logged in as: %v\n", p.Username)
if p.Cluster != "" {
fmt.Printf(" Cluster: %v\n", p.Cluster)
}
fmt.Printf(" Roles: %v*\n", strings.Join(p.Roles, ", "))
fmt.Printf(" Logins: %v\n", strings.Join(p.Logins, ", "))
fmt.Printf(" Valid until: %v [%v]\n", p.ValidUntil, humanDuration)
fmt.Printf(" Extensions: %v\n\n", strings.Join(p.Extensions, ", "))
} | [
"func",
"printStatus",
"(",
"p",
"*",
"client",
".",
"ProfileStatus",
",",
"isActive",
"bool",
")",
"{",
"var",
"prefix",
"string",
"\n",
"if",
"isActive",
"{",
"prefix",
"=",
"\"> \"",
"\n",
"}",
"else",
"{",
"prefix",
"=",
"\" \"",
"\n",
"}",
"\n",
"duration",
":=",
"p",
".",
"ValidUntil",
".",
"Sub",
"(",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"humanDuration",
":=",
"\"EXPIRED\"",
"\n",
"if",
"duration",
".",
"Nanoseconds",
"(",
")",
">",
"0",
"{",
"humanDuration",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"valid for %v\"",
",",
"duration",
".",
"Round",
"(",
"time",
".",
"Minute",
")",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"%vProfile URL: %v\\n\"",
",",
"\\n",
",",
"prefix",
")",
"\n",
"p",
".",
"ProxyURL",
".",
"String",
"(",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\" Logged in as: %v\\n\"",
",",
"\\n",
")",
"\n",
"p",
".",
"Username",
"\n",
"if",
"p",
".",
"Cluster",
"!=",
"\"\"",
"{",
"fmt",
".",
"Printf",
"(",
"\" Cluster: %v\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"p",
".",
"Cluster",
"\n",
"fmt",
".",
"Printf",
"(",
"\" Roles: %v*\\n\"",
",",
"\\n",
")",
"\n",
"}"
] | // printStatus prints the status of the profile. | [
"printStatus",
"prints",
"the",
"status",
"of",
"the",
"profile",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L1127-L1149 | train |
gravitational/teleport | tool/tsh/tsh.go | onStatus | func onStatus(cf *CLIConf) {
// Get the status of the active profile ~/.tsh/profile as well as the status
// of any other proxies the user is logged into.
profile, profiles, err := client.Status("", cf.Proxy)
if err != nil {
if trace.IsNotFound(err) {
fmt.Printf("Not logged in.\n")
return
}
utils.FatalError(err)
}
printProfiles(profile, profiles)
} | go | func onStatus(cf *CLIConf) {
// Get the status of the active profile ~/.tsh/profile as well as the status
// of any other proxies the user is logged into.
profile, profiles, err := client.Status("", cf.Proxy)
if err != nil {
if trace.IsNotFound(err) {
fmt.Printf("Not logged in.\n")
return
}
utils.FatalError(err)
}
printProfiles(profile, profiles)
} | [
"func",
"onStatus",
"(",
"cf",
"*",
"CLIConf",
")",
"{",
"profile",
",",
"profiles",
",",
"err",
":=",
"client",
".",
"Status",
"(",
"\"\"",
",",
"cf",
".",
"Proxy",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"Not logged in.\\n\"",
")",
"\n",
"\\n",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}"
] | // onStatus command shows which proxy the user is logged into and metadata
// about the certificate. | [
"onStatus",
"command",
"shows",
"which",
"proxy",
"the",
"user",
"is",
"logged",
"into",
"and",
"metadata",
"about",
"the",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tsh/tsh.go#L1153-L1165 | train |
gravitational/teleport | lib/services/user.go | NewUser | func NewUser(name string) (User, error) {
u := &UserV2{
Kind: KindUser,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | go | func NewUser(name string) (User, error) {
u := &UserV2{
Kind: KindUser,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | [
"func",
"NewUser",
"(",
"name",
"string",
")",
"(",
"User",
",",
"error",
")",
"{",
"u",
":=",
"&",
"UserV2",
"{",
"Kind",
":",
"KindUser",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"}",
"\n",
"if",
"err",
":=",
"u",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"u",
",",
"nil",
"\n",
"}"
] | // NewUser creates new empty user | [
"NewUser",
"creates",
"new",
"empty",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L74-L87 | train |
gravitational/teleport | lib/services/user.go | String | func (c CreatedBy) String() string {
if c.User.Name == "" {
return "system"
}
if c.Connector != nil {
return fmt.Sprintf("%v connector %v for user %v at %v",
c.Connector.Type, c.Connector.ID, c.Connector.Identity, utils.HumanTimeFormat(c.Time))
}
return fmt.Sprintf("%v at %v", c.User.Name, c.Time)
} | go | func (c CreatedBy) String() string {
if c.User.Name == "" {
return "system"
}
if c.Connector != nil {
return fmt.Sprintf("%v connector %v for user %v at %v",
c.Connector.Type, c.Connector.ID, c.Connector.Identity, utils.HumanTimeFormat(c.Time))
}
return fmt.Sprintf("%v at %v", c.User.Name, c.Time)
} | [
"func",
"(",
"c",
"CreatedBy",
")",
"String",
"(",
")",
"string",
"{",
"if",
"c",
".",
"User",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"\"system\"",
"\n",
"}",
"\n",
"if",
"c",
".",
"Connector",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%v connector %v for user %v at %v\"",
",",
"c",
".",
"Connector",
".",
"Type",
",",
"c",
".",
"Connector",
".",
"ID",
",",
"c",
".",
"Connector",
".",
"Identity",
",",
"utils",
".",
"HumanTimeFormat",
"(",
"c",
".",
"Time",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%v at %v\"",
",",
"c",
".",
"User",
".",
"Name",
",",
"c",
".",
"Time",
")",
"\n",
"}"
] | // String returns human readable information about the user | [
"String",
"returns",
"human",
"readable",
"information",
"about",
"the",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L123-L132 | train |
gravitational/teleport | lib/services/user.go | Check | func (la *LoginAttempt) Check() error {
if la.Time.IsZero() {
return trace.BadParameter("missing parameter time")
}
return nil
} | go | func (la *LoginAttempt) Check() error {
if la.Time.IsZero() {
return trace.BadParameter("missing parameter time")
}
return nil
} | [
"func",
"(",
"la",
"*",
"LoginAttempt",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"la",
".",
"Time",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter time\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check checks parameters | [
"Check",
"checks",
"parameters"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L154-L159 | train |
gravitational/teleport | lib/services/user.go | WebSessionInfo | func (u *UserV2) WebSessionInfo(allowedLogins []string) interface{} {
out := u.V1()
out.AllowedLogins = allowedLogins
return *out
} | go | func (u *UserV2) WebSessionInfo(allowedLogins []string) interface{} {
out := u.V1()
out.AllowedLogins = allowedLogins
return *out
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"WebSessionInfo",
"(",
"allowedLogins",
"[",
"]",
"string",
")",
"interface",
"{",
"}",
"{",
"out",
":=",
"u",
".",
"V1",
"(",
")",
"\n",
"out",
".",
"AllowedLogins",
"=",
"allowedLogins",
"\n",
"return",
"*",
"out",
"\n",
"}"
] | // WebSessionInfo returns web session information about user | [
"WebSessionInfo",
"returns",
"web",
"session",
"information",
"about",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L217-L221 | train |
gravitational/teleport | lib/services/user.go | SetTraits | func (u *UserV2) SetTraits(traits map[string][]string) {
u.Spec.Traits = traits
} | go | func (u *UserV2) SetTraits(traits map[string][]string) {
u.Spec.Traits = traits
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"SetTraits",
"(",
"traits",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"{",
"u",
".",
"Spec",
".",
"Traits",
"=",
"traits",
"\n",
"}"
] | // SetTraits sets the trait map for this user used to populate role variables. | [
"SetTraits",
"sets",
"the",
"trait",
"map",
"for",
"this",
"user",
"used",
"to",
"populate",
"role",
"variables",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L229-L231 | train |
gravitational/teleport | lib/services/user.go | V1 | func (u *UserV2) V1() *UserV1 {
return &UserV1{
Name: u.Metadata.Name,
OIDCIdentities: u.Spec.OIDCIdentities,
Status: u.Spec.Status,
Expires: u.Spec.Expires,
CreatedBy: u.Spec.CreatedBy,
}
} | go | func (u *UserV2) V1() *UserV1 {
return &UserV1{
Name: u.Metadata.Name,
OIDCIdentities: u.Spec.OIDCIdentities,
Status: u.Spec.Status,
Expires: u.Spec.Expires,
CreatedBy: u.Spec.CreatedBy,
}
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"V1",
"(",
")",
"*",
"UserV1",
"{",
"return",
"&",
"UserV1",
"{",
"Name",
":",
"u",
".",
"Metadata",
".",
"Name",
",",
"OIDCIdentities",
":",
"u",
".",
"Spec",
".",
"OIDCIdentities",
",",
"Status",
":",
"u",
".",
"Spec",
".",
"Status",
",",
"Expires",
":",
"u",
".",
"Spec",
".",
"Expires",
",",
"CreatedBy",
":",
"u",
".",
"Spec",
".",
"CreatedBy",
",",
"}",
"\n",
"}"
] | // V1 converts UserV2 to UserV1 format | [
"V1",
"converts",
"UserV2",
"to",
"UserV1",
"format"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L249-L257 | train |
gravitational/teleport | lib/services/user.go | Equals | func (u *UserV2) Equals(other User) bool {
if u.Metadata.Name != other.GetName() {
return false
}
otherIdentities := other.GetOIDCIdentities()
if len(u.Spec.OIDCIdentities) != len(otherIdentities) {
return false
}
for i := range u.Spec.OIDCIdentities {
if !u.Spec.OIDCIdentities[i].Equals(&otherIdentities[i]) {
return false
}
}
otherSAMLIdentities := other.GetSAMLIdentities()
if len(u.Spec.SAMLIdentities) != len(otherSAMLIdentities) {
return false
}
for i := range u.Spec.SAMLIdentities {
if !u.Spec.SAMLIdentities[i].Equals(&otherSAMLIdentities[i]) {
return false
}
}
otherGithubIdentities := other.GetGithubIdentities()
if len(u.Spec.GithubIdentities) != len(otherGithubIdentities) {
return false
}
for i := range u.Spec.GithubIdentities {
if !u.Spec.GithubIdentities[i].Equals(&otherGithubIdentities[i]) {
return false
}
}
return true
} | go | func (u *UserV2) Equals(other User) bool {
if u.Metadata.Name != other.GetName() {
return false
}
otherIdentities := other.GetOIDCIdentities()
if len(u.Spec.OIDCIdentities) != len(otherIdentities) {
return false
}
for i := range u.Spec.OIDCIdentities {
if !u.Spec.OIDCIdentities[i].Equals(&otherIdentities[i]) {
return false
}
}
otherSAMLIdentities := other.GetSAMLIdentities()
if len(u.Spec.SAMLIdentities) != len(otherSAMLIdentities) {
return false
}
for i := range u.Spec.SAMLIdentities {
if !u.Spec.SAMLIdentities[i].Equals(&otherSAMLIdentities[i]) {
return false
}
}
otherGithubIdentities := other.GetGithubIdentities()
if len(u.Spec.GithubIdentities) != len(otherGithubIdentities) {
return false
}
for i := range u.Spec.GithubIdentities {
if !u.Spec.GithubIdentities[i].Equals(&otherGithubIdentities[i]) {
return false
}
}
return true
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"Equals",
"(",
"other",
"User",
")",
"bool",
"{",
"if",
"u",
".",
"Metadata",
".",
"Name",
"!=",
"other",
".",
"GetName",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"otherIdentities",
":=",
"other",
".",
"GetOIDCIdentities",
"(",
")",
"\n",
"if",
"len",
"(",
"u",
".",
"Spec",
".",
"OIDCIdentities",
")",
"!=",
"len",
"(",
"otherIdentities",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"u",
".",
"Spec",
".",
"OIDCIdentities",
"{",
"if",
"!",
"u",
".",
"Spec",
".",
"OIDCIdentities",
"[",
"i",
"]",
".",
"Equals",
"(",
"&",
"otherIdentities",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"otherSAMLIdentities",
":=",
"other",
".",
"GetSAMLIdentities",
"(",
")",
"\n",
"if",
"len",
"(",
"u",
".",
"Spec",
".",
"SAMLIdentities",
")",
"!=",
"len",
"(",
"otherSAMLIdentities",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"u",
".",
"Spec",
".",
"SAMLIdentities",
"{",
"if",
"!",
"u",
".",
"Spec",
".",
"SAMLIdentities",
"[",
"i",
"]",
".",
"Equals",
"(",
"&",
"otherSAMLIdentities",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"otherGithubIdentities",
":=",
"other",
".",
"GetGithubIdentities",
"(",
")",
"\n",
"if",
"len",
"(",
"u",
".",
"Spec",
".",
"GithubIdentities",
")",
"!=",
"len",
"(",
"otherGithubIdentities",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"u",
".",
"Spec",
".",
"GithubIdentities",
"{",
"if",
"!",
"u",
".",
"Spec",
".",
"GithubIdentities",
"[",
"i",
"]",
".",
"Equals",
"(",
"&",
"otherGithubIdentities",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Equals checks if user equals to another | [
"Equals",
"checks",
"if",
"user",
"equals",
"to",
"another"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L316-L348 | train |
gravitational/teleport | lib/services/user.go | Expiry | func (u *UserV2) Expiry() time.Time {
if u.Metadata.Expires != nil && !u.Metadata.Expires.IsZero() {
return *u.Metadata.Expires
}
return u.Spec.Expires
} | go | func (u *UserV2) Expiry() time.Time {
if u.Metadata.Expires != nil && !u.Metadata.Expires.IsZero() {
return *u.Metadata.Expires
}
return u.Spec.Expires
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"Expiry",
"(",
")",
"time",
".",
"Time",
"{",
"if",
"u",
".",
"Metadata",
".",
"Expires",
"!=",
"nil",
"&&",
"!",
"u",
".",
"Metadata",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"return",
"*",
"u",
".",
"Metadata",
".",
"Expires",
"\n",
"}",
"\n",
"return",
"u",
".",
"Spec",
".",
"Expires",
"\n",
"}"
] | // Expiry returns expiry time for temporary users. Prefer expires from
// metadata, if it does not exist, fall back to expires in spec. | [
"Expiry",
"returns",
"expiry",
"time",
"for",
"temporary",
"users",
".",
"Prefer",
"expires",
"from",
"metadata",
"if",
"it",
"does",
"not",
"exist",
"fall",
"back",
"to",
"expires",
"in",
"spec",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L352-L357 | train |
gravitational/teleport | lib/services/user.go | SetRoles | func (u *UserV2) SetRoles(roles []string) {
u.Spec.Roles = utils.Deduplicate(roles)
} | go | func (u *UserV2) SetRoles(roles []string) {
u.Spec.Roles = utils.Deduplicate(roles)
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"SetRoles",
"(",
"roles",
"[",
"]",
"string",
")",
"{",
"u",
".",
"Spec",
".",
"Roles",
"=",
"utils",
".",
"Deduplicate",
"(",
"roles",
")",
"\n",
"}"
] | // SetRoles sets a list of roles for user | [
"SetRoles",
"sets",
"a",
"list",
"of",
"roles",
"for",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L360-L362 | train |
gravitational/teleport | lib/services/user.go | AddRole | func (u *UserV2) AddRole(name string) {
for _, r := range u.Spec.Roles {
if r == name {
return
}
}
u.Spec.Roles = append(u.Spec.Roles, name)
} | go | func (u *UserV2) AddRole(name string) {
for _, r := range u.Spec.Roles {
if r == name {
return
}
}
u.Spec.Roles = append(u.Spec.Roles, name)
} | [
"func",
"(",
"u",
"*",
"UserV2",
")",
"AddRole",
"(",
"name",
"string",
")",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"u",
".",
"Spec",
".",
"Roles",
"{",
"if",
"r",
"==",
"name",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"u",
".",
"Spec",
".",
"Roles",
"=",
"append",
"(",
"u",
".",
"Spec",
".",
"Roles",
",",
"name",
")",
"\n",
"}"
] | // AddRole adds a role to user's role list | [
"AddRole",
"adds",
"a",
"role",
"to",
"user",
"s",
"role",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L390-L397 | train |
gravitational/teleport | lib/services/user.go | V2 | func (u *UserV1) V2() *UserV2 {
return &UserV2{
Kind: KindUser,
Version: V2,
Metadata: Metadata{
Name: u.Name,
Namespace: defaults.Namespace,
},
Spec: UserSpecV2{
OIDCIdentities: u.OIDCIdentities,
Status: u.Status,
Expires: u.Expires,
CreatedBy: u.CreatedBy,
Roles: u.Roles,
Traits: map[string][]string{
teleport.TraitLogins: u.AllowedLogins,
teleport.TraitKubeGroups: u.KubeGroups,
},
},
}
} | go | func (u *UserV1) V2() *UserV2 {
return &UserV2{
Kind: KindUser,
Version: V2,
Metadata: Metadata{
Name: u.Name,
Namespace: defaults.Namespace,
},
Spec: UserSpecV2{
OIDCIdentities: u.OIDCIdentities,
Status: u.Status,
Expires: u.Expires,
CreatedBy: u.CreatedBy,
Roles: u.Roles,
Traits: map[string][]string{
teleport.TraitLogins: u.AllowedLogins,
teleport.TraitKubeGroups: u.KubeGroups,
},
},
}
} | [
"func",
"(",
"u",
"*",
"UserV1",
")",
"V2",
"(",
")",
"*",
"UserV2",
"{",
"return",
"&",
"UserV2",
"{",
"Kind",
":",
"KindUser",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"u",
".",
"Name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"UserSpecV2",
"{",
"OIDCIdentities",
":",
"u",
".",
"OIDCIdentities",
",",
"Status",
":",
"u",
".",
"Status",
",",
"Expires",
":",
"u",
".",
"Expires",
",",
"CreatedBy",
":",
"u",
".",
"CreatedBy",
",",
"Roles",
":",
"u",
".",
"Roles",
",",
"Traits",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"teleport",
".",
"TraitLogins",
":",
"u",
".",
"AllowedLogins",
",",
"teleport",
".",
"TraitKubeGroups",
":",
"u",
".",
"KubeGroups",
",",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | //V2 converts UserV1 to UserV2 format | [
"V2",
"converts",
"UserV1",
"to",
"UserV2",
"format"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L483-L503 | train |
gravitational/teleport | lib/services/user.go | GetUserSchema | func GetUserSchema(extensionSchema string) string {
var userSchema string
if extensionSchema == "" {
userSchema = fmt.Sprintf(UserSpecV2SchemaTemplate, ExternalIdentitySchema, ExternalIdentitySchema, ExternalIdentitySchema, LoginStatusSchema, CreatedBySchema, ``)
} else {
userSchema = fmt.Sprintf(UserSpecV2SchemaTemplate, ExternalIdentitySchema, ExternalIdentitySchema, ExternalIdentitySchema, LoginStatusSchema, CreatedBySchema, ", "+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, userSchema, DefaultDefinitions)
} | go | func GetUserSchema(extensionSchema string) string {
var userSchema string
if extensionSchema == "" {
userSchema = fmt.Sprintf(UserSpecV2SchemaTemplate, ExternalIdentitySchema, ExternalIdentitySchema, ExternalIdentitySchema, LoginStatusSchema, CreatedBySchema, ``)
} else {
userSchema = fmt.Sprintf(UserSpecV2SchemaTemplate, ExternalIdentitySchema, ExternalIdentitySchema, ExternalIdentitySchema, LoginStatusSchema, CreatedBySchema, ", "+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, userSchema, DefaultDefinitions)
} | [
"func",
"GetUserSchema",
"(",
"extensionSchema",
"string",
")",
"string",
"{",
"var",
"userSchema",
"string",
"\n",
"if",
"extensionSchema",
"==",
"\"\"",
"{",
"userSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"UserSpecV2SchemaTemplate",
",",
"ExternalIdentitySchema",
",",
"ExternalIdentitySchema",
",",
"ExternalIdentitySchema",
",",
"LoginStatusSchema",
",",
"CreatedBySchema",
",",
"``",
")",
"\n",
"}",
"else",
"{",
"userSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"UserSpecV2SchemaTemplate",
",",
"ExternalIdentitySchema",
",",
"ExternalIdentitySchema",
",",
"ExternalIdentitySchema",
",",
"LoginStatusSchema",
",",
"CreatedBySchema",
",",
"\", \"",
"+",
"extensionSchema",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"userSchema",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] | // GetRoleSchema returns role schema with optionally injected
// schema for extensions | [
"GetRoleSchema",
"returns",
"role",
"schema",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L536-L544 | train |
gravitational/teleport | lib/services/user.go | UnmarshalUser | func (*TeleportUserMarshaler) UnmarshalUser(bytes []byte, opts ...MarshalOption) (User, error) {
var h ResourceHeader
err := json.Unmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var u UserV1
err := json.Unmarshal(bytes, &u)
if err != nil {
return nil, trace.Wrap(err)
}
return u.V2(), nil
case V2:
var u UserV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &u); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetUserSchema(""), &u, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
u.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
u.SetExpiry(cfg.Expires)
}
return &u, nil
}
return nil, trace.BadParameter("user resource version %v is not supported", h.Version)
} | go | func (*TeleportUserMarshaler) UnmarshalUser(bytes []byte, opts ...MarshalOption) (User, error) {
var h ResourceHeader
err := json.Unmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var u UserV1
err := json.Unmarshal(bytes, &u)
if err != nil {
return nil, trace.Wrap(err)
}
return u.V2(), nil
case V2:
var u UserV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &u); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetUserSchema(""), &u, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
u.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
u.SetExpiry(cfg.Expires)
}
return &u, nil
}
return nil, trace.BadParameter("user resource version %v is not supported", h.Version)
} | [
"func",
"(",
"*",
"TeleportUserMarshaler",
")",
"UnmarshalUser",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"User",
",",
"error",
")",
"{",
"var",
"h",
"ResourceHeader",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"u",
"UserV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"u",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"u",
"UserV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"u",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetUserSchema",
"(",
"\"\"",
")",
",",
"&",
"u",
",",
"bytes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"u",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"u",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"u",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"u",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"user resource version %v is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalUser unmarshals user from JSON | [
"UnmarshalUser",
"unmarshals",
"user",
"from",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L549-L595 | train |
gravitational/teleport | lib/services/user.go | MarshalUser | func (*TeleportUserMarshaler) MarshalUser(u User, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type userv1 interface {
V1() *UserV1
}
type userv2 interface {
V2() *UserV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := u.(userv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := u.(userv2)
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 (*TeleportUserMarshaler) MarshalUser(u User, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type userv1 interface {
V1() *UserV1
}
type userv2 interface {
V2() *UserV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := u.(userv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := u.(userv2)
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",
"(",
"*",
"TeleportUserMarshaler",
")",
"MarshalUser",
"(",
"u",
"User",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"userv1",
"interface",
"{",
"V1",
"(",
")",
"*",
"UserV1",
"\n",
"}",
"\n",
"type",
"userv2",
"interface",
"{",
"V2",
"(",
")",
"*",
"UserV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"u",
".",
"(",
"userv1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"u",
".",
"(",
"userv2",
")",
"\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",
"}"
] | // MarshalUser marshalls user into JSON | [
"MarshalUser",
"marshalls",
"user",
"into",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/user.go#L603-L640 | train |
gravitational/teleport | lib/backend/wrap.go | GetReadError | func (s *Wrapper) GetReadError() error {
s.RLock()
defer s.RUnlock()
return s.readErr
} | go | func (s *Wrapper) GetReadError() error {
s.RLock()
defer s.RUnlock()
return s.readErr
} | [
"func",
"(",
"s",
"*",
"Wrapper",
")",
"GetReadError",
"(",
")",
"error",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"s",
".",
"readErr",
"\n",
"}"
] | // GetReadError returns error to be returned by
// read backend operations | [
"GetReadError",
"returns",
"error",
"to",
"be",
"returned",
"by",
"read",
"backend",
"operations"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/wrap.go#L47-L51 | train |
gravitational/teleport | lib/backend/wrap.go | SetReadError | func (s *Wrapper) SetReadError(err error) {
s.Lock()
defer s.Unlock()
s.readErr = err
} | go | func (s *Wrapper) SetReadError(err error) {
s.Lock()
defer s.Unlock()
s.readErr = err
} | [
"func",
"(",
"s",
"*",
"Wrapper",
")",
"SetReadError",
"(",
"err",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"readErr",
"=",
"err",
"\n",
"}"
] | // SetReadError sets error to be returned by read backend operations | [
"SetReadError",
"sets",
"error",
"to",
"be",
"returned",
"by",
"read",
"backend",
"operations"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/wrap.go#L54-L58 | train |
gravitational/teleport | lib/services/local/users.go | DeleteAllUsers | func (s *IdentityService) DeleteAllUsers() error {
startKey := backend.Key(webPrefix, usersPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | func (s *IdentityService) DeleteAllUsers() error {
startKey := backend.Key(webPrefix, usersPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteAllUsers",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
")",
"\n",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"}"
] | // DeleteAllUsers deletes all users | [
"DeleteAllUsers",
"deletes",
"all",
"users"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L54-L57 | train |
gravitational/teleport | lib/services/local/users.go | GetUsers | func (s *IdentityService) GetUsers() ([]services.User, error) {
startKey := backend.Key(webPrefix, usersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
var out []services.User
for _, item := range result.Items {
if !bytes.HasSuffix(item.Key, []byte(paramsPrefix)) {
continue
}
u, err := services.GetUserMarshaler().UnmarshalUser(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, u)
}
return out, nil
} | go | func (s *IdentityService) GetUsers() ([]services.User, error) {
startKey := backend.Key(webPrefix, usersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
var out []services.User
for _, item := range result.Items {
if !bytes.HasSuffix(item.Key, []byte(paramsPrefix)) {
continue
}
u, err := services.GetUserMarshaler().UnmarshalUser(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, u)
}
return out, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetUsers",
"(",
")",
"(",
"[",
"]",
"services",
".",
"User",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"out",
"[",
"]",
"services",
".",
"User",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"if",
"!",
"bytes",
".",
"HasSuffix",
"(",
"item",
".",
"Key",
",",
"[",
"]",
"byte",
"(",
"paramsPrefix",
")",
")",
"{",
"continue",
"\n",
"}",
"\n",
"u",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"UnmarshalUser",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"u",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // GetUsers returns a list of users registered with the local auth server | [
"GetUsers",
"returns",
"a",
"list",
"of",
"users",
"registered",
"with",
"the",
"local",
"auth",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L60-L79 | train |
gravitational/teleport | lib/services/local/users.go | CreateUser | func (s *IdentityService) CreateUser(user services.User) error {
if err := user.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetUserMarshaler().MarshalUser(user)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user.GetName(), paramsPrefix),
Value: value,
Expires: user.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateUser(user services.User) error {
if err := user.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetUserMarshaler().MarshalUser(user)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user.GetName(), paramsPrefix),
Value: value,
Expires: user.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateUser",
"(",
"user",
"services",
".",
"User",
")",
"error",
"{",
"if",
"err",
":=",
"user",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"MarshalUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
".",
"GetName",
"(",
")",
",",
"paramsPrefix",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"user",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateUser creates user if it does not exist | [
"CreateUser",
"creates",
"user",
"if",
"it",
"does",
"not",
"exist"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L82-L100 | train |
gravitational/teleport | lib/services/local/users.go | GetUser | func (s *IdentityService) GetUser(user string) (services.User, error) {
if user == "" {
return nil, trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, paramsPrefix))
if err != nil {
return nil, trace.NotFound("user %q is not found", user)
}
u, err := services.GetUserMarshaler().UnmarshalUser(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | go | func (s *IdentityService) GetUser(user string) (services.User, error) {
if user == "" {
return nil, trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, paramsPrefix))
if err != nil {
return nil, trace.NotFound("user %q is not found", user)
}
u, err := services.GetUserMarshaler().UnmarshalUser(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetUser",
"(",
"user",
"string",
")",
"(",
"services",
".",
"User",
",",
"error",
")",
"{",
"if",
"user",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing user name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"user %q is not found\"",
",",
"user",
")",
"\n",
"}",
"\n",
"u",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"UnmarshalUser",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"u",
",",
"nil",
"\n",
"}"
] | // GetUser returns a user by name | [
"GetUser",
"returns",
"a",
"user",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L125-L139 | train |
gravitational/teleport | lib/services/local/users.go | GetUserByOIDCIdentity | func (s *IdentityService) GetUserByOIDCIdentity(id services.ExternalIdentity) (services.User, error) {
users, err := s.GetUsers()
if err != nil {
return nil, trace.Wrap(err)
}
for _, u := range users {
for _, uid := range u.GetOIDCIdentities() {
if uid.Equals(&id) {
return u, nil
}
}
}
return nil, trace.NotFound("user with identity %q not found", &id)
} | go | func (s *IdentityService) GetUserByOIDCIdentity(id services.ExternalIdentity) (services.User, error) {
users, err := s.GetUsers()
if err != nil {
return nil, trace.Wrap(err)
}
for _, u := range users {
for _, uid := range u.GetOIDCIdentities() {
if uid.Equals(&id) {
return u, nil
}
}
}
return nil, trace.NotFound("user with identity %q not found", &id)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetUserByOIDCIdentity",
"(",
"id",
"services",
".",
"ExternalIdentity",
")",
"(",
"services",
".",
"User",
",",
"error",
")",
"{",
"users",
",",
"err",
":=",
"s",
".",
"GetUsers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"u",
":=",
"range",
"users",
"{",
"for",
"_",
",",
"uid",
":=",
"range",
"u",
".",
"GetOIDCIdentities",
"(",
")",
"{",
"if",
"uid",
".",
"Equals",
"(",
"&",
"id",
")",
"{",
"return",
"u",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"user with identity %q not found\"",
",",
"&",
"id",
")",
"\n",
"}"
] | // GetUserByOIDCIdentity returns a user by it's specified OIDC Identity, returns first
// user specified with this identity | [
"GetUserByOIDCIdentity",
"returns",
"a",
"user",
"by",
"it",
"s",
"specified",
"OIDC",
"Identity",
"returns",
"first",
"user",
"specified",
"with",
"this",
"identity"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L143-L156 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.