repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | tool/tctl/common/token_command.go | calculateCAPin | func calculateCAPin(client auth.ClientI) (string, error) {
localCA, err := client.GetClusterCACert()
if err != nil {
return "", trace.Wrap(err)
}
tlsCA, err := tlsca.ParseCertificatePEM(localCA.TLSCA)
if err != nil {
return "", trace.Wrap(err)
}
return utils.CalculateSPKI(tlsCA), nil
} | go | func calculateCAPin(client auth.ClientI) (string, error) {
localCA, err := client.GetClusterCACert()
if err != nil {
return "", trace.Wrap(err)
}
tlsCA, err := tlsca.ParseCertificatePEM(localCA.TLSCA)
if err != nil {
return "", trace.Wrap(err)
}
return utils.CalculateSPKI(tlsCA), nil
} | [
"func",
"calculateCAPin",
"(",
"client",
"auth",
".",
"ClientI",
")",
"(",
"string",
",",
"error",
")",
"{",
"localCA",
",",
"err",
":=",
"client",
".",
"GetClusterCACert",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsCA",
",",
"err",
":=",
"tlsca",
".",
"ParseCertificatePEM",
"(",
"localCA",
".",
"TLSCA",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"CalculateSPKI",
"(",
"tlsCA",
")",
",",
"nil",
"\n",
"}"
] | // calculateCAPin returns the SPKI pin for the local cluster. | [
"calculateCAPin",
"returns",
"the",
"SPKI",
"pin",
"for",
"the",
"local",
"cluster",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/token_command.go#L210-L221 | train |
gravitational/teleport | lib/backend/sanitize.go | isKeySafe | func isKeySafe(s []byte) bool {
return whitelistPattern.Match(s) && !blacklistPattern.Match(s)
} | go | func isKeySafe(s []byte) bool {
return whitelistPattern.Match(s) && !blacklistPattern.Match(s)
} | [
"func",
"isKeySafe",
"(",
"s",
"[",
"]",
"byte",
")",
"bool",
"{",
"return",
"whitelistPattern",
".",
"Match",
"(",
"s",
")",
"&&",
"!",
"blacklistPattern",
".",
"Match",
"(",
"s",
")",
"\n",
"}"
] | // isKeySafe checks if the passed in key conforms to whitelist | [
"isKeySafe",
"checks",
"if",
"the",
"passed",
"in",
"key",
"conforms",
"to",
"whitelist"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/sanitize.go#L40-L42 | train |
gravitational/teleport | lib/client/weblogin.go | Check | func (r SSOLoginConsoleReq) Check() error {
if r.RedirectURL == "" {
return trace.BadParameter("missing RedirectURL")
}
if len(r.PublicKey) == 0 {
return trace.BadParameter("missing PublicKey")
}
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
return nil
} | go | func (r SSOLoginConsoleReq) Check() error {
if r.RedirectURL == "" {
return trace.BadParameter("missing RedirectURL")
}
if len(r.PublicKey) == 0 {
return trace.BadParameter("missing PublicKey")
}
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
return nil
} | [
"func",
"(",
"r",
"SSOLoginConsoleReq",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"r",
".",
"RedirectURL",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing RedirectURL\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"r",
".",
"PublicKey",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing PublicKey\"",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"ConnectorID",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing ConnectorID\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check makes sure that the request is valid | [
"Check",
"makes",
"sure",
"that",
"the",
"request",
"is",
"valid"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/weblogin.go#L60-L71 | train |
gravitational/teleport | lib/client/weblogin.go | NewCredentialsClient | func NewCredentialsClient(proxyAddr string, insecure bool, pool *x509.CertPool) (*CredentialsClient, error) {
log := logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentClient,
})
log.Debugf("HTTPS client init(proxyAddr=%v, insecure=%v)", proxyAddr, insecure)
// validate proxyAddr:
host, port, err := net.SplitHostPort(proxyAddr)
if err != nil || host == "" || port == "" {
if err != nil {
log.Error(err)
}
return nil, trace.BadParameter("'%v' is not a valid proxy address", proxyAddr)
}
proxyAddr = "https://" + net.JoinHostPort(host, port)
u, err := url.Parse(proxyAddr)
if err != nil {
return nil, trace.BadParameter("'%v' is not a valid proxy address", proxyAddr)
}
var opts []roundtrip.ClientParam
if insecure {
// Skip https cert verification, print a warning that this is insecure.
fmt.Printf("WARNING: You are using insecure connection to SSH proxy %v\n", proxyAddr)
opts = append(opts, roundtrip.HTTPClient(NewInsecureWebClient()))
} else if pool != nil {
// use custom set of trusted CAs
opts = append(opts, roundtrip.HTTPClient(newClientWithPool(pool)))
}
clt, err := NewWebClient(proxyAddr, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return &CredentialsClient{
log: log,
clt: clt,
url: u,
}, nil
} | go | func NewCredentialsClient(proxyAddr string, insecure bool, pool *x509.CertPool) (*CredentialsClient, error) {
log := logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentClient,
})
log.Debugf("HTTPS client init(proxyAddr=%v, insecure=%v)", proxyAddr, insecure)
// validate proxyAddr:
host, port, err := net.SplitHostPort(proxyAddr)
if err != nil || host == "" || port == "" {
if err != nil {
log.Error(err)
}
return nil, trace.BadParameter("'%v' is not a valid proxy address", proxyAddr)
}
proxyAddr = "https://" + net.JoinHostPort(host, port)
u, err := url.Parse(proxyAddr)
if err != nil {
return nil, trace.BadParameter("'%v' is not a valid proxy address", proxyAddr)
}
var opts []roundtrip.ClientParam
if insecure {
// Skip https cert verification, print a warning that this is insecure.
fmt.Printf("WARNING: You are using insecure connection to SSH proxy %v\n", proxyAddr)
opts = append(opts, roundtrip.HTTPClient(NewInsecureWebClient()))
} else if pool != nil {
// use custom set of trusted CAs
opts = append(opts, roundtrip.HTTPClient(newClientWithPool(pool)))
}
clt, err := NewWebClient(proxyAddr, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return &CredentialsClient{
log: log,
clt: clt,
url: u,
}, nil
} | [
"func",
"NewCredentialsClient",
"(",
"proxyAddr",
"string",
",",
"insecure",
"bool",
",",
"pool",
"*",
"x509",
".",
"CertPool",
")",
"(",
"*",
"CredentialsClient",
",",
"error",
")",
"{",
"log",
":=",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentClient",
",",
"}",
")",
"\n",
"log",
".",
"Debugf",
"(",
"\"HTTPS client init(proxyAddr=%v, insecure=%v)\"",
",",
"proxyAddr",
",",
"insecure",
")",
"\n",
"host",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"proxyAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"host",
"==",
"\"\"",
"||",
"port",
"==",
"\"\"",
"{",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"'%v' is not a valid proxy address\"",
",",
"proxyAddr",
")",
"\n",
"}",
"\n",
"proxyAddr",
"=",
"\"https://\"",
"+",
"net",
".",
"JoinHostPort",
"(",
"host",
",",
"port",
")",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"proxyAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"'%v' is not a valid proxy address\"",
",",
"proxyAddr",
")",
"\n",
"}",
"\n",
"var",
"opts",
"[",
"]",
"roundtrip",
".",
"ClientParam",
"\n",
"if",
"insecure",
"{",
"fmt",
".",
"Printf",
"(",
"\"WARNING: You are using insecure connection to SSH proxy %v\\n\"",
",",
"\\n",
")",
"\n",
"proxyAddr",
"\n",
"}",
"else",
"opts",
"=",
"append",
"(",
"opts",
",",
"roundtrip",
".",
"HTTPClient",
"(",
"NewInsecureWebClient",
"(",
")",
")",
")",
"\n",
"if",
"pool",
"!=",
"nil",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"roundtrip",
".",
"HTTPClient",
"(",
"newClientWithPool",
"(",
"pool",
")",
")",
")",
"\n",
"}",
"\n",
"clt",
",",
"err",
":=",
"NewWebClient",
"(",
"proxyAddr",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // NewCredentialsClient creates a new client to the HTTPS web proxy. | [
"NewCredentialsClient",
"creates",
"a",
"new",
"client",
"to",
"the",
"HTTPS",
"web",
"proxy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/weblogin.go#L253-L294 | train |
gravitational/teleport | lib/client/weblogin.go | SSHAgentLogin | func (c *CredentialsClient) SSHAgentLogin(ctx context.Context, user string, password string, otpToken string, pubKey []byte, ttl time.Duration, compatibility string) (*auth.SSHLoginResponse, error) {
re, err := c.clt.PostJSON(ctx, c.clt.Endpoint("webapi", "ssh", "certs"), CreateSSHCertReq{
User: user,
Password: password,
OTPToken: otpToken,
PubKey: pubKey,
TTL: ttl,
Compatibility: compatibility,
})
if err != nil {
return nil, trace.Wrap(err)
}
var out *auth.SSHLoginResponse
err = json.Unmarshal(re.Bytes(), &out)
if err != nil {
return nil, trace.Wrap(err)
}
return out, nil
} | go | func (c *CredentialsClient) SSHAgentLogin(ctx context.Context, user string, password string, otpToken string, pubKey []byte, ttl time.Duration, compatibility string) (*auth.SSHLoginResponse, error) {
re, err := c.clt.PostJSON(ctx, c.clt.Endpoint("webapi", "ssh", "certs"), CreateSSHCertReq{
User: user,
Password: password,
OTPToken: otpToken,
PubKey: pubKey,
TTL: ttl,
Compatibility: compatibility,
})
if err != nil {
return nil, trace.Wrap(err)
}
var out *auth.SSHLoginResponse
err = json.Unmarshal(re.Bytes(), &out)
if err != nil {
return nil, trace.Wrap(err)
}
return out, nil
} | [
"func",
"(",
"c",
"*",
"CredentialsClient",
")",
"SSHAgentLogin",
"(",
"ctx",
"context",
".",
"Context",
",",
"user",
"string",
",",
"password",
"string",
",",
"otpToken",
"string",
",",
"pubKey",
"[",
"]",
"byte",
",",
"ttl",
"time",
".",
"Duration",
",",
"compatibility",
"string",
")",
"(",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"error",
")",
"{",
"re",
",",
"err",
":=",
"c",
".",
"clt",
".",
"PostJSON",
"(",
"ctx",
",",
"c",
".",
"clt",
".",
"Endpoint",
"(",
"\"webapi\"",
",",
"\"ssh\"",
",",
"\"certs\"",
")",
",",
"CreateSSHCertReq",
"{",
"User",
":",
"user",
",",
"Password",
":",
"password",
",",
"OTPToken",
":",
"otpToken",
",",
"PubKey",
":",
"pubKey",
",",
"TTL",
":",
"ttl",
",",
"Compatibility",
":",
"compatibility",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"out",
"*",
"auth",
".",
"SSHLoginResponse",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"re",
".",
"Bytes",
"(",
")",
",",
"&",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // SSHAgentLogin is used by tsh to fetch local user credentials. | [
"SSHAgentLogin",
"is",
"used",
"by",
"tsh",
"to",
"fetch",
"local",
"user",
"credentials",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/weblogin.go#L400-L420 | train |
gravitational/teleport | lib/client/weblogin.go | HostCredentials | func (c *CredentialsClient) HostCredentials(ctx context.Context, req auth.RegisterUsingTokenRequest) (*auth.PackedKeys, error) {
resp, err := c.clt.PostJSON(ctx, c.clt.Endpoint("webapi", "host", "credentials"), req)
if err != nil {
return nil, trace.Wrap(err)
}
var packedKeys *auth.PackedKeys
err = json.Unmarshal(resp.Bytes(), &packedKeys)
if err != nil {
return nil, trace.Wrap(err)
}
return packedKeys, nil
} | go | func (c *CredentialsClient) HostCredentials(ctx context.Context, req auth.RegisterUsingTokenRequest) (*auth.PackedKeys, error) {
resp, err := c.clt.PostJSON(ctx, c.clt.Endpoint("webapi", "host", "credentials"), req)
if err != nil {
return nil, trace.Wrap(err)
}
var packedKeys *auth.PackedKeys
err = json.Unmarshal(resp.Bytes(), &packedKeys)
if err != nil {
return nil, trace.Wrap(err)
}
return packedKeys, nil
} | [
"func",
"(",
"c",
"*",
"CredentialsClient",
")",
"HostCredentials",
"(",
"ctx",
"context",
".",
"Context",
",",
"req",
"auth",
".",
"RegisterUsingTokenRequest",
")",
"(",
"*",
"auth",
".",
"PackedKeys",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"c",
".",
"clt",
".",
"PostJSON",
"(",
"ctx",
",",
"c",
".",
"clt",
".",
"Endpoint",
"(",
"\"webapi\"",
",",
"\"host\"",
",",
"\"credentials\"",
")",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"packedKeys",
"*",
"auth",
".",
"PackedKeys",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"resp",
".",
"Bytes",
"(",
")",
",",
"&",
"packedKeys",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"packedKeys",
",",
"nil",
"\n",
"}"
] | // HostCredentials is used to fetch host credentials for a node. | [
"HostCredentials",
"is",
"used",
"to",
"fetch",
"host",
"credentials",
"for",
"a",
"node",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/weblogin.go#L508-L521 | train |
gravitational/teleport | lib/services/local/access.go | DeleteAllRoles | func (s *AccessService) DeleteAllRoles() error {
return s.DeleteRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)))
} | go | func (s *AccessService) DeleteAllRoles() error {
return s.DeleteRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)))
} | [
"func",
"(",
"s",
"*",
"AccessService",
")",
"DeleteAllRoles",
"(",
")",
"error",
"{",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"rolesPrefix",
")",
",",
"backend",
".",
"RangeEnd",
"(",
"backend",
".",
"Key",
"(",
"rolesPrefix",
")",
")",
")",
"\n",
"}"
] | // DeleteAllRoles deletes all roles | [
"DeleteAllRoles",
"deletes",
"all",
"roles"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/access.go#L40-L42 | train |
gravitational/teleport | lib/services/local/access.go | GetRoles | func (s *AccessService) GetRoles() ([]services.Role, error) {
result, err := s.GetRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.Role, 0, len(result.Items))
for _, item := range result.Items {
role, err := services.GetRoleMarshaler().UnmarshalRole(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, role)
}
sort.Sort(services.SortedRoles(out))
return out, nil
} | go | func (s *AccessService) GetRoles() ([]services.Role, error) {
result, err := s.GetRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.Role, 0, len(result.Items))
for _, item := range result.Items {
role, err := services.GetRoleMarshaler().UnmarshalRole(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, role)
}
sort.Sort(services.SortedRoles(out))
return out, nil
} | [
"func",
"(",
"s",
"*",
"AccessService",
")",
"GetRoles",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Role",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"rolesPrefix",
")",
",",
"backend",
".",
"RangeEnd",
"(",
"backend",
".",
"Key",
"(",
"rolesPrefix",
")",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Role",
",",
"0",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"role",
",",
"err",
":=",
"services",
".",
"GetRoleMarshaler",
"(",
")",
".",
"UnmarshalRole",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"role",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedRoles",
"(",
"out",
")",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // GetRoles returns a list of roles registered with the local auth server | [
"GetRoles",
"returns",
"a",
"list",
"of",
"roles",
"registered",
"with",
"the",
"local",
"auth",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/access.go#L45-L61 | train |
gravitational/teleport | lib/services/local/access.go | CreateRole | func (s *AccessService) CreateRole(role services.Role) error {
value, err := services.GetRoleMarshaler().MarshalRole(role)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(rolesPrefix, role.GetName(), paramsPrefix),
Value: value,
Expires: role.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (s *AccessService) CreateRole(role services.Role) error {
value, err := services.GetRoleMarshaler().MarshalRole(role)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(rolesPrefix, role.GetName(), paramsPrefix),
Value: value,
Expires: role.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"s",
"*",
"AccessService",
")",
"CreateRole",
"(",
"role",
"services",
".",
"Role",
")",
"error",
"{",
"value",
",",
"err",
":=",
"services",
".",
"GetRoleMarshaler",
"(",
")",
".",
"MarshalRole",
"(",
"role",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"rolesPrefix",
",",
"role",
".",
"GetName",
"(",
")",
",",
"paramsPrefix",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"role",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateRole creates a role on the backend. | [
"CreateRole",
"creates",
"a",
"role",
"on",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/access.go#L64-L81 | train |
gravitational/teleport | lib/services/local/access.go | GetRole | func (s *AccessService) GetRole(name string) (services.Role, error) {
if name == "" {
return nil, trace.BadParameter("missing role name")
}
item, err := s.Get(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("role %v is not found", name)
}
return nil, trace.Wrap(err)
}
return services.GetRoleMarshaler().UnmarshalRole(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | go | func (s *AccessService) GetRole(name string) (services.Role, error) {
if name == "" {
return nil, trace.BadParameter("missing role name")
}
item, err := s.Get(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("role %v is not found", name)
}
return nil, trace.Wrap(err)
}
return services.GetRoleMarshaler().UnmarshalRole(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | [
"func",
"(",
"s",
"*",
"AccessService",
")",
"GetRole",
"(",
"name",
"string",
")",
"(",
"services",
".",
"Role",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing role name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"rolesPrefix",
",",
"name",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"role %v is not found\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetRoleMarshaler",
"(",
")",
".",
"UnmarshalRole",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"}"
] | // GetRole returns a role by name | [
"GetRole",
"returns",
"a",
"role",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/access.go#L105-L118 | train |
gravitational/teleport | lib/services/local/access.go | DeleteRole | func (s *AccessService) DeleteRole(name string) error {
if name == "" {
return trace.BadParameter("missing role name")
}
err := s.Delete(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("role %q is not found", name)
}
}
return trace.Wrap(err)
} | go | func (s *AccessService) DeleteRole(name string) error {
if name == "" {
return trace.BadParameter("missing role name")
}
err := s.Delete(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("role %q is not found", name)
}
}
return trace.Wrap(err)
} | [
"func",
"(",
"s",
"*",
"AccessService",
")",
"DeleteRole",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing role name\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"rolesPrefix",
",",
"name",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"role %q is not found\"",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteRole deletes a role from the backend | [
"DeleteRole",
"deletes",
"a",
"role",
"from",
"the",
"backend"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/access.go#L121-L132 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | hasRemoteBuiltinRole | func (a *AuthWithRoles) hasRemoteBuiltinRole(name string) bool {
if _, ok := a.checker.(RemoteBuiltinRoleSet); !ok {
return false
}
if !a.checker.HasRole(name) {
return false
}
return true
} | go | func (a *AuthWithRoles) hasRemoteBuiltinRole(name string) bool {
if _, ok := a.checker.(RemoteBuiltinRoleSet); !ok {
return false
}
if !a.checker.HasRole(name) {
return false
}
return true
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"hasRemoteBuiltinRole",
"(",
"name",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"ok",
":=",
"a",
".",
"checker",
".",
"(",
"RemoteBuiltinRoleSet",
")",
";",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"a",
".",
"checker",
".",
"HasRole",
"(",
"name",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // hasRemoteBuiltinRole checks the type of the role set returned and the name.
// Returns true if role set is remote builtin and the name matches. | [
"hasRemoteBuiltinRole",
"checks",
"the",
"type",
"of",
"the",
"role",
"set",
"returned",
"and",
"the",
"name",
".",
"Returns",
"true",
"if",
"role",
"set",
"is",
"remote",
"builtin",
"and",
"the",
"name",
"matches",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L98-L107 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | RotateExternalCertAuthority | func (a *AuthWithRoles) RotateExternalCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
ctx := &services.Context{User: a.user, Resource: ca}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbRotate); err != nil {
return trace.Wrap(err)
}
return a.authServer.RotateExternalCertAuthority(ca)
} | go | func (a *AuthWithRoles) RotateExternalCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
ctx := &services.Context{User: a.user, Resource: ca}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbRotate); err != nil {
return trace.Wrap(err)
}
return a.authServer.RotateExternalCertAuthority(ca)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"RotateExternalCertAuthority",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"ca",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing certificate authority\"",
")",
"\n",
"}",
"\n",
"ctx",
":=",
"&",
"services",
".",
"Context",
"{",
"User",
":",
"a",
".",
"user",
",",
"Resource",
":",
"ca",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"actionWithContext",
"(",
"ctx",
",",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindCertAuthority",
",",
"services",
".",
"VerbRotate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"RotateExternalCertAuthority",
"(",
"ca",
")",
"\n",
"}"
] | // RotateExternalCertAuthority rotates external certificate authority,
// this method is called by a remote trusted cluster and is used to update
// only public keys and certificates of the certificate authority. | [
"RotateExternalCertAuthority",
"rotates",
"external",
"certificate",
"authority",
"this",
"method",
"is",
"called",
"by",
"a",
"remote",
"trusted",
"cluster",
"and",
"is",
"used",
"to",
"update",
"only",
"public",
"keys",
"and",
"certificates",
"of",
"the",
"certificate",
"authority",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L181-L190 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | UpsertCertAuthority | func (a *AuthWithRoles) UpsertCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
ctx := &services.Context{User: a.user, Resource: ca}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.UpsertCertAuthority(ca)
} | go | func (a *AuthWithRoles) UpsertCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
ctx := &services.Context{User: a.user, Resource: ca}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.UpsertCertAuthority(ca)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"UpsertCertAuthority",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"ca",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing certificate authority\"",
")",
"\n",
"}",
"\n",
"ctx",
":=",
"&",
"services",
".",
"Context",
"{",
"User",
":",
"a",
".",
"user",
",",
"Resource",
":",
"ca",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"actionWithContext",
"(",
"ctx",
",",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindCertAuthority",
",",
"services",
".",
"VerbCreate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"actionWithContext",
"(",
"ctx",
",",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindCertAuthority",
",",
"services",
".",
"VerbUpdate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"UpsertCertAuthority",
"(",
"ca",
")",
"\n",
"}"
] | // UpsertCertAuthority updates existing cert authority or updates the existing one. | [
"UpsertCertAuthority",
"updates",
"existing",
"cert",
"authority",
"or",
"updates",
"the",
"existing",
"one",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L193-L205 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | UpsertNodes | func (a *AuthWithRoles) UpsertNodes(namespace string, servers []services.Server) error {
if err := a.action(namespace, services.KindNode, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(namespace, services.KindNode, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.UpsertNodes(namespace, servers)
} | go | func (a *AuthWithRoles) UpsertNodes(namespace string, servers []services.Server) error {
if err := a.action(namespace, services.KindNode, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(namespace, services.KindNode, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.UpsertNodes(namespace, servers)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"UpsertNodes",
"(",
"namespace",
"string",
",",
"servers",
"[",
"]",
"services",
".",
"Server",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"namespace",
",",
"services",
".",
"KindNode",
",",
"services",
".",
"VerbCreate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"namespace",
",",
"services",
".",
"KindNode",
",",
"services",
".",
"VerbUpdate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"UpsertNodes",
"(",
"namespace",
",",
"servers",
")",
"\n",
"}"
] | // UpsertNodes bulk upserts nodes into the backend. | [
"UpsertNodes",
"bulk",
"upserts",
"nodes",
"into",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L327-L335 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | filterNodes | func (a *AuthWithRoles) filterNodes(nodes []services.Server) ([]services.Server, error) {
// For certain built-in roles, continue to allow full access and return
// the full set of nodes to not break existing clusters during migration.
//
// In addition, allow proxy (and remote proxy) to access all nodes for it's
// smart resolution address resolution. Once the smart resolution logic is
// moved to the auth server, this logic can be removed.
if a.hasBuiltinRole(string(teleport.RoleAdmin)) ||
a.hasBuiltinRole(string(teleport.RoleProxy)) ||
a.hasRemoteBuiltinRole(string(teleport.RoleRemoteProxy)) {
return nodes, nil
}
// Fetch services.RoleSet for the identity of the logged in user.
roles, err := services.FetchRoles(a.user.GetRoles(), a.authServer, a.user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Extract all unique allowed logins across all roles.
allowedLogins := make(map[string]bool)
for _, role := range roles {
for _, login := range role.GetLogins(services.Allow) {
allowedLogins[login] = true
}
}
// Loop over all nodes and check if the caller has access.
filteredNodes := make([]services.Server, 0, len(nodes))
NextNode:
for _, node := range nodes {
for login, _ := range allowedLogins {
err := roles.CheckAccessToServer(login, node)
if err == nil {
filteredNodes = append(filteredNodes, node)
continue NextNode
}
}
}
return filteredNodes, nil
} | go | func (a *AuthWithRoles) filterNodes(nodes []services.Server) ([]services.Server, error) {
// For certain built-in roles, continue to allow full access and return
// the full set of nodes to not break existing clusters during migration.
//
// In addition, allow proxy (and remote proxy) to access all nodes for it's
// smart resolution address resolution. Once the smart resolution logic is
// moved to the auth server, this logic can be removed.
if a.hasBuiltinRole(string(teleport.RoleAdmin)) ||
a.hasBuiltinRole(string(teleport.RoleProxy)) ||
a.hasRemoteBuiltinRole(string(teleport.RoleRemoteProxy)) {
return nodes, nil
}
// Fetch services.RoleSet for the identity of the logged in user.
roles, err := services.FetchRoles(a.user.GetRoles(), a.authServer, a.user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Extract all unique allowed logins across all roles.
allowedLogins := make(map[string]bool)
for _, role := range roles {
for _, login := range role.GetLogins(services.Allow) {
allowedLogins[login] = true
}
}
// Loop over all nodes and check if the caller has access.
filteredNodes := make([]services.Server, 0, len(nodes))
NextNode:
for _, node := range nodes {
for login, _ := range allowedLogins {
err := roles.CheckAccessToServer(login, node)
if err == nil {
filteredNodes = append(filteredNodes, node)
continue NextNode
}
}
}
return filteredNodes, nil
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"filterNodes",
"(",
"nodes",
"[",
"]",
"services",
".",
"Server",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"if",
"a",
".",
"hasBuiltinRole",
"(",
"string",
"(",
"teleport",
".",
"RoleAdmin",
")",
")",
"||",
"a",
".",
"hasBuiltinRole",
"(",
"string",
"(",
"teleport",
".",
"RoleProxy",
")",
")",
"||",
"a",
".",
"hasRemoteBuiltinRole",
"(",
"string",
"(",
"teleport",
".",
"RoleRemoteProxy",
")",
")",
"{",
"return",
"nodes",
",",
"nil",
"\n",
"}",
"\n",
"roles",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"a",
".",
"user",
".",
"GetRoles",
"(",
")",
",",
"a",
".",
"authServer",
",",
"a",
".",
"user",
".",
"GetTraits",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"allowedLogins",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"role",
":=",
"range",
"roles",
"{",
"for",
"_",
",",
"login",
":=",
"range",
"role",
".",
"GetLogins",
"(",
"services",
".",
"Allow",
")",
"{",
"allowedLogins",
"[",
"login",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"filteredNodes",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"0",
",",
"len",
"(",
"nodes",
")",
")",
"\n",
"NextNode",
":",
"for",
"_",
",",
"node",
":=",
"range",
"nodes",
"{",
"for",
"login",
",",
"_",
":=",
"range",
"allowedLogins",
"{",
"err",
":=",
"roles",
".",
"CheckAccessToServer",
"(",
"login",
",",
"node",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"filteredNodes",
"=",
"append",
"(",
"filteredNodes",
",",
"node",
")",
"\n",
"continue",
"NextNode",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"filteredNodes",
",",
"nil",
"\n",
"}"
] | // filterNodes filters nodes based off the role of the logged in user. | [
"filterNodes",
"filters",
"nodes",
"based",
"off",
"the",
"role",
"of",
"the",
"logged",
"in",
"user",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L448-L489 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | DeleteProxy | func (a *AuthWithRoles) DeleteProxy(name string) error {
if err := a.action(defaults.Namespace, services.KindProxy, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteProxy(name)
} | go | func (a *AuthWithRoles) DeleteProxy(name string) error {
if err := a.action(defaults.Namespace, services.KindProxy, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteProxy(name)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"DeleteProxy",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindProxy",
",",
"services",
".",
"VerbDelete",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"DeleteProxy",
"(",
"name",
")",
"\n",
"}"
] | // DeleteProxy deletes proxy by name | [
"DeleteProxy",
"deletes",
"proxy",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L604-L609 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | DeleteNamespace | func (a *AuthWithRoles) DeleteNamespace(name string) error {
if err := a.action(defaults.Namespace, services.KindNamespace, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteNamespace(name)
} | go | func (a *AuthWithRoles) DeleteNamespace(name string) error {
if err := a.action(defaults.Namespace, services.KindNamespace, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteNamespace(name)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"DeleteNamespace",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindNamespace",
",",
"services",
".",
"VerbDelete",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"DeleteNamespace",
"(",
"name",
")",
"\n",
"}"
] | // DeleteNamespace deletes namespace by name | [
"DeleteNamespace",
"deletes",
"namespace",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1163-L1168 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | DeleteRole | func (a *AuthWithRoles) DeleteRole(name string) error {
if err := a.action(defaults.Namespace, services.KindRole, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteRole(name)
} | go | func (a *AuthWithRoles) DeleteRole(name string) error {
if err := a.action(defaults.Namespace, services.KindRole, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteRole(name)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"DeleteRole",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindRole",
",",
"services",
".",
"VerbDelete",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"DeleteRole",
"(",
"name",
")",
"\n",
"}"
] | // DeleteRole deletes role by name | [
"DeleteRole",
"deletes",
"role",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1210-L1215 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | GetClusterConfig | func (a *AuthWithRoles) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbRead); err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterConfig(opts...)
} | go | func (a *AuthWithRoles) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbRead); err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterConfig(opts...)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"GetClusterConfig",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"ClusterConfig",
",",
"error",
")",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterConfig",
",",
"services",
".",
"VerbRead",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"GetClusterConfig",
"(",
"opts",
"...",
")",
"\n",
"}"
] | // GetClusterConfig gets cluster level configuration. | [
"GetClusterConfig",
"gets",
"cluster",
"level",
"configuration",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1218-L1223 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | DeleteClusterConfig | func (a *AuthWithRoles) DeleteClusterConfig() error {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterConfig()
} | go | func (a *AuthWithRoles) DeleteClusterConfig() error {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterConfig()
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"DeleteClusterConfig",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterConfig",
",",
"services",
".",
"VerbDelete",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"DeleteClusterConfig",
"(",
")",
"\n",
"}"
] | // DeleteClusterConfig deletes cluster config | [
"DeleteClusterConfig",
"deletes",
"cluster",
"config"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1226-L1231 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | DeleteClusterName | func (a *AuthWithRoles) DeleteClusterName() error {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterName()
} | go | func (a *AuthWithRoles) DeleteClusterName() error {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterName()
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"DeleteClusterName",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterName",
",",
"services",
".",
"VerbDelete",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"DeleteClusterName",
"(",
")",
"\n",
"}"
] | // DeleteClusterName deletes cluster name | [
"DeleteClusterName",
"deletes",
"cluster",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1234-L1239 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | SetClusterConfig | func (a *AuthWithRoles) SetClusterConfig(c services.ClusterConfig) error {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.SetClusterConfig(c)
} | go | func (a *AuthWithRoles) SetClusterConfig(c services.ClusterConfig) error {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.SetClusterConfig(c)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"SetClusterConfig",
"(",
"c",
"services",
".",
"ClusterConfig",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterConfig",
",",
"services",
".",
"VerbCreate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterConfig",
",",
"services",
".",
"VerbUpdate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"SetClusterConfig",
"(",
"c",
")",
"\n",
"}"
] | // SetClusterConfig sets cluster level configuration. | [
"SetClusterConfig",
"sets",
"cluster",
"level",
"configuration",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1250-L1258 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | GetClusterName | func (a *AuthWithRoles) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbRead); err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterName()
} | go | func (a *AuthWithRoles) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbRead); err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterName()
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"GetClusterName",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"ClusterName",
",",
"error",
")",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterName",
",",
"services",
".",
"VerbRead",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"GetClusterName",
"(",
")",
"\n",
"}"
] | // GetClusterName gets the name of the cluster. | [
"GetClusterName",
"gets",
"the",
"name",
"of",
"the",
"cluster",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1261-L1266 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | SetClusterName | func (a *AuthWithRoles) SetClusterName(c services.ClusterName) error {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.SetClusterName(c)
} | go | func (a *AuthWithRoles) SetClusterName(c services.ClusterName) error {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.SetClusterName(c)
} | [
"func",
"(",
"a",
"*",
"AuthWithRoles",
")",
"SetClusterName",
"(",
"c",
"services",
".",
"ClusterName",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterName",
",",
"services",
".",
"VerbCreate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"action",
"(",
"defaults",
".",
"Namespace",
",",
"services",
".",
"KindClusterName",
",",
"services",
".",
"VerbUpdate",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"authServer",
".",
"SetClusterName",
"(",
"c",
")",
"\n",
"}"
] | // SetClusterName sets the name of the cluster. SetClusterName can only be called once. | [
"SetClusterName",
"sets",
"the",
"name",
"of",
"the",
"cluster",
".",
"SetClusterName",
"can",
"only",
"be",
"called",
"once",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1269-L1277 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | NewAdminAuthServer | func NewAdminAuthServer(authServer *AuthServer, sessions session.Service, alog events.IAuditLog) (ClientI, error) {
ctx, err := NewAdminContext()
if err != nil {
return nil, trace.Wrap(err)
}
return &AuthWithRoles{
authServer: authServer,
checker: ctx.Checker,
user: ctx.User,
alog: alog,
sessions: sessions,
}, nil
} | go | func NewAdminAuthServer(authServer *AuthServer, sessions session.Service, alog events.IAuditLog) (ClientI, error) {
ctx, err := NewAdminContext()
if err != nil {
return nil, trace.Wrap(err)
}
return &AuthWithRoles{
authServer: authServer,
checker: ctx.Checker,
user: ctx.User,
alog: alog,
sessions: sessions,
}, nil
} | [
"func",
"NewAdminAuthServer",
"(",
"authServer",
"*",
"AuthServer",
",",
"sessions",
"session",
".",
"Service",
",",
"alog",
"events",
".",
"IAuditLog",
")",
"(",
"ClientI",
",",
"error",
")",
"{",
"ctx",
",",
"err",
":=",
"NewAdminContext",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"AuthWithRoles",
"{",
"authServer",
":",
"authServer",
",",
"checker",
":",
"ctx",
".",
"Checker",
",",
"user",
":",
"ctx",
".",
"User",
",",
"alog",
":",
"alog",
",",
"sessions",
":",
"sessions",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewAdminAuthServer returns auth server authorized as admin,
// used for auth server cached access | [
"NewAdminAuthServer",
"returns",
"auth",
"server",
"authorized",
"as",
"admin",
"used",
"for",
"auth",
"server",
"cached",
"access"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1510-L1522 | train |
gravitational/teleport | lib/auth/auth_with_roles.go | NewAuthWithRoles | func NewAuthWithRoles(authServer *AuthServer,
checker services.AccessChecker,
user services.User,
sessions session.Service,
alog events.IAuditLog) *AuthWithRoles {
return &AuthWithRoles{
authServer: authServer,
checker: checker,
sessions: sessions,
user: user,
alog: alog,
}
} | go | func NewAuthWithRoles(authServer *AuthServer,
checker services.AccessChecker,
user services.User,
sessions session.Service,
alog events.IAuditLog) *AuthWithRoles {
return &AuthWithRoles{
authServer: authServer,
checker: checker,
sessions: sessions,
user: user,
alog: alog,
}
} | [
"func",
"NewAuthWithRoles",
"(",
"authServer",
"*",
"AuthServer",
",",
"checker",
"services",
".",
"AccessChecker",
",",
"user",
"services",
".",
"User",
",",
"sessions",
"session",
".",
"Service",
",",
"alog",
"events",
".",
"IAuditLog",
")",
"*",
"AuthWithRoles",
"{",
"return",
"&",
"AuthWithRoles",
"{",
"authServer",
":",
"authServer",
",",
"checker",
":",
"checker",
",",
"sessions",
":",
"sessions",
",",
"user",
":",
"user",
",",
"alog",
":",
"alog",
",",
"}",
"\n",
"}"
] | // NewAuthWithRoles creates new auth server with access control | [
"NewAuthWithRoles",
"creates",
"new",
"auth",
"server",
"with",
"access",
"control"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth_with_roles.go#L1525-L1537 | train |
gravitational/teleport | lib/sshutils/scp/local.go | SetChmod | func (l *localFileSystem) SetChmod(path string, mode int) error {
chmode := os.FileMode(mode & int(os.ModePerm))
if err := os.Chmod(path, chmode); err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (l *localFileSystem) SetChmod(path string, mode int) error {
chmode := os.FileMode(mode & int(os.ModePerm))
if err := os.Chmod(path, chmode); err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"l",
"*",
"localFileSystem",
")",
"SetChmod",
"(",
"path",
"string",
",",
"mode",
"int",
")",
"error",
"{",
"chmode",
":=",
"os",
".",
"FileMode",
"(",
"mode",
"&",
"int",
"(",
"os",
".",
"ModePerm",
")",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Chmod",
"(",
"path",
",",
"chmode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetChmod sets file permissions | [
"SetChmod",
"sets",
"file",
"permissions"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L34-L41 | train |
gravitational/teleport | lib/sshutils/scp/local.go | MkDir | func (l *localFileSystem) MkDir(path string, mode int) error {
fileMode := os.FileMode(mode & int(os.ModePerm))
err := os.MkdirAll(path, fileMode)
if err != nil && !os.IsExist(err) {
return trace.ConvertSystemError(err)
}
return nil
} | go | func (l *localFileSystem) MkDir(path string, mode int) error {
fileMode := os.FileMode(mode & int(os.ModePerm))
err := os.MkdirAll(path, fileMode)
if err != nil && !os.IsExist(err) {
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"(",
"l",
"*",
"localFileSystem",
")",
"MkDir",
"(",
"path",
"string",
",",
"mode",
"int",
")",
"error",
"{",
"fileMode",
":=",
"os",
".",
"FileMode",
"(",
"mode",
"&",
"int",
"(",
"os",
".",
"ModePerm",
")",
")",
"\n",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"path",
",",
"fileMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsExist",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // MkDir creates a directory | [
"MkDir",
"creates",
"a",
"directory"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L44-L52 | train |
gravitational/teleport | lib/sshutils/scp/local.go | OpenFile | func (l *localFileSystem) OpenFile(filePath string) (io.ReadCloser, error) {
f, err := os.Open(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | go | func (l *localFileSystem) OpenFile(filePath string) (io.ReadCloser, error) {
f, err := os.Open(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | [
"func",
"(",
"l",
"*",
"localFileSystem",
")",
"OpenFile",
"(",
"filePath",
"string",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // OpenFile opens a file for read operations and returns a Reader | [
"OpenFile",
"opens",
"a",
"file",
"for",
"read",
"operations",
"and",
"returns",
"a",
"Reader"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L60-L67 | train |
gravitational/teleport | lib/sshutils/scp/local.go | GetFileInfo | func (l *localFileSystem) GetFileInfo(filePath string) (FileInfo, error) {
info, err := makeFileInfo(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return info, nil
} | go | func (l *localFileSystem) GetFileInfo(filePath string) (FileInfo, error) {
info, err := makeFileInfo(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return info, nil
} | [
"func",
"(",
"l",
"*",
"localFileSystem",
")",
"GetFileInfo",
"(",
"filePath",
"string",
")",
"(",
"FileInfo",
",",
"error",
")",
"{",
"info",
",",
"err",
":=",
"makeFileInfo",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"info",
",",
"nil",
"\n",
"}"
] | // GetFileInfo returns FileInfo for a given file path | [
"GetFileInfo",
"returns",
"FileInfo",
"for",
"a",
"given",
"file",
"path"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L70-L77 | train |
gravitational/teleport | lib/sshutils/scp/local.go | CreateFile | func (l *localFileSystem) CreateFile(filePath string, length uint64) (io.WriteCloser, error) {
f, err := os.Create(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | go | func (l *localFileSystem) CreateFile(filePath string, length uint64) (io.WriteCloser, error) {
f, err := os.Create(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | [
"func",
"(",
"l",
"*",
"localFileSystem",
")",
"CreateFile",
"(",
"filePath",
"string",
",",
"length",
"uint64",
")",
"(",
"io",
".",
"WriteCloser",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // CreateFile creates a new file and returns a Writer | [
"CreateFile",
"creates",
"a",
"new",
"file",
"and",
"returns",
"a",
"Writer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L80-L87 | train |
gravitational/teleport | lib/sshutils/scp/local.go | ReadDir | func (l *localFileInfo) ReadDir() ([]FileInfo, error) {
f, err := os.Open(l.filePath)
if err != nil {
return nil, trace.Wrap(err)
}
fis, err := f.Readdir(0)
if err != nil {
return nil, trace.Wrap(err)
}
infos := make([]FileInfo, len(fis))
for i := range fis {
fi := fis[i]
info, err := makeFileInfo(filepath.Join(l.GetPath(), fi.Name()))
if err != nil {
return nil, trace.Wrap(err)
}
infos[i] = info
}
return infos, nil
} | go | func (l *localFileInfo) ReadDir() ([]FileInfo, error) {
f, err := os.Open(l.filePath)
if err != nil {
return nil, trace.Wrap(err)
}
fis, err := f.Readdir(0)
if err != nil {
return nil, trace.Wrap(err)
}
infos := make([]FileInfo, len(fis))
for i := range fis {
fi := fis[i]
info, err := makeFileInfo(filepath.Join(l.GetPath(), fi.Name()))
if err != nil {
return nil, trace.Wrap(err)
}
infos[i] = info
}
return infos, nil
} | [
"func",
"(",
"l",
"*",
"localFileInfo",
")",
"ReadDir",
"(",
")",
"(",
"[",
"]",
"FileInfo",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"l",
".",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fis",
",",
"err",
":=",
"f",
".",
"Readdir",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"infos",
":=",
"make",
"(",
"[",
"]",
"FileInfo",
",",
"len",
"(",
"fis",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"fis",
"{",
"fi",
":=",
"fis",
"[",
"i",
"]",
"\n",
"info",
",",
"err",
":=",
"makeFileInfo",
"(",
"filepath",
".",
"Join",
"(",
"l",
".",
"GetPath",
"(",
")",
",",
"fi",
".",
"Name",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"infos",
"[",
"i",
"]",
"=",
"info",
"\n",
"}",
"\n",
"return",
"infos",
",",
"nil",
"\n",
"}"
] | // ReadDir returns all files in this directory | [
"ReadDir",
"returns",
"all",
"files",
"in",
"this",
"directory"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L128-L150 | train |
gravitational/teleport | lib/sshutils/scp/local.go | GetModePerm | func (l *localFileInfo) GetModePerm() os.FileMode {
return l.fileInfo.Mode() & os.ModePerm
} | go | func (l *localFileInfo) GetModePerm() os.FileMode {
return l.fileInfo.Mode() & os.ModePerm
} | [
"func",
"(",
"l",
"*",
"localFileInfo",
")",
"GetModePerm",
"(",
")",
"os",
".",
"FileMode",
"{",
"return",
"l",
".",
"fileInfo",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModePerm",
"\n",
"}"
] | // GetModePerm returns file permissions | [
"GetModePerm",
"returns",
"file",
"permissions"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/local.go#L153-L155 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | Close | func (s *remoteSite) Close() error {
s.Lock()
defer s.Unlock()
s.cancel()
for i := range s.connections {
s.connections[i].Close()
}
s.connections = []*remoteConn{}
return nil
} | go | func (s *remoteSite) Close() error {
s.Lock()
defer s.Unlock()
s.cancel()
for i := range s.connections {
s.connections[i].Close()
}
s.connections = []*remoteConn{}
return nil
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"cancel",
"(",
")",
"\n",
"for",
"i",
":=",
"range",
"s",
".",
"connections",
"{",
"s",
".",
"connections",
"[",
"i",
"]",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"s",
".",
"connections",
"=",
"[",
"]",
"*",
"remoteConn",
"{",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Clos closes remote cluster connections | [
"Clos",
"closes",
"remote",
"cluster",
"connections"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L158-L168 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | nextConn | func (s *remoteSite) nextConn() (*remoteConn, error) {
s.Lock()
defer s.Unlock()
s.removeInvalidConns()
for i := 0; i < len(s.connections); i++ {
s.lastUsed = (s.lastUsed + 1) % len(s.connections)
remoteConn := s.connections[s.lastUsed]
// connection could have been initated, but agent
// on the other side is not ready yet.
// Proxy assumes that connection is ready to serve when
// it has received a first heartbeat, otherwise
// it could attempt to use it before the agent
// had a chance to start handling connection requests,
// what could lead to proxy marking the connection
// as invalid without a good reason.
if remoteConn.isReady() {
return remoteConn, nil
}
}
return nil, trace.NotFound("%v is offline: no active tunnels to %v found", s.GetName(), s.srv.ClusterName)
} | go | func (s *remoteSite) nextConn() (*remoteConn, error) {
s.Lock()
defer s.Unlock()
s.removeInvalidConns()
for i := 0; i < len(s.connections); i++ {
s.lastUsed = (s.lastUsed + 1) % len(s.connections)
remoteConn := s.connections[s.lastUsed]
// connection could have been initated, but agent
// on the other side is not ready yet.
// Proxy assumes that connection is ready to serve when
// it has received a first heartbeat, otherwise
// it could attempt to use it before the agent
// had a chance to start handling connection requests,
// what could lead to proxy marking the connection
// as invalid without a good reason.
if remoteConn.isReady() {
return remoteConn, nil
}
}
return nil, trace.NotFound("%v is offline: no active tunnels to %v found", s.GetName(), s.srv.ClusterName)
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"nextConn",
"(",
")",
"(",
"*",
"remoteConn",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"removeInvalidConns",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"s",
".",
"connections",
")",
";",
"i",
"++",
"{",
"s",
".",
"lastUsed",
"=",
"(",
"s",
".",
"lastUsed",
"+",
"1",
")",
"%",
"len",
"(",
"s",
".",
"connections",
")",
"\n",
"remoteConn",
":=",
"s",
".",
"connections",
"[",
"s",
".",
"lastUsed",
"]",
"\n",
"if",
"remoteConn",
".",
"isReady",
"(",
")",
"{",
"return",
"remoteConn",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"%v is offline: no active tunnels to %v found\"",
",",
"s",
".",
"GetName",
"(",
")",
",",
"s",
".",
"srv",
".",
"ClusterName",
")",
"\n",
"}"
] | // nextConn returns next connection that is ready
// and has not been marked as invalid
// it will close connections marked as invalid | [
"nextConn",
"returns",
"next",
"connection",
"that",
"is",
"ready",
"and",
"has",
"not",
"been",
"marked",
"as",
"invalid",
"it",
"will",
"close",
"connections",
"marked",
"as",
"invalid"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L173-L196 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | removeInvalidConns | func (s *remoteSite) removeInvalidConns() {
// for first pass, do nothing if no connections are marked
count := 0
for _, conn := range s.connections {
if conn.isInvalid() {
count++
}
}
if count == 0 {
return
}
s.lastUsed = 0
conns := make([]*remoteConn, 0, len(s.connections)-count)
for i := range s.connections {
if !s.connections[i].isInvalid() {
conns = append(conns, s.connections[i])
} else {
go s.connections[i].Close()
}
}
s.connections = conns
} | go | func (s *remoteSite) removeInvalidConns() {
// for first pass, do nothing if no connections are marked
count := 0
for _, conn := range s.connections {
if conn.isInvalid() {
count++
}
}
if count == 0 {
return
}
s.lastUsed = 0
conns := make([]*remoteConn, 0, len(s.connections)-count)
for i := range s.connections {
if !s.connections[i].isInvalid() {
conns = append(conns, s.connections[i])
} else {
go s.connections[i].Close()
}
}
s.connections = conns
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"removeInvalidConns",
"(",
")",
"{",
"count",
":=",
"0",
"\n",
"for",
"_",
",",
"conn",
":=",
"range",
"s",
".",
"connections",
"{",
"if",
"conn",
".",
"isInvalid",
"(",
")",
"{",
"count",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"count",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"s",
".",
"lastUsed",
"=",
"0",
"\n",
"conns",
":=",
"make",
"(",
"[",
"]",
"*",
"remoteConn",
",",
"0",
",",
"len",
"(",
"s",
".",
"connections",
")",
"-",
"count",
")",
"\n",
"for",
"i",
":=",
"range",
"s",
".",
"connections",
"{",
"if",
"!",
"s",
".",
"connections",
"[",
"i",
"]",
".",
"isInvalid",
"(",
")",
"{",
"conns",
"=",
"append",
"(",
"conns",
",",
"s",
".",
"connections",
"[",
"i",
"]",
")",
"\n",
"}",
"else",
"{",
"go",
"s",
".",
"connections",
"[",
"i",
"]",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"s",
".",
"connections",
"=",
"conns",
"\n",
"}"
] | // removeInvalidConns removes connections marked as invalid,
// it should be called only under write lock | [
"removeInvalidConns",
"removes",
"connections",
"marked",
"as",
"invalid",
"it",
"should",
"be",
"called",
"only",
"under",
"write",
"lock"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L200-L221 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | addConn | func (s *remoteSite) addConn(conn net.Conn, sconn ssh.Conn) (*remoteConn, error) {
s.Lock()
defer s.Unlock()
cn, err := s.localAccessPoint.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
rconn := newRemoteConn(&connConfig{
conn: conn,
sconn: sconn,
accessPoint: s.localAccessPoint,
tunnelID: cn.GetClusterName(),
tunnelType: string(services.ProxyTunnel),
proxyName: s.connInfo.GetProxyName(),
clusterName: s.domainName,
})
s.connections = append(s.connections, rconn)
s.lastUsed = 0
return rconn, nil
} | go | func (s *remoteSite) addConn(conn net.Conn, sconn ssh.Conn) (*remoteConn, error) {
s.Lock()
defer s.Unlock()
cn, err := s.localAccessPoint.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
rconn := newRemoteConn(&connConfig{
conn: conn,
sconn: sconn,
accessPoint: s.localAccessPoint,
tunnelID: cn.GetClusterName(),
tunnelType: string(services.ProxyTunnel),
proxyName: s.connInfo.GetProxyName(),
clusterName: s.domainName,
})
s.connections = append(s.connections, rconn)
s.lastUsed = 0
return rconn, nil
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"addConn",
"(",
"conn",
"net",
".",
"Conn",
",",
"sconn",
"ssh",
".",
"Conn",
")",
"(",
"*",
"remoteConn",
",",
"error",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"cn",
",",
"err",
":=",
"s",
".",
"localAccessPoint",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"rconn",
":=",
"newRemoteConn",
"(",
"&",
"connConfig",
"{",
"conn",
":",
"conn",
",",
"sconn",
":",
"sconn",
",",
"accessPoint",
":",
"s",
".",
"localAccessPoint",
",",
"tunnelID",
":",
"cn",
".",
"GetClusterName",
"(",
")",
",",
"tunnelType",
":",
"string",
"(",
"services",
".",
"ProxyTunnel",
")",
",",
"proxyName",
":",
"s",
".",
"connInfo",
".",
"GetProxyName",
"(",
")",
",",
"clusterName",
":",
"s",
".",
"domainName",
",",
"}",
")",
"\n",
"s",
".",
"connections",
"=",
"append",
"(",
"s",
".",
"connections",
",",
"rconn",
")",
"\n",
"s",
".",
"lastUsed",
"=",
"0",
"\n",
"return",
"rconn",
",",
"nil",
"\n",
"}"
] | // addConn helper adds a new active remote cluster connection to the list
// of such connections | [
"addConn",
"helper",
"adds",
"a",
"new",
"active",
"remote",
"cluster",
"connection",
"to",
"the",
"list",
"of",
"such",
"connections"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L225-L247 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | deleteConnectionRecord | func (s *remoteSite) deleteConnectionRecord() {
s.localAccessPoint.DeleteTunnelConnection(s.connInfo.GetClusterName(), s.connInfo.GetName())
} | go | func (s *remoteSite) deleteConnectionRecord() {
s.localAccessPoint.DeleteTunnelConnection(s.connInfo.GetClusterName(), s.connInfo.GetName())
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"deleteConnectionRecord",
"(",
")",
"{",
"s",
".",
"localAccessPoint",
".",
"DeleteTunnelConnection",
"(",
"s",
".",
"connInfo",
".",
"GetClusterName",
"(",
")",
",",
"s",
".",
"connInfo",
".",
"GetName",
"(",
")",
")",
"\n",
"}"
] | // deleteConnectionRecord deletes connection record to let know peer proxies
// that this node lost the connection and needs to be discovered | [
"deleteConnectionRecord",
"deletes",
"connection",
"record",
"to",
"let",
"know",
"peer",
"proxies",
"that",
"this",
"node",
"lost",
"the",
"connection",
"and",
"needs",
"to",
"be",
"discovered"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L291-L293 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | handleHeartbeat | func (s *remoteSite) handleHeartbeat(conn *remoteConn, ch ssh.Channel, reqC <-chan *ssh.Request) {
defer func() {
s.Infof("Cluster connection closed.")
conn.Close()
}()
for {
select {
case <-s.ctx.Done():
s.Infof("closing")
return
case req := <-reqC:
if req == nil {
s.Infof("Cluster agent disconnected.")
conn.markInvalid(trace.ConnectionProblem(nil, "agent disconnected"))
if !s.hasValidConnections() {
s.Debugf("Deleting connection record.")
s.deleteConnectionRecord()
}
return
}
var timeSent time.Time
var roundtrip time.Duration
if req.Payload != nil {
if err := timeSent.UnmarshalText(req.Payload); err == nil {
roundtrip = s.srv.Clock.Now().Sub(timeSent)
}
}
if roundtrip != 0 {
s.WithFields(log.Fields{"latency": roundtrip}).Debugf("ping <- %v", conn.conn.RemoteAddr())
} else {
s.Debugf("Ping <- %v.", conn.conn.RemoteAddr())
}
tm := time.Now().UTC()
conn.setLastHeartbeat(tm)
go s.registerHeartbeat(tm)
// since we block on select, time.After is re-created everytime we process a request.
case <-time.After(defaults.ReverseTunnelOfflineThreshold):
conn.markInvalid(trace.ConnectionProblem(nil, "no heartbeats for %v", defaults.ReverseTunnelOfflineThreshold))
}
}
} | go | func (s *remoteSite) handleHeartbeat(conn *remoteConn, ch ssh.Channel, reqC <-chan *ssh.Request) {
defer func() {
s.Infof("Cluster connection closed.")
conn.Close()
}()
for {
select {
case <-s.ctx.Done():
s.Infof("closing")
return
case req := <-reqC:
if req == nil {
s.Infof("Cluster agent disconnected.")
conn.markInvalid(trace.ConnectionProblem(nil, "agent disconnected"))
if !s.hasValidConnections() {
s.Debugf("Deleting connection record.")
s.deleteConnectionRecord()
}
return
}
var timeSent time.Time
var roundtrip time.Duration
if req.Payload != nil {
if err := timeSent.UnmarshalText(req.Payload); err == nil {
roundtrip = s.srv.Clock.Now().Sub(timeSent)
}
}
if roundtrip != 0 {
s.WithFields(log.Fields{"latency": roundtrip}).Debugf("ping <- %v", conn.conn.RemoteAddr())
} else {
s.Debugf("Ping <- %v.", conn.conn.RemoteAddr())
}
tm := time.Now().UTC()
conn.setLastHeartbeat(tm)
go s.registerHeartbeat(tm)
// since we block on select, time.After is re-created everytime we process a request.
case <-time.After(defaults.ReverseTunnelOfflineThreshold):
conn.markInvalid(trace.ConnectionProblem(nil, "no heartbeats for %v", defaults.ReverseTunnelOfflineThreshold))
}
}
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"handleHeartbeat",
"(",
"conn",
"*",
"remoteConn",
",",
"ch",
"ssh",
".",
"Channel",
",",
"reqC",
"<-",
"chan",
"*",
"ssh",
".",
"Request",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"s",
".",
"Infof",
"(",
"\"Cluster connection closed.\"",
")",
"\n",
"conn",
".",
"Close",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"s",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"s",
".",
"Infof",
"(",
"\"closing\"",
")",
"\n",
"return",
"\n",
"case",
"req",
":=",
"<-",
"reqC",
":",
"if",
"req",
"==",
"nil",
"{",
"s",
".",
"Infof",
"(",
"\"Cluster agent disconnected.\"",
")",
"\n",
"conn",
".",
"markInvalid",
"(",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"agent disconnected\"",
")",
")",
"\n",
"if",
"!",
"s",
".",
"hasValidConnections",
"(",
")",
"{",
"s",
".",
"Debugf",
"(",
"\"Deleting connection record.\"",
")",
"\n",
"s",
".",
"deleteConnectionRecord",
"(",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"timeSent",
"time",
".",
"Time",
"\n",
"var",
"roundtrip",
"time",
".",
"Duration",
"\n",
"if",
"req",
".",
"Payload",
"!=",
"nil",
"{",
"if",
"err",
":=",
"timeSent",
".",
"UnmarshalText",
"(",
"req",
".",
"Payload",
")",
";",
"err",
"==",
"nil",
"{",
"roundtrip",
"=",
"s",
".",
"srv",
".",
"Clock",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"timeSent",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"roundtrip",
"!=",
"0",
"{",
"s",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"latency\"",
":",
"roundtrip",
"}",
")",
".",
"Debugf",
"(",
"\"ping <- %v\"",
",",
"conn",
".",
"conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"Debugf",
"(",
"\"Ping <- %v.\"",
",",
"conn",
".",
"conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\n",
"tm",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"conn",
".",
"setLastHeartbeat",
"(",
"tm",
")",
"\n",
"go",
"s",
".",
"registerHeartbeat",
"(",
"tm",
")",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"defaults",
".",
"ReverseTunnelOfflineThreshold",
")",
":",
"conn",
".",
"markInvalid",
"(",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"no heartbeats for %v\"",
",",
"defaults",
".",
"ReverseTunnelOfflineThreshold",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // handleHearbeat receives heartbeat messages from the connected agent
// if the agent has missed several heartbeats in a row, Proxy marks
// the connection as invalid. | [
"handleHearbeat",
"receives",
"heartbeat",
"messages",
"from",
"the",
"connected",
"agent",
"if",
"the",
"agent",
"has",
"missed",
"several",
"heartbeats",
"in",
"a",
"row",
"Proxy",
"marks",
"the",
"connection",
"as",
"invalid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L298-L338 | train |
gravitational/teleport | lib/reversetunnel/remotesite.go | updateCertAuthorities | func (s *remoteSite) updateCertAuthorities() error {
// update main cluster cert authorities on the remote side
// remote side makes sure that only relevant fields
// are updated
hostCA, err := s.localClient.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: s.srv.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = s.remoteClient.RotateExternalCertAuthority(hostCA)
if err != nil {
return trace.Wrap(err)
}
userCA, err := s.localClient.GetCertAuthority(services.CertAuthID{
Type: services.UserCA,
DomainName: s.srv.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = s.remoteClient.RotateExternalCertAuthority(userCA)
if err != nil {
return trace.Wrap(err)
}
// update remote cluster's host cert authoritiy on a local cluster
// local proxy is authorized to perform this operation only for
// host authorities of remote clusters.
remoteCA, err := s.remoteClient.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: s.domainName,
}, false)
if err != nil {
return trace.Wrap(err)
}
if remoteCA.GetClusterName() != s.domainName {
return trace.BadParameter(
"remote cluster sent different cluster name %v instead of expected one %v",
remoteCA.GetClusterName(), s.domainName)
}
err = s.localClient.UpsertCertAuthority(remoteCA)
if err != nil {
return trace.Wrap(err)
}
return s.compareAndSwapCertAuthority(remoteCA)
} | go | func (s *remoteSite) updateCertAuthorities() error {
// update main cluster cert authorities on the remote side
// remote side makes sure that only relevant fields
// are updated
hostCA, err := s.localClient.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: s.srv.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = s.remoteClient.RotateExternalCertAuthority(hostCA)
if err != nil {
return trace.Wrap(err)
}
userCA, err := s.localClient.GetCertAuthority(services.CertAuthID{
Type: services.UserCA,
DomainName: s.srv.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = s.remoteClient.RotateExternalCertAuthority(userCA)
if err != nil {
return trace.Wrap(err)
}
// update remote cluster's host cert authoritiy on a local cluster
// local proxy is authorized to perform this operation only for
// host authorities of remote clusters.
remoteCA, err := s.remoteClient.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: s.domainName,
}, false)
if err != nil {
return trace.Wrap(err)
}
if remoteCA.GetClusterName() != s.domainName {
return trace.BadParameter(
"remote cluster sent different cluster name %v instead of expected one %v",
remoteCA.GetClusterName(), s.domainName)
}
err = s.localClient.UpsertCertAuthority(remoteCA)
if err != nil {
return trace.Wrap(err)
}
return s.compareAndSwapCertAuthority(remoteCA)
} | [
"func",
"(",
"s",
"*",
"remoteSite",
")",
"updateCertAuthorities",
"(",
")",
"error",
"{",
"hostCA",
",",
"err",
":=",
"s",
".",
"localClient",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"HostCA",
",",
"DomainName",
":",
"s",
".",
"srv",
".",
"ClusterName",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"remoteClient",
".",
"RotateExternalCertAuthority",
"(",
"hostCA",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"userCA",
",",
"err",
":=",
"s",
".",
"localClient",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"UserCA",
",",
"DomainName",
":",
"s",
".",
"srv",
".",
"ClusterName",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"remoteClient",
".",
"RotateExternalCertAuthority",
"(",
"userCA",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"remoteCA",
",",
"err",
":=",
"s",
".",
"remoteClient",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"HostCA",
",",
"DomainName",
":",
"s",
".",
"domainName",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"remoteCA",
".",
"GetClusterName",
"(",
")",
"!=",
"s",
".",
"domainName",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"remote cluster sent different cluster name %v instead of expected one %v\"",
",",
"remoteCA",
".",
"GetClusterName",
"(",
")",
",",
"s",
".",
"domainName",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"localClient",
".",
"UpsertCertAuthority",
"(",
"remoteCA",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"compareAndSwapCertAuthority",
"(",
"remoteCA",
")",
"\n",
"}"
] | // updateCertAuthorities updates local and remote cert authorities | [
"updateCertAuthorities",
"updates",
"local",
"and",
"remote",
"cert",
"authorities"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/remotesite.go#L371-L421 | train |
gravitational/teleport | lib/backend/report.go | CheckAndSetDefaults | func (r *ReporterConfig) CheckAndSetDefaults() error {
if r.Backend == nil {
return trace.BadParameter("missing parameter Backend")
}
if r.Component == "" {
r.Component = teleport.ComponentBackend
}
return nil
} | go | func (r *ReporterConfig) CheckAndSetDefaults() error {
if r.Backend == nil {
return trace.BadParameter("missing parameter Backend")
}
if r.Component == "" {
r.Component = teleport.ComponentBackend
}
return nil
} | [
"func",
"(",
"r",
"*",
"ReporterConfig",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"r",
".",
"Backend",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Backend\"",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Component",
"==",
"\"\"",
"{",
"r",
".",
"Component",
"=",
"teleport",
".",
"ComponentBackend",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets | [
"CheckAndSetDefaults",
"checks",
"and",
"sets"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/report.go#L44-L52 | train |
gravitational/teleport | lib/backend/report.go | NewReporter | func NewReporter(cfg ReporterConfig) (*Reporter, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
r := &Reporter{
ReporterConfig: cfg,
}
return r, nil
} | go | func NewReporter(cfg ReporterConfig) (*Reporter, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
r := &Reporter{
ReporterConfig: cfg,
}
return r, nil
} | [
"func",
"NewReporter",
"(",
"cfg",
"ReporterConfig",
")",
"(",
"*",
"Reporter",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"r",
":=",
"&",
"Reporter",
"{",
"ReporterConfig",
":",
"cfg",
",",
"}",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
] | // NewReporter returns a new Reporter. | [
"NewReporter",
"returns",
"a",
"new",
"Reporter",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/report.go#L62-L70 | train |
gravitational/teleport | lib/backend/report.go | trackRequest | func (s *Reporter) trackRequest(opType OpType, key []byte, endKey []byte) {
if !s.TrackTopRequests {
return
}
if len(key) == 0 {
return
}
// take just the first two parts, otherwise too many distinct requests
// can end up in the map
parts := bytes.Split(key, []byte{Separator})
if len(parts) > 3 {
parts = parts[:3]
}
rangeSuffix := teleport.TagFalse
if len(endKey) != 0 {
// Range denotes range queries in stat entry
rangeSuffix = teleport.TagTrue
}
counter, err := requests.GetMetricWithLabelValues(s.Component, string(bytes.Join(parts, []byte{Separator})), rangeSuffix)
if err != nil {
log.Warningf("Failed to get counter: %v", err)
return
}
counter.Inc()
} | go | func (s *Reporter) trackRequest(opType OpType, key []byte, endKey []byte) {
if !s.TrackTopRequests {
return
}
if len(key) == 0 {
return
}
// take just the first two parts, otherwise too many distinct requests
// can end up in the map
parts := bytes.Split(key, []byte{Separator})
if len(parts) > 3 {
parts = parts[:3]
}
rangeSuffix := teleport.TagFalse
if len(endKey) != 0 {
// Range denotes range queries in stat entry
rangeSuffix = teleport.TagTrue
}
counter, err := requests.GetMetricWithLabelValues(s.Component, string(bytes.Join(parts, []byte{Separator})), rangeSuffix)
if err != nil {
log.Warningf("Failed to get counter: %v", err)
return
}
counter.Inc()
} | [
"func",
"(",
"s",
"*",
"Reporter",
")",
"trackRequest",
"(",
"opType",
"OpType",
",",
"key",
"[",
"]",
"byte",
",",
"endKey",
"[",
"]",
"byte",
")",
"{",
"if",
"!",
"s",
".",
"TrackTopRequests",
"{",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"key",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"parts",
":=",
"bytes",
".",
"Split",
"(",
"key",
",",
"[",
"]",
"byte",
"{",
"Separator",
"}",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
">",
"3",
"{",
"parts",
"=",
"parts",
"[",
":",
"3",
"]",
"\n",
"}",
"\n",
"rangeSuffix",
":=",
"teleport",
".",
"TagFalse",
"\n",
"if",
"len",
"(",
"endKey",
")",
"!=",
"0",
"{",
"rangeSuffix",
"=",
"teleport",
".",
"TagTrue",
"\n",
"}",
"\n",
"counter",
",",
"err",
":=",
"requests",
".",
"GetMetricWithLabelValues",
"(",
"s",
".",
"Component",
",",
"string",
"(",
"bytes",
".",
"Join",
"(",
"parts",
",",
"[",
"]",
"byte",
"{",
"Separator",
"}",
")",
")",
",",
"rangeSuffix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"Failed to get counter: %v\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"counter",
".",
"Inc",
"(",
")",
"\n",
"}"
] | // trackRequests tracks top requests, endKey is supplied for ranges | [
"trackRequests",
"tracks",
"top",
"requests",
"endKey",
"is",
"supplied",
"for",
"ranges"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/report.go#L220-L244 | train |
gravitational/teleport | lib/backend/report.go | NewReporterWatcher | func NewReporterWatcher(ctx context.Context, component string, w Watcher) *ReporterWatcher {
rw := &ReporterWatcher{
Watcher: w,
Component: component,
}
go rw.watch(ctx)
return rw
} | go | func NewReporterWatcher(ctx context.Context, component string, w Watcher) *ReporterWatcher {
rw := &ReporterWatcher{
Watcher: w,
Component: component,
}
go rw.watch(ctx)
return rw
} | [
"func",
"NewReporterWatcher",
"(",
"ctx",
"context",
".",
"Context",
",",
"component",
"string",
",",
"w",
"Watcher",
")",
"*",
"ReporterWatcher",
"{",
"rw",
":=",
"&",
"ReporterWatcher",
"{",
"Watcher",
":",
"w",
",",
"Component",
":",
"component",
",",
"}",
"\n",
"go",
"rw",
".",
"watch",
"(",
"ctx",
")",
"\n",
"return",
"rw",
"\n",
"}"
] | // NewReporterWatcher creates new reporter watcher instance | [
"NewReporterWatcher",
"creates",
"new",
"reporter",
"watcher",
"instance"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/report.go#L254-L261 | train |
gravitational/teleport | lib/asciitable/table.go | MakeTable | func MakeTable(headers []string) Table {
t := MakeHeadlessTable(len(headers))
for i := range t.columns {
t.columns[i].title = headers[i]
t.columns[i].width = len(headers[i])
}
return t
} | go | func MakeTable(headers []string) Table {
t := MakeHeadlessTable(len(headers))
for i := range t.columns {
t.columns[i].title = headers[i]
t.columns[i].width = len(headers[i])
}
return t
} | [
"func",
"MakeTable",
"(",
"headers",
"[",
"]",
"string",
")",
"Table",
"{",
"t",
":=",
"MakeHeadlessTable",
"(",
"len",
"(",
"headers",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"t",
".",
"columns",
"{",
"t",
".",
"columns",
"[",
"i",
"]",
".",
"title",
"=",
"headers",
"[",
"i",
"]",
"\n",
"t",
".",
"columns",
"[",
"i",
"]",
".",
"width",
"=",
"len",
"(",
"headers",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] | // MakeTable creates a new instance of the table with given column names. | [
"MakeTable",
"creates",
"a",
"new",
"instance",
"of",
"the",
"table",
"with",
"given",
"column",
"names",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/asciitable/table.go#L42-L49 | train |
gravitational/teleport | lib/asciitable/table.go | MakeHeadlessTable | func MakeHeadlessTable(columnCount int) Table {
return Table{
columns: make([]column, columnCount),
rows: make([][]string, 0),
}
} | go | func MakeHeadlessTable(columnCount int) Table {
return Table{
columns: make([]column, columnCount),
rows: make([][]string, 0),
}
} | [
"func",
"MakeHeadlessTable",
"(",
"columnCount",
"int",
")",
"Table",
"{",
"return",
"Table",
"{",
"columns",
":",
"make",
"(",
"[",
"]",
"column",
",",
"columnCount",
")",
",",
"rows",
":",
"make",
"(",
"[",
"]",
"[",
"]",
"string",
",",
"0",
")",
",",
"}",
"\n",
"}"
] | // MakeTable creates a new instance of the table without any column names.
// The number of columns is required. | [
"MakeTable",
"creates",
"a",
"new",
"instance",
"of",
"the",
"table",
"without",
"any",
"column",
"names",
".",
"The",
"number",
"of",
"columns",
"is",
"required",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/asciitable/table.go#L53-L58 | train |
gravitational/teleport | lib/asciitable/table.go | AddRow | func (t *Table) AddRow(row []string) {
limit := min(len(row), len(t.columns))
for i := 0; i < limit; i++ {
cellWidth := len(row[i])
t.columns[i].width = max(cellWidth, t.columns[i].width)
}
t.rows = append(t.rows, row[:limit])
} | go | func (t *Table) AddRow(row []string) {
limit := min(len(row), len(t.columns))
for i := 0; i < limit; i++ {
cellWidth := len(row[i])
t.columns[i].width = max(cellWidth, t.columns[i].width)
}
t.rows = append(t.rows, row[:limit])
} | [
"func",
"(",
"t",
"*",
"Table",
")",
"AddRow",
"(",
"row",
"[",
"]",
"string",
")",
"{",
"limit",
":=",
"min",
"(",
"len",
"(",
"row",
")",
",",
"len",
"(",
"t",
".",
"columns",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"limit",
";",
"i",
"++",
"{",
"cellWidth",
":=",
"len",
"(",
"row",
"[",
"i",
"]",
")",
"\n",
"t",
".",
"columns",
"[",
"i",
"]",
".",
"width",
"=",
"max",
"(",
"cellWidth",
",",
"t",
".",
"columns",
"[",
"i",
"]",
".",
"width",
")",
"\n",
"}",
"\n",
"t",
".",
"rows",
"=",
"append",
"(",
"t",
".",
"rows",
",",
"row",
"[",
":",
"limit",
"]",
")",
"\n",
"}"
] | // AddRow adds a row of cells to the table. | [
"AddRow",
"adds",
"a",
"row",
"of",
"cells",
"to",
"the",
"table",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/asciitable/table.go#L61-L68 | train |
gravitational/teleport | lib/asciitable/table.go | IsHeadless | func (t *Table) IsHeadless() bool {
total := 0
for i := range t.columns {
total += len(t.columns[i].title)
}
return total == 0
} | go | func (t *Table) IsHeadless() bool {
total := 0
for i := range t.columns {
total += len(t.columns[i].title)
}
return total == 0
} | [
"func",
"(",
"t",
"*",
"Table",
")",
"IsHeadless",
"(",
")",
"bool",
"{",
"total",
":=",
"0",
"\n",
"for",
"i",
":=",
"range",
"t",
".",
"columns",
"{",
"total",
"+=",
"len",
"(",
"t",
".",
"columns",
"[",
"i",
"]",
".",
"title",
")",
"\n",
"}",
"\n",
"return",
"total",
"==",
"0",
"\n",
"}"
] | // IsHeadless returns true if none of the table title cells contains any text. | [
"IsHeadless",
"returns",
"true",
"if",
"none",
"of",
"the",
"table",
"title",
"cells",
"contains",
"any",
"text",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/asciitable/table.go#L104-L110 | train |
gravitational/teleport | lib/utils/uri.go | ParseSessionsURI | func ParseSessionsURI(in string) (*url.URL, error) {
if in == "" {
return nil, trace.BadParameter("uri is empty")
}
u, err := url.Parse(in)
if err != nil {
return nil, trace.BadParameter("failed to parse URI %q: %v", in, err)
}
if u.Scheme == "" {
u.Scheme = teleport.SchemeFile
}
return u, nil
} | go | func ParseSessionsURI(in string) (*url.URL, error) {
if in == "" {
return nil, trace.BadParameter("uri is empty")
}
u, err := url.Parse(in)
if err != nil {
return nil, trace.BadParameter("failed to parse URI %q: %v", in, err)
}
if u.Scheme == "" {
u.Scheme = teleport.SchemeFile
}
return u, nil
} | [
"func",
"ParseSessionsURI",
"(",
"in",
"string",
")",
"(",
"*",
"url",
".",
"URL",
",",
"error",
")",
"{",
"if",
"in",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"uri is empty\"",
")",
"\n",
"}",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"in",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse URI %q: %v\"",
",",
"in",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Scheme",
"==",
"\"\"",
"{",
"u",
".",
"Scheme",
"=",
"teleport",
".",
"SchemeFile",
"\n",
"}",
"\n",
"return",
"u",
",",
"nil",
"\n",
"}"
] | // ParseSessionsURI parses uri per convention of session upload URIs
// file is a default scheme | [
"ParseSessionsURI",
"parses",
"uri",
"per",
"convention",
"of",
"session",
"upload",
"URIs",
"file",
"is",
"a",
"default",
"scheme"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/uri.go#L28-L40 | train |
gravitational/teleport | lib/utils/cli.go | GetIterations | func GetIterations() int {
out := os.Getenv(teleport.IterationsEnvVar)
if out == "" {
return 1
}
iter, err := strconv.Atoi(out)
if err != nil {
panic(err)
}
log.Debugf("Starting tests with %v iterations.", iter)
return iter
} | go | func GetIterations() int {
out := os.Getenv(teleport.IterationsEnvVar)
if out == "" {
return 1
}
iter, err := strconv.Atoi(out)
if err != nil {
panic(err)
}
log.Debugf("Starting tests with %v iterations.", iter)
return iter
} | [
"func",
"GetIterations",
"(",
")",
"int",
"{",
"out",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"IterationsEnvVar",
")",
"\n",
"if",
"out",
"==",
"\"\"",
"{",
"return",
"1",
"\n",
"}",
"\n",
"iter",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Starting tests with %v iterations.\"",
",",
"iter",
")",
"\n",
"return",
"iter",
"\n",
"}"
] | // GetIterations provides a simple way to add iterations to the test
// by setting environment variable "ITERATIONS", by default it returns 1 | [
"GetIterations",
"provides",
"a",
"simple",
"way",
"to",
"add",
"iterations",
"to",
"the",
"test",
"by",
"setting",
"environment",
"variable",
"ITERATIONS",
"by",
"default",
"it",
"returns",
"1"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/cli.go#L103-L114 | train |
gravitational/teleport | lib/utils/cli.go | UserMessageFromError | func UserMessageFromError(err error) string {
// untrusted cert?
switch innerError := trace.Unwrap(err).(type) {
case x509.HostnameError:
return fmt.Sprintf("Cannot establish https connection to %s:\n%s\n%s\n",
innerError.Host,
innerError.Error(),
"try a different hostname for --proxy or specify --insecure flag if you know what you're doing.")
case x509.UnknownAuthorityError:
return `WARNING:
The proxy you are connecting to has presented a certificate signed by a
unknown authority. This is most likely due to either being presented
with a self-signed certificate or the certificate was truly signed by an
authority not known to the client.
If you know the certificate is self-signed and would like to ignore this
error use the --insecure flag.
If you have your own certificate authority that you would like to use to
validate the certificate chain presented by the proxy, set the
SSL_CERT_FILE and SSL_CERT_DIR environment variables respectively and try
again.
If you think something malicious may be occurring, contact your Teleport
system administrator to resolve this issue.
`
case x509.CertificateInvalidError:
return fmt.Sprintf(`WARNING:
The certificate presented by the proxy is invalid: %v.
Contact your Teleport system administrator to resolve this issue.`, innerError)
}
if log.GetLevel() == log.DebugLevel {
return trace.DebugReport(err)
}
if err != nil {
// If the error is a trace error, check if it has a user message embedded in
// it. If a user message is embedded in it, print the user message and the
// original error. Otherwise return the original with a generic "A fatal
// error occurred" message.
if er, ok := err.(*trace.TraceErr); ok {
if er.Message != "" {
return fmt.Sprintf("error: %v", EscapeControl(er.Message))
}
}
return fmt.Sprintf("error: %v", EscapeControl(err.Error()))
}
return ""
} | go | func UserMessageFromError(err error) string {
// untrusted cert?
switch innerError := trace.Unwrap(err).(type) {
case x509.HostnameError:
return fmt.Sprintf("Cannot establish https connection to %s:\n%s\n%s\n",
innerError.Host,
innerError.Error(),
"try a different hostname for --proxy or specify --insecure flag if you know what you're doing.")
case x509.UnknownAuthorityError:
return `WARNING:
The proxy you are connecting to has presented a certificate signed by a
unknown authority. This is most likely due to either being presented
with a self-signed certificate or the certificate was truly signed by an
authority not known to the client.
If you know the certificate is self-signed and would like to ignore this
error use the --insecure flag.
If you have your own certificate authority that you would like to use to
validate the certificate chain presented by the proxy, set the
SSL_CERT_FILE and SSL_CERT_DIR environment variables respectively and try
again.
If you think something malicious may be occurring, contact your Teleport
system administrator to resolve this issue.
`
case x509.CertificateInvalidError:
return fmt.Sprintf(`WARNING:
The certificate presented by the proxy is invalid: %v.
Contact your Teleport system administrator to resolve this issue.`, innerError)
}
if log.GetLevel() == log.DebugLevel {
return trace.DebugReport(err)
}
if err != nil {
// If the error is a trace error, check if it has a user message embedded in
// it. If a user message is embedded in it, print the user message and the
// original error. Otherwise return the original with a generic "A fatal
// error occurred" message.
if er, ok := err.(*trace.TraceErr); ok {
if er.Message != "" {
return fmt.Sprintf("error: %v", EscapeControl(er.Message))
}
}
return fmt.Sprintf("error: %v", EscapeControl(err.Error()))
}
return ""
} | [
"func",
"UserMessageFromError",
"(",
"err",
"error",
")",
"string",
"{",
"switch",
"innerError",
":=",
"trace",
".",
"Unwrap",
"(",
"err",
")",
".",
"(",
"type",
")",
"{",
"case",
"x509",
".",
"HostnameError",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"Cannot establish https connection to %s:\\n%s\\n%s\\n\"",
",",
"\\n",
",",
"\\n",
",",
"\\n",
")",
"\n",
"innerError",
".",
"Host",
"innerError",
".",
"Error",
"(",
")",
"}",
"\n",
"\"try a different hostname for --proxy or specify --insecure flag if you know what you're doing.\"",
"\n",
"case",
"x509",
".",
"UnknownAuthorityError",
":",
"return",
"`WARNING: The proxy you are connecting to has presented a certificate signed by a unknown authority. This is most likely due to either being presented with a self-signed certificate or the certificate was truly signed by an authority not known to the client. If you know the certificate is self-signed and would like to ignore this error use the --insecure flag. If you have your own certificate authority that you would like to use to validate the certificate chain presented by the proxy, set the SSL_CERT_FILE and SSL_CERT_DIR environment variables respectively and try again. If you think something malicious may be occurring, contact your Teleport system administrator to resolve this issue.`",
"\n",
"\n",
"case",
"x509",
".",
"CertificateInvalidError",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"`WARNING: The certificate presented by the proxy is invalid: %v. Contact your Teleport system administrator to resolve this issue.`",
",",
"innerError",
")",
"\n",
"\n",
"}"
] | // UserMessageFromError returns user friendly error message from error | [
"UserMessageFromError",
"returns",
"user",
"friendly",
"error",
"message",
"from",
"error"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/cli.go#L117-L167 | train |
gravitational/teleport | lib/utils/cli.go | InitCLIParser | func InitCLIParser(appName, appHelp string) (app *kingpin.Application) {
app = kingpin.New(appName, appHelp)
// hide "--help" flag
app.HelpFlag.Hidden()
app.HelpFlag.NoEnvar()
// set our own help template
return app.UsageTemplate(defaultUsageTemplate)
} | go | func InitCLIParser(appName, appHelp string) (app *kingpin.Application) {
app = kingpin.New(appName, appHelp)
// hide "--help" flag
app.HelpFlag.Hidden()
app.HelpFlag.NoEnvar()
// set our own help template
return app.UsageTemplate(defaultUsageTemplate)
} | [
"func",
"InitCLIParser",
"(",
"appName",
",",
"appHelp",
"string",
")",
"(",
"app",
"*",
"kingpin",
".",
"Application",
")",
"{",
"app",
"=",
"kingpin",
".",
"New",
"(",
"appName",
",",
"appHelp",
")",
"\n",
"app",
".",
"HelpFlag",
".",
"Hidden",
"(",
")",
"\n",
"app",
".",
"HelpFlag",
".",
"NoEnvar",
"(",
")",
"\n",
"return",
"app",
".",
"UsageTemplate",
"(",
"defaultUsageTemplate",
")",
"\n",
"}"
] | // InitCLIParser configures kingpin command line args parser with
// some defaults common for all Teleport CLI tools | [
"InitCLIParser",
"configures",
"kingpin",
"command",
"line",
"args",
"parser",
"with",
"some",
"defaults",
"common",
"for",
"all",
"Teleport",
"CLI",
"tools"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/cli.go#L185-L194 | train |
gravitational/teleport | lib/utils/cli.go | needsQuoting | func needsQuoting(text string) bool {
for _, r := range text {
if !strconv.IsPrint(r) {
return true
}
}
return false
} | go | func needsQuoting(text string) bool {
for _, r := range text {
if !strconv.IsPrint(r) {
return true
}
}
return false
} | [
"func",
"needsQuoting",
"(",
"text",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"text",
"{",
"if",
"!",
"strconv",
".",
"IsPrint",
"(",
"r",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // needsQuoting returns true if any non-printable characters are found. | [
"needsQuoting",
"returns",
"true",
"if",
"any",
"non",
"-",
"printable",
"characters",
"are",
"found",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/cli.go#L208-L215 | train |
gravitational/teleport | lib/web/ui/server.go | MakeServers | func MakeServers(clusterName string, servers []services.Server) []Server {
uiServers := []Server{}
for _, server := range servers {
uiLabels := []Label{}
serverLabels := server.GetLabels()
for name, value := range serverLabels {
uiLabels = append(uiLabels, Label{
Name: name,
Value: value,
})
}
serverCmdLabels := server.GetCmdLabels()
for name, cmd := range serverCmdLabels {
uiLabels = append(uiLabels, Label{
Name: name,
Value: cmd.GetResult(),
})
}
sort.Sort(sortedLabels(uiLabels))
uiServers = append(uiServers, Server{
ClusterName: clusterName,
Name: server.GetName(),
Hostname: server.GetHostname(),
Addr: server.GetAddr(),
Labels: uiLabels,
})
}
return uiServers
} | go | func MakeServers(clusterName string, servers []services.Server) []Server {
uiServers := []Server{}
for _, server := range servers {
uiLabels := []Label{}
serverLabels := server.GetLabels()
for name, value := range serverLabels {
uiLabels = append(uiLabels, Label{
Name: name,
Value: value,
})
}
serverCmdLabels := server.GetCmdLabels()
for name, cmd := range serverCmdLabels {
uiLabels = append(uiLabels, Label{
Name: name,
Value: cmd.GetResult(),
})
}
sort.Sort(sortedLabels(uiLabels))
uiServers = append(uiServers, Server{
ClusterName: clusterName,
Name: server.GetName(),
Hostname: server.GetHostname(),
Addr: server.GetAddr(),
Labels: uiLabels,
})
}
return uiServers
} | [
"func",
"MakeServers",
"(",
"clusterName",
"string",
",",
"servers",
"[",
"]",
"services",
".",
"Server",
")",
"[",
"]",
"Server",
"{",
"uiServers",
":=",
"[",
"]",
"Server",
"{",
"}",
"\n",
"for",
"_",
",",
"server",
":=",
"range",
"servers",
"{",
"uiLabels",
":=",
"[",
"]",
"Label",
"{",
"}",
"\n",
"serverLabels",
":=",
"server",
".",
"GetLabels",
"(",
")",
"\n",
"for",
"name",
",",
"value",
":=",
"range",
"serverLabels",
"{",
"uiLabels",
"=",
"append",
"(",
"uiLabels",
",",
"Label",
"{",
"Name",
":",
"name",
",",
"Value",
":",
"value",
",",
"}",
")",
"\n",
"}",
"\n",
"serverCmdLabels",
":=",
"server",
".",
"GetCmdLabels",
"(",
")",
"\n",
"for",
"name",
",",
"cmd",
":=",
"range",
"serverCmdLabels",
"{",
"uiLabels",
"=",
"append",
"(",
"uiLabels",
",",
"Label",
"{",
"Name",
":",
"name",
",",
"Value",
":",
"cmd",
".",
"GetResult",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"sortedLabels",
"(",
"uiLabels",
")",
")",
"\n",
"uiServers",
"=",
"append",
"(",
"uiServers",
",",
"Server",
"{",
"ClusterName",
":",
"clusterName",
",",
"Name",
":",
"server",
".",
"GetName",
"(",
")",
",",
"Hostname",
":",
"server",
".",
"GetHostname",
"(",
")",
",",
"Addr",
":",
"server",
".",
"GetAddr",
"(",
")",
",",
"Labels",
":",
"uiLabels",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"uiServers",
"\n",
"}"
] | // MakeServers creates server objects for webapp | [
"MakeServers",
"creates",
"server",
"objects",
"for",
"webapp"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/ui/server.go#L63-L95 | train |
gravitational/teleport | lib/service/signals.go | printShutdownStatus | func (process *TeleportProcess) printShutdownStatus(ctx context.Context) {
t := time.NewTicker(defaults.HighResReportingPeriod)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
log.Infof("Waiting for services: %v to finish.", process.Supervisor.Services())
}
}
} | go | func (process *TeleportProcess) printShutdownStatus(ctx context.Context) {
t := time.NewTicker(defaults.HighResReportingPeriod)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
log.Infof("Waiting for services: %v to finish.", process.Supervisor.Services())
}
}
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"printShutdownStatus",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"t",
":=",
"time",
".",
"NewTicker",
"(",
"defaults",
".",
"HighResReportingPeriod",
")",
"\n",
"defer",
"t",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"case",
"<-",
"t",
".",
"C",
":",
"log",
".",
"Infof",
"(",
"\"Waiting for services: %v to finish.\"",
",",
"process",
".",
"Supervisor",
".",
"Services",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // printShutdownStatus prints running services until shut down | [
"printShutdownStatus",
"prints",
"running",
"services",
"until",
"shut",
"down"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/signals.go#L38-L49 | train |
gravitational/teleport | lib/service/signals.go | closeImportedDescriptors | func (process *TeleportProcess) closeImportedDescriptors(prefix string) error {
process.Lock()
defer process.Unlock()
var errors []error
for i := range process.importedDescriptors {
d := process.importedDescriptors[i]
if strings.HasPrefix(d.Type, prefix) {
process.Infof("Closing imported but unused descriptor %v %v.", d.Type, d.Address)
errors = append(errors, d.File.Close())
}
}
return trace.NewAggregate(errors...)
} | go | func (process *TeleportProcess) closeImportedDescriptors(prefix string) error {
process.Lock()
defer process.Unlock()
var errors []error
for i := range process.importedDescriptors {
d := process.importedDescriptors[i]
if strings.HasPrefix(d.Type, prefix) {
process.Infof("Closing imported but unused descriptor %v %v.", d.Type, d.Address)
errors = append(errors, d.File.Close())
}
}
return trace.NewAggregate(errors...)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"closeImportedDescriptors",
"(",
"prefix",
"string",
")",
"error",
"{",
"process",
".",
"Lock",
"(",
")",
"\n",
"defer",
"process",
".",
"Unlock",
"(",
")",
"\n",
"var",
"errors",
"[",
"]",
"error",
"\n",
"for",
"i",
":=",
"range",
"process",
".",
"importedDescriptors",
"{",
"d",
":=",
"process",
".",
"importedDescriptors",
"[",
"i",
"]",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"d",
".",
"Type",
",",
"prefix",
")",
"{",
"process",
".",
"Infof",
"(",
"\"Closing imported but unused descriptor %v %v.\"",
",",
"d",
".",
"Type",
",",
"d",
".",
"Address",
")",
"\n",
"errors",
"=",
"append",
"(",
"errors",
",",
"d",
".",
"File",
".",
"Close",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] | // closeImportedDescriptors closes imported but unused file descriptors,
// what could happen if service has updated configuration | [
"closeImportedDescriptors",
"closes",
"imported",
"but",
"unused",
"file",
"descriptors",
"what",
"could",
"happen",
"if",
"service",
"has",
"updated",
"configuration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/signals.go#L186-L199 | train |
gravitational/teleport | lib/service/signals.go | importListener | func (process *TeleportProcess) importListener(listenerType, address string) (net.Listener, error) {
process.Lock()
defer process.Unlock()
for i := range process.importedDescriptors {
d := process.importedDescriptors[i]
if d.Type == listenerType && d.Address == address {
l, err := d.ToListener()
if err != nil {
return nil, trace.Wrap(err)
}
process.importedDescriptors = append(process.importedDescriptors[:i], process.importedDescriptors[i+1:]...)
process.registeredListeners = append(process.registeredListeners, RegisteredListener{Type: listenerType, Address: address, Listener: l})
return l, nil
}
}
return nil, trace.NotFound("no file descriptor for type %v and address %v has been imported", listenerType, address)
} | go | func (process *TeleportProcess) importListener(listenerType, address string) (net.Listener, error) {
process.Lock()
defer process.Unlock()
for i := range process.importedDescriptors {
d := process.importedDescriptors[i]
if d.Type == listenerType && d.Address == address {
l, err := d.ToListener()
if err != nil {
return nil, trace.Wrap(err)
}
process.importedDescriptors = append(process.importedDescriptors[:i], process.importedDescriptors[i+1:]...)
process.registeredListeners = append(process.registeredListeners, RegisteredListener{Type: listenerType, Address: address, Listener: l})
return l, nil
}
}
return nil, trace.NotFound("no file descriptor for type %v and address %v has been imported", listenerType, address)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"importListener",
"(",
"listenerType",
",",
"address",
"string",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"process",
".",
"Lock",
"(",
")",
"\n",
"defer",
"process",
".",
"Unlock",
"(",
")",
"\n",
"for",
"i",
":=",
"range",
"process",
".",
"importedDescriptors",
"{",
"d",
":=",
"process",
".",
"importedDescriptors",
"[",
"i",
"]",
"\n",
"if",
"d",
".",
"Type",
"==",
"listenerType",
"&&",
"d",
".",
"Address",
"==",
"address",
"{",
"l",
",",
"err",
":=",
"d",
".",
"ToListener",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"importedDescriptors",
"=",
"append",
"(",
"process",
".",
"importedDescriptors",
"[",
":",
"i",
"]",
",",
"process",
".",
"importedDescriptors",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"process",
".",
"registeredListeners",
"=",
"append",
"(",
"process",
".",
"registeredListeners",
",",
"RegisteredListener",
"{",
"Type",
":",
"listenerType",
",",
"Address",
":",
"address",
",",
"Listener",
":",
"l",
"}",
")",
"\n",
"return",
"l",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"no file descriptor for type %v and address %v has been imported\"",
",",
"listenerType",
",",
"address",
")",
"\n",
"}"
] | // importListener imports listener passed by the parent process, if no listener is found
// returns NotFound, otherwise removes the file from the list | [
"importListener",
"imports",
"listener",
"passed",
"by",
"the",
"parent",
"process",
"if",
"no",
"listener",
"is",
"found",
"returns",
"NotFound",
"otherwise",
"removes",
"the",
"file",
"from",
"the",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/signals.go#L233-L251 | train |
gravitational/teleport | lib/service/signals.go | createListener | func (process *TeleportProcess) createListener(listenerType, address string) (net.Listener, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, trace.Wrap(err)
}
process.Lock()
defer process.Unlock()
r := RegisteredListener{Type: listenerType, Address: address, Listener: listener}
process.registeredListeners = append(process.registeredListeners, r)
return listener, nil
} | go | func (process *TeleportProcess) createListener(listenerType, address string) (net.Listener, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, trace.Wrap(err)
}
process.Lock()
defer process.Unlock()
r := RegisteredListener{Type: listenerType, Address: address, Listener: listener}
process.registeredListeners = append(process.registeredListeners, r)
return listener, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"createListener",
"(",
"listenerType",
",",
"address",
"string",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"Lock",
"(",
")",
"\n",
"defer",
"process",
".",
"Unlock",
"(",
")",
"\n",
"r",
":=",
"RegisteredListener",
"{",
"Type",
":",
"listenerType",
",",
"Address",
":",
"address",
",",
"Listener",
":",
"listener",
"}",
"\n",
"process",
".",
"registeredListeners",
"=",
"append",
"(",
"process",
".",
"registeredListeners",
",",
"r",
")",
"\n",
"return",
"listener",
",",
"nil",
"\n",
"}"
] | // createListener creates listener and adds to a list of tracked listeners | [
"createListener",
"creates",
"listener",
"and",
"adds",
"to",
"a",
"list",
"of",
"tracked",
"listeners"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/signals.go#L254-L264 | train |
gravitational/teleport | lib/service/signals.go | ExportFileDescriptors | func (process *TeleportProcess) ExportFileDescriptors() ([]FileDescriptor, error) {
var out []FileDescriptor
process.Lock()
defer process.Unlock()
for _, r := range process.registeredListeners {
file, err := utils.GetListenerFile(r.Listener)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, FileDescriptor{File: file, Type: r.Type, Address: r.Address})
}
return out, nil
} | go | func (process *TeleportProcess) ExportFileDescriptors() ([]FileDescriptor, error) {
var out []FileDescriptor
process.Lock()
defer process.Unlock()
for _, r := range process.registeredListeners {
file, err := utils.GetListenerFile(r.Listener)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, FileDescriptor{File: file, Type: r.Type, Address: r.Address})
}
return out, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"ExportFileDescriptors",
"(",
")",
"(",
"[",
"]",
"FileDescriptor",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"FileDescriptor",
"\n",
"process",
".",
"Lock",
"(",
")",
"\n",
"defer",
"process",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"process",
".",
"registeredListeners",
"{",
"file",
",",
"err",
":=",
"utils",
".",
"GetListenerFile",
"(",
"r",
".",
"Listener",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"FileDescriptor",
"{",
"File",
":",
"file",
",",
"Type",
":",
"r",
".",
"Type",
",",
"Address",
":",
"r",
".",
"Address",
"}",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // ExportFileDescriptors exports file descriptors to be passed to child process | [
"ExportFileDescriptors",
"exports",
"file",
"descriptors",
"to",
"be",
"passed",
"to",
"child",
"process"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/signals.go#L267-L279 | train |
gravitational/teleport | lib/service/signals.go | importFileDescriptors | func importFileDescriptors() ([]FileDescriptor, error) {
// These files may be passed in by the parent process
filesString := os.Getenv(teleportFilesEnvVar)
if filesString == "" {
return nil, nil
}
files, err := filesFromString(filesString)
if err != nil {
return nil, trace.BadParameter("child process has failed to read files, error %q", err)
}
if len(files) != 0 {
log.Infof("Child has been passed files: %v", files)
}
return files, nil
} | go | func importFileDescriptors() ([]FileDescriptor, error) {
// These files may be passed in by the parent process
filesString := os.Getenv(teleportFilesEnvVar)
if filesString == "" {
return nil, nil
}
files, err := filesFromString(filesString)
if err != nil {
return nil, trace.BadParameter("child process has failed to read files, error %q", err)
}
if len(files) != 0 {
log.Infof("Child has been passed files: %v", files)
}
return files, nil
} | [
"func",
"importFileDescriptors",
"(",
")",
"(",
"[",
"]",
"FileDescriptor",
",",
"error",
")",
"{",
"filesString",
":=",
"os",
".",
"Getenv",
"(",
"teleportFilesEnvVar",
")",
"\n",
"if",
"filesString",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"files",
",",
"err",
":=",
"filesFromString",
"(",
"filesString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"child process has failed to read files, error %q\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"files",
")",
"!=",
"0",
"{",
"log",
".",
"Infof",
"(",
"\"Child has been passed files: %v\"",
",",
"files",
")",
"\n",
"}",
"\n",
"return",
"files",
",",
"nil",
"\n",
"}"
] | // importFileDescriptors imports file descriptors from environment if there are any | [
"importFileDescriptors",
"imports",
"file",
"descriptors",
"from",
"environment",
"if",
"there",
"are",
"any"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/signals.go#L282-L299 | train |
gravitational/teleport | lib/events/recorder.go | NewForwardRecorder | func NewForwardRecorder(cfg ForwardRecorderConfig) (*ForwardRecorder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
// Always write sessions to local disk first, then forward them to the Auth
// Server later.
auditLog, err := NewForwarder(ForwarderConfig{
SessionID: cfg.SessionID,
ServerID: teleport.ComponentUpload,
DataDir: cfg.DataDir,
RecordSessions: cfg.RecordSessions,
Namespace: cfg.Namespace,
ForwardTo: cfg.ForwardTo,
})
if err != nil {
return nil, trace.Wrap(err)
}
sr := &ForwardRecorder{
ForwardRecorderConfig: cfg,
Entry: logrus.WithFields(logrus.Fields{
trace.Component: cfg.Component,
}),
AuditLog: auditLog,
}
return sr, nil
} | go | func NewForwardRecorder(cfg ForwardRecorderConfig) (*ForwardRecorder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
// Always write sessions to local disk first, then forward them to the Auth
// Server later.
auditLog, err := NewForwarder(ForwarderConfig{
SessionID: cfg.SessionID,
ServerID: teleport.ComponentUpload,
DataDir: cfg.DataDir,
RecordSessions: cfg.RecordSessions,
Namespace: cfg.Namespace,
ForwardTo: cfg.ForwardTo,
})
if err != nil {
return nil, trace.Wrap(err)
}
sr := &ForwardRecorder{
ForwardRecorderConfig: cfg,
Entry: logrus.WithFields(logrus.Fields{
trace.Component: cfg.Component,
}),
AuditLog: auditLog,
}
return sr, nil
} | [
"func",
"NewForwardRecorder",
"(",
"cfg",
"ForwardRecorderConfig",
")",
"(",
"*",
"ForwardRecorder",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"auditLog",
",",
"err",
":=",
"NewForwarder",
"(",
"ForwarderConfig",
"{",
"SessionID",
":",
"cfg",
".",
"SessionID",
",",
"ServerID",
":",
"teleport",
".",
"ComponentUpload",
",",
"DataDir",
":",
"cfg",
".",
"DataDir",
",",
"RecordSessions",
":",
"cfg",
".",
"RecordSessions",
",",
"Namespace",
":",
"cfg",
".",
"Namespace",
",",
"ForwardTo",
":",
"cfg",
".",
"ForwardTo",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sr",
":=",
"&",
"ForwardRecorder",
"{",
"ForwardRecorderConfig",
":",
"cfg",
",",
"Entry",
":",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"cfg",
".",
"Component",
",",
"}",
")",
",",
"AuditLog",
":",
"auditLog",
",",
"}",
"\n",
"return",
"sr",
",",
"nil",
"\n",
"}"
] | // NewForwardRecorder returns a new instance of session recorder | [
"NewForwardRecorder",
"returns",
"a",
"new",
"instance",
"of",
"session",
"recorder"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/recorder.go#L112-L139 | train |
gravitational/teleport | lib/events/recorder.go | Write | func (r *ForwardRecorder) Write(data []byte) (int, error) {
// we are copying buffer to prevent data corruption:
// io.Copy allocates single buffer and calls multiple writes in a loop
// our PostSessionSlice is async and sends reader wrapping buffer
// to the channel. This can lead to cases when the buffer is re-used
// and data is corrupted unless we copy the data buffer in the first place
dataCopy := make([]byte, len(data))
copy(dataCopy, data)
// post the chunk of bytes to the audit log:
chunk := &SessionChunk{
EventType: SessionPrintEvent,
Data: dataCopy,
Time: time.Now().UTC().UnixNano(),
}
if err := r.AuditLog.PostSessionSlice(SessionSlice{
Namespace: r.Namespace,
SessionID: string(r.SessionID),
Chunks: []*SessionChunk{chunk},
}); err != nil {
r.Error(trace.DebugReport(err))
}
return len(data), nil
} | go | func (r *ForwardRecorder) Write(data []byte) (int, error) {
// we are copying buffer to prevent data corruption:
// io.Copy allocates single buffer and calls multiple writes in a loop
// our PostSessionSlice is async and sends reader wrapping buffer
// to the channel. This can lead to cases when the buffer is re-used
// and data is corrupted unless we copy the data buffer in the first place
dataCopy := make([]byte, len(data))
copy(dataCopy, data)
// post the chunk of bytes to the audit log:
chunk := &SessionChunk{
EventType: SessionPrintEvent,
Data: dataCopy,
Time: time.Now().UTC().UnixNano(),
}
if err := r.AuditLog.PostSessionSlice(SessionSlice{
Namespace: r.Namespace,
SessionID: string(r.SessionID),
Chunks: []*SessionChunk{chunk},
}); err != nil {
r.Error(trace.DebugReport(err))
}
return len(data), nil
} | [
"func",
"(",
"r",
"*",
"ForwardRecorder",
")",
"Write",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"dataCopy",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"data",
")",
")",
"\n",
"copy",
"(",
"dataCopy",
",",
"data",
")",
"\n",
"chunk",
":=",
"&",
"SessionChunk",
"{",
"EventType",
":",
"SessionPrintEvent",
",",
"Data",
":",
"dataCopy",
",",
"Time",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"UnixNano",
"(",
")",
",",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"AuditLog",
".",
"PostSessionSlice",
"(",
"SessionSlice",
"{",
"Namespace",
":",
"r",
".",
"Namespace",
",",
"SessionID",
":",
"string",
"(",
"r",
".",
"SessionID",
")",
",",
"Chunks",
":",
"[",
"]",
"*",
"SessionChunk",
"{",
"chunk",
"}",
",",
"}",
")",
";",
"err",
"!=",
"nil",
"{",
"r",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"len",
"(",
"data",
")",
",",
"nil",
"\n",
"}"
] | // Write takes a chunk and writes it into the audit log | [
"Write",
"takes",
"a",
"chunk",
"and",
"writes",
"it",
"into",
"the",
"audit",
"log"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/recorder.go#L147-L169 | train |
gravitational/teleport | lib/events/recorder.go | Close | func (r *ForwardRecorder) Close() error {
var errors []error
err := r.AuditLog.Close()
errors = append(errors, err)
// wait until all events from recorder get flushed, it is important
// to do so before we send SessionEndEvent to advise the audit log
// to release resources associated with this session.
// not doing so will not result in memory leak, but could result
// in missing playback events
context, cancel := context.WithTimeout(context.TODO(), defaults.ReadHeadersTimeout)
defer cancel() // releases resources if slowOperation completes before timeout elapses
err = r.AuditLog.WaitForDelivery(context)
if err != nil {
errors = append(errors, err)
r.Warnf("Timeout waiting for session to flush events: %v", trace.DebugReport(err))
}
return trace.NewAggregate(errors...)
} | go | func (r *ForwardRecorder) Close() error {
var errors []error
err := r.AuditLog.Close()
errors = append(errors, err)
// wait until all events from recorder get flushed, it is important
// to do so before we send SessionEndEvent to advise the audit log
// to release resources associated with this session.
// not doing so will not result in memory leak, but could result
// in missing playback events
context, cancel := context.WithTimeout(context.TODO(), defaults.ReadHeadersTimeout)
defer cancel() // releases resources if slowOperation completes before timeout elapses
err = r.AuditLog.WaitForDelivery(context)
if err != nil {
errors = append(errors, err)
r.Warnf("Timeout waiting for session to flush events: %v", trace.DebugReport(err))
}
return trace.NewAggregate(errors...)
} | [
"func",
"(",
"r",
"*",
"ForwardRecorder",
")",
"Close",
"(",
")",
"error",
"{",
"var",
"errors",
"[",
"]",
"error",
"\n",
"err",
":=",
"r",
".",
"AuditLog",
".",
"Close",
"(",
")",
"\n",
"errors",
"=",
"append",
"(",
"errors",
",",
"err",
")",
"\n",
"context",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"defaults",
".",
"ReadHeadersTimeout",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"err",
"=",
"r",
".",
"AuditLog",
".",
"WaitForDelivery",
"(",
"context",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"err",
")",
"\n",
"r",
".",
"Warnf",
"(",
"\"Timeout waiting for session to flush events: %v\"",
",",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] | // Close closes audit log session recorder | [
"Close",
"closes",
"audit",
"log",
"session",
"recorder"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/recorder.go#L172-L191 | train |
gravitational/teleport | lib/backend/helpers.go | AcquireLock | func AcquireLock(ctx context.Context, backend Backend, lockName string, ttl time.Duration) (err error) {
if lockName == "" {
return trace.BadParameter("missing parameter lock name")
}
key := []byte(filepath.Join(locksPrefix, lockName))
for {
// Get will clear TTL on a lock
backend.Get(ctx, key)
// CreateVal is atomic:
_, err = backend.Create(ctx, Item{Key: key, Value: []byte{1}, Expires: backend.Clock().Now().UTC().Add(ttl)})
if err == nil {
break // success
}
if trace.IsAlreadyExists(err) { // locked? wait and repeat:
backend.Clock().Sleep(250 * time.Millisecond)
continue
}
return trace.ConvertSystemError(err)
}
return nil
} | go | func AcquireLock(ctx context.Context, backend Backend, lockName string, ttl time.Duration) (err error) {
if lockName == "" {
return trace.BadParameter("missing parameter lock name")
}
key := []byte(filepath.Join(locksPrefix, lockName))
for {
// Get will clear TTL on a lock
backend.Get(ctx, key)
// CreateVal is atomic:
_, err = backend.Create(ctx, Item{Key: key, Value: []byte{1}, Expires: backend.Clock().Now().UTC().Add(ttl)})
if err == nil {
break // success
}
if trace.IsAlreadyExists(err) { // locked? wait and repeat:
backend.Clock().Sleep(250 * time.Millisecond)
continue
}
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"AcquireLock",
"(",
"ctx",
"context",
".",
"Context",
",",
"backend",
"Backend",
",",
"lockName",
"string",
",",
"ttl",
"time",
".",
"Duration",
")",
"(",
"err",
"error",
")",
"{",
"if",
"lockName",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter lock name\"",
")",
"\n",
"}",
"\n",
"key",
":=",
"[",
"]",
"byte",
"(",
"filepath",
".",
"Join",
"(",
"locksPrefix",
",",
"lockName",
")",
")",
"\n",
"for",
"{",
"backend",
".",
"Get",
"(",
"ctx",
",",
"key",
")",
"\n",
"_",
",",
"err",
"=",
"backend",
".",
"Create",
"(",
"ctx",
",",
"Item",
"{",
"Key",
":",
"key",
",",
"Value",
":",
"[",
"]",
"byte",
"{",
"1",
"}",
",",
"Expires",
":",
"backend",
".",
"Clock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"ttl",
")",
"}",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"if",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"backend",
".",
"Clock",
"(",
")",
".",
"Sleep",
"(",
"250",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // AcquireLock grabs a lock that will be released automatically in TTL | [
"AcquireLock",
"grabs",
"a",
"lock",
"that",
"will",
"be",
"released",
"automatically",
"in",
"TTL"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/helpers.go#L30-L51 | train |
gravitational/teleport | lib/backend/helpers.go | ReleaseLock | func ReleaseLock(ctx context.Context, backend Backend, lockName string) error {
if lockName == "" {
return trace.BadParameter("missing parameter lockName")
}
key := []byte(filepath.Join(locksPrefix, lockName))
if err := backend.Delete(ctx, key); err != nil {
return trace.Wrap(err)
}
return nil
} | go | func ReleaseLock(ctx context.Context, backend Backend, lockName string) error {
if lockName == "" {
return trace.BadParameter("missing parameter lockName")
}
key := []byte(filepath.Join(locksPrefix, lockName))
if err := backend.Delete(ctx, key); err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"ReleaseLock",
"(",
"ctx",
"context",
".",
"Context",
",",
"backend",
"Backend",
",",
"lockName",
"string",
")",
"error",
"{",
"if",
"lockName",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter lockName\"",
")",
"\n",
"}",
"\n",
"key",
":=",
"[",
"]",
"byte",
"(",
"filepath",
".",
"Join",
"(",
"locksPrefix",
",",
"lockName",
")",
")",
"\n",
"if",
"err",
":=",
"backend",
".",
"Delete",
"(",
"ctx",
",",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ReleaseLock forces lock release | [
"ReleaseLock",
"forces",
"lock",
"release"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/helpers.go#L54-L63 | train |
gravitational/teleport | lib/services/authority.go | Check | func (c *HostCertParams) Check() error {
if c.HostID == "" && len(c.Principals) == 0 {
return trace.BadParameter("HostID [%q] or Principals [%q] are required",
c.HostID, c.Principals)
}
if c.ClusterName == "" {
return trace.BadParameter("ClusterName [%q] is required", c.ClusterName)
}
if err := c.Roles.Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *HostCertParams) Check() error {
if c.HostID == "" && len(c.Principals) == 0 {
return trace.BadParameter("HostID [%q] or Principals [%q] are required",
c.HostID, c.Principals)
}
if c.ClusterName == "" {
return trace.BadParameter("ClusterName [%q] is required", c.ClusterName)
}
if err := c.Roles.Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"HostCertParams",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"c",
".",
"HostID",
"==",
"\"\"",
"&&",
"len",
"(",
"c",
".",
"Principals",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"HostID [%q] or Principals [%q] are required\"",
",",
"c",
".",
"HostID",
",",
"c",
".",
"Principals",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"ClusterName",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"ClusterName [%q] is required\"",
",",
"c",
".",
"ClusterName",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"Roles",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check checks parameters for errors | [
"Check",
"checks",
"parameters",
"for",
"errors"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L57-L71 | train |
gravitational/teleport | lib/services/authority.go | MarshalCertRoles | func MarshalCertRoles(roles []string) (string, error) {
out, err := json.Marshal(CertRoles{Version: V1, Roles: roles})
if err != nil {
return "", trace.Wrap(err)
}
return string(out), err
} | go | func MarshalCertRoles(roles []string) (string, error) {
out, err := json.Marshal(CertRoles{Version: V1, Roles: roles})
if err != nil {
return "", trace.Wrap(err)
}
return string(out), err
} | [
"func",
"MarshalCertRoles",
"(",
"roles",
"[",
"]",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"CertRoles",
"{",
"Version",
":",
"V1",
",",
"Roles",
":",
"roles",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"out",
")",
",",
"err",
"\n",
"}"
] | // MarshalCertRoles marshal roles list to OpenSSH | [
"MarshalCertRoles",
"marshal",
"roles",
"list",
"to",
"OpenSSH"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L133-L139 | train |
gravitational/teleport | lib/services/authority.go | UnmarshalCertRoles | func UnmarshalCertRoles(data string) ([]string, error) {
var certRoles CertRoles
if err := utils.UnmarshalWithSchema(CertRolesSchema, &certRoles, []byte(data)); err != nil {
return nil, trace.BadParameter(err.Error())
}
return certRoles.Roles, nil
} | go | func UnmarshalCertRoles(data string) ([]string, error) {
var certRoles CertRoles
if err := utils.UnmarshalWithSchema(CertRolesSchema, &certRoles, []byte(data)); err != nil {
return nil, trace.BadParameter(err.Error())
}
return certRoles.Roles, nil
} | [
"func",
"UnmarshalCertRoles",
"(",
"data",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"certRoles",
"CertRoles",
"\n",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"CertRolesSchema",
",",
"&",
"certRoles",
",",
"[",
"]",
"byte",
"(",
"data",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"certRoles",
".",
"Roles",
",",
"nil",
"\n",
"}"
] | // UnmarshalCertRoles marshals roles list to OpenSSH | [
"UnmarshalCertRoles",
"marshals",
"roles",
"list",
"to",
"OpenSSH"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L142-L148 | train |
gravitational/teleport | lib/services/authority.go | CertPoolFromCertAuthorities | func CertPoolFromCertAuthorities(cas []CertAuthority) (*x509.CertPool, error) {
certPool := x509.NewCertPool()
for _, ca := range cas {
keyPairs := ca.GetTLSKeyPairs()
if len(keyPairs) == 0 {
continue
}
for _, keyPair := range keyPairs {
cert, err := tlsca.ParseCertificatePEM(keyPair.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
certPool.AddCert(cert)
}
return certPool, nil
}
return certPool, nil
} | go | func CertPoolFromCertAuthorities(cas []CertAuthority) (*x509.CertPool, error) {
certPool := x509.NewCertPool()
for _, ca := range cas {
keyPairs := ca.GetTLSKeyPairs()
if len(keyPairs) == 0 {
continue
}
for _, keyPair := range keyPairs {
cert, err := tlsca.ParseCertificatePEM(keyPair.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
certPool.AddCert(cert)
}
return certPool, nil
}
return certPool, nil
} | [
"func",
"CertPoolFromCertAuthorities",
"(",
"cas",
"[",
"]",
"CertAuthority",
")",
"(",
"*",
"x509",
".",
"CertPool",
",",
"error",
")",
"{",
"certPool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"for",
"_",
",",
"ca",
":=",
"range",
"cas",
"{",
"keyPairs",
":=",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
"\n",
"if",
"len",
"(",
"keyPairs",
")",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"keyPair",
":=",
"range",
"keyPairs",
"{",
"cert",
",",
"err",
":=",
"tlsca",
".",
"ParseCertificatePEM",
"(",
"keyPair",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certPool",
".",
"AddCert",
"(",
"cert",
")",
"\n",
"}",
"\n",
"return",
"certPool",
",",
"nil",
"\n",
"}",
"\n",
"return",
"certPool",
",",
"nil",
"\n",
"}"
] | // CertPoolFromCertAuthorities returns certificate pools from TLS certificates
// set up in the certificate authorities list | [
"CertPoolFromCertAuthorities",
"returns",
"certificate",
"pools",
"from",
"TLS",
"certificates",
"set",
"up",
"in",
"the",
"certificate",
"authorities",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L217-L234 | train |
gravitational/teleport | lib/services/authority.go | TLSCerts | func TLSCerts(ca CertAuthority) [][]byte {
pairs := ca.GetTLSKeyPairs()
out := make([][]byte, len(pairs))
for i, pair := range pairs {
out[i] = append([]byte{}, pair.Cert...)
}
return out
} | go | func TLSCerts(ca CertAuthority) [][]byte {
pairs := ca.GetTLSKeyPairs()
out := make([][]byte, len(pairs))
for i, pair := range pairs {
out[i] = append([]byte{}, pair.Cert...)
}
return out
} | [
"func",
"TLSCerts",
"(",
"ca",
"CertAuthority",
")",
"[",
"]",
"[",
"]",
"byte",
"{",
"pairs",
":=",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"pairs",
")",
")",
"\n",
"for",
"i",
",",
"pair",
":=",
"range",
"pairs",
"{",
"out",
"[",
"i",
"]",
"=",
"append",
"(",
"[",
"]",
"byte",
"{",
"}",
",",
"pair",
".",
"Cert",
"...",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // TLSCerts returns TLS certificates from CA | [
"TLSCerts",
"returns",
"TLS",
"certificates",
"from",
"CA"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L255-L262 | train |
gravitational/teleport | lib/services/authority.go | NewCertAuthority | func NewCertAuthority(caType CertAuthType, clusterName string, signingKeys, checkingKeys [][]byte, roles []string) CertAuthority {
return &CertAuthorityV2{
Kind: KindCertAuthority,
Version: V2,
SubKind: string(caType),
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: CertAuthoritySpecV2{
Roles: roles,
Type: caType,
ClusterName: clusterName,
CheckingKeys: checkingKeys,
SigningKeys: signingKeys,
},
}
} | go | func NewCertAuthority(caType CertAuthType, clusterName string, signingKeys, checkingKeys [][]byte, roles []string) CertAuthority {
return &CertAuthorityV2{
Kind: KindCertAuthority,
Version: V2,
SubKind: string(caType),
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: CertAuthoritySpecV2{
Roles: roles,
Type: caType,
ClusterName: clusterName,
CheckingKeys: checkingKeys,
SigningKeys: signingKeys,
},
}
} | [
"func",
"NewCertAuthority",
"(",
"caType",
"CertAuthType",
",",
"clusterName",
"string",
",",
"signingKeys",
",",
"checkingKeys",
"[",
"]",
"[",
"]",
"byte",
",",
"roles",
"[",
"]",
"string",
")",
"CertAuthority",
"{",
"return",
"&",
"CertAuthorityV2",
"{",
"Kind",
":",
"KindCertAuthority",
",",
"Version",
":",
"V2",
",",
"SubKind",
":",
"string",
"(",
"caType",
")",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"clusterName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"CertAuthoritySpecV2",
"{",
"Roles",
":",
"roles",
",",
"Type",
":",
"caType",
",",
"ClusterName",
":",
"clusterName",
",",
"CheckingKeys",
":",
"checkingKeys",
",",
"SigningKeys",
":",
"signingKeys",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewCertAuthority returns new cert authority | [
"NewCertAuthority",
"returns",
"new",
"cert",
"authority"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L265-L282 | train |
gravitational/teleport | lib/services/authority.go | CertAuthoritiesToV1 | func CertAuthoritiesToV1(in []CertAuthority) ([]CertAuthorityV1, error) {
out := make([]CertAuthorityV1, len(in))
type cav1 interface {
V1() *CertAuthorityV1
}
for i, ca := range in {
v1, ok := ca.(cav1)
if !ok {
return nil, trace.BadParameter("could not transform object to V1")
}
out[i] = *(v1.V1())
}
return out, nil
} | go | func CertAuthoritiesToV1(in []CertAuthority) ([]CertAuthorityV1, error) {
out := make([]CertAuthorityV1, len(in))
type cav1 interface {
V1() *CertAuthorityV1
}
for i, ca := range in {
v1, ok := ca.(cav1)
if !ok {
return nil, trace.BadParameter("could not transform object to V1")
}
out[i] = *(v1.V1())
}
return out, nil
} | [
"func",
"CertAuthoritiesToV1",
"(",
"in",
"[",
"]",
"CertAuthority",
")",
"(",
"[",
"]",
"CertAuthorityV1",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"CertAuthorityV1",
",",
"len",
"(",
"in",
")",
")",
"\n",
"type",
"cav1",
"interface",
"{",
"V1",
"(",
")",
"*",
"CertAuthorityV1",
"\n",
"}",
"\n",
"for",
"i",
",",
"ca",
":=",
"range",
"in",
"{",
"v1",
",",
"ok",
":=",
"ca",
".",
"(",
"cav1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"could not transform object to V1\"",
")",
"\n",
"}",
"\n",
"out",
"[",
"i",
"]",
"=",
"*",
"(",
"v1",
".",
"V1",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // CertAuthoritiesToV1 converts list of cert authorities to V1 slice | [
"CertAuthoritiesToV1",
"converts",
"list",
"of",
"cert",
"authorities",
"to",
"V1",
"slice"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L285-L298 | train |
gravitational/teleport | lib/services/authority.go | Clone | func (c *CertAuthorityV2) Clone() CertAuthority {
out := *c
out.Spec.CheckingKeys = utils.CopyByteSlices(c.Spec.CheckingKeys)
out.Spec.SigningKeys = utils.CopyByteSlices(c.Spec.SigningKeys)
for i, kp := range c.Spec.TLSKeyPairs {
out.Spec.TLSKeyPairs[i] = TLSKeyPair{
Key: utils.CopyByteSlice(kp.Key),
Cert: utils.CopyByteSlice(kp.Cert),
}
}
out.Spec.Roles = utils.CopyStrings(c.Spec.Roles)
return &out
} | go | func (c *CertAuthorityV2) Clone() CertAuthority {
out := *c
out.Spec.CheckingKeys = utils.CopyByteSlices(c.Spec.CheckingKeys)
out.Spec.SigningKeys = utils.CopyByteSlices(c.Spec.SigningKeys)
for i, kp := range c.Spec.TLSKeyPairs {
out.Spec.TLSKeyPairs[i] = TLSKeyPair{
Key: utils.CopyByteSlice(kp.Key),
Cert: utils.CopyByteSlice(kp.Cert),
}
}
out.Spec.Roles = utils.CopyStrings(c.Spec.Roles)
return &out
} | [
"func",
"(",
"c",
"*",
"CertAuthorityV2",
")",
"Clone",
"(",
")",
"CertAuthority",
"{",
"out",
":=",
"*",
"c",
"\n",
"out",
".",
"Spec",
".",
"CheckingKeys",
"=",
"utils",
".",
"CopyByteSlices",
"(",
"c",
".",
"Spec",
".",
"CheckingKeys",
")",
"\n",
"out",
".",
"Spec",
".",
"SigningKeys",
"=",
"utils",
".",
"CopyByteSlices",
"(",
"c",
".",
"Spec",
".",
"SigningKeys",
")",
"\n",
"for",
"i",
",",
"kp",
":=",
"range",
"c",
".",
"Spec",
".",
"TLSKeyPairs",
"{",
"out",
".",
"Spec",
".",
"TLSKeyPairs",
"[",
"i",
"]",
"=",
"TLSKeyPair",
"{",
"Key",
":",
"utils",
".",
"CopyByteSlice",
"(",
"kp",
".",
"Key",
")",
",",
"Cert",
":",
"utils",
".",
"CopyByteSlice",
"(",
"kp",
".",
"Cert",
")",
",",
"}",
"\n",
"}",
"\n",
"out",
".",
"Spec",
".",
"Roles",
"=",
"utils",
".",
"CopyStrings",
"(",
"c",
".",
"Spec",
".",
"Roles",
")",
"\n",
"return",
"&",
"out",
"\n",
"}"
] | // Clone returns a copy of the cert authority object. | [
"Clone",
"returns",
"a",
"copy",
"of",
"the",
"cert",
"authority",
"object",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L321-L333 | train |
gravitational/teleport | lib/services/authority.go | GetRotation | func (c *CertAuthorityV2) GetRotation() Rotation {
if c.Spec.Rotation == nil {
return Rotation{}
}
return *c.Spec.Rotation
} | go | func (c *CertAuthorityV2) GetRotation() Rotation {
if c.Spec.Rotation == nil {
return Rotation{}
}
return *c.Spec.Rotation
} | [
"func",
"(",
"c",
"*",
"CertAuthorityV2",
")",
"GetRotation",
"(",
")",
"Rotation",
"{",
"if",
"c",
".",
"Spec",
".",
"Rotation",
"==",
"nil",
"{",
"return",
"Rotation",
"{",
"}",
"\n",
"}",
"\n",
"return",
"*",
"c",
".",
"Spec",
".",
"Rotation",
"\n",
"}"
] | // GetRotation returns rotation state. | [
"GetRotation",
"returns",
"rotation",
"state",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L336-L341 | train |
gravitational/teleport | lib/services/authority.go | TLSCA | func (c *CertAuthorityV2) TLSCA() (*tlsca.CertAuthority, error) {
if len(c.Spec.TLSKeyPairs) == 0 {
return nil, trace.BadParameter("no TLS key pairs found for certificate authority")
}
return tlsca.New(c.Spec.TLSKeyPairs[0].Cert, c.Spec.TLSKeyPairs[0].Key)
} | go | func (c *CertAuthorityV2) TLSCA() (*tlsca.CertAuthority, error) {
if len(c.Spec.TLSKeyPairs) == 0 {
return nil, trace.BadParameter("no TLS key pairs found for certificate authority")
}
return tlsca.New(c.Spec.TLSKeyPairs[0].Cert, c.Spec.TLSKeyPairs[0].Key)
} | [
"func",
"(",
"c",
"*",
"CertAuthorityV2",
")",
"TLSCA",
"(",
")",
"(",
"*",
"tlsca",
".",
"CertAuthority",
",",
"error",
")",
"{",
"if",
"len",
"(",
"c",
".",
"Spec",
".",
"TLSKeyPairs",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"no TLS key pairs found for certificate authority\"",
")",
"\n",
"}",
"\n",
"return",
"tlsca",
".",
"New",
"(",
"c",
".",
"Spec",
".",
"TLSKeyPairs",
"[",
"0",
"]",
".",
"Cert",
",",
"c",
".",
"Spec",
".",
"TLSKeyPairs",
"[",
"0",
"]",
".",
"Key",
")",
"\n",
"}"
] | // TLSCA returns TLS certificate authority | [
"TLSCA",
"returns",
"TLS",
"certificate",
"authority"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L349-L354 | train |
gravitational/teleport | lib/services/authority.go | String | func (c *CertAuthorityV2) String() string {
return fmt.Sprintf("CA(name=%v, type=%v)", c.GetClusterName(), c.GetType())
} | go | func (c *CertAuthorityV2) String() string {
return fmt.Sprintf("CA(name=%v, type=%v)", c.GetClusterName(), c.GetType())
} | [
"func",
"(",
"c",
"*",
"CertAuthorityV2",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"CA(name=%v, type=%v)\"",
",",
"c",
".",
"GetClusterName",
"(",
")",
",",
"c",
".",
"GetType",
"(",
")",
")",
"\n",
"}"
] | // String returns human readable version of the CertAuthorityV2. | [
"String",
"returns",
"human",
"readable",
"version",
"of",
"the",
"CertAuthorityV2",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L402-L404 | train |
gravitational/teleport | lib/services/authority.go | AddRole | func (ca *CertAuthorityV2) AddRole(name string) {
for _, r := range ca.Spec.Roles {
if r == name {
return
}
}
ca.Spec.Roles = append(ca.Spec.Roles, name)
} | go | func (ca *CertAuthorityV2) AddRole(name string) {
for _, r := range ca.Spec.Roles {
if r == name {
return
}
}
ca.Spec.Roles = append(ca.Spec.Roles, name)
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"AddRole",
"(",
"name",
"string",
")",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"ca",
".",
"Spec",
".",
"Roles",
"{",
"if",
"r",
"==",
"name",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"ca",
".",
"Spec",
".",
"Roles",
"=",
"append",
"(",
"ca",
".",
"Spec",
".",
"Roles",
",",
"name",
")",
"\n",
"}"
] | // AddRole adds a role to ca role list | [
"AddRole",
"adds",
"a",
"role",
"to",
"ca",
"role",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L417-L424 | train |
gravitational/teleport | lib/services/authority.go | SetSigningKeys | func (ca *CertAuthorityV2) SetSigningKeys(keys [][]byte) error {
ca.Spec.SigningKeys = keys
return nil
} | go | func (ca *CertAuthorityV2) SetSigningKeys(keys [][]byte) error {
ca.Spec.SigningKeys = keys
return nil
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"SetSigningKeys",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
")",
"error",
"{",
"ca",
".",
"Spec",
".",
"SigningKeys",
"=",
"keys",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetSigningKeys sets signing keys | [
"SetSigningKeys",
"sets",
"signing",
"keys"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L432-L435 | train |
gravitational/teleport | lib/services/authority.go | SetCheckingKeys | func (ca *CertAuthorityV2) SetCheckingKeys(keys [][]byte) error {
ca.Spec.CheckingKeys = keys
return nil
} | go | func (ca *CertAuthorityV2) SetCheckingKeys(keys [][]byte) error {
ca.Spec.CheckingKeys = keys
return nil
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"SetCheckingKeys",
"(",
"keys",
"[",
"]",
"[",
"]",
"byte",
")",
"error",
"{",
"ca",
".",
"Spec",
".",
"CheckingKeys",
"=",
"keys",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetCheckingKeys sets SSH public keys | [
"SetCheckingKeys",
"sets",
"SSH",
"public",
"keys"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L438-L441 | train |
gravitational/teleport | lib/services/authority.go | GetID | func (ca *CertAuthorityV2) GetID() CertAuthID {
return CertAuthID{Type: ca.Spec.Type, DomainName: ca.Metadata.Name}
} | go | func (ca *CertAuthorityV2) GetID() CertAuthID {
return CertAuthID{Type: ca.Spec.Type, DomainName: ca.Metadata.Name}
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"GetID",
"(",
")",
"CertAuthID",
"{",
"return",
"CertAuthID",
"{",
"Type",
":",
"ca",
".",
"Spec",
".",
"Type",
",",
"DomainName",
":",
"ca",
".",
"Metadata",
".",
"Name",
"}",
"\n",
"}"
] | // GetID returns certificate authority ID -
// combined type and name | [
"GetID",
"returns",
"certificate",
"authority",
"ID",
"-",
"combined",
"type",
"and",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L445-L447 | train |
gravitational/teleport | lib/services/authority.go | SetRoleMap | func (c *CertAuthorityV2) SetRoleMap(m RoleMap) {
c.Spec.RoleMap = []RoleMapping(m)
} | go | func (c *CertAuthorityV2) SetRoleMap(m RoleMap) {
c.Spec.RoleMap = []RoleMapping(m)
} | [
"func",
"(",
"c",
"*",
"CertAuthorityV2",
")",
"SetRoleMap",
"(",
"m",
"RoleMap",
")",
"{",
"c",
".",
"Spec",
".",
"RoleMap",
"=",
"[",
"]",
"RoleMapping",
"(",
"m",
")",
"\n",
"}"
] | // SetRoleMap sets role map | [
"SetRoleMap",
"sets",
"role",
"map"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L500-L502 | train |
gravitational/teleport | lib/services/authority.go | FirstSigningKey | func (ca *CertAuthorityV2) FirstSigningKey() ([]byte, error) {
if len(ca.Spec.SigningKeys) == 0 {
return nil, trace.NotFound("%v has no signing keys", ca.Metadata.Name)
}
return ca.Spec.SigningKeys[0], nil
} | go | func (ca *CertAuthorityV2) FirstSigningKey() ([]byte, error) {
if len(ca.Spec.SigningKeys) == 0 {
return nil, trace.NotFound("%v has no signing keys", ca.Metadata.Name)
}
return ca.Spec.SigningKeys[0], nil
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"FirstSigningKey",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"ca",
".",
"Spec",
".",
"SigningKeys",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"%v has no signing keys\"",
",",
"ca",
".",
"Metadata",
".",
"Name",
")",
"\n",
"}",
"\n",
"return",
"ca",
".",
"Spec",
".",
"SigningKeys",
"[",
"0",
"]",
",",
"nil",
"\n",
"}"
] | // FirstSigningKey returns first signing key or returns error if it's not here | [
"FirstSigningKey",
"returns",
"first",
"signing",
"key",
"or",
"returns",
"error",
"if",
"it",
"s",
"not",
"here"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L505-L510 | train |
gravitational/teleport | lib/services/authority.go | Checkers | func (ca *CertAuthorityV2) Checkers() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(ca.Spec.CheckingKeys))
for _, keyBytes := range ca.Spec.CheckingKeys {
key, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.BadParameter("invalid authority public key (len=%d): %v", len(keyBytes), err)
}
out = append(out, key)
}
return out, nil
} | go | func (ca *CertAuthorityV2) Checkers() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(ca.Spec.CheckingKeys))
for _, keyBytes := range ca.Spec.CheckingKeys {
key, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.BadParameter("invalid authority public key (len=%d): %v", len(keyBytes), err)
}
out = append(out, key)
}
return out, nil
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"Checkers",
"(",
")",
"(",
"[",
"]",
"ssh",
".",
"PublicKey",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"ssh",
".",
"PublicKey",
",",
"0",
",",
"len",
"(",
"ca",
".",
"Spec",
".",
"CheckingKeys",
")",
")",
"\n",
"for",
"_",
",",
"keyBytes",
":=",
"range",
"ca",
".",
"Spec",
".",
"CheckingKeys",
"{",
"key",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid authority public key (len=%d): %v\"",
",",
"len",
"(",
"keyBytes",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"key",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // Checkers returns public keys that can be used to check cert authorities | [
"Checkers",
"returns",
"public",
"keys",
"that",
"can",
"be",
"used",
"to",
"check",
"cert",
"authorities"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L519-L529 | train |
gravitational/teleport | lib/services/authority.go | Signers | func (ca *CertAuthorityV2) Signers() ([]ssh.Signer, error) {
out := make([]ssh.Signer, 0, len(ca.Spec.SigningKeys))
for _, keyBytes := range ca.Spec.SigningKeys {
signer, err := ssh.ParsePrivateKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, signer)
}
return out, nil
} | go | func (ca *CertAuthorityV2) Signers() ([]ssh.Signer, error) {
out := make([]ssh.Signer, 0, len(ca.Spec.SigningKeys))
for _, keyBytes := range ca.Spec.SigningKeys {
signer, err := ssh.ParsePrivateKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, signer)
}
return out, nil
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"Signers",
"(",
")",
"(",
"[",
"]",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"ssh",
".",
"Signer",
",",
"0",
",",
"len",
"(",
"ca",
".",
"Spec",
".",
"SigningKeys",
")",
")",
"\n",
"for",
"_",
",",
"keyBytes",
":=",
"range",
"ca",
".",
"Spec",
".",
"SigningKeys",
"{",
"signer",
",",
"err",
":=",
"ssh",
".",
"ParsePrivateKey",
"(",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"signer",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // Signers returns a list of signers that could be used to sign keys | [
"Signers",
"returns",
"a",
"list",
"of",
"signers",
"that",
"could",
"be",
"used",
"to",
"sign",
"keys"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L532-L542 | train |
gravitational/teleport | lib/services/authority.go | Check | func (ca *CertAuthorityV2) Check() error {
err := ca.ID().Check()
if err != nil {
return trace.Wrap(err)
}
_, err = ca.Checkers()
if err != nil {
return trace.Wrap(err)
}
_, err = ca.Signers()
if err != nil {
return trace.Wrap(err)
}
// This is to force users to migrate
if len(ca.Spec.Roles) != 0 && len(ca.Spec.RoleMap) != 0 {
return trace.BadParameter("should set either 'roles' or 'role_map', not both")
}
if err := RoleMap(ca.Spec.RoleMap).Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (ca *CertAuthorityV2) Check() error {
err := ca.ID().Check()
if err != nil {
return trace.Wrap(err)
}
_, err = ca.Checkers()
if err != nil {
return trace.Wrap(err)
}
_, err = ca.Signers()
if err != nil {
return trace.Wrap(err)
}
// This is to force users to migrate
if len(ca.Spec.Roles) != 0 && len(ca.Spec.RoleMap) != 0 {
return trace.BadParameter("should set either 'roles' or 'role_map', not both")
}
if err := RoleMap(ca.Spec.RoleMap).Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"ca",
"*",
"CertAuthorityV2",
")",
"Check",
"(",
")",
"error",
"{",
"err",
":=",
"ca",
".",
"ID",
"(",
")",
".",
"Check",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"ca",
".",
"Checkers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"ca",
".",
"Signers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"ca",
".",
"Spec",
".",
"Roles",
")",
"!=",
"0",
"&&",
"len",
"(",
"ca",
".",
"Spec",
".",
"RoleMap",
")",
"!=",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"should set either 'roles' or 'role_map', not both\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"RoleMap",
"(",
"ca",
".",
"Spec",
".",
"RoleMap",
")",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check checks if all passed parameters are valid | [
"Check",
"checks",
"if",
"all",
"passed",
"parameters",
"are",
"valid"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L545-L566 | train |
gravitational/teleport | lib/services/authority.go | RemoveCASecrets | func RemoveCASecrets(ca CertAuthority) {
ca.SetSigningKeys(nil)
keyPairs := ca.GetTLSKeyPairs()
for i := range keyPairs {
keyPairs[i].Key = nil
}
ca.SetTLSKeyPairs(keyPairs)
} | go | func RemoveCASecrets(ca CertAuthority) {
ca.SetSigningKeys(nil)
keyPairs := ca.GetTLSKeyPairs()
for i := range keyPairs {
keyPairs[i].Key = nil
}
ca.SetTLSKeyPairs(keyPairs)
} | [
"func",
"RemoveCASecrets",
"(",
"ca",
"CertAuthority",
")",
"{",
"ca",
".",
"SetSigningKeys",
"(",
"nil",
")",
"\n",
"keyPairs",
":=",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
"\n",
"for",
"i",
":=",
"range",
"keyPairs",
"{",
"keyPairs",
"[",
"i",
"]",
".",
"Key",
"=",
"nil",
"\n",
"}",
"\n",
"ca",
".",
"SetTLSKeyPairs",
"(",
"keyPairs",
")",
"\n",
"}"
] | // RemoveCASecrets removes secret values and keys
// from the certificate authority | [
"RemoveCASecrets",
"removes",
"secret",
"values",
"and",
"keys",
"from",
"the",
"certificate",
"authority"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L585-L592 | train |
gravitational/teleport | lib/services/authority.go | Matches | func (s *Rotation) Matches(rotation Rotation) bool {
return s.CurrentID == rotation.CurrentID && s.State == rotation.State && s.Phase == rotation.Phase
} | go | func (s *Rotation) Matches(rotation Rotation) bool {
return s.CurrentID == rotation.CurrentID && s.State == rotation.State && s.Phase == rotation.Phase
} | [
"func",
"(",
"s",
"*",
"Rotation",
")",
"Matches",
"(",
"rotation",
"Rotation",
")",
"bool",
"{",
"return",
"s",
".",
"CurrentID",
"==",
"rotation",
".",
"CurrentID",
"&&",
"s",
".",
"State",
"==",
"rotation",
".",
"State",
"&&",
"s",
".",
"Phase",
"==",
"rotation",
".",
"Phase",
"\n",
"}"
] | // Matches returns true if this state rotation matches
// external rotation state, phase and rotation ID should match,
// notice that matches does not behave like Equals because it does not require
// all fields to be the same. | [
"Matches",
"returns",
"true",
"if",
"this",
"state",
"rotation",
"matches",
"external",
"rotation",
"state",
"phase",
"and",
"rotation",
"ID",
"should",
"match",
"notice",
"that",
"matches",
"does",
"not",
"behave",
"like",
"Equals",
"because",
"it",
"does",
"not",
"require",
"all",
"fields",
"to",
"be",
"the",
"same",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L641-L643 | train |
gravitational/teleport | lib/services/authority.go | LastRotatedDescription | func (r *Rotation) LastRotatedDescription() string {
if r.LastRotated.IsZero() {
return "never updated"
}
return fmt.Sprintf("last rotated %v", r.LastRotated.Format(teleport.HumanDateFormatSeconds))
} | go | func (r *Rotation) LastRotatedDescription() string {
if r.LastRotated.IsZero() {
return "never updated"
}
return fmt.Sprintf("last rotated %v", r.LastRotated.Format(teleport.HumanDateFormatSeconds))
} | [
"func",
"(",
"r",
"*",
"Rotation",
")",
"LastRotatedDescription",
"(",
")",
"string",
"{",
"if",
"r",
".",
"LastRotated",
".",
"IsZero",
"(",
")",
"{",
"return",
"\"never updated\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"last rotated %v\"",
",",
"r",
".",
"LastRotated",
".",
"Format",
"(",
"teleport",
".",
"HumanDateFormatSeconds",
")",
")",
"\n",
"}"
] | // LastRotatedDescription returns human friendly description. | [
"LastRotatedDescription",
"returns",
"human",
"friendly",
"description",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L646-L651 | train |
gravitational/teleport | lib/services/authority.go | PhaseDescription | func (r *Rotation) PhaseDescription() string {
switch r.Phase {
case RotationPhaseInit:
return "initialized"
case RotationPhaseStandby, "":
return "on standby"
case RotationPhaseUpdateClients:
return "rotating clients"
case RotationPhaseUpdateServers:
return "rotating servers"
case RotationPhaseRollback:
return "rolling back"
default:
return fmt.Sprintf("unknown phase: %q", r.Phase)
}
} | go | func (r *Rotation) PhaseDescription() string {
switch r.Phase {
case RotationPhaseInit:
return "initialized"
case RotationPhaseStandby, "":
return "on standby"
case RotationPhaseUpdateClients:
return "rotating clients"
case RotationPhaseUpdateServers:
return "rotating servers"
case RotationPhaseRollback:
return "rolling back"
default:
return fmt.Sprintf("unknown phase: %q", r.Phase)
}
} | [
"func",
"(",
"r",
"*",
"Rotation",
")",
"PhaseDescription",
"(",
")",
"string",
"{",
"switch",
"r",
".",
"Phase",
"{",
"case",
"RotationPhaseInit",
":",
"return",
"\"initialized\"",
"\n",
"case",
"RotationPhaseStandby",
",",
"\"\"",
":",
"return",
"\"on standby\"",
"\n",
"case",
"RotationPhaseUpdateClients",
":",
"return",
"\"rotating clients\"",
"\n",
"case",
"RotationPhaseUpdateServers",
":",
"return",
"\"rotating servers\"",
"\n",
"case",
"RotationPhaseRollback",
":",
"return",
"\"rolling back\"",
"\n",
"default",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"unknown phase: %q\"",
",",
"r",
".",
"Phase",
")",
"\n",
"}",
"\n",
"}"
] | // PhaseDescription returns human friendly description of a current rotation phase. | [
"PhaseDescription",
"returns",
"human",
"friendly",
"description",
"of",
"a",
"current",
"rotation",
"phase",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L654-L669 | train |
gravitational/teleport | lib/services/authority.go | String | func (r *Rotation) String() string {
switch r.State {
case "", RotationStateStandby:
if r.LastRotated.IsZero() {
return "never updated"
}
return fmt.Sprintf("rotated %v", r.LastRotated.Format(teleport.HumanDateFormatSeconds))
case RotationStateInProgress:
return fmt.Sprintf("%v (mode: %v, started: %v, ending: %v)",
r.PhaseDescription(),
r.Mode,
r.Started.Format(teleport.HumanDateFormatSeconds),
r.Started.Add(r.GracePeriod.Duration()).Format(teleport.HumanDateFormatSeconds),
)
default:
return "unknown"
}
} | go | func (r *Rotation) String() string {
switch r.State {
case "", RotationStateStandby:
if r.LastRotated.IsZero() {
return "never updated"
}
return fmt.Sprintf("rotated %v", r.LastRotated.Format(teleport.HumanDateFormatSeconds))
case RotationStateInProgress:
return fmt.Sprintf("%v (mode: %v, started: %v, ending: %v)",
r.PhaseDescription(),
r.Mode,
r.Started.Format(teleport.HumanDateFormatSeconds),
r.Started.Add(r.GracePeriod.Duration()).Format(teleport.HumanDateFormatSeconds),
)
default:
return "unknown"
}
} | [
"func",
"(",
"r",
"*",
"Rotation",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"r",
".",
"State",
"{",
"case",
"\"\"",
",",
"RotationStateStandby",
":",
"if",
"r",
".",
"LastRotated",
".",
"IsZero",
"(",
")",
"{",
"return",
"\"never updated\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"rotated %v\"",
",",
"r",
".",
"LastRotated",
".",
"Format",
"(",
"teleport",
".",
"HumanDateFormatSeconds",
")",
")",
"\n",
"case",
"RotationStateInProgress",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%v (mode: %v, started: %v, ending: %v)\"",
",",
"r",
".",
"PhaseDescription",
"(",
")",
",",
"r",
".",
"Mode",
",",
"r",
".",
"Started",
".",
"Format",
"(",
"teleport",
".",
"HumanDateFormatSeconds",
")",
",",
"r",
".",
"Started",
".",
"Add",
"(",
"r",
".",
"GracePeriod",
".",
"Duration",
"(",
")",
")",
".",
"Format",
"(",
"teleport",
".",
"HumanDateFormatSeconds",
")",
",",
")",
"\n",
"default",
":",
"return",
"\"unknown\"",
"\n",
"}",
"\n",
"}"
] | // String returns user friendly information about certificate authority. | [
"String",
"returns",
"user",
"friendly",
"information",
"about",
"certificate",
"authority",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L672-L689 | train |
gravitational/teleport | lib/services/authority.go | CheckAndSetDefaults | func (r *Rotation) CheckAndSetDefaults(clock clockwork.Clock) error {
switch r.Phase {
case "", RotationPhaseRollback, RotationPhaseUpdateClients, RotationPhaseUpdateServers:
default:
return trace.BadParameter("unsupported phase: %q", r.Phase)
}
switch r.Mode {
case "", RotationModeAuto, RotationModeManual:
default:
return trace.BadParameter("unsupported mode: %q", r.Mode)
}
switch r.State {
case "":
r.State = RotationStateStandby
case RotationStateStandby:
case RotationStateInProgress:
if r.CurrentID == "" {
return trace.BadParameter("set 'current_id' parameter for in progress rotation")
}
if r.Started.IsZero() {
return trace.BadParameter("set 'started' parameter for in progress rotation")
}
default:
return trace.BadParameter(
"unsupported rotation 'state': %q, supported states are: %q, %q",
r.State, RotationStateStandby, RotationStateInProgress)
}
return nil
} | go | func (r *Rotation) CheckAndSetDefaults(clock clockwork.Clock) error {
switch r.Phase {
case "", RotationPhaseRollback, RotationPhaseUpdateClients, RotationPhaseUpdateServers:
default:
return trace.BadParameter("unsupported phase: %q", r.Phase)
}
switch r.Mode {
case "", RotationModeAuto, RotationModeManual:
default:
return trace.BadParameter("unsupported mode: %q", r.Mode)
}
switch r.State {
case "":
r.State = RotationStateStandby
case RotationStateStandby:
case RotationStateInProgress:
if r.CurrentID == "" {
return trace.BadParameter("set 'current_id' parameter for in progress rotation")
}
if r.Started.IsZero() {
return trace.BadParameter("set 'started' parameter for in progress rotation")
}
default:
return trace.BadParameter(
"unsupported rotation 'state': %q, supported states are: %q, %q",
r.State, RotationStateStandby, RotationStateInProgress)
}
return nil
} | [
"func",
"(",
"r",
"*",
"Rotation",
")",
"CheckAndSetDefaults",
"(",
"clock",
"clockwork",
".",
"Clock",
")",
"error",
"{",
"switch",
"r",
".",
"Phase",
"{",
"case",
"\"\"",
",",
"RotationPhaseRollback",
",",
"RotationPhaseUpdateClients",
",",
"RotationPhaseUpdateServers",
":",
"default",
":",
"return",
"trace",
".",
"BadParameter",
"(",
"\"unsupported phase: %q\"",
",",
"r",
".",
"Phase",
")",
"\n",
"}",
"\n",
"switch",
"r",
".",
"Mode",
"{",
"case",
"\"\"",
",",
"RotationModeAuto",
",",
"RotationModeManual",
":",
"default",
":",
"return",
"trace",
".",
"BadParameter",
"(",
"\"unsupported mode: %q\"",
",",
"r",
".",
"Mode",
")",
"\n",
"}",
"\n",
"switch",
"r",
".",
"State",
"{",
"case",
"\"\"",
":",
"r",
".",
"State",
"=",
"RotationStateStandby",
"\n",
"case",
"RotationStateStandby",
":",
"case",
"RotationStateInProgress",
":",
"if",
"r",
".",
"CurrentID",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"set 'current_id' parameter for in progress rotation\"",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Started",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"set 'started' parameter for in progress rotation\"",
")",
"\n",
"}",
"\n",
"default",
":",
"return",
"trace",
".",
"BadParameter",
"(",
"\"unsupported rotation 'state': %q, supported states are: %q, %q\"",
",",
"r",
".",
"State",
",",
"RotationStateStandby",
",",
"RotationStateInProgress",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets default rotation parameters. | [
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"rotation",
"parameters",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L692-L720 | train |
gravitational/teleport | lib/services/authority.go | GenerateSchedule | func GenerateSchedule(clock clockwork.Clock, gracePeriod time.Duration) (*RotationSchedule, error) {
if gracePeriod <= 0 {
return nil, trace.BadParameter("invalid grace period %q, provide value > 0", gracePeriod)
}
return &RotationSchedule{
UpdateClients: clock.Now().UTC().Add(gracePeriod / 3).UTC(),
UpdateServers: clock.Now().UTC().Add((gracePeriod * 2) / 3).UTC(),
Standby: clock.Now().UTC().Add(gracePeriod).UTC(),
}, nil
} | go | func GenerateSchedule(clock clockwork.Clock, gracePeriod time.Duration) (*RotationSchedule, error) {
if gracePeriod <= 0 {
return nil, trace.BadParameter("invalid grace period %q, provide value > 0", gracePeriod)
}
return &RotationSchedule{
UpdateClients: clock.Now().UTC().Add(gracePeriod / 3).UTC(),
UpdateServers: clock.Now().UTC().Add((gracePeriod * 2) / 3).UTC(),
Standby: clock.Now().UTC().Add(gracePeriod).UTC(),
}, nil
} | [
"func",
"GenerateSchedule",
"(",
"clock",
"clockwork",
".",
"Clock",
",",
"gracePeriod",
"time",
".",
"Duration",
")",
"(",
"*",
"RotationSchedule",
",",
"error",
")",
"{",
"if",
"gracePeriod",
"<=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid grace period %q, provide value > 0\"",
",",
"gracePeriod",
")",
"\n",
"}",
"\n",
"return",
"&",
"RotationSchedule",
"{",
"UpdateClients",
":",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"gracePeriod",
"/",
"3",
")",
".",
"UTC",
"(",
")",
",",
"UpdateServers",
":",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"(",
"gracePeriod",
"*",
"2",
")",
"/",
"3",
")",
".",
"UTC",
"(",
")",
",",
"Standby",
":",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"gracePeriod",
")",
".",
"UTC",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // GenerateSchedule generates schedule based on the time period, using
// even time periods between rotation phases. | [
"GenerateSchedule",
"generates",
"schedule",
"based",
"on",
"the",
"time",
"period",
"using",
"even",
"time",
"periods",
"between",
"rotation",
"phases",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L724-L733 | train |
gravitational/teleport | lib/services/authority.go | CheckAndSetDefaults | func (s *RotationSchedule) CheckAndSetDefaults(clock clockwork.Clock) error {
if s.UpdateServers.IsZero() {
return trace.BadParameter("phase %q has no time switch scheduled", RotationPhaseUpdateServers)
}
if s.Standby.IsZero() {
return trace.BadParameter("phase %q has no time switch scheduled", RotationPhaseStandby)
}
if s.Standby.Before(s.UpdateServers) {
return trace.BadParameter("phase %q can not be scheduled before %q", RotationPhaseStandby, RotationPhaseUpdateServers)
}
if s.UpdateServers.Before(clock.Now()) {
return trace.BadParameter("phase %q can not be scheduled in the past", RotationPhaseUpdateServers)
}
if s.Standby.Before(clock.Now()) {
return trace.BadParameter("phase %q can not be scheduled in the past", RotationPhaseStandby)
}
return nil
} | go | func (s *RotationSchedule) CheckAndSetDefaults(clock clockwork.Clock) error {
if s.UpdateServers.IsZero() {
return trace.BadParameter("phase %q has no time switch scheduled", RotationPhaseUpdateServers)
}
if s.Standby.IsZero() {
return trace.BadParameter("phase %q has no time switch scheduled", RotationPhaseStandby)
}
if s.Standby.Before(s.UpdateServers) {
return trace.BadParameter("phase %q can not be scheduled before %q", RotationPhaseStandby, RotationPhaseUpdateServers)
}
if s.UpdateServers.Before(clock.Now()) {
return trace.BadParameter("phase %q can not be scheduled in the past", RotationPhaseUpdateServers)
}
if s.Standby.Before(clock.Now()) {
return trace.BadParameter("phase %q can not be scheduled in the past", RotationPhaseStandby)
}
return nil
} | [
"func",
"(",
"s",
"*",
"RotationSchedule",
")",
"CheckAndSetDefaults",
"(",
"clock",
"clockwork",
".",
"Clock",
")",
"error",
"{",
"if",
"s",
".",
"UpdateServers",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"phase %q has no time switch scheduled\"",
",",
"RotationPhaseUpdateServers",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"Standby",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"phase %q has no time switch scheduled\"",
",",
"RotationPhaseStandby",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"Standby",
".",
"Before",
"(",
"s",
".",
"UpdateServers",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"phase %q can not be scheduled before %q\"",
",",
"RotationPhaseStandby",
",",
"RotationPhaseUpdateServers",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"UpdateServers",
".",
"Before",
"(",
"clock",
".",
"Now",
"(",
")",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"phase %q can not be scheduled in the past\"",
",",
"RotationPhaseUpdateServers",
")",
"\n",
"}",
"\n",
"if",
"s",
".",
"Standby",
".",
"Before",
"(",
"clock",
".",
"Now",
"(",
")",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"phase %q can not be scheduled in the past\"",
",",
"RotationPhaseStandby",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets default values of the rotation schedule. | [
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"values",
"of",
"the",
"rotation",
"schedule",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L736-L753 | train |
gravitational/teleport | lib/services/authority.go | String | func (c *CertAuthorityV1) String() string {
return fmt.Sprintf("CA(name=%v, type=%v)", c.DomainName, c.Type)
} | go | func (c *CertAuthorityV1) String() string {
return fmt.Sprintf("CA(name=%v, type=%v)", c.DomainName, c.Type)
} | [
"func",
"(",
"c",
"*",
"CertAuthorityV1",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"CA(name=%v, type=%v)\"",
",",
"c",
".",
"DomainName",
",",
"c",
".",
"Type",
")",
"\n",
"}"
] | // String returns human readable version of the CertAuthorityV1. | [
"String",
"returns",
"human",
"readable",
"version",
"of",
"the",
"CertAuthorityV1",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L878-L880 | train |
gravitational/teleport | lib/services/authority.go | GetCertAuthoritySchema | func GetCertAuthoritySchema() string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(CertAuthoritySpecV2Schema, RotationSchema, RoleMapSchema), DefaultDefinitions)
} | go | func GetCertAuthoritySchema() string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(CertAuthoritySpecV2Schema, RotationSchema, RoleMapSchema), DefaultDefinitions)
} | [
"func",
"GetCertAuthoritySchema",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"fmt",
".",
"Sprintf",
"(",
"CertAuthoritySpecV2Schema",
",",
"RotationSchema",
",",
"RoleMapSchema",
")",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] | // GetCertAuthoritySchema returns JSON Schema for cert authorities | [
"GetCertAuthoritySchema",
"returns",
"JSON",
"Schema",
"for",
"cert",
"authorities"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L912-L914 | train |
gravitational/teleport | lib/services/authority.go | UnmarshalCertAuthority | func (*TeleportCertAuthorityMarshaler) UnmarshalCertAuthority(bytes []byte, opts ...MarshalOption) (CertAuthority, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var ca CertAuthorityV1
err := json.Unmarshal(bytes, &ca)
if err != nil {
return nil, trace.Wrap(err)
}
return ca.V2(), nil
case V2:
var ca CertAuthorityV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &ca); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetCertAuthoritySchema(), &ca, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := ca.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
ca.SetResourceID(cfg.ID)
}
return &ca, nil
}
return nil, trace.BadParameter("cert authority resource version %v is not supported", h.Version)
} | go | func (*TeleportCertAuthorityMarshaler) UnmarshalCertAuthority(bytes []byte, opts ...MarshalOption) (CertAuthority, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var ca CertAuthorityV1
err := json.Unmarshal(bytes, &ca)
if err != nil {
return nil, trace.Wrap(err)
}
return ca.V2(), nil
case V2:
var ca CertAuthorityV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &ca); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetCertAuthoritySchema(), &ca, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := ca.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
ca.SetResourceID(cfg.ID)
}
return &ca, nil
}
return nil, trace.BadParameter("cert authority resource version %v is not supported", h.Version)
} | [
"func",
"(",
"*",
"TeleportCertAuthorityMarshaler",
")",
"UnmarshalCertAuthority",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"CertAuthority",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"h",
"ResourceHeader",
"\n",
"err",
"=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"ca",
"CertAuthorityV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"ca",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ca",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"ca",
"CertAuthorityV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"ca",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetCertAuthoritySchema",
"(",
")",
",",
"&",
"ca",
",",
"bytes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"ca",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"ca",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"return",
"&",
"ca",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"cert authority resource version %v is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalCertAuthority unmarshals cert authority from JSON | [
"UnmarshalCertAuthority",
"unmarshals",
"cert",
"authority",
"from",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L926-L965 | train |
gravitational/teleport | lib/services/authority.go | MarshalCertAuthority | func (*TeleportCertAuthorityMarshaler) MarshalCertAuthority(ca CertAuthority, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type cav1 interface {
V1() *CertAuthorityV1
}
type cav2 interface {
V2() *CertAuthorityV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := ca.(cav1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return utils.FastMarshal(v.V1())
case V2:
v, ok := ca.(cav2)
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 (*TeleportCertAuthorityMarshaler) MarshalCertAuthority(ca CertAuthority, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type cav1 interface {
V1() *CertAuthorityV1
}
type cav2 interface {
V2() *CertAuthorityV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := ca.(cav1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return utils.FastMarshal(v.V1())
case V2:
v, ok := ca.(cav2)
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",
"(",
"*",
"TeleportCertAuthorityMarshaler",
")",
"MarshalCertAuthority",
"(",
"ca",
"CertAuthority",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"cav1",
"interface",
"{",
"V1",
"(",
")",
"*",
"CertAuthorityV1",
"\n",
"}",
"\n",
"type",
"cav2",
"interface",
"{",
"V2",
"(",
")",
"*",
"CertAuthorityV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"ca",
".",
"(",
"cav1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"ca",
".",
"(",
"cav2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"version %v is not supported\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] | // MarshalCertAuthority marshalls cert authority into JSON | [
"MarshalCertAuthority",
"marshalls",
"cert",
"authority",
"into",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/authority.go#L968-L1005 | train |
gravitational/teleport | lib/events/fields.go | UpdateEventFields | func UpdateEventFields(event Event, fields EventFields, clock clockwork.Clock, uid utils.UID) (err error) {
additionalFields := make(map[string]interface{})
if fields.GetType() == "" {
additionalFields[EventType] = event.Name
}
if fields.GetID() == "" {
additionalFields[EventID] = uid.New()
}
if fields.GetTimestamp().IsZero() {
additionalFields[EventTime] = clock.Now().UTC().Round(time.Second)
}
if event.Code != "" {
additionalFields[EventCode] = event.Code
}
for k, v := range additionalFields {
fields[k] = v
}
return nil
} | go | func UpdateEventFields(event Event, fields EventFields, clock clockwork.Clock, uid utils.UID) (err error) {
additionalFields := make(map[string]interface{})
if fields.GetType() == "" {
additionalFields[EventType] = event.Name
}
if fields.GetID() == "" {
additionalFields[EventID] = uid.New()
}
if fields.GetTimestamp().IsZero() {
additionalFields[EventTime] = clock.Now().UTC().Round(time.Second)
}
if event.Code != "" {
additionalFields[EventCode] = event.Code
}
for k, v := range additionalFields {
fields[k] = v
}
return nil
} | [
"func",
"UpdateEventFields",
"(",
"event",
"Event",
",",
"fields",
"EventFields",
",",
"clock",
"clockwork",
".",
"Clock",
",",
"uid",
"utils",
".",
"UID",
")",
"(",
"err",
"error",
")",
"{",
"additionalFields",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"fields",
".",
"GetType",
"(",
")",
"==",
"\"\"",
"{",
"additionalFields",
"[",
"EventType",
"]",
"=",
"event",
".",
"Name",
"\n",
"}",
"\n",
"if",
"fields",
".",
"GetID",
"(",
")",
"==",
"\"\"",
"{",
"additionalFields",
"[",
"EventID",
"]",
"=",
"uid",
".",
"New",
"(",
")",
"\n",
"}",
"\n",
"if",
"fields",
".",
"GetTimestamp",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"additionalFields",
"[",
"EventTime",
"]",
"=",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Round",
"(",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"if",
"event",
".",
"Code",
"!=",
"\"\"",
"{",
"additionalFields",
"[",
"EventCode",
"]",
"=",
"event",
".",
"Code",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"additionalFields",
"{",
"fields",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpdateEventFields updates passed event fields with additional information
// common for all event types such as unique IDs, timestamps, codes, etc.
//
// This method is a "final stop" for various audit log implementations for
// updating event fields before it gets persisted in the backend. | [
"UpdateEventFields",
"updates",
"passed",
"event",
"fields",
"with",
"additional",
"information",
"common",
"for",
"all",
"event",
"types",
"such",
"as",
"unique",
"IDs",
"timestamps",
"codes",
"etc",
".",
"This",
"method",
"is",
"a",
"final",
"stop",
"for",
"various",
"audit",
"log",
"implementations",
"for",
"updating",
"event",
"fields",
"before",
"it",
"gets",
"persisted",
"in",
"the",
"backend",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/fields.go#L32-L50 | train |
gravitational/teleport | lib/reversetunnel/api.go | CheckAndSetDefaults | func (d *DialParams) CheckAndSetDefaults() error {
if d.From == nil {
return trace.BadParameter("parameter From required")
}
if d.To == nil {
return trace.BadParameter("parameter To required")
}
return nil
} | go | func (d *DialParams) CheckAndSetDefaults() error {
if d.From == nil {
return trace.BadParameter("parameter From required")
}
if d.To == nil {
return trace.BadParameter("parameter To required")
}
return nil
} | [
"func",
"(",
"d",
"*",
"DialParams",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"d",
".",
"From",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"parameter From required\"",
")",
"\n",
"}",
"\n",
"if",
"d",
".",
"To",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"parameter To required\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults makes sure the minimal parameters are set. | [
"CheckAndSetDefaults",
"makes",
"sure",
"the",
"minimal",
"parameters",
"are",
"set",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/api.go#L54-L63 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.