repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/auth/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",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"id",
")",
",",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"[",
"]",
"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",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"q",
".",
"Set",
"(",
"\"",
"\"",
",",
"from",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"q",
".",
"Set",
"(",
"\"",
"\"",
",",
"to",
".",
"Format",
"(",
"time",
".",
"RFC3339",
")",
")",
"\n",
"q",
".",
"Set",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"limit",
")",
")",
"\n",
"response",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"",
"\"",
")",
",",
"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",
"(",
"\"",
"\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"cc",
",",
"err",
":=",
"services",
".",
"GetClusterConfigMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"",
"\"",
")",
",",
"&",
"setClusterConfigReq",
"{",
"ClusterConfig",
":",
"data",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"cn",
",",
"err",
":=",
"services",
".",
"GetClusterNameMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"&",
"setClusterNameReq",
"{",
"ClusterName",
":",
"data",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"st",
",",
"err",
":=",
"services",
".",
"GetStaticTokensMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"&",
"setStaticTokensReq",
"{",
"StaticTokens",
":",
"data",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\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\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// emit an event to the audit log with the reason remote execution failed",
"r",
".",
"emitAuditEvent",
"(",
"err",
")",
"\n\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// copy back and forth between stdin, stdout, and stderr and the SSH channel.",
"go",
"func",
"(",
")",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"channel",
",",
"stdout",
")",
"\n",
"r",
".",
"errorCh",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"channel",
".",
"Stderr",
"(",
")",
",",
"stderr",
")",
"\n",
"r",
".",
"errorCh",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"stdin",
",",
"channel",
")",
"\n",
"r",
".",
"errorCh",
"<-",
"err",
"\n",
"}",
"(",
")",
"\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\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"3",
";",
"i",
"++",
"{",
"select",
"{",
"case",
"err",
":=",
"<-",
"r",
".",
"errorCh",
":",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"r",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"trace",
".",
"DebugReport",
"(",
"err",
")",
",",
"err",
")",
"\n",
"lastErr",
"=",
"err",
"\n",
"}",
"\n",
"case",
"<-",
"r",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"lastErr",
"=",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// emit an event to the audit log with the result of execution",
"r",
".",
"emitAuditEvent",
"(",
"lastErr",
")",
"\n\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",
"\"",
"\"",
"\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\n",
"if",
"err",
":=",
"ws",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"ws",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"ws",
".",
"(",
"ws2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"// avoid modifying the original object",
"// to prevent unexpected data races",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"Metadata",
".",
"ID",
"=",
"0",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"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\n",
"// Emit session join event to Audit Log.",
"ctx",
".",
"session",
".",
"recorder",
".",
"GetAuditLog",
"(",
")",
".",
"EmitAuditEvent",
"(",
"events",
".",
"SessionJoin",
",",
"sessionJoinEvent",
")",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"ctx",
".",
"session",
".",
"id",
")",
"\n\n",
"// Update the in-memory data structure that a party member has joined.",
"_",
",",
"err",
":=",
"ctx",
".",
"session",
".",
"join",
"(",
"ch",
",",
"req",
",",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"// session not found? need to create one. start by getting/generating an ID for it",
"sid",
",",
"found",
":=",
"ctx",
".",
"GetEnv",
"(",
"sshutils",
".",
"SessionEnvVar",
")",
"\n",
"if",
"!",
"found",
"{",
"sid",
"=",
"string",
"(",
"rsession",
".",
"NewID",
"(",
")",
")",
"\n",
"ctx",
".",
"SetEnv",
"(",
"sshutils",
".",
"SessionEnvVar",
",",
"sid",
")",
"\n",
"}",
"\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
".",
"session",
"=",
"sess",
"\n",
"s",
".",
"addSession",
"(",
"sess",
")",
"\n",
"ctx",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sid",
")",
"\n\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\n",
"// Emit session leave event to Audit Log.",
"party",
".",
"s",
".",
"recorder",
".",
"GetAuditLog",
"(",
")",
".",
"EmitAuditEvent",
"(",
"events",
".",
"SessionLeave",
",",
"sessionLeaveEvent",
")",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"events",
".",
"SessionJoinEvent",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"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\n",
"// 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",
")",
"\n\n",
"// Remove member from in-members representation of party.",
"if",
"err",
":=",
"sess",
".",
"removeParty",
"(",
"party",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
"\n",
"if",
"lingerTTL",
">",
"0",
"{",
"time",
".",
"Sleep",
"(",
"lingerTTL",
")",
"\n",
"}",
"\n",
"// not lingering anymore? someone reconnected? cool then... no need",
"// to die...",
"if",
"!",
"sess",
".",
"isLingering",
"(",
")",
"{",
"s",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sess",
".",
"id",
")",
"\n",
"return",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"sess",
".",
"id",
")",
"\n\n",
"// no more people left? Need to end the session!",
"s",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"s",
".",
"sessions",
",",
"sess",
".",
"id",
")",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"// 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",
"(",
")",
",",
"}",
")",
"\n\n",
"// close recorder to free up associated resources",
"// and flush data",
"sess",
".",
"recorder",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"sess",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"sess",
".",
"id",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// mark it as inactive in the DB",
"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",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"sid",
":=",
"ctx",
".",
"session",
".",
"id",
"\n\n",
"// 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",
"(",
")",
",",
"}",
"\n\n",
"// 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",
")",
"\n\n",
"// Update the size of the server side PTY.",
"err",
":=",
"ctx",
".",
"session",
".",
"term",
".",
"SetWinSize",
"(",
"params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"}",
"\n\n",
"eventPayload",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"resizeEvent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// Send the message as a global request.",
"_",
",",
"_",
",",
"err",
"=",
"p",
".",
"sconn",
".",
"SendRequest",
"(",
"teleport",
".",
"SessionEvent",
",",
"false",
",",
"eventPayload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"params",
",",
"p",
".",
"sconn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\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\n",
"// 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",
"(",
")",
"\n\n",
"err",
":=",
"sessionServer",
".",
"CreateSession",
"(",
"rsess",
")",
"\n",
"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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"existing",
".",
"Login",
"!=",
"rsess",
".",
"Login",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
",",
"rsess",
".",
"Login",
",",
"existing",
".",
"Login",
",",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// return nil, trace.Wrap(err)",
"// No need to abort. Perhaps the auth server is down?",
"// Log the error and continue:",
"r",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\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\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",
"(",
")",
"{",
"// 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",
"(",
"\"",
"\"",
",",
"s",
".",
"id",
")",
"\n",
"if",
"s",
".",
"term",
"!=",
"nil",
"{",
"s",
".",
"term",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"close",
"(",
"s",
".",
"closeC",
")",
"\n\n",
"// close all writers in our multi-writer",
"s",
".",
"writer",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"writer",
".",
"Unlock",
"(",
")",
"\n",
"for",
"writerName",
",",
"writer",
":=",
"range",
"s",
".",
"writer",
".",
"writers",
"{",
"s",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"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\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",
"(",
"\"",
"\"",
",",
"p",
",",
"s",
".",
"id",
")",
"\n\n",
"// Removes participant from in-memory map of party members.",
"s",
".",
"removePartyMember",
"(",
"p",
")",
"\n\n",
"s",
".",
"writer",
".",
"deleteWriter",
"(",
"string",
"(",
"p",
".",
"id",
")",
")",
"\n\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\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\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 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",
"\n",
"}",
"\n\n",
"// 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",
"(",
")",
"\n",
"if",
"sessionServer",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"tickerCh",
":=",
"time",
".",
"NewTicker",
"(",
"defaults",
".",
"SessionRefreshPeriod",
")",
"\n",
"defer",
"tickerCh",
".",
"Stop",
"(",
")",
"\n\n",
"// Loop as long as the session is active, updating the session in the backend.",
"for",
"{",
"select",
"{",
"case",
"<-",
"tickerCh",
".",
"C",
":",
"partyList",
":=",
"s",
".",
"exportPartyMembers",
"(",
")",
"\n\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",
"(",
"\"",
"\"",
",",
"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\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",
"(",
"\"",
"\"",
",",
"s",
".",
"login",
",",
"p",
".",
"login",
",",
"s",
".",
"id",
")",
"\n",
"}",
"\n\n",
"// Adds participant to in-memory map of party members.",
"s",
".",
"addPartyMember",
"(",
"p",
")",
"\n\n",
"// Write last chunk (so the newly joined parties won't stare at a blank",
"// screen).",
"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\n",
"// Register this party as one of the session writers (output will go to it).",
"s",
".",
"writer",
".",
"addWriter",
"(",
"string",
"(",
"p",
".",
"id",
")",
",",
"p",
",",
"true",
")",
"\n",
"p",
".",
"ctx",
".",
"AddCloser",
"(",
"p",
")",
"\n",
"s",
".",
"term",
".",
"AddParty",
"(",
"1",
")",
"\n\n",
"s",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"p",
".",
"String",
"(",
")",
",",
"s",
".",
"id",
")",
"\n\n",
"// This goroutine keeps pumping party's input into the session.",
"go",
"func",
"(",
")",
"{",
"defer",
"s",
".",
"term",
".",
"AddParty",
"(",
"-",
"1",
")",
"\n",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"s",
".",
"term",
".",
"PTY",
"(",
")",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"id",
",",
"s",
".",
"id",
",",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"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",
")",
"{",
"// lock and make a local copy of available writers:",
"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\n",
"// add the recent write chunk to the \"instant replay\" buffer",
"// of the session, to be replayed to newly joining parties:",
"m",
".",
"lockedAddRecentWrite",
"(",
"p",
")",
"\n",
"return",
"writers",
"\n",
"}",
"\n\n",
"// unlock and multiplex the write to all writers:",
"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",
"(",
"\"",
"\"",
",",
"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\n",
"exitContext",
",",
"signalExit",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"reloadContext",
",",
"signalReload",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n\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",
"{",
"\"",
"\"",
":",
"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",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"l",
".",
"Warningf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"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\n",
"switch",
"event",
".",
"Name",
"{",
"case",
"TeleportExitEvent",
":",
"s",
".",
"signalExit",
"(",
")",
"\n",
"case",
"TeleportReloadEvent",
":",
"s",
".",
"signalReload",
"(",
")",
"\n",
"}",
"\n\n",
"s",
".",
"events",
"[",
"event",
".",
"Name",
"]",
"=",
"event",
"\n\n",
"// Log all events other than recovered events to prevent the logs from",
"// being flooded.",
"if",
"event",
".",
"String",
"(",
")",
"!=",
"TeleportOKEvent",
"{",
"log",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"event",
".",
"String",
"(",
")",
",",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentProcess",
",",
"s",
".",
"id",
")",
"}",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"go",
"func",
"(",
")",
"{",
"select",
"{",
"case",
"s",
".",
"eventsC",
"<-",
"event",
":",
"case",
"<-",
"s",
".",
"closeContext",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\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",
"{",
"\"",
"\"",
":",
"event",
".",
"String",
"(",
")",
",",
"\"",
"\"",
":",
"m",
".",
"String",
"(",
")",
",",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentProcess",
",",
"s",
".",
"id",
")",
"}",
")",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\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\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\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\n",
"if",
"cf",
".",
"IdentityFileIn",
"!=",
"\"",
"\"",
"{",
"utils",
".",
"FatalError",
"(",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"if",
"cf",
".",
"IdentityFormat",
"!=",
"client",
".",
"IdentityFormatOpenSSH",
"&&",
"cf",
".",
"IdentityFormat",
"!=",
"client",
".",
"IdentityFormatFile",
"{",
"utils",
".",
"FatalError",
"(",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"cf",
".",
"IdentityFormat",
")",
")",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// make the teleport client and retrieve the certificate from the proxy:",
"tc",
",",
"err",
"=",
"makeClient",
"(",
"cf",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
")",
"\n",
"return",
"\n",
"// in case if parameters match, print current status",
"case",
"host",
"(",
"cf",
".",
"Proxy",
")",
"==",
"host",
"(",
"profile",
".",
"ProxyURL",
".",
"Host",
")",
"&&",
"cf",
".",
"SiteName",
"==",
"profile",
".",
"Cluster",
":",
"printProfiles",
"(",
"profile",
",",
"profiles",
")",
"\n",
"return",
"\n",
"// 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",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
":=",
"kubeclient",
".",
"UpdateKubeconfig",
"(",
"tc",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"onStatus",
"(",
"cf",
")",
"\n",
"return",
"\n",
"// otherwise just passthrough to standard login",
"default",
":",
"}",
"\n",
"}",
"\n\n",
"if",
"cf",
".",
"Username",
"==",
"\"",
"\"",
"{",
"cf",
".",
"Username",
"=",
"tc",
".",
"Username",
"\n",
"}",
"\n\n",
"// -i flag specified? save the retreived cert into an identity file",
"makeIdentityFile",
":=",
"(",
"cf",
".",
"IdentityFileOut",
"!=",
"\"",
"\"",
")",
"\n",
"activateKey",
":=",
"!",
"makeIdentityFile",
"\n\n",
"key",
",",
"err",
"=",
"tc",
".",
"Login",
"(",
"cf",
".",
"Context",
",",
"activateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"cf",
".",
"IdentityFileOut",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// If the proxy is advertising that it supports Kubernetes, update kubeconfig.",
"if",
"tc",
".",
"KubeProxyAddr",
"!=",
"\"",
"\"",
"{",
"if",
"err",
":=",
"kubeclient",
".",
"UpdateKubeconfig",
"(",
"tc",
")",
";",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Regular login without -i flag.",
"tc",
".",
"SaveProfile",
"(",
"key",
".",
"ProxyHost",
",",
"\"",
"\"",
")",
"\n\n",
"// 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",
"(",
")",
"\n",
"cf",
".",
"Proxy",
"=",
"webProxyHost",
"\n",
"onStatus",
"(",
"cf",
")",
"\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\n",
"// 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",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"certPrincipals",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tc",
".",
"HostLogin",
"=",
"certPrincipals",
"[",
"0",
"]",
"\n\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\n",
"// Get list of all nodes in backend and sort by \"Node Name\".",
"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\n",
"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",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"nodes",
"{",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"n",
".",
"GetHostname",
"(",
")",
",",
"n",
".",
"GetName",
"(",
")",
",",
"n",
".",
"GetAddr",
"(",
")",
",",
"n",
".",
"LabelsString",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"t",
".",
"AsBuffer",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"// In normal mode chunk the labels and print two per line and allow multiple",
"// lines per node.",
"case",
"false",
":",
"t",
":=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\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",
"{",
"// First sort labels so they always occur in the same order.",
"sorted",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"labels",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"labels",
"{",
"sorted",
"=",
"append",
"(",
"sorted",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Slice",
"(",
"sorted",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"sorted",
"[",
"i",
"]",
"<",
"sorted",
"[",
"j",
"]",
"}",
")",
"\n\n",
"// Then chunk labels into sized chunks.",
"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\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\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",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\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\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",
"{",
"// exit with the same exit status as the failed command:",
"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",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"result",
".",
"RequestsOriginated",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"result",
".",
"RequestsFailed",
")",
"\n",
"if",
"result",
".",
"LastError",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"result",
".",
"LastError",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
")",
"\n",
"t",
":=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\n",
"for",
"_",
",",
"quantile",
":=",
"range",
"[",
"]",
"float64",
"{",
"25",
",",
"50",
",",
"75",
",",
"90",
",",
"95",
",",
"99",
",",
"100",
"}",
"{",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"quantile",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"result",
".",
"Histogram",
".",
"ValueAtQuantile",
"(",
"quantile",
")",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"io",
".",
"Copy",
"(",
"os",
".",
"Stdout",
",",
"t",
".",
"AsBuffer",
"(",
")",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\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",
"(",
"\"",
"\"",
",",
"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",
"{",
"// exit with the same exit status as the failed command:",
"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",
":=",
"\"",
"\"",
"\n",
"if",
"duration",
".",
"Nanoseconds",
"(",
")",
">",
"0",
"{",
"humanDuration",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"duration",
".",
"Round",
"(",
"time",
".",
"Minute",
")",
")",
"\n",
"}",
"\n\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"prefix",
",",
"p",
".",
"ProxyURL",
".",
"String",
"(",
")",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"p",
".",
"Username",
")",
"\n",
"if",
"p",
".",
"Cluster",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"p",
".",
"Cluster",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"strings",
".",
"Join",
"(",
"p",
".",
"Roles",
",",
"\"",
"\"",
")",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"strings",
".",
"Join",
"(",
"p",
".",
"Logins",
",",
"\"",
"\"",
")",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"p",
".",
"ValidUntil",
",",
"humanDuration",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"strings",
".",
"Join",
"(",
"p",
".",
"Extensions",
",",
"\"",
"\"",
")",
")",
"\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",
")",
"{",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"printProfiles",
"(",
"profile",
",",
"profiles",
")",
"\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",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"c",
".",
"Connector",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"Connector",
".",
"Type",
",",
"c",
".",
"Connector",
".",
"ID",
",",
"c",
".",
"Connector",
".",
"Identity",
",",
"utils",
".",
"HumanTimeFormat",
"(",
"c",
".",
"Time",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
")",
"\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\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\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\n",
"return",
"&",
"u",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"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\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",
"(",
"\"",
"\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"u",
".",
"(",
"userv2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"// avoid modifying the original object",
"// to prevent unexpected data races",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] | // MarshalUser 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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"&",
"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 |
gravitational/teleport | lib/services/local/users.go | DeleteUser | func (s *IdentityService) DeleteUser(user string) error {
_, err := s.GetUser(user)
if err != nil {
return trace.Wrap(err)
}
startKey := backend.Key(webPrefix, usersPrefix, user)
err = s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteUser(user string) error {
_, err := s.GetUser(user)
if err != nil {
return trace.Wrap(err)
}
startKey := backend.Key(webPrefix, usersPrefix, user)
err = s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteUser",
"(",
"user",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"s",
".",
"GetUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
")",
"\n",
"err",
"=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteUser deletes a user with all the keys from the backend | [
"DeleteUser",
"deletes",
"a",
"user",
"with",
"all",
"the",
"keys",
"from",
"the",
"backend"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L192-L200 | train |
gravitational/teleport | lib/services/local/users.go | UpsertPasswordHash | func (s *IdentityService) UpsertPasswordHash(username string, hash []byte) error {
userPrototype, err := services.NewUser(username)
if err != nil {
return trace.Wrap(err)
}
user, err := services.GetUserMarshaler().GenerateUser(userPrototype)
if err != nil {
return trace.Wrap(err)
}
err = s.CreateUser(user)
if err != nil {
if !trace.IsAlreadyExists(err) {
return trace.Wrap(err)
}
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, username, pwdPrefix),
Value: hash,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertPasswordHash(username string, hash []byte) error {
userPrototype, err := services.NewUser(username)
if err != nil {
return trace.Wrap(err)
}
user, err := services.GetUserMarshaler().GenerateUser(userPrototype)
if err != nil {
return trace.Wrap(err)
}
err = s.CreateUser(user)
if err != nil {
if !trace.IsAlreadyExists(err) {
return trace.Wrap(err)
}
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, username, pwdPrefix),
Value: hash,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertPasswordHash",
"(",
"username",
"string",
",",
"hash",
"[",
"]",
"byte",
")",
"error",
"{",
"userPrototype",
",",
"err",
":=",
"services",
".",
"NewUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"GenerateUser",
"(",
"userPrototype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"CreateUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"username",
",",
"pwdPrefix",
")",
",",
"Value",
":",
"hash",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertPasswordHash upserts user password hash | [
"UpsertPasswordHash",
"upserts",
"user",
"password",
"hash"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L203-L227 | train |
gravitational/teleport | lib/services/local/users.go | UpsertTOTP | func (s *IdentityService) UpsertTOTP(user string, secretKey string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, totpPrefix),
Value: []byte(secretKey),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertTOTP(user string, secretKey string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, totpPrefix),
Value: []byte(secretKey),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertTOTP",
"(",
"user",
"string",
",",
"secretKey",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"totpPrefix",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"secretKey",
")",
",",
"}",
"\n\n",
"_",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UpsertTOTP upserts TOTP secret key for a user that can be used to generate and validate tokens. | [
"UpsertTOTP",
"upserts",
"TOTP",
"secret",
"key",
"for",
"a",
"user",
"that",
"can",
"be",
"used",
"to",
"generate",
"and",
"validate",
"tokens",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L292-L308 | train |
gravitational/teleport | lib/services/local/users.go | GetTOTP | func (s *IdentityService) GetTOTP(user string) (string, error) {
if user == "" {
return "", trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, totpPrefix))
if err != nil {
if trace.IsNotFound(err) {
return "", trace.NotFound("user %q is not found", user)
}
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | go | func (s *IdentityService) GetTOTP(user string) (string, error) {
if user == "" {
return "", trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, totpPrefix))
if err != nil {
if trace.IsNotFound(err) {
return "", trace.NotFound("user %q is not found", user)
}
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetTOTP",
"(",
"user",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"totpPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"user",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"item",
".",
"Value",
")",
",",
"nil",
"\n",
"}"
] | // GetTOTP returns the secret key used by the TOTP algorithm to validate tokens | [
"GetTOTP",
"returns",
"the",
"secret",
"key",
"used",
"by",
"the",
"TOTP",
"algorithm",
"to",
"validate",
"tokens"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L311-L325 | train |
gravitational/teleport | lib/services/local/users.go | UpsertUsedTOTPToken | func (s *IdentityService) UpsertUsedTOTPToken(user string, otpToken string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix),
Value: []byte(otpToken),
Expires: s.Clock().Now().UTC().Add(usedTOTPTTL),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertUsedTOTPToken(user string, otpToken string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix),
Value: []byte(otpToken),
Expires: s.Clock().Now().UTC().Add(usedTOTPTTL),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertUsedTOTPToken",
"(",
"user",
"string",
",",
"otpToken",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"usedTOTPPrefix",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"otpToken",
")",
",",
"Expires",
":",
"s",
".",
"Clock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"usedTOTPTTL",
")",
",",
"}",
"\n",
"_",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertUsedTOTPToken upserts a TOTP token to the backend so it can't be used again
// during the 30 second window it's valid. | [
"UpsertUsedTOTPToken",
"upserts",
"a",
"TOTP",
"token",
"to",
"the",
"backend",
"so",
"it",
"can",
"t",
"be",
"used",
"again",
"during",
"the",
"30",
"second",
"window",
"it",
"s",
"valid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L329-L343 | train |
gravitational/teleport | lib/services/local/users.go | DeleteUsedTOTPToken | func (s *IdentityService) DeleteUsedTOTPToken(user string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
return s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix))
} | go | func (s *IdentityService) DeleteUsedTOTPToken(user string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
return s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix))
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteUsedTOTPToken",
"(",
"user",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"usedTOTPPrefix",
")",
")",
"\n",
"}"
] | // DeleteUsedTOTPToken removes the used token from the backend. This should only
// be used during tests. | [
"DeleteUsedTOTPToken",
"removes",
"the",
"used",
"token",
"from",
"the",
"backend",
".",
"This",
"should",
"only",
"be",
"used",
"during",
"tests",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L363-L368 | train |
gravitational/teleport | lib/services/local/users.go | UpsertWebSession | func (s *IdentityService) UpsertWebSession(user, sid string, session services.WebSession) error {
session.SetUser(user)
session.SetName(sid)
value, err := services.GetWebSessionMarshaler().MarshalWebSession(session)
if err != nil {
return trace.Wrap(err)
}
sessionMetadata := session.GetMetadata()
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid),
Value: value,
Expires: backend.EarliestExpiry(session.GetBearerTokenExpiryTime(), sessionMetadata.Expiry()),
}
_, err = s.Put(context.TODO(), item)
return trace.Wrap(err)
} | go | func (s *IdentityService) UpsertWebSession(user, sid string, session services.WebSession) error {
session.SetUser(user)
session.SetName(sid)
value, err := services.GetWebSessionMarshaler().MarshalWebSession(session)
if err != nil {
return trace.Wrap(err)
}
sessionMetadata := session.GetMetadata()
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid),
Value: value,
Expires: backend.EarliestExpiry(session.GetBearerTokenExpiryTime(), sessionMetadata.Expiry()),
}
_, err = s.Put(context.TODO(), item)
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertWebSession",
"(",
"user",
",",
"sid",
"string",
",",
"session",
"services",
".",
"WebSession",
")",
"error",
"{",
"session",
".",
"SetUser",
"(",
"user",
")",
"\n",
"session",
".",
"SetName",
"(",
"sid",
")",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"MarshalWebSession",
"(",
"session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sessionMetadata",
":=",
"session",
".",
"GetMetadata",
"(",
")",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"sessionsPrefix",
",",
"sid",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"backend",
".",
"EarliestExpiry",
"(",
"session",
".",
"GetBearerTokenExpiryTime",
"(",
")",
",",
"sessionMetadata",
".",
"Expiry",
"(",
")",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertWebSession updates or inserts a web session for a user and session id
// the session will be created with bearer token expiry time TTL, because
// it is expected to be extended by the client before then | [
"UpsertWebSession",
"updates",
"or",
"inserts",
"a",
"web",
"session",
"for",
"a",
"user",
"and",
"session",
"id",
"the",
"session",
"will",
"be",
"created",
"with",
"bearer",
"token",
"expiry",
"time",
"TTL",
"because",
"it",
"is",
"expected",
"to",
"be",
"extended",
"by",
"the",
"client",
"before",
"then"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L373-L388 | train |
gravitational/teleport | lib/services/local/users.go | GetUserLoginAttempts | func (s *IdentityService) GetUserLoginAttempts(user string) ([]services.LoginAttempt, error) {
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.LoginAttempt, len(result.Items))
for i, item := range result.Items {
var a services.LoginAttempt
if err := json.Unmarshal(item.Value, &a); err != nil {
return nil, trace.Wrap(err)
}
out[i] = a
}
sort.Sort(services.SortedLoginAttempts(out))
return out, nil
} | go | func (s *IdentityService) GetUserLoginAttempts(user string) ([]services.LoginAttempt, error) {
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.LoginAttempt, len(result.Items))
for i, item := range result.Items {
var a services.LoginAttempt
if err := json.Unmarshal(item.Value, &a); err != nil {
return nil, trace.Wrap(err)
}
out[i] = a
}
sort.Sort(services.SortedLoginAttempts(out))
return out, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetUserLoginAttempts",
"(",
"user",
"string",
")",
"(",
"[",
"]",
"services",
".",
"LoginAttempt",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"attemptsPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"LoginAttempt",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"var",
"a",
"services",
".",
"LoginAttempt",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"a",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"[",
"i",
"]",
"=",
"a",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedLoginAttempts",
"(",
"out",
")",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // GetUserLoginAttempts returns user login attempts | [
"GetUserLoginAttempts",
"returns",
"user",
"login",
"attempts"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L409-L425 | train |
gravitational/teleport | lib/services/local/users.go | DeleteUserLoginAttempts | func (s *IdentityService) DeleteUserLoginAttempts(user string) error {
if user == "" {
return trace.BadParameter("missing username")
}
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) DeleteUserLoginAttempts(user string) error {
if user == "" {
return trace.BadParameter("missing username")
}
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteUserLoginAttempts",
"(",
"user",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"attemptsPrefix",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteUserLoginAttempts removes all login attempts of a user. Should be
// called after successful login. | [
"DeleteUserLoginAttempts",
"removes",
"all",
"login",
"attempts",
"of",
"a",
"user",
".",
"Should",
"be",
"called",
"after",
"successful",
"login",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L429-L439 | train |
gravitational/teleport | lib/services/local/users.go | GetWebSession | func (s *IdentityService) GetWebSession(user, sid string) (services.WebSession, error) {
if user == "" {
return nil, trace.BadParameter("missing username")
}
if sid == "" {
return nil, trace.BadParameter("missing session id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
if err != nil {
return nil, trace.Wrap(err)
}
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
// this is for backwards compatibility to ensure we
// always have these values
session.SetUser(user)
session.SetName(sid)
return session, nil
} | go | func (s *IdentityService) GetWebSession(user, sid string) (services.WebSession, error) {
if user == "" {
return nil, trace.BadParameter("missing username")
}
if sid == "" {
return nil, trace.BadParameter("missing session id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
if err != nil {
return nil, trace.Wrap(err)
}
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
// this is for backwards compatibility to ensure we
// always have these values
session.SetUser(user)
session.SetName(sid)
return session, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetWebSession",
"(",
"user",
",",
"sid",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"sid",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"sessionsPrefix",
",",
"sid",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"session",
",",
"err",
":=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"item",
".",
"Value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"// this is for backwards compatibility to ensure we",
"// always have these values",
"session",
".",
"SetUser",
"(",
"user",
")",
"\n",
"session",
".",
"SetName",
"(",
"sid",
")",
"\n",
"return",
"session",
",",
"nil",
"\n",
"}"
] | // GetWebSession returns a web session state for a given user and session id | [
"GetWebSession",
"returns",
"a",
"web",
"session",
"state",
"for",
"a",
"given",
"user",
"and",
"session",
"id"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L442-L462 | train |
gravitational/teleport | lib/services/local/users.go | DeleteWebSession | func (s *IdentityService) DeleteWebSession(user, sid string) error {
if user == "" {
return trace.BadParameter("missing username")
}
if sid == "" {
return trace.BadParameter("missing session id")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteWebSession(user, sid string) error {
if user == "" {
return trace.BadParameter("missing username")
}
if sid == "" {
return trace.BadParameter("missing session id")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteWebSession",
"(",
"user",
",",
"sid",
"string",
")",
"error",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"sid",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"usersPrefix",
",",
"user",
",",
"sessionsPrefix",
",",
"sid",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteWebSession deletes web session from the storage | [
"DeleteWebSession",
"deletes",
"web",
"session",
"from",
"the",
"storage"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L465-L474 | train |
gravitational/teleport | lib/services/local/users.go | UpsertPassword | func (s *IdentityService) UpsertPassword(user string, password []byte) error {
if user == "" {
return trace.BadParameter("missing username")
}
err := services.VerifyPassword(password)
if err != nil {
return trace.Wrap(err)
}
hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertPasswordHash(user, hash)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertPassword(user string, password []byte) error {
if user == "" {
return trace.BadParameter("missing username")
}
err := services.VerifyPassword(password)
if err != nil {
return trace.Wrap(err)
}
hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertPasswordHash(user, hash)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertPassword",
"(",
"user",
"string",
",",
"password",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"user",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"services",
".",
"VerifyPassword",
"(",
"password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"hash",
",",
"err",
":=",
"bcrypt",
".",
"GenerateFromPassword",
"(",
"password",
",",
"bcrypt",
".",
"DefaultCost",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"s",
".",
"UpsertPasswordHash",
"(",
"user",
",",
"hash",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UpsertPassword upserts new password hash into a backend. | [
"UpsertPassword",
"upserts",
"new",
"password",
"hash",
"into",
"a",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L477-L496 | train |
gravitational/teleport | lib/services/local/users.go | UpsertSignupToken | func (s *IdentityService) UpsertSignupToken(token string, tokenData services.SignupToken, ttl time.Duration) error {
if ttl < time.Second || ttl > defaults.MaxSignupTokenTTL {
ttl = defaults.MaxSignupTokenTTL
}
tokenData.Expires = time.Now().UTC().Add(ttl)
value, err := json.Marshal(tokenData)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(userTokensPrefix, token),
Value: value,
Expires: tokenData.Expires,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertSignupToken(token string, tokenData services.SignupToken, ttl time.Duration) error {
if ttl < time.Second || ttl > defaults.MaxSignupTokenTTL {
ttl = defaults.MaxSignupTokenTTL
}
tokenData.Expires = time.Now().UTC().Add(ttl)
value, err := json.Marshal(tokenData)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(userTokensPrefix, token),
Value: value,
Expires: tokenData.Expires,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertSignupToken",
"(",
"token",
"string",
",",
"tokenData",
"services",
".",
"SignupToken",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"ttl",
"<",
"time",
".",
"Second",
"||",
"ttl",
">",
"defaults",
".",
"MaxSignupTokenTTL",
"{",
"ttl",
"=",
"defaults",
".",
"MaxSignupTokenTTL",
"\n",
"}",
"\n",
"tokenData",
".",
"Expires",
"=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"ttl",
")",
"\n",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"tokenData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
",",
"token",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"tokenData",
".",
"Expires",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n\n",
"}"
] | // UpsertSignupToken upserts signup token - one time token that lets user to create a user account | [
"UpsertSignupToken",
"upserts",
"signup",
"token",
"-",
"one",
"time",
"token",
"that",
"lets",
"user",
"to",
"create",
"a",
"user",
"account"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L499-L519 | train |
gravitational/teleport | lib/services/local/users.go | GetSignupToken | func (s *IdentityService) GetSignupToken(token string) (*services.SignupToken, error) {
if token == "" {
return nil, trace.BadParameter("missing token")
}
item, err := s.Get(context.TODO(), backend.Key(userTokensPrefix, token))
if err != nil {
return nil, trace.Wrap(err)
}
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
return &signupToken, nil
} | go | func (s *IdentityService) GetSignupToken(token string) (*services.SignupToken, error) {
if token == "" {
return nil, trace.BadParameter("missing token")
}
item, err := s.Get(context.TODO(), backend.Key(userTokensPrefix, token))
if err != nil {
return nil, trace.Wrap(err)
}
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
return &signupToken, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSignupToken",
"(",
"token",
"string",
")",
"(",
"*",
"services",
".",
"SignupToken",
",",
"error",
")",
"{",
"if",
"token",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
",",
"token",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"signupToken",
"services",
".",
"SignupToken",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"signupToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"signupToken",
",",
"nil",
"\n",
"}"
] | // GetSignupToken returns signup token data | [
"GetSignupToken",
"returns",
"signup",
"token",
"data"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L522-L536 | train |
gravitational/teleport | lib/services/local/users.go | GetSignupTokens | func (s *IdentityService) GetSignupTokens() ([]services.SignupToken, error) {
startKey := backend.Key(userTokensPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tokens := make([]services.SignupToken, len(result.Items))
for i, item := range result.Items {
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
tokens[i] = signupToken
}
return tokens, nil
} | go | func (s *IdentityService) GetSignupTokens() ([]services.SignupToken, error) {
startKey := backend.Key(userTokensPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tokens := make([]services.SignupToken, len(result.Items))
for i, item := range result.Items {
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
tokens[i] = signupToken
}
return tokens, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetSignupTokens",
"(",
")",
"(",
"[",
"]",
"services",
".",
"SignupToken",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tokens",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"SignupToken",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"var",
"signupToken",
"services",
".",
"SignupToken",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"signupToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tokens",
"[",
"i",
"]",
"=",
"signupToken",
"\n",
"}",
"\n",
"return",
"tokens",
",",
"nil",
"\n",
"}"
] | // GetSignupTokens returns all non-expired user tokens | [
"GetSignupTokens",
"returns",
"all",
"non",
"-",
"expired",
"user",
"tokens"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L539-L555 | train |
gravitational/teleport | lib/services/local/users.go | DeleteSignupToken | func (s *IdentityService) DeleteSignupToken(token string) error {
if token == "" {
return trace.BadParameter("missing parameter token")
}
err := s.Delete(context.TODO(), backend.Key(userTokensPrefix, token))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteSignupToken(token string) error {
if token == "" {
return trace.BadParameter("missing parameter token")
}
err := s.Delete(context.TODO(), backend.Key(userTokensPrefix, token))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteSignupToken",
"(",
"token",
"string",
")",
"error",
"{",
"if",
"token",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"userTokensPrefix",
",",
"token",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteSignupToken deletes signup token from the storage | [
"DeleteSignupToken",
"deletes",
"signup",
"token",
"from",
"the",
"storage"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L558-L564 | train |
gravitational/teleport | lib/services/local/users.go | UpsertOIDCConnector | func (s *IdentityService) UpsertOIDCConnector(connector services.OIDCConnector) error {
if err := connector.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
ID: connector.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) UpsertOIDCConnector(connector services.OIDCConnector) error {
if err := connector.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
ID: connector.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"UpsertOIDCConnector",
"(",
"connector",
"services",
".",
"OIDCConnector",
")",
"error",
"{",
"if",
"err",
":=",
"connector",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"MarshalOIDCConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"connectorsPrefix",
",",
"connector",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"connector",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"connector",
".",
"GetResourceID",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertOIDCConnector upserts OIDC Connector | [
"UpsertOIDCConnector",
"upserts",
"OIDC",
"Connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L746-L765 | train |
gravitational/teleport | lib/services/local/users.go | GetOIDCConnector | func (s *IdentityService) GetOIDCConnector(name string, withSecrets bool) (services.OIDCConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("OpenID connector '%v' is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(item.Value,
services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
return conn, nil
} | go | func (s *IdentityService) GetOIDCConnector(name string, withSecrets bool) (services.OIDCConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("OpenID connector '%v' is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(item.Value,
services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
return conn, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetOIDCConnector",
"(",
"name",
"string",
",",
"withSecrets",
"bool",
")",
"(",
"services",
".",
"OIDCConnector",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"UnmarshalOIDCConnector",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"conn",
".",
"SetClientSecret",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // GetOIDCConnector returns OIDC connector data, parameter 'withSecrets'
// includes or excludes client secret from return results | [
"GetOIDCConnector",
"returns",
"OIDC",
"connector",
"data",
"parameter",
"withSecrets",
"includes",
"or",
"excludes",
"client",
"secret",
"from",
"return",
"results"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L778-L798 | train |
gravitational/teleport | lib/services/local/users.go | GetOIDCConnectors | func (s *IdentityService) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(result.Items))
for i, item := range result.Items {
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
connectors[i] = conn
}
return connectors, nil
} | go | func (s *IdentityService) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(result.Items))
for i, item := range result.Items {
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
connectors[i] = conn
}
return connectors, nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"GetOIDCConnectors",
"(",
"withSecrets",
"bool",
")",
"(",
"[",
"]",
"services",
".",
"OIDCConnector",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"connectorsPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connectors",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"OIDCConnector",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"conn",
",",
"err",
":=",
"services",
".",
"GetOIDCConnectorMarshaler",
"(",
")",
".",
"UnmarshalOIDCConnector",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"withSecrets",
"{",
"conn",
".",
"SetClientSecret",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"connectors",
"[",
"i",
"]",
"=",
"conn",
"\n",
"}",
"\n",
"return",
"connectors",
",",
"nil",
"\n",
"}"
] | // GetOIDCConnectors returns registered connectors, withSecrets adds or removes client secret from return results | [
"GetOIDCConnectors",
"returns",
"registered",
"connectors",
"withSecrets",
"adds",
"or",
"removes",
"client",
"secret",
"from",
"return",
"results"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L801-L820 | train |
gravitational/teleport | lib/services/local/users.go | CreateOIDCAuthRequest | func (s *IdentityService) CreateOIDCAuthRequest(req services.OIDCAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateOIDCAuthRequest(req services.OIDCAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateOIDCAuthRequest",
"(",
"req",
"services",
".",
"OIDCAuthRequest",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"err",
":=",
"req",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"oidcPrefix",
",",
"requestsPrefix",
",",
"req",
".",
"StateToken",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"backend",
".",
"Expiry",
"(",
"s",
".",
"Clock",
"(",
")",
",",
"ttl",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateOIDCAuthRequest creates new auth request | [
"CreateOIDCAuthRequest",
"creates",
"new",
"auth",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L823-L841 | train |
gravitational/teleport | lib/services/local/users.go | CreateSAMLConnector | func (s *IdentityService) CreateSAMLConnector(connector services.SAMLConnector) error {
if err := connector.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *IdentityService) CreateSAMLConnector(connector services.SAMLConnector) error {
if err := connector.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"CreateSAMLConnector",
"(",
"connector",
"services",
".",
"SAMLConnector",
")",
"error",
"{",
"if",
"err",
":=",
"connector",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetSAMLConnectorMarshaler",
"(",
")",
".",
"MarshalSAMLConnector",
"(",
"connector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"connectorsPrefix",
",",
"connector",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"connector",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateSAMLConnector creates SAML Connector | [
"CreateSAMLConnector",
"creates",
"SAML",
"Connector"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L860-L878 | train |
gravitational/teleport | lib/services/local/users.go | DeleteSAMLConnector | func (s *IdentityService) DeleteSAMLConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
return trace.Wrap(err)
} | go | func (s *IdentityService) DeleteSAMLConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"IdentityService",
")",
"DeleteSAMLConnector",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"webPrefix",
",",
"connectorsPrefix",
",",
"samlPrefix",
",",
"connectorsPrefix",
",",
"name",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteSAMLConnector deletes SAML Connector by name | [
"DeleteSAMLConnector",
"deletes",
"SAML",
"Connector",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/users.go#L902-L908 | train |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.