repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/services/role.go | MarshalTo | func (b BoolOption) MarshalTo(data []byte) (int, error) {
return b.protoType().MarshalTo(data)
} | go | func (b BoolOption) MarshalTo(data []byte) (int, error) {
return b.protoType().MarshalTo(data)
} | [
"func",
"(",
"b",
"BoolOption",
")",
"MarshalTo",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"b",
".",
"protoType",
"(",
")",
".",
"MarshalTo",
"(",
"data",
")",
"\n",
"}"
] | // MarshalTo marshals value to the slice | [
"MarshalTo",
"marshals",
"value",
"to",
"the",
"slice"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/role.go#L1933-L1935 | train |
gravitational/teleport | lib/services/role.go | UnmarshalJSON | func (d *Duration) UnmarshalJSON(data []byte) error {
if len(data) == 0 {
return nil
}
var stringVar string
if err := json.Unmarshal(data, &stringVar); err != nil {
return trace.Wrap(err)
}
if stringVar == teleport.DurationNever {
*d = Duration(0)
} else {
out, err := time.ParseDuration(stringVar)
if err != nil {
return trace.BadParameter(err.Error())
}
*d = Duration(out)
}
return nil
} | go | func (d *Duration) UnmarshalJSON(data []byte) error {
if len(data) == 0 {
return nil
}
var stringVar string
if err := json.Unmarshal(data, &stringVar); err != nil {
return trace.Wrap(err)
}
if stringVar == teleport.DurationNever {
*d = Duration(0)
} else {
out, err := time.ParseDuration(stringVar)
if err != nil {
return trace.BadParameter(err.Error())
}
*d = Duration(out)
}
return nil
} | [
"func",
"(",
"d",
"*",
"Duration",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"stringVar",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"stringVar",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"stringVar",
"==",
"teleport",
".",
"DurationNever",
"{",
"*",
"d",
"=",
"Duration",
"(",
"0",
")",
"\n",
"}",
"else",
"{",
"out",
",",
"err",
":=",
"time",
".",
"ParseDuration",
"(",
"stringVar",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"*",
"d",
"=",
"Duration",
"(",
"out",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON marshals Duration to string | [
"UnmarshalJSON",
"marshals",
"Duration",
"to",
"string"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/role.go#L2007-L2025 | train |
gravitational/teleport | lib/services/role.go | GetRoleSchema | func GetRoleSchema(version string, extensionSchema string) string {
schemaDefinitions := "," + RoleSpecV3SchemaDefinitions
if version == V2 {
schemaDefinitions = DefaultDefinitions
}
schemaTemplate := RoleSpecV3SchemaTemplate
if version == V2 {
schemaTemplate = RoleSpecV2SchemaTemplate
}
schema := fmt.Sprintf(schemaTemplate, ``)
if extensionSchema != "" {
schema = fmt.Sprintf(schemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, schema, schemaDefinitions)
} | go | func GetRoleSchema(version string, extensionSchema string) string {
schemaDefinitions := "," + RoleSpecV3SchemaDefinitions
if version == V2 {
schemaDefinitions = DefaultDefinitions
}
schemaTemplate := RoleSpecV3SchemaTemplate
if version == V2 {
schemaTemplate = RoleSpecV2SchemaTemplate
}
schema := fmt.Sprintf(schemaTemplate, ``)
if extensionSchema != "" {
schema = fmt.Sprintf(schemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, schema, schemaDefinitions)
} | [
"func",
"GetRoleSchema",
"(",
"version",
"string",
",",
"extensionSchema",
"string",
")",
"string",
"{",
"schemaDefinitions",
":=",
"\",\"",
"+",
"RoleSpecV3SchemaDefinitions",
"\n",
"if",
"version",
"==",
"V2",
"{",
"schemaDefinitions",
"=",
"DefaultDefinitions",
"\n",
"}",
"\n",
"schemaTemplate",
":=",
"RoleSpecV3SchemaTemplate",
"\n",
"if",
"version",
"==",
"V2",
"{",
"schemaTemplate",
"=",
"RoleSpecV2SchemaTemplate",
"\n",
"}",
"\n",
"schema",
":=",
"fmt",
".",
"Sprintf",
"(",
"schemaTemplate",
",",
"``",
")",
"\n",
"if",
"extensionSchema",
"!=",
"\"\"",
"{",
"schema",
"=",
"fmt",
".",
"Sprintf",
"(",
"schemaTemplate",
",",
"\",\"",
"+",
"extensionSchema",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"schema",
",",
"schemaDefinitions",
")",
"\n",
"}"
] | // GetRoleSchema returns role schema for the version requested with optionally
// injected schema for extensions. | [
"GetRoleSchema",
"returns",
"role",
"schema",
"for",
"the",
"version",
"requested",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/role.go#L2158-L2175 | train |
gravitational/teleport | lib/services/role.go | UnmarshalRole | func UnmarshalRole(data []byte, opts ...MarshalOption) (*RoleV3, error) {
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
h.Version = V2
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case V2:
var role RoleV2
if err := utils.UnmarshalWithSchema(GetRoleSchema(V2, ""), &role, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
if err := role.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
roleV3 := role.V3()
roleV3.SetResourceID(cfg.ID)
return roleV3, nil
case V3:
var role RoleV3
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &role); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetRoleSchema(V3, ""), &role, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := role.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
role.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
role.SetExpiry(cfg.Expires)
}
return &role, nil
}
return nil, trace.BadParameter("role version %q is not supported", h.Version)
} | go | func UnmarshalRole(data []byte, opts ...MarshalOption) (*RoleV3, error) {
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
h.Version = V2
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case V2:
var role RoleV2
if err := utils.UnmarshalWithSchema(GetRoleSchema(V2, ""), &role, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
if err := role.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
roleV3 := role.V3()
roleV3.SetResourceID(cfg.ID)
return roleV3, nil
case V3:
var role RoleV3
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &role); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetRoleSchema(V3, ""), &role, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := role.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
role.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
role.SetExpiry(cfg.Expires)
}
return &role, nil
}
return nil, trace.BadParameter("role version %q is not supported", h.Version)
} | [
"func",
"UnmarshalRole",
"(",
"data",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"*",
"RoleV3",
",",
"error",
")",
"{",
"var",
"h",
"ResourceHeader",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"h",
".",
"Version",
"=",
"V2",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"V2",
":",
"var",
"role",
"RoleV2",
"\n",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetRoleSchema",
"(",
"V2",
",",
"\"\"",
")",
",",
"&",
"role",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"role",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roleV3",
":=",
"role",
".",
"V3",
"(",
")",
"\n",
"roleV3",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"return",
"roleV3",
",",
"nil",
"\n",
"case",
"V3",
":",
"var",
"role",
"RoleV3",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"role",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetRoleSchema",
"(",
"V3",
",",
"\"\"",
")",
",",
"&",
"role",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"role",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"role",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"role",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"role",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"role version %q is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalRole unmarshals role from JSON, sets defaults, and checks schema. | [
"UnmarshalRole",
"unmarshals",
"role",
"from",
"JSON",
"sets",
"defaults",
"and",
"checks",
"schema",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/role.go#L2178-L2230 | train |
gravitational/teleport | lib/services/role.go | UnmarshalRole | func (*TeleportRoleMarshaler) UnmarshalRole(bytes []byte, opts ...MarshalOption) (Role, error) {
return UnmarshalRole(bytes, opts...)
} | go | func (*TeleportRoleMarshaler) UnmarshalRole(bytes []byte, opts ...MarshalOption) (Role, error) {
return UnmarshalRole(bytes, opts...)
} | [
"func",
"(",
"*",
"TeleportRoleMarshaler",
")",
"UnmarshalRole",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"Role",
",",
"error",
")",
"{",
"return",
"UnmarshalRole",
"(",
"bytes",
",",
"opts",
"...",
")",
"\n",
"}"
] | // UnmarshalRole unmarshals role from JSON. | [
"UnmarshalRole",
"unmarshals",
"role",
"from",
"JSON",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/role.go#L2258-L2260 | train |
gravitational/teleport | lib/services/role.go | MarshalRole | func (*TeleportRoleMarshaler) MarshalRole(r Role, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch role := r.(type) {
case *RoleV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *role
copy.SetResourceID(0)
role = ©
}
return utils.FastMarshal(role)
default:
return nil, trace.BadParameter("unrecognized role version %T", r)
}
} | go | func (*TeleportRoleMarshaler) MarshalRole(r Role, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch role := r.(type) {
case *RoleV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *role
copy.SetResourceID(0)
role = ©
}
return utils.FastMarshal(role)
default:
return nil, trace.BadParameter("unrecognized role version %T", r)
}
} | [
"func",
"(",
"*",
"TeleportRoleMarshaler",
")",
"MarshalRole",
"(",
"r",
"Role",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"role",
":=",
"r",
".",
"(",
"type",
")",
"{",
"case",
"*",
"RoleV3",
":",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"role",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"role",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"role",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unrecognized role version %T\"",
",",
"r",
")",
"\n",
"}",
"\n",
"}"
] | // MarshalRole marshalls role into JSON. | [
"MarshalRole",
"marshalls",
"role",
"into",
"JSON",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/role.go#L2263-L2281 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | Initialize | func (g *ResourceCommand) Initialize(app *kingpin.Application, config *service.Config) {
g.CreateHandlers = map[ResourceKind]ResourceCreateHandler{
services.KindUser: g.createUser,
services.KindTrustedCluster: g.createTrustedCluster,
services.KindGithubConnector: g.createGithubConnector,
services.KindCertAuthority: g.createCertAuthority,
}
g.config = config
g.createCmd = app.Command("create", "Create or update a Teleport resource from a YAML file")
g.createCmd.Arg("filename", "resource definition file").Required().StringVar(&g.filename)
g.createCmd.Flag("force", "Overwrite the resource if already exists").Short('f').BoolVar(&g.force)
g.deleteCmd = app.Command("rm", "Delete a resource").Alias("del")
g.deleteCmd.Arg("resource", "Resource to delete").SetValue(&g.ref)
g.getCmd = app.Command("get", "Print a YAML declaration of various Teleport resources")
g.getCmd.Arg("resource", "Resource spec: 'type/[name]'").SetValue(&g.ref)
g.getCmd.Flag("format", "Output format: 'yaml', 'json' or 'text'").Default(formatYAML).StringVar(&g.format)
g.getCmd.Flag("namespace", "Namespace of the resources").Hidden().Default(defaults.Namespace).StringVar(&g.namespace)
g.getCmd.Flag("with-secrets", "Include secrets in resources like certificate authorities or OIDC connectors").Default("false").BoolVar(&g.withSecrets)
g.getCmd.Alias(getHelp)
} | go | func (g *ResourceCommand) Initialize(app *kingpin.Application, config *service.Config) {
g.CreateHandlers = map[ResourceKind]ResourceCreateHandler{
services.KindUser: g.createUser,
services.KindTrustedCluster: g.createTrustedCluster,
services.KindGithubConnector: g.createGithubConnector,
services.KindCertAuthority: g.createCertAuthority,
}
g.config = config
g.createCmd = app.Command("create", "Create or update a Teleport resource from a YAML file")
g.createCmd.Arg("filename", "resource definition file").Required().StringVar(&g.filename)
g.createCmd.Flag("force", "Overwrite the resource if already exists").Short('f').BoolVar(&g.force)
g.deleteCmd = app.Command("rm", "Delete a resource").Alias("del")
g.deleteCmd.Arg("resource", "Resource to delete").SetValue(&g.ref)
g.getCmd = app.Command("get", "Print a YAML declaration of various Teleport resources")
g.getCmd.Arg("resource", "Resource spec: 'type/[name]'").SetValue(&g.ref)
g.getCmd.Flag("format", "Output format: 'yaml', 'json' or 'text'").Default(formatYAML).StringVar(&g.format)
g.getCmd.Flag("namespace", "Namespace of the resources").Hidden().Default(defaults.Namespace).StringVar(&g.namespace)
g.getCmd.Flag("with-secrets", "Include secrets in resources like certificate authorities or OIDC connectors").Default("false").BoolVar(&g.withSecrets)
g.getCmd.Alias(getHelp)
} | [
"func",
"(",
"g",
"*",
"ResourceCommand",
")",
"Initialize",
"(",
"app",
"*",
"kingpin",
".",
"Application",
",",
"config",
"*",
"service",
".",
"Config",
")",
"{",
"g",
".",
"CreateHandlers",
"=",
"map",
"[",
"ResourceKind",
"]",
"ResourceCreateHandler",
"{",
"services",
".",
"KindUser",
":",
"g",
".",
"createUser",
",",
"services",
".",
"KindTrustedCluster",
":",
"g",
".",
"createTrustedCluster",
",",
"services",
".",
"KindGithubConnector",
":",
"g",
".",
"createGithubConnector",
",",
"services",
".",
"KindCertAuthority",
":",
"g",
".",
"createCertAuthority",
",",
"}",
"\n",
"g",
".",
"config",
"=",
"config",
"\n",
"g",
".",
"createCmd",
"=",
"app",
".",
"Command",
"(",
"\"create\"",
",",
"\"Create or update a Teleport resource from a YAML file\"",
")",
"\n",
"g",
".",
"createCmd",
".",
"Arg",
"(",
"\"filename\"",
",",
"\"resource definition file\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"g",
".",
"filename",
")",
"\n",
"g",
".",
"createCmd",
".",
"Flag",
"(",
"\"force\"",
",",
"\"Overwrite the resource if already exists\"",
")",
".",
"Short",
"(",
"'f'",
")",
".",
"BoolVar",
"(",
"&",
"g",
".",
"force",
")",
"\n",
"g",
".",
"deleteCmd",
"=",
"app",
".",
"Command",
"(",
"\"rm\"",
",",
"\"Delete a resource\"",
")",
".",
"Alias",
"(",
"\"del\"",
")",
"\n",
"g",
".",
"deleteCmd",
".",
"Arg",
"(",
"\"resource\"",
",",
"\"Resource to delete\"",
")",
".",
"SetValue",
"(",
"&",
"g",
".",
"ref",
")",
"\n",
"g",
".",
"getCmd",
"=",
"app",
".",
"Command",
"(",
"\"get\"",
",",
"\"Print a YAML declaration of various Teleport resources\"",
")",
"\n",
"g",
".",
"getCmd",
".",
"Arg",
"(",
"\"resource\"",
",",
"\"Resource spec: 'type/[name]'\"",
")",
".",
"SetValue",
"(",
"&",
"g",
".",
"ref",
")",
"\n",
"g",
".",
"getCmd",
".",
"Flag",
"(",
"\"format\"",
",",
"\"Output format: 'yaml', 'json' or 'text'\"",
")",
".",
"Default",
"(",
"formatYAML",
")",
".",
"StringVar",
"(",
"&",
"g",
".",
"format",
")",
"\n",
"g",
".",
"getCmd",
".",
"Flag",
"(",
"\"namespace\"",
",",
"\"Namespace of the resources\"",
")",
".",
"Hidden",
"(",
")",
".",
"Default",
"(",
"defaults",
".",
"Namespace",
")",
".",
"StringVar",
"(",
"&",
"g",
".",
"namespace",
")",
"\n",
"g",
".",
"getCmd",
".",
"Flag",
"(",
"\"with-secrets\"",
",",
"\"Include secrets in resources like certificate authorities or OIDC connectors\"",
")",
".",
"Default",
"(",
"\"false\"",
")",
".",
"BoolVar",
"(",
"&",
"g",
".",
"withSecrets",
")",
"\n",
"g",
".",
"getCmd",
".",
"Alias",
"(",
"getHelp",
")",
"\n",
"}"
] | // Initialize allows ResourceCommand to plug itself into the CLI parser | [
"Initialize",
"allows",
"ResourceCommand",
"to",
"plug",
"itself",
"into",
"the",
"CLI",
"parser"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L71-L94 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | IsDeleteSubcommand | func (g *ResourceCommand) IsDeleteSubcommand(cmd string) bool {
return cmd == g.deleteCmd.FullCommand()
} | go | func (g *ResourceCommand) IsDeleteSubcommand(cmd string) bool {
return cmd == g.deleteCmd.FullCommand()
} | [
"func",
"(",
"g",
"*",
"ResourceCommand",
")",
"IsDeleteSubcommand",
"(",
"cmd",
"string",
")",
"bool",
"{",
"return",
"cmd",
"==",
"g",
".",
"deleteCmd",
".",
"FullCommand",
"(",
")",
"\n",
"}"
] | // IsDeleteSubcommand returns 'true' if the given command is `tctl rm` | [
"IsDeleteSubcommand",
"returns",
"true",
"if",
"the",
"given",
"command",
"is",
"tctl",
"rm"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L116-L118 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | Get | func (g *ResourceCommand) Get(client auth.ClientI) error {
collection, err := g.getCollection(client)
if err != nil {
return trace.Wrap(err)
}
// Note that only YAML is officially supported. Support for text and JSON
// is experimental.
switch g.format {
case teleport.YAML:
return collection.writeYAML(os.Stdout)
case teleport.Text:
return collection.writeText(os.Stdout)
case teleport.JSON:
return collection.writeJSON(os.Stdout)
}
return trace.BadParameter("unsupported format")
} | go | func (g *ResourceCommand) Get(client auth.ClientI) error {
collection, err := g.getCollection(client)
if err != nil {
return trace.Wrap(err)
}
// Note that only YAML is officially supported. Support for text and JSON
// is experimental.
switch g.format {
case teleport.YAML:
return collection.writeYAML(os.Stdout)
case teleport.Text:
return collection.writeText(os.Stdout)
case teleport.JSON:
return collection.writeJSON(os.Stdout)
}
return trace.BadParameter("unsupported format")
} | [
"func",
"(",
"g",
"*",
"ResourceCommand",
")",
"Get",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"collection",
",",
"err",
":=",
"g",
".",
"getCollection",
"(",
"client",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"g",
".",
"format",
"{",
"case",
"teleport",
".",
"YAML",
":",
"return",
"collection",
".",
"writeYAML",
"(",
"os",
".",
"Stdout",
")",
"\n",
"case",
"teleport",
".",
"Text",
":",
"return",
"collection",
".",
"writeText",
"(",
"os",
".",
"Stdout",
")",
"\n",
"case",
"teleport",
".",
"JSON",
":",
"return",
"collection",
".",
"writeJSON",
"(",
"os",
".",
"Stdout",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"unsupported format\"",
")",
"\n",
"}"
] | // Get prints one or many resources of a certain type | [
"Get",
"prints",
"one",
"or",
"many",
"resources",
"of",
"a",
"certain",
"type"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L127-L144 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | Create | func (u *ResourceCommand) Create(client auth.ClientI) error {
reader, err := utils.OpenFile(u.filename)
if err != nil {
return trace.Wrap(err)
}
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
count := 0
for {
var raw services.UnknownResource
err := decoder.Decode(&raw)
if err != nil {
if err == io.EOF {
if count == 0 {
return trace.BadParameter("no resources found, empty input?")
}
return nil
}
return trace.Wrap(err)
}
count++
// locate the creator function for a given resource kind:
creator, found := u.CreateHandlers[ResourceKind(raw.Kind)]
if !found {
return trace.BadParameter("creating resources of type %q is not supported", raw.Kind)
}
// only return in case of error, to create multiple resources
// in case if yaml spec is a list
if err := creator(client, raw); err != nil {
return trace.Wrap(err)
}
}
} | go | func (u *ResourceCommand) Create(client auth.ClientI) error {
reader, err := utils.OpenFile(u.filename)
if err != nil {
return trace.Wrap(err)
}
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
count := 0
for {
var raw services.UnknownResource
err := decoder.Decode(&raw)
if err != nil {
if err == io.EOF {
if count == 0 {
return trace.BadParameter("no resources found, empty input?")
}
return nil
}
return trace.Wrap(err)
}
count++
// locate the creator function for a given resource kind:
creator, found := u.CreateHandlers[ResourceKind(raw.Kind)]
if !found {
return trace.BadParameter("creating resources of type %q is not supported", raw.Kind)
}
// only return in case of error, to create multiple resources
// in case if yaml spec is a list
if err := creator(client, raw); err != nil {
return trace.Wrap(err)
}
}
} | [
"func",
"(",
"u",
"*",
"ResourceCommand",
")",
"Create",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"reader",
",",
"err",
":=",
"utils",
".",
"OpenFile",
"(",
"u",
".",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"decoder",
":=",
"kyaml",
".",
"NewYAMLOrJSONDecoder",
"(",
"reader",
",",
"32",
"*",
"1024",
")",
"\n",
"count",
":=",
"0",
"\n",
"for",
"{",
"var",
"raw",
"services",
".",
"UnknownResource",
"\n",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"&",
"raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"if",
"count",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"no resources found, empty input?\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"count",
"++",
"\n",
"creator",
",",
"found",
":=",
"u",
".",
"CreateHandlers",
"[",
"ResourceKind",
"(",
"raw",
".",
"Kind",
")",
"]",
"\n",
"if",
"!",
"found",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"creating resources of type %q is not supported\"",
",",
"raw",
".",
"Kind",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"creator",
"(",
"client",
",",
"raw",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Create updates or insterts one or many resources | [
"Create",
"updates",
"or",
"insterts",
"one",
"or",
"many",
"resources"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L147-L179 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | createTrustedCluster | func (u *ResourceCommand) createTrustedCluster(client auth.ClientI, raw services.UnknownResource) error {
tc, err := services.GetTrustedClusterMarshaler().Unmarshal(raw.Raw)
if err != nil {
return trace.Wrap(err)
}
// check if such cluster already exists:
name := tc.GetName()
_, err = client.GetTrustedCluster(name)
if err != nil && !trace.IsNotFound(err) {
return trace.Wrap(err)
}
exists := (err == nil)
if u.force == false && exists {
return trace.AlreadyExists("trusted cluster '%s' already exists", name)
}
out, err := client.UpsertTrustedCluster(tc)
if err != nil {
// If force is used and UpsertTrustedCluster returns trace.AlreadyExists,
// this means the user tried to upsert a cluster whose exact match already
// exists in the backend, nothing needs to occur other than happy message
// that the trusted cluster has been created.
if u.force && trace.IsAlreadyExists(err) {
out = tc
} else {
return trace.Wrap(err)
}
}
if out.GetName() != tc.GetName() {
fmt.Printf("WARNING: trusted cluster %q resource has been renamed to match remote cluster name %q\n", name, out.GetName())
}
fmt.Printf("trusted cluster %q has been %v\n", out.GetName(), UpsertVerb(exists, u.force))
return nil
} | go | func (u *ResourceCommand) createTrustedCluster(client auth.ClientI, raw services.UnknownResource) error {
tc, err := services.GetTrustedClusterMarshaler().Unmarshal(raw.Raw)
if err != nil {
return trace.Wrap(err)
}
// check if such cluster already exists:
name := tc.GetName()
_, err = client.GetTrustedCluster(name)
if err != nil && !trace.IsNotFound(err) {
return trace.Wrap(err)
}
exists := (err == nil)
if u.force == false && exists {
return trace.AlreadyExists("trusted cluster '%s' already exists", name)
}
out, err := client.UpsertTrustedCluster(tc)
if err != nil {
// If force is used and UpsertTrustedCluster returns trace.AlreadyExists,
// this means the user tried to upsert a cluster whose exact match already
// exists in the backend, nothing needs to occur other than happy message
// that the trusted cluster has been created.
if u.force && trace.IsAlreadyExists(err) {
out = tc
} else {
return trace.Wrap(err)
}
}
if out.GetName() != tc.GetName() {
fmt.Printf("WARNING: trusted cluster %q resource has been renamed to match remote cluster name %q\n", name, out.GetName())
}
fmt.Printf("trusted cluster %q has been %v\n", out.GetName(), UpsertVerb(exists, u.force))
return nil
} | [
"func",
"(",
"u",
"*",
"ResourceCommand",
")",
"createTrustedCluster",
"(",
"client",
"auth",
".",
"ClientI",
",",
"raw",
"services",
".",
"UnknownResource",
")",
"error",
"{",
"tc",
",",
"err",
":=",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"raw",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"name",
":=",
"tc",
".",
"GetName",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"client",
".",
"GetTrustedCluster",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"exists",
":=",
"(",
"err",
"==",
"nil",
")",
"\n",
"if",
"u",
".",
"force",
"==",
"false",
"&&",
"exists",
"{",
"return",
"trace",
".",
"AlreadyExists",
"(",
"\"trusted cluster '%s' already exists\"",
",",
"name",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"client",
".",
"UpsertTrustedCluster",
"(",
"tc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"u",
".",
"force",
"&&",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"out",
"=",
"tc",
"\n",
"}",
"else",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"out",
".",
"GetName",
"(",
")",
"!=",
"tc",
".",
"GetName",
"(",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"WARNING: trusted cluster %q resource has been renamed to match remote cluster name %q\\n\"",
",",
"\\n",
",",
"name",
")",
"\n",
"}",
"\n",
"out",
".",
"GetName",
"(",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"trusted cluster %q has been %v\\n\"",
",",
"\\n",
",",
"out",
".",
"GetName",
"(",
")",
")",
"\n",
"}"
] | // createTrustedCluster implements `tctl create cluster.yaml` command | [
"createTrustedCluster",
"implements",
"tctl",
"create",
"cluster",
".",
"yaml",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L182-L216 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | createCertAuthority | func (u *ResourceCommand) createCertAuthority(client auth.ClientI, raw services.UnknownResource) error {
certAuthority, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw.Raw)
if err != nil {
return trace.Wrap(err)
}
if err := client.UpsertCertAuthority(certAuthority); err != nil {
return trace.Wrap(err)
}
fmt.Printf("certificate authority '%s' has been updated\n", certAuthority.GetName())
return nil
} | go | func (u *ResourceCommand) createCertAuthority(client auth.ClientI, raw services.UnknownResource) error {
certAuthority, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw.Raw)
if err != nil {
return trace.Wrap(err)
}
if err := client.UpsertCertAuthority(certAuthority); err != nil {
return trace.Wrap(err)
}
fmt.Printf("certificate authority '%s' has been updated\n", certAuthority.GetName())
return nil
} | [
"func",
"(",
"u",
"*",
"ResourceCommand",
")",
"createCertAuthority",
"(",
"client",
"auth",
".",
"ClientI",
",",
"raw",
"services",
".",
"UnknownResource",
")",
"error",
"{",
"certAuthority",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"UnmarshalCertAuthority",
"(",
"raw",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"client",
".",
"UpsertCertAuthority",
"(",
"certAuthority",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"certificate authority '%s' has been updated\\n\"",
",",
"\\n",
")",
"\n",
"certAuthority",
".",
"GetName",
"(",
")",
"\n",
"}"
] | // createCertAuthority creates certificate authority | [
"createCertAuthority",
"creates",
"certificate",
"authority"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L219-L229 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | createUser | func (u *ResourceCommand) createUser(client auth.ClientI, raw services.UnknownResource) error {
user, err := services.GetUserMarshaler().UnmarshalUser(raw.Raw)
if err != nil {
return trace.Wrap(err)
}
userName := user.GetName()
if err := client.UpsertUser(user); err != nil {
return trace.Wrap(err)
}
fmt.Printf("user '%s' has been updated\n", userName)
return nil
} | go | func (u *ResourceCommand) createUser(client auth.ClientI, raw services.UnknownResource) error {
user, err := services.GetUserMarshaler().UnmarshalUser(raw.Raw)
if err != nil {
return trace.Wrap(err)
}
userName := user.GetName()
if err := client.UpsertUser(user); err != nil {
return trace.Wrap(err)
}
fmt.Printf("user '%s' has been updated\n", userName)
return nil
} | [
"func",
"(",
"u",
"*",
"ResourceCommand",
")",
"createUser",
"(",
"client",
"auth",
".",
"ClientI",
",",
"raw",
"services",
".",
"UnknownResource",
")",
"error",
"{",
"user",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"UnmarshalUser",
"(",
"raw",
".",
"Raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"userName",
":=",
"user",
".",
"GetName",
"(",
")",
"\n",
"if",
"err",
":=",
"client",
".",
"UpsertUser",
"(",
"user",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"user '%s' has been updated\\n\"",
",",
"\\n",
")",
"\n",
"userName",
"\n",
"}"
] | // createUser implements 'tctl create user.yaml' command | [
"createUser",
"implements",
"tctl",
"create",
"user",
".",
"yaml",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L255-L266 | train |
gravitational/teleport | tool/tctl/common/resource_command.go | Delete | func (d *ResourceCommand) Delete(client auth.ClientI) (err error) {
if d.ref.Kind == "" || d.ref.Name == "" {
return trace.BadParameter("provide a full resource name to delete, for example:\n$ tctl rm cluster/east\n")
}
switch d.ref.Kind {
case services.KindNode:
if err = client.DeleteNode(defaults.Namespace, d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("node %v has been deleted\n", d.ref.Name)
case services.KindUser:
if err = client.DeleteUser(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("user %v has been deleted\n", d.ref.Name)
case services.KindSAMLConnector:
if err = client.DeleteSAMLConnector(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("SAML Connector %v has been deleted\n", d.ref.Name)
case services.KindOIDCConnector:
if err = client.DeleteOIDCConnector(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("OIDC Connector %v has been deleted\n", d.ref.Name)
case services.KindGithubConnector:
if err = client.DeleteGithubConnector(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("github connector %q has been deleted\n", d.ref.Name)
case services.KindReverseTunnel:
if err := client.DeleteReverseTunnel(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("reverse tunnel %v has been deleted\n", d.ref.Name)
case services.KindTrustedCluster:
if err = client.DeleteTrustedCluster(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("trusted cluster %q has been deleted\n", d.ref.Name)
case services.KindRemoteCluster:
if err = client.DeleteRemoteCluster(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("remote cluster %q has been deleted\n", d.ref.Name)
default:
return trace.BadParameter("deleting resources of type %q is not supported", d.ref.Kind)
}
return nil
} | go | func (d *ResourceCommand) Delete(client auth.ClientI) (err error) {
if d.ref.Kind == "" || d.ref.Name == "" {
return trace.BadParameter("provide a full resource name to delete, for example:\n$ tctl rm cluster/east\n")
}
switch d.ref.Kind {
case services.KindNode:
if err = client.DeleteNode(defaults.Namespace, d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("node %v has been deleted\n", d.ref.Name)
case services.KindUser:
if err = client.DeleteUser(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("user %v has been deleted\n", d.ref.Name)
case services.KindSAMLConnector:
if err = client.DeleteSAMLConnector(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("SAML Connector %v has been deleted\n", d.ref.Name)
case services.KindOIDCConnector:
if err = client.DeleteOIDCConnector(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("OIDC Connector %v has been deleted\n", d.ref.Name)
case services.KindGithubConnector:
if err = client.DeleteGithubConnector(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("github connector %q has been deleted\n", d.ref.Name)
case services.KindReverseTunnel:
if err := client.DeleteReverseTunnel(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("reverse tunnel %v has been deleted\n", d.ref.Name)
case services.KindTrustedCluster:
if err = client.DeleteTrustedCluster(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("trusted cluster %q has been deleted\n", d.ref.Name)
case services.KindRemoteCluster:
if err = client.DeleteRemoteCluster(d.ref.Name); err != nil {
return trace.Wrap(err)
}
fmt.Printf("remote cluster %q has been deleted\n", d.ref.Name)
default:
return trace.BadParameter("deleting resources of type %q is not supported", d.ref.Kind)
}
return nil
} | [
"func",
"(",
"d",
"*",
"ResourceCommand",
")",
"Delete",
"(",
"client",
"auth",
".",
"ClientI",
")",
"(",
"err",
"error",
")",
"{",
"if",
"d",
".",
"ref",
".",
"Kind",
"==",
"\"\"",
"||",
"d",
".",
"ref",
".",
"Name",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"provide a full resource name to delete, for example:\\n$ tctl rm cluster/east\\n\"",
")",
"\n",
"}",
"\n",
"\\n",
"\n",
"\\n",
"\n",
"}"
] | // Delete deletes resource by name | [
"Delete",
"deletes",
"resource",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/resource_command.go#L269-L319 | train |
gravitational/teleport | lib/reversetunnel/cache.go | NewHostCertificateCache | func NewHostCertificateCache(keygen sshca.Authority, authClient auth.ClientI) (*certificateCache, error) {
cache, err := ttlmap.New(defaults.HostCertCacheSize)
if err != nil {
return nil, trace.Wrap(err)
}
return &certificateCache{
keygen: keygen,
cache: cache,
authClient: authClient,
}, nil
} | go | func NewHostCertificateCache(keygen sshca.Authority, authClient auth.ClientI) (*certificateCache, error) {
cache, err := ttlmap.New(defaults.HostCertCacheSize)
if err != nil {
return nil, trace.Wrap(err)
}
return &certificateCache{
keygen: keygen,
cache: cache,
authClient: authClient,
}, nil
} | [
"func",
"NewHostCertificateCache",
"(",
"keygen",
"sshca",
".",
"Authority",
",",
"authClient",
"auth",
".",
"ClientI",
")",
"(",
"*",
"certificateCache",
",",
"error",
")",
"{",
"cache",
",",
"err",
":=",
"ttlmap",
".",
"New",
"(",
"defaults",
".",
"HostCertCacheSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"certificateCache",
"{",
"keygen",
":",
"keygen",
",",
"cache",
":",
"cache",
",",
"authClient",
":",
"authClient",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewHostCertificateCache creates a shared host certificate cache that is
// used by the forwarding server. | [
"NewHostCertificateCache",
"creates",
"a",
"shared",
"host",
"certificate",
"cache",
"that",
"is",
"used",
"by",
"the",
"forwarding",
"server",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/cache.go#L45-L56 | train |
gravitational/teleport | lib/reversetunnel/cache.go | GetHostCertificate | func (c *certificateCache) GetHostCertificate(addr string, additionalPrincipals []string) (ssh.Signer, error) {
var certificate ssh.Signer
var err error
var ok bool
var principals []string
principals = append(principals, addr)
principals = append(principals, additionalPrincipals...)
certificate, ok = c.get(strings.Join(principals, "."))
if !ok {
certificate, err = c.generateHostCert(principals)
if err != nil {
return nil, trace.Wrap(err)
}
err = c.set(addr, certificate, defaults.HostCertCacheTime)
if err != nil {
return nil, trace.Wrap(err)
}
}
return certificate, nil
} | go | func (c *certificateCache) GetHostCertificate(addr string, additionalPrincipals []string) (ssh.Signer, error) {
var certificate ssh.Signer
var err error
var ok bool
var principals []string
principals = append(principals, addr)
principals = append(principals, additionalPrincipals...)
certificate, ok = c.get(strings.Join(principals, "."))
if !ok {
certificate, err = c.generateHostCert(principals)
if err != nil {
return nil, trace.Wrap(err)
}
err = c.set(addr, certificate, defaults.HostCertCacheTime)
if err != nil {
return nil, trace.Wrap(err)
}
}
return certificate, nil
} | [
"func",
"(",
"c",
"*",
"certificateCache",
")",
"GetHostCertificate",
"(",
"addr",
"string",
",",
"additionalPrincipals",
"[",
"]",
"string",
")",
"(",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"var",
"certificate",
"ssh",
".",
"Signer",
"\n",
"var",
"err",
"error",
"\n",
"var",
"ok",
"bool",
"\n",
"var",
"principals",
"[",
"]",
"string",
"\n",
"principals",
"=",
"append",
"(",
"principals",
",",
"addr",
")",
"\n",
"principals",
"=",
"append",
"(",
"principals",
",",
"additionalPrincipals",
"...",
")",
"\n",
"certificate",
",",
"ok",
"=",
"c",
".",
"get",
"(",
"strings",
".",
"Join",
"(",
"principals",
",",
"\".\"",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
"certificate",
",",
"err",
"=",
"c",
".",
"generateHostCert",
"(",
"principals",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"c",
".",
"set",
"(",
"addr",
",",
"certificate",
",",
"defaults",
".",
"HostCertCacheTime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"certificate",
",",
"nil",
"\n",
"}"
] | // GetHostCertificate will fetch a certificate from the cache. If the certificate
// is not in the cache, it will be generated, put in the cache, and returned. Mul
// Multiple callers can arrive and generate a host certificate at the same time.
// This is a tradeoff to prevent long delays here due to the expensive
// certificate generation call. | [
"GetHostCertificate",
"will",
"fetch",
"a",
"certificate",
"from",
"the",
"cache",
".",
"If",
"the",
"certificate",
"is",
"not",
"in",
"the",
"cache",
"it",
"will",
"be",
"generated",
"put",
"in",
"the",
"cache",
"and",
"returned",
".",
"Mul",
"Multiple",
"callers",
"can",
"arrive",
"and",
"generate",
"a",
"host",
"certificate",
"at",
"the",
"same",
"time",
".",
"This",
"is",
"a",
"tradeoff",
"to",
"prevent",
"long",
"delays",
"here",
"due",
"to",
"the",
"expensive",
"certificate",
"generation",
"call",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/cache.go#L63-L86 | train |
gravitational/teleport | lib/reversetunnel/cache.go | get | func (c *certificateCache) get(addr string) (ssh.Signer, bool) {
c.mu.Lock()
defer c.mu.Unlock()
certificate, ok := c.cache.Get(addr)
if !ok {
return nil, false
}
certificateSigner, ok := certificate.(ssh.Signer)
if !ok {
return nil, false
}
return certificateSigner, true
} | go | func (c *certificateCache) get(addr string) (ssh.Signer, bool) {
c.mu.Lock()
defer c.mu.Unlock()
certificate, ok := c.cache.Get(addr)
if !ok {
return nil, false
}
certificateSigner, ok := certificate.(ssh.Signer)
if !ok {
return nil, false
}
return certificateSigner, true
} | [
"func",
"(",
"c",
"*",
"certificateCache",
")",
"get",
"(",
"addr",
"string",
")",
"(",
"ssh",
".",
"Signer",
",",
"bool",
")",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"certificate",
",",
"ok",
":=",
"c",
".",
"cache",
".",
"Get",
"(",
"addr",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"certificateSigner",
",",
"ok",
":=",
"certificate",
".",
"(",
"ssh",
".",
"Signer",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"return",
"certificateSigner",
",",
"true",
"\n",
"}"
] | // get is goroutine safe and will return a ssh.Signer for a principal from
// the cache. | [
"get",
"is",
"goroutine",
"safe",
"and",
"will",
"return",
"a",
"ssh",
".",
"Signer",
"for",
"a",
"principal",
"from",
"the",
"cache",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/cache.go#L90-L105 | train |
gravitational/teleport | lib/reversetunnel/cache.go | set | func (c *certificateCache) set(addr string, certificate ssh.Signer, ttl time.Duration) error {
c.mu.Lock()
defer c.mu.Unlock()
err := c.cache.Set(addr, certificate, ttl)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *certificateCache) set(addr string, certificate ssh.Signer, ttl time.Duration) error {
c.mu.Lock()
defer c.mu.Unlock()
err := c.cache.Set(addr, certificate, ttl)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"certificateCache",
")",
"set",
"(",
"addr",
"string",
",",
"certificate",
"ssh",
".",
"Signer",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"err",
":=",
"c",
".",
"cache",
".",
"Set",
"(",
"addr",
",",
"certificate",
",",
"ttl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // set is goroutine safe and will set a ssh.Signer for a principal in
// the cache. | [
"set",
"is",
"goroutine",
"safe",
"and",
"will",
"set",
"a",
"ssh",
".",
"Signer",
"for",
"a",
"principal",
"in",
"the",
"cache",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/cache.go#L109-L119 | train |
gravitational/teleport | lib/reversetunnel/cache.go | generateHostCert | func (c *certificateCache) generateHostCert(principals []string) (ssh.Signer, error) {
if len(principals) == 0 {
return nil, trace.BadParameter("at least one principal must be provided")
}
// Generate public/private keypair.
privBytes, pubBytes, err := c.keygen.GetNewKeyPairFromPool()
if err != nil {
return nil, trace.Wrap(err)
}
// Generate a SSH host certificate.
clusterName, err := c.authClient.GetDomainName()
if err != nil {
return nil, trace.Wrap(err)
}
certBytes, err := c.authClient.GenerateHostCert(
pubBytes,
principals[0],
principals[0],
principals,
clusterName,
teleport.Roles{teleport.RoleNode},
0)
if err != nil {
return nil, trace.Wrap(err)
}
// create a *ssh.Certificate
privateKey, err := ssh.ParsePrivateKey(privBytes)
if err != nil {
return nil, trace.Wrap(err)
}
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(certBytes)
if err != nil {
return nil, err
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("not a certificate")
}
// return a ssh.Signer
s, err := ssh.NewCertSigner(cert, privateKey)
if err != nil {
return nil, trace.Wrap(err)
}
return s, nil
} | go | func (c *certificateCache) generateHostCert(principals []string) (ssh.Signer, error) {
if len(principals) == 0 {
return nil, trace.BadParameter("at least one principal must be provided")
}
// Generate public/private keypair.
privBytes, pubBytes, err := c.keygen.GetNewKeyPairFromPool()
if err != nil {
return nil, trace.Wrap(err)
}
// Generate a SSH host certificate.
clusterName, err := c.authClient.GetDomainName()
if err != nil {
return nil, trace.Wrap(err)
}
certBytes, err := c.authClient.GenerateHostCert(
pubBytes,
principals[0],
principals[0],
principals,
clusterName,
teleport.Roles{teleport.RoleNode},
0)
if err != nil {
return nil, trace.Wrap(err)
}
// create a *ssh.Certificate
privateKey, err := ssh.ParsePrivateKey(privBytes)
if err != nil {
return nil, trace.Wrap(err)
}
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(certBytes)
if err != nil {
return nil, err
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("not a certificate")
}
// return a ssh.Signer
s, err := ssh.NewCertSigner(cert, privateKey)
if err != nil {
return nil, trace.Wrap(err)
}
return s, nil
} | [
"func",
"(",
"c",
"*",
"certificateCache",
")",
"generateHostCert",
"(",
"principals",
"[",
"]",
"string",
")",
"(",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"if",
"len",
"(",
"principals",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"at least one principal must be provided\"",
")",
"\n",
"}",
"\n",
"privBytes",
",",
"pubBytes",
",",
"err",
":=",
"c",
".",
"keygen",
".",
"GetNewKeyPairFromPool",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"clusterName",
",",
"err",
":=",
"c",
".",
"authClient",
".",
"GetDomainName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certBytes",
",",
"err",
":=",
"c",
".",
"authClient",
".",
"GenerateHostCert",
"(",
"pubBytes",
",",
"principals",
"[",
"0",
"]",
",",
"principals",
"[",
"0",
"]",
",",
"principals",
",",
"clusterName",
",",
"teleport",
".",
"Roles",
"{",
"teleport",
".",
"RoleNode",
"}",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"privateKey",
",",
"err",
":=",
"ssh",
".",
"ParsePrivateKey",
"(",
"privBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"publicKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"certBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"publicKey",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"not a certificate\"",
")",
"\n",
"}",
"\n",
"s",
",",
"err",
":=",
"ssh",
".",
"NewCertSigner",
"(",
"cert",
",",
"privateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] | // generateHostCert will generate a SSH host certificate for a given
// principal. | [
"generateHostCert",
"will",
"generate",
"a",
"SSH",
"host",
"certificate",
"for",
"a",
"given",
"principal",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/cache.go#L123-L173 | train |
gravitational/teleport | lib/srv/monitor.go | NewMonitor | func NewMonitor(cfg MonitorConfig) (*Monitor, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &Monitor{
MonitorConfig: cfg,
}, nil
} | go | func NewMonitor(cfg MonitorConfig) (*Monitor, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &Monitor{
MonitorConfig: cfg,
}, nil
} | [
"func",
"NewMonitor",
"(",
"cfg",
"MonitorConfig",
")",
"(",
"*",
"Monitor",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"Monitor",
"{",
"MonitorConfig",
":",
"cfg",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewMonitor returns a new monitor | [
"NewMonitor",
"returns",
"a",
"new",
"monitor"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/monitor.go#L107-L114 | train |
gravitational/teleport | tool/teleport/common/teleport.go | OnStart | func OnStart(config *service.Config) error {
return service.Run(context.TODO(), *config, nil)
} | go | func OnStart(config *service.Config) error {
return service.Run(context.TODO(), *config, nil)
} | [
"func",
"OnStart",
"(",
"config",
"*",
"service",
".",
"Config",
")",
"error",
"{",
"return",
"service",
".",
"Run",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"*",
"config",
",",
"nil",
")",
"\n",
"}"
] | // OnStart is the handler for "start" CLI command | [
"OnStart",
"is",
"the",
"handler",
"for",
"start",
"CLI",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/teleport/common/teleport.go#L169-L171 | train |
gravitational/teleport | tool/teleport/common/teleport.go | onStatus | func onStatus() error {
sshClient := os.Getenv("SSH_CLIENT")
systemUser := os.Getenv("USER")
teleportUser := os.Getenv(teleport.SSHTeleportUser)
proxyHost := os.Getenv(teleport.SSHSessionWebproxyAddr)
clusterName := os.Getenv(teleport.SSHTeleportClusterName)
hostUUID := os.Getenv(teleport.SSHTeleportHostUUID)
sid := os.Getenv(teleport.SSHSessionID)
if sid == "" || proxyHost == "" {
fmt.Println("You are not inside of a Teleport SSH session")
return nil
}
fmt.Printf("User ID : %s, logged in as %s from %s\n", teleportUser, systemUser, sshClient)
fmt.Printf("Cluster Name: %s\n", clusterName)
fmt.Printf("Host UUID : %s\n", hostUUID)
fmt.Printf("Session ID : %s\n", sid)
fmt.Printf("Session URL : https://%s/web/cluster/%v/node/%v/%v/%v\n", proxyHost, clusterName, hostUUID, systemUser, sid)
return nil
} | go | func onStatus() error {
sshClient := os.Getenv("SSH_CLIENT")
systemUser := os.Getenv("USER")
teleportUser := os.Getenv(teleport.SSHTeleportUser)
proxyHost := os.Getenv(teleport.SSHSessionWebproxyAddr)
clusterName := os.Getenv(teleport.SSHTeleportClusterName)
hostUUID := os.Getenv(teleport.SSHTeleportHostUUID)
sid := os.Getenv(teleport.SSHSessionID)
if sid == "" || proxyHost == "" {
fmt.Println("You are not inside of a Teleport SSH session")
return nil
}
fmt.Printf("User ID : %s, logged in as %s from %s\n", teleportUser, systemUser, sshClient)
fmt.Printf("Cluster Name: %s\n", clusterName)
fmt.Printf("Host UUID : %s\n", hostUUID)
fmt.Printf("Session ID : %s\n", sid)
fmt.Printf("Session URL : https://%s/web/cluster/%v/node/%v/%v/%v\n", proxyHost, clusterName, hostUUID, systemUser, sid)
return nil
} | [
"func",
"onStatus",
"(",
")",
"error",
"{",
"sshClient",
":=",
"os",
".",
"Getenv",
"(",
"\"SSH_CLIENT\"",
")",
"\n",
"systemUser",
":=",
"os",
".",
"Getenv",
"(",
"\"USER\"",
")",
"\n",
"teleportUser",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"SSHTeleportUser",
")",
"\n",
"proxyHost",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"SSHSessionWebproxyAddr",
")",
"\n",
"clusterName",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"SSHTeleportClusterName",
")",
"\n",
"hostUUID",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"SSHTeleportHostUUID",
")",
"\n",
"sid",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"SSHSessionID",
")",
"\n",
"if",
"sid",
"==",
"\"\"",
"||",
"proxyHost",
"==",
"\"\"",
"{",
"fmt",
".",
"Println",
"(",
"\"You are not inside of a Teleport SSH session\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"User ID : %s, logged in as %s from %s\\n\"",
",",
"\\n",
",",
"teleportUser",
",",
"systemUser",
")",
"\n",
"sshClient",
"\n",
"fmt",
".",
"Printf",
"(",
"\"Cluster Name: %s\\n\"",
",",
"\\n",
")",
"\n",
"clusterName",
"\n",
"fmt",
".",
"Printf",
"(",
"\"Host UUID : %s\\n\"",
",",
"\\n",
")",
"\n",
"hostUUID",
"\n",
"}"
] | // onStatus is the handler for "status" CLI command | [
"onStatus",
"is",
"the",
"handler",
"for",
"status",
"CLI",
"command"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/teleport/common/teleport.go#L174-L195 | train |
gravitational/teleport | lib/utils/copy.go | CopyByteSlice | func CopyByteSlice(in []byte) []byte {
if in == nil {
return nil
}
out := make([]byte, len(in))
copy(out, in)
return out
} | go | func CopyByteSlice(in []byte) []byte {
if in == nil {
return nil
}
out := make([]byte, len(in))
copy(out, in)
return out
} | [
"func",
"CopyByteSlice",
"(",
"in",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"in",
")",
")",
"\n",
"copy",
"(",
"out",
",",
"in",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // CopyByteSlice returns a copy of the byte slice. | [
"CopyByteSlice",
"returns",
"a",
"copy",
"of",
"the",
"byte",
"slice",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L20-L27 | train |
gravitational/teleport | lib/utils/copy.go | CopyByteSlices | func CopyByteSlices(in [][]byte) [][]byte {
if in == nil {
return nil
}
out := make([][]byte, len(in))
for i := range in {
out[i] = CopyByteSlice(in[i])
}
return out
} | go | func CopyByteSlices(in [][]byte) [][]byte {
if in == nil {
return nil
}
out := make([][]byte, len(in))
for i := range in {
out[i] = CopyByteSlice(in[i])
}
return out
} | [
"func",
"CopyByteSlices",
"(",
"in",
"[",
"]",
"[",
"]",
"byte",
")",
"[",
"]",
"[",
"]",
"byte",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"in",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"in",
"{",
"out",
"[",
"i",
"]",
"=",
"CopyByteSlice",
"(",
"in",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // CopyByteSlices returns a copy of the byte slices. | [
"CopyByteSlices",
"returns",
"a",
"copy",
"of",
"the",
"byte",
"slices",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L30-L39 | train |
gravitational/teleport | lib/utils/copy.go | JoinStringSlices | func JoinStringSlices(a []string, b []string) []string {
if len(a)+len(b) == 0 {
return nil
}
out := make([]string, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | go | func JoinStringSlices(a []string, b []string) []string {
if len(a)+len(b) == 0 {
return nil
}
out := make([]string, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | [
"func",
"JoinStringSlices",
"(",
"a",
"[",
"]",
"string",
",",
"b",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
")",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"a",
"...",
")",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"b",
"...",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // JoinStringSlices joins two string slices and returns a resulting slice | [
"JoinStringSlices",
"joins",
"two",
"string",
"slices",
"and",
"returns",
"a",
"resulting",
"slice"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L42-L50 | train |
gravitational/teleport | lib/utils/copy.go | CopyStrings | func CopyStrings(in []string) []string {
if in == nil {
return nil
}
out := make([]string, len(in))
copy(out, in)
return out
} | go | func CopyStrings(in []string) []string {
if in == nil {
return nil
}
out := make([]string, len(in))
copy(out, in)
return out
} | [
"func",
"CopyStrings",
"(",
"in",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"in",
")",
")",
"\n",
"copy",
"(",
"out",
",",
"in",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // CopyStrings makes a deep copy of the passed in string slice and returns
// the copy. | [
"CopyStrings",
"makes",
"a",
"deep",
"copy",
"of",
"the",
"passed",
"in",
"string",
"slice",
"and",
"returns",
"the",
"copy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L54-L63 | train |
gravitational/teleport | lib/utils/copy.go | ReplaceInSlice | func ReplaceInSlice(s []string, old string, new string) []string {
out := make([]string, 0, len(s))
for _, x := range s {
if x == old {
out = append(out, new)
} else {
out = append(out, x)
}
}
return out
} | go | func ReplaceInSlice(s []string, old string, new string) []string {
out := make([]string, 0, len(s))
for _, x := range s {
if x == old {
out = append(out, new)
} else {
out = append(out, x)
}
}
return out
} | [
"func",
"ReplaceInSlice",
"(",
"s",
"[",
"]",
"string",
",",
"old",
"string",
",",
"new",
"string",
")",
"[",
"]",
"string",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"s",
")",
")",
"\n",
"for",
"_",
",",
"x",
":=",
"range",
"s",
"{",
"if",
"x",
"==",
"old",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"new",
")",
"\n",
"}",
"else",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"x",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // ReplaceInSlice replaces element old with new and returns a new slice. | [
"ReplaceInSlice",
"replaces",
"element",
"old",
"with",
"new",
"and",
"returns",
"a",
"new",
"slice",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L112-L124 | train |
gravitational/teleport | lib/service/connect.go | reconnectToAuthService | func (process *TeleportProcess) reconnectToAuthService(role teleport.Role) (*Connector, error) {
retryTime := defaults.HighResPollingPeriod
for {
connector, err := process.connectToAuthService(role)
if err == nil {
// if connected and client is present, make sure the connector's
// client works, by using call that should succeed at all times
if connector.Client != nil {
_, err = connector.Client.GetNamespace(defaults.Namespace)
if err == nil {
return connector, nil
}
process.Debugf("Connected client %v failed to execute test call: %v. Node or proxy credentials are out of sync.", role, err)
if err := connector.Client.Close(); err != nil {
process.Debugf("Failed to close the client: %v.", err)
}
}
}
process.Infof("%v failed attempt connecting to auth server: %v.", role, err)
// Wait in between attempts, but return if teleport is shutting down
select {
case <-time.After(retryTime):
case <-process.ExitContext().Done():
process.Infof("%v stopping connection attempts, teleport is shutting down.", role)
return nil, ErrTeleportExited
}
}
} | go | func (process *TeleportProcess) reconnectToAuthService(role teleport.Role) (*Connector, error) {
retryTime := defaults.HighResPollingPeriod
for {
connector, err := process.connectToAuthService(role)
if err == nil {
// if connected and client is present, make sure the connector's
// client works, by using call that should succeed at all times
if connector.Client != nil {
_, err = connector.Client.GetNamespace(defaults.Namespace)
if err == nil {
return connector, nil
}
process.Debugf("Connected client %v failed to execute test call: %v. Node or proxy credentials are out of sync.", role, err)
if err := connector.Client.Close(); err != nil {
process.Debugf("Failed to close the client: %v.", err)
}
}
}
process.Infof("%v failed attempt connecting to auth server: %v.", role, err)
// Wait in between attempts, but return if teleport is shutting down
select {
case <-time.After(retryTime):
case <-process.ExitContext().Done():
process.Infof("%v stopping connection attempts, teleport is shutting down.", role)
return nil, ErrTeleportExited
}
}
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"reconnectToAuthService",
"(",
"role",
"teleport",
".",
"Role",
")",
"(",
"*",
"Connector",
",",
"error",
")",
"{",
"retryTime",
":=",
"defaults",
".",
"HighResPollingPeriod",
"\n",
"for",
"{",
"connector",
",",
"err",
":=",
"process",
".",
"connectToAuthService",
"(",
"role",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"connector",
".",
"Client",
"!=",
"nil",
"{",
"_",
",",
"err",
"=",
"connector",
".",
"Client",
".",
"GetNamespace",
"(",
"defaults",
".",
"Namespace",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"connector",
",",
"nil",
"\n",
"}",
"\n",
"process",
".",
"Debugf",
"(",
"\"Connected client %v failed to execute test call: %v. Node or proxy credentials are out of sync.\"",
",",
"role",
",",
"err",
")",
"\n",
"if",
"err",
":=",
"connector",
".",
"Client",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"process",
".",
"Debugf",
"(",
"\"Failed to close the client: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"process",
".",
"Infof",
"(",
"\"%v failed attempt connecting to auth server: %v.\"",
",",
"role",
",",
"err",
")",
"\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"retryTime",
")",
":",
"case",
"<-",
"process",
".",
"ExitContext",
"(",
")",
".",
"Done",
"(",
")",
":",
"process",
".",
"Infof",
"(",
"\"%v stopping connection attempts, teleport is shutting down.\"",
",",
"role",
")",
"\n",
"return",
"nil",
",",
"ErrTeleportExited",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // reconnectToAuthService continuously attempts to reconnect to the auth
// service until succeeds or process gets shut down | [
"reconnectToAuthService",
"continuously",
"attempts",
"to",
"reconnect",
"to",
"the",
"auth",
"service",
"until",
"succeeds",
"or",
"process",
"gets",
"shut",
"down"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L41-L68 | train |
gravitational/teleport | lib/service/connect.go | connectToAuthService | func (process *TeleportProcess) connectToAuthService(role teleport.Role) (*Connector, error) {
connector, err := process.connect(role)
if err != nil {
return nil, trace.Wrap(err)
}
process.Debugf("Connected client: %v", connector.ClientIdentity)
process.Debugf("Connected server: %v", connector.ServerIdentity)
process.addConnector(connector)
return connector, nil
} | go | func (process *TeleportProcess) connectToAuthService(role teleport.Role) (*Connector, error) {
connector, err := process.connect(role)
if err != nil {
return nil, trace.Wrap(err)
}
process.Debugf("Connected client: %v", connector.ClientIdentity)
process.Debugf("Connected server: %v", connector.ServerIdentity)
process.addConnector(connector)
return connector, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"connectToAuthService",
"(",
"role",
"teleport",
".",
"Role",
")",
"(",
"*",
"Connector",
",",
"error",
")",
"{",
"connector",
",",
"err",
":=",
"process",
".",
"connect",
"(",
"role",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"Debugf",
"(",
"\"Connected client: %v\"",
",",
"connector",
".",
"ClientIdentity",
")",
"\n",
"process",
".",
"Debugf",
"(",
"\"Connected server: %v\"",
",",
"connector",
".",
"ServerIdentity",
")",
"\n",
"process",
".",
"addConnector",
"(",
"connector",
")",
"\n",
"return",
"connector",
",",
"nil",
"\n",
"}"
] | // connectToAuthService attempts to login into the auth servers specified in the
// configuration and receive credentials. | [
"connectToAuthService",
"attempts",
"to",
"login",
"into",
"the",
"auth",
"servers",
"specified",
"in",
"the",
"configuration",
"and",
"receive",
"credentials",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L72-L82 | train |
gravitational/teleport | lib/service/connect.go | newWatcher | func (process *TeleportProcess) newWatcher(conn *Connector, watch services.Watch) (services.Watcher, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.NewWatcher(process.ExitContext(), watch)
}
return conn.Client.NewWatcher(process.ExitContext(), watch)
} | go | func (process *TeleportProcess) newWatcher(conn *Connector, watch services.Watch) (services.Watcher, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.NewWatcher(process.ExitContext(), watch)
}
return conn.Client.NewWatcher(process.ExitContext(), watch)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newWatcher",
"(",
"conn",
"*",
"Connector",
",",
"watch",
"services",
".",
"Watch",
")",
"(",
"services",
".",
"Watcher",
",",
"error",
")",
"{",
"if",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAdmin",
"||",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAuth",
"{",
"return",
"process",
".",
"localAuth",
".",
"NewWatcher",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"watch",
")",
"\n",
"}",
"\n",
"return",
"conn",
".",
"Client",
".",
"NewWatcher",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"watch",
")",
"\n",
"}"
] | // newWatcher returns a new watcher,
// either using local auth server connection or remote client | [
"newWatcher",
"returns",
"a",
"new",
"watcher",
"either",
"using",
"local",
"auth",
"server",
"connection",
"or",
"remote",
"client"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L279-L284 | train |
gravitational/teleport | lib/service/connect.go | getCertAuthority | func (process *TeleportProcess) getCertAuthority(conn *Connector, id services.CertAuthID, loadPrivateKeys bool) (services.CertAuthority, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.GetCertAuthority(id, loadPrivateKeys)
}
return conn.Client.GetCertAuthority(id, loadPrivateKeys)
} | go | func (process *TeleportProcess) getCertAuthority(conn *Connector, id services.CertAuthID, loadPrivateKeys bool) (services.CertAuthority, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.GetCertAuthority(id, loadPrivateKeys)
}
return conn.Client.GetCertAuthority(id, loadPrivateKeys)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"getCertAuthority",
"(",
"conn",
"*",
"Connector",
",",
"id",
"services",
".",
"CertAuthID",
",",
"loadPrivateKeys",
"bool",
")",
"(",
"services",
".",
"CertAuthority",
",",
"error",
")",
"{",
"if",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAdmin",
"||",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAuth",
"{",
"return",
"process",
".",
"localAuth",
".",
"GetCertAuthority",
"(",
"id",
",",
"loadPrivateKeys",
")",
"\n",
"}",
"\n",
"return",
"conn",
".",
"Client",
".",
"GetCertAuthority",
"(",
"id",
",",
"loadPrivateKeys",
")",
"\n",
"}"
] | // getCertAuthority returns cert authority by ID.
// In case if auth servers, the role is 'TeleportAdmin' and instead of using
// TLS client this method uses the local auth server. | [
"getCertAuthority",
"returns",
"cert",
"authority",
"by",
"ID",
".",
"In",
"case",
"if",
"auth",
"servers",
"the",
"role",
"is",
"TeleportAdmin",
"and",
"instead",
"of",
"using",
"TLS",
"client",
"this",
"method",
"uses",
"the",
"local",
"auth",
"server",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L289-L294 | train |
gravitational/teleport | lib/service/connect.go | reRegister | func (process *TeleportProcess) reRegister(conn *Connector, additionalPrincipals []string, dnsNames []string, rotation services.Rotation) (*auth.Identity, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return auth.GenerateIdentity(process.localAuth, conn.ClientIdentity.ID, additionalPrincipals, dnsNames)
}
const reason = "re-register"
keyPair, err := process.generateKeyPair(conn.ClientIdentity.ID.Role, reason)
if err != nil {
return nil, trace.Wrap(err)
}
identity, err := auth.ReRegister(auth.ReRegisterParams{
Client: conn.Client,
ID: conn.ClientIdentity.ID,
AdditionalPrincipals: additionalPrincipals,
PrivateKey: keyPair.PrivateKey,
PublicTLSKey: keyPair.PublicTLSKey,
PublicSSHKey: keyPair.PublicSSHKey,
DNSNames: dnsNames,
Rotation: rotation,
})
if err != nil {
return nil, trace.Wrap(err)
}
process.deleteKeyPair(conn.ClientIdentity.ID.Role, reason)
return identity, nil
} | go | func (process *TeleportProcess) reRegister(conn *Connector, additionalPrincipals []string, dnsNames []string, rotation services.Rotation) (*auth.Identity, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return auth.GenerateIdentity(process.localAuth, conn.ClientIdentity.ID, additionalPrincipals, dnsNames)
}
const reason = "re-register"
keyPair, err := process.generateKeyPair(conn.ClientIdentity.ID.Role, reason)
if err != nil {
return nil, trace.Wrap(err)
}
identity, err := auth.ReRegister(auth.ReRegisterParams{
Client: conn.Client,
ID: conn.ClientIdentity.ID,
AdditionalPrincipals: additionalPrincipals,
PrivateKey: keyPair.PrivateKey,
PublicTLSKey: keyPair.PublicTLSKey,
PublicSSHKey: keyPair.PublicSSHKey,
DNSNames: dnsNames,
Rotation: rotation,
})
if err != nil {
return nil, trace.Wrap(err)
}
process.deleteKeyPair(conn.ClientIdentity.ID.Role, reason)
return identity, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"reRegister",
"(",
"conn",
"*",
"Connector",
",",
"additionalPrincipals",
"[",
"]",
"string",
",",
"dnsNames",
"[",
"]",
"string",
",",
"rotation",
"services",
".",
"Rotation",
")",
"(",
"*",
"auth",
".",
"Identity",
",",
"error",
")",
"{",
"if",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAdmin",
"||",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAuth",
"{",
"return",
"auth",
".",
"GenerateIdentity",
"(",
"process",
".",
"localAuth",
",",
"conn",
".",
"ClientIdentity",
".",
"ID",
",",
"additionalPrincipals",
",",
"dnsNames",
")",
"\n",
"}",
"\n",
"const",
"reason",
"=",
"\"re-register\"",
"\n",
"keyPair",
",",
"err",
":=",
"process",
".",
"generateKeyPair",
"(",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
",",
"reason",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"identity",
",",
"err",
":=",
"auth",
".",
"ReRegister",
"(",
"auth",
".",
"ReRegisterParams",
"{",
"Client",
":",
"conn",
".",
"Client",
",",
"ID",
":",
"conn",
".",
"ClientIdentity",
".",
"ID",
",",
"AdditionalPrincipals",
":",
"additionalPrincipals",
",",
"PrivateKey",
":",
"keyPair",
".",
"PrivateKey",
",",
"PublicTLSKey",
":",
"keyPair",
".",
"PublicTLSKey",
",",
"PublicSSHKey",
":",
"keyPair",
".",
"PublicSSHKey",
",",
"DNSNames",
":",
"dnsNames",
",",
"Rotation",
":",
"rotation",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"deleteKeyPair",
"(",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
",",
"reason",
")",
"\n",
"return",
"identity",
",",
"nil",
"\n",
"}"
] | // reRegister receives new identity credentials for proxy, node and auth.
// In case if auth servers, the role is 'TeleportAdmin' and instead of using
// TLS client this method uses the local auth server. | [
"reRegister",
"receives",
"new",
"identity",
"credentials",
"for",
"proxy",
"node",
"and",
"auth",
".",
"In",
"case",
"if",
"auth",
"servers",
"the",
"role",
"is",
"TeleportAdmin",
"and",
"instead",
"of",
"using",
"TLS",
"client",
"this",
"method",
"uses",
"the",
"local",
"auth",
"server",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L299-L323 | train |
gravitational/teleport | lib/service/connect.go | periodicSyncRotationState | func (process *TeleportProcess) periodicSyncRotationState() error {
// start rotation only after teleport process has started
eventC := make(chan Event, 1)
process.WaitForEvent(process.ExitContext(), TeleportReadyEvent, eventC)
select {
case <-eventC:
process.Infof("The new service has started successfully. Starting syncing rotation status with period %v.", process.Config.PollingPeriod)
case <-process.ExitContext().Done():
return nil
}
retryTicker := time.NewTicker(defaults.HighResPollingPeriod)
defer retryTicker.Stop()
for {
err := process.syncRotationStateCycle()
if err == nil {
return nil
}
process.Warningf("Sync rotation state cycle failed: %v, going to retry after %v.", err, defaults.HighResPollingPeriod)
select {
case <-retryTicker.C:
case <-process.ExitContext().Done():
return nil
}
}
} | go | func (process *TeleportProcess) periodicSyncRotationState() error {
// start rotation only after teleport process has started
eventC := make(chan Event, 1)
process.WaitForEvent(process.ExitContext(), TeleportReadyEvent, eventC)
select {
case <-eventC:
process.Infof("The new service has started successfully. Starting syncing rotation status with period %v.", process.Config.PollingPeriod)
case <-process.ExitContext().Done():
return nil
}
retryTicker := time.NewTicker(defaults.HighResPollingPeriod)
defer retryTicker.Stop()
for {
err := process.syncRotationStateCycle()
if err == nil {
return nil
}
process.Warningf("Sync rotation state cycle failed: %v, going to retry after %v.", err, defaults.HighResPollingPeriod)
select {
case <-retryTicker.C:
case <-process.ExitContext().Done():
return nil
}
}
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"periodicSyncRotationState",
"(",
")",
"error",
"{",
"eventC",
":=",
"make",
"(",
"chan",
"Event",
",",
"1",
")",
"\n",
"process",
".",
"WaitForEvent",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"TeleportReadyEvent",
",",
"eventC",
")",
"\n",
"select",
"{",
"case",
"<-",
"eventC",
":",
"process",
".",
"Infof",
"(",
"\"The new service has started successfully. Starting syncing rotation status with period %v.\"",
",",
"process",
".",
"Config",
".",
"PollingPeriod",
")",
"\n",
"case",
"<-",
"process",
".",
"ExitContext",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"}",
"\n",
"retryTicker",
":=",
"time",
".",
"NewTicker",
"(",
"defaults",
".",
"HighResPollingPeriod",
")",
"\n",
"defer",
"retryTicker",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"err",
":=",
"process",
".",
"syncRotationStateCycle",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"process",
".",
"Warningf",
"(",
"\"Sync rotation state cycle failed: %v, going to retry after %v.\"",
",",
"err",
",",
"defaults",
".",
"HighResPollingPeriod",
")",
"\n",
"select",
"{",
"case",
"<-",
"retryTicker",
".",
"C",
":",
"case",
"<-",
"process",
".",
"ExitContext",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // periodicSyncRotationState checks rotation state periodically and
// takes action if necessary | [
"periodicSyncRotationState",
"checks",
"rotation",
"state",
"periodically",
"and",
"takes",
"action",
"if",
"necessary"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L441-L466 | train |
gravitational/teleport | lib/service/connect.go | syncRotationStateAndBroadcast | func (process *TeleportProcess) syncRotationStateAndBroadcast(conn *Connector) (*rotationStatus, error) {
status, err := process.syncRotationState(conn)
if err != nil {
process.BroadcastEvent(Event{Name: TeleportDegradedEvent, Payload: nil})
if trace.IsConnectionProblem(err) {
process.Warningf("Connection problem: sync rotation state: %v.", err)
} else {
process.Warningf("Failed to sync rotation state: %v.", err)
}
return nil, trace.Wrap(err)
}
process.BroadcastEvent(Event{Name: TeleportOKEvent, Payload: nil})
if status.phaseChanged || status.needsReload {
process.Debugf("Sync rotation state detected cert authority reload phase update.")
}
if status.phaseChanged {
process.BroadcastEvent(Event{Name: TeleportPhaseChangeEvent})
}
if status.needsReload {
process.Debugf("Triggering reload process.")
process.BroadcastEvent(Event{Name: TeleportReloadEvent})
}
return status, nil
} | go | func (process *TeleportProcess) syncRotationStateAndBroadcast(conn *Connector) (*rotationStatus, error) {
status, err := process.syncRotationState(conn)
if err != nil {
process.BroadcastEvent(Event{Name: TeleportDegradedEvent, Payload: nil})
if trace.IsConnectionProblem(err) {
process.Warningf("Connection problem: sync rotation state: %v.", err)
} else {
process.Warningf("Failed to sync rotation state: %v.", err)
}
return nil, trace.Wrap(err)
}
process.BroadcastEvent(Event{Name: TeleportOKEvent, Payload: nil})
if status.phaseChanged || status.needsReload {
process.Debugf("Sync rotation state detected cert authority reload phase update.")
}
if status.phaseChanged {
process.BroadcastEvent(Event{Name: TeleportPhaseChangeEvent})
}
if status.needsReload {
process.Debugf("Triggering reload process.")
process.BroadcastEvent(Event{Name: TeleportReloadEvent})
}
return status, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"syncRotationStateAndBroadcast",
"(",
"conn",
"*",
"Connector",
")",
"(",
"*",
"rotationStatus",
",",
"error",
")",
"{",
"status",
",",
"err",
":=",
"process",
".",
"syncRotationState",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportDegradedEvent",
",",
"Payload",
":",
"nil",
"}",
")",
"\n",
"if",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
"{",
"process",
".",
"Warningf",
"(",
"\"Connection problem: sync rotation state: %v.\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"process",
".",
"Warningf",
"(",
"\"Failed to sync rotation state: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportOKEvent",
",",
"Payload",
":",
"nil",
"}",
")",
"\n",
"if",
"status",
".",
"phaseChanged",
"||",
"status",
".",
"needsReload",
"{",
"process",
".",
"Debugf",
"(",
"\"Sync rotation state detected cert authority reload phase update.\"",
")",
"\n",
"}",
"\n",
"if",
"status",
".",
"phaseChanged",
"{",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportPhaseChangeEvent",
"}",
")",
"\n",
"}",
"\n",
"if",
"status",
".",
"needsReload",
"{",
"process",
".",
"Debugf",
"(",
"\"Triggering reload process.\"",
")",
"\n",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportReloadEvent",
"}",
")",
"\n",
"}",
"\n",
"return",
"status",
",",
"nil",
"\n",
"}"
] | // syncRotationStateAndBroadcast syncs rotation state and broadcasts events
// when phase has been changed or reload happened | [
"syncRotationStateAndBroadcast",
"syncs",
"rotation",
"state",
"and",
"broadcasts",
"events",
"when",
"phase",
"has",
"been",
"changed",
"or",
"reload",
"happened"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L546-L570 | train |
gravitational/teleport | lib/service/connect.go | syncRotationState | func (process *TeleportProcess) syncRotationState(conn *Connector) (*rotationStatus, error) {
connectors := process.getConnectors()
ca, err := process.getCertAuthority(conn, services.CertAuthID{
DomainName: conn.ClientIdentity.ClusterName,
Type: services.HostCA,
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
var status rotationStatus
status.ca = ca
for _, conn := range connectors {
serviceStatus, err := process.syncServiceRotationState(ca, conn)
if err != nil {
return nil, trace.Wrap(err)
}
if serviceStatus.needsReload {
status.needsReload = true
}
if serviceStatus.phaseChanged {
status.phaseChanged = true
}
}
return &status, nil
} | go | func (process *TeleportProcess) syncRotationState(conn *Connector) (*rotationStatus, error) {
connectors := process.getConnectors()
ca, err := process.getCertAuthority(conn, services.CertAuthID{
DomainName: conn.ClientIdentity.ClusterName,
Type: services.HostCA,
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
var status rotationStatus
status.ca = ca
for _, conn := range connectors {
serviceStatus, err := process.syncServiceRotationState(ca, conn)
if err != nil {
return nil, trace.Wrap(err)
}
if serviceStatus.needsReload {
status.needsReload = true
}
if serviceStatus.phaseChanged {
status.phaseChanged = true
}
}
return &status, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"syncRotationState",
"(",
"conn",
"*",
"Connector",
")",
"(",
"*",
"rotationStatus",
",",
"error",
")",
"{",
"connectors",
":=",
"process",
".",
"getConnectors",
"(",
")",
"\n",
"ca",
",",
"err",
":=",
"process",
".",
"getCertAuthority",
"(",
"conn",
",",
"services",
".",
"CertAuthID",
"{",
"DomainName",
":",
"conn",
".",
"ClientIdentity",
".",
"ClusterName",
",",
"Type",
":",
"services",
".",
"HostCA",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"status",
"rotationStatus",
"\n",
"status",
".",
"ca",
"=",
"ca",
"\n",
"for",
"_",
",",
"conn",
":=",
"range",
"connectors",
"{",
"serviceStatus",
",",
"err",
":=",
"process",
".",
"syncServiceRotationState",
"(",
"ca",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"serviceStatus",
".",
"needsReload",
"{",
"status",
".",
"needsReload",
"=",
"true",
"\n",
"}",
"\n",
"if",
"serviceStatus",
".",
"phaseChanged",
"{",
"status",
".",
"phaseChanged",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"status",
",",
"nil",
"\n",
"}"
] | // syncRotationState compares cluster rotation state with the state of
// internal services and performs the rotation if necessary. | [
"syncRotationState",
"compares",
"cluster",
"rotation",
"state",
"with",
"the",
"state",
"of",
"internal",
"services",
"and",
"performs",
"the",
"rotation",
"if",
"necessary",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L574-L598 | train |
gravitational/teleport | lib/service/connect.go | newClient | func (process *TeleportProcess) newClient(authServers []utils.NetAddr, identity *auth.Identity) (*auth.Client, bool, error) {
directClient, err := process.newClientDirect(authServers, identity)
if err != nil {
return nil, false, trace.Wrap(err)
}
// Try and connect to the Auth Server. If the request fails, try and
// connect through a tunnel.
log.Debugf("Attempting to connect to Auth Server directly.")
_, err = directClient.GetLocalClusterName()
if err != nil {
// Only attempt to connect through the proxy for nodes.
if identity.ID.Role != teleport.RoleNode {
return nil, false, trace.Wrap(err)
}
log.Debugf("Attempting to connect to Auth Server through tunnel.")
tunnelClient, er := process.newClientThroughTunnel(authServers, identity)
if er != nil {
return nil, false, trace.NewAggregate(err, er)
}
log.Debugf("Connected to Auth Server through tunnel.")
return tunnelClient, true, nil
}
log.Debugf("Connected to Auth Server with direct connection.")
return directClient, false, nil
} | go | func (process *TeleportProcess) newClient(authServers []utils.NetAddr, identity *auth.Identity) (*auth.Client, bool, error) {
directClient, err := process.newClientDirect(authServers, identity)
if err != nil {
return nil, false, trace.Wrap(err)
}
// Try and connect to the Auth Server. If the request fails, try and
// connect through a tunnel.
log.Debugf("Attempting to connect to Auth Server directly.")
_, err = directClient.GetLocalClusterName()
if err != nil {
// Only attempt to connect through the proxy for nodes.
if identity.ID.Role != teleport.RoleNode {
return nil, false, trace.Wrap(err)
}
log.Debugf("Attempting to connect to Auth Server through tunnel.")
tunnelClient, er := process.newClientThroughTunnel(authServers, identity)
if er != nil {
return nil, false, trace.NewAggregate(err, er)
}
log.Debugf("Connected to Auth Server through tunnel.")
return tunnelClient, true, nil
}
log.Debugf("Connected to Auth Server with direct connection.")
return directClient, false, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newClient",
"(",
"authServers",
"[",
"]",
"utils",
".",
"NetAddr",
",",
"identity",
"*",
"auth",
".",
"Identity",
")",
"(",
"*",
"auth",
".",
"Client",
",",
"bool",
",",
"error",
")",
"{",
"directClient",
",",
"err",
":=",
"process",
".",
"newClientDirect",
"(",
"authServers",
",",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Attempting to connect to Auth Server directly.\"",
")",
"\n",
"_",
",",
"err",
"=",
"directClient",
".",
"GetLocalClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"identity",
".",
"ID",
".",
"Role",
"!=",
"teleport",
".",
"RoleNode",
"{",
"return",
"nil",
",",
"false",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Attempting to connect to Auth Server through tunnel.\"",
")",
"\n",
"tunnelClient",
",",
"er",
":=",
"process",
".",
"newClientThroughTunnel",
"(",
"authServers",
",",
"identity",
")",
"\n",
"if",
"er",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"trace",
".",
"NewAggregate",
"(",
"err",
",",
"er",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Connected to Auth Server through tunnel.\"",
")",
"\n",
"return",
"tunnelClient",
",",
"true",
",",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Connected to Auth Server with direct connection.\"",
")",
"\n",
"return",
"directClient",
",",
"false",
",",
"nil",
"\n",
"}"
] | // newClient attempts to connect directly to the Auth Server. If it fails, it
// falls back to trying to connect to the Auth Server through the proxy. | [
"newClient",
"attempts",
"to",
"connect",
"directly",
"to",
"the",
"Auth",
"Server",
".",
"If",
"it",
"fails",
"it",
"falls",
"back",
"to",
"trying",
"to",
"connect",
"to",
"the",
"Auth",
"Server",
"through",
"the",
"proxy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L778-L806 | train |
gravitational/teleport | lib/service/connect.go | findReverseTunnel | func (process *TeleportProcess) findReverseTunnel(addrs []utils.NetAddr) (string, error) {
var errs []error
for _, addr := range addrs {
// In insecure mode, any certificate is accepted. In secure mode the hosts
// CAs are used to validate the certificate on the proxy.
clt, err := client.NewCredentialsClient(
addr.String(),
lib.IsInsecureDevMode(),
nil)
if err != nil {
return "", trace.Wrap(err)
}
resp, err := clt.Find(process.ExitContext())
if err == nil {
// If a tunnel public address is set, return it otherwise return the
// tunnel listen address.
if resp.Proxy.SSH.TunnelPublicAddr != "" {
return resp.Proxy.SSH.TunnelPublicAddr, nil
}
return resp.Proxy.SSH.TunnelListenAddr, nil
}
errs = append(errs, err)
}
return "", trace.NewAggregate(errs...)
} | go | func (process *TeleportProcess) findReverseTunnel(addrs []utils.NetAddr) (string, error) {
var errs []error
for _, addr := range addrs {
// In insecure mode, any certificate is accepted. In secure mode the hosts
// CAs are used to validate the certificate on the proxy.
clt, err := client.NewCredentialsClient(
addr.String(),
lib.IsInsecureDevMode(),
nil)
if err != nil {
return "", trace.Wrap(err)
}
resp, err := clt.Find(process.ExitContext())
if err == nil {
// If a tunnel public address is set, return it otherwise return the
// tunnel listen address.
if resp.Proxy.SSH.TunnelPublicAddr != "" {
return resp.Proxy.SSH.TunnelPublicAddr, nil
}
return resp.Proxy.SSH.TunnelListenAddr, nil
}
errs = append(errs, err)
}
return "", trace.NewAggregate(errs...)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"findReverseTunnel",
"(",
"addrs",
"[",
"]",
"utils",
".",
"NetAddr",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"errs",
"[",
"]",
"error",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"clt",
",",
"err",
":=",
"client",
".",
"NewCredentialsClient",
"(",
"addr",
".",
"String",
"(",
")",
",",
"lib",
".",
"IsInsecureDevMode",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"resp",
",",
"err",
":=",
"clt",
".",
"Find",
"(",
"process",
".",
"ExitContext",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"resp",
".",
"Proxy",
".",
"SSH",
".",
"TunnelPublicAddr",
"!=",
"\"\"",
"{",
"return",
"resp",
".",
"Proxy",
".",
"SSH",
".",
"TunnelPublicAddr",
",",
"nil",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Proxy",
".",
"SSH",
".",
"TunnelListenAddr",
",",
"nil",
"\n",
"}",
"\n",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"trace",
".",
"NewAggregate",
"(",
"errs",
"...",
")",
"\n",
"}"
] | // findReverseTunnel uses the web proxy to discover where the SSH reverse tunnel
// server is running. | [
"findReverseTunnel",
"uses",
"the",
"web",
"proxy",
"to",
"discover",
"where",
"the",
"SSH",
"reverse",
"tunnel",
"server",
"is",
"running",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L810-L835 | train |
gravitational/teleport | lib/utils/spki.go | CalculateSPKI | func CalculateSPKI(cert *x509.Certificate) string {
sum := sha256.Sum256(cert.RawSubjectPublicKeyInfo)
return "sha256:" + hex.EncodeToString(sum[:])
} | go | func CalculateSPKI(cert *x509.Certificate) string {
sum := sha256.Sum256(cert.RawSubjectPublicKeyInfo)
return "sha256:" + hex.EncodeToString(sum[:])
} | [
"func",
"CalculateSPKI",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"string",
"{",
"sum",
":=",
"sha256",
".",
"Sum256",
"(",
"cert",
".",
"RawSubjectPublicKeyInfo",
")",
"\n",
"return",
"\"sha256:\"",
"+",
"hex",
".",
"EncodeToString",
"(",
"sum",
"[",
":",
"]",
")",
"\n",
"}"
] | // CalculateSPKI the hash value of the SPKI header in a certificate. | [
"CalculateSPKI",
"the",
"hash",
"value",
"of",
"the",
"SPKI",
"header",
"in",
"a",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/spki.go#L30-L33 | train |
gravitational/teleport | lib/utils/spki.go | CheckSPKI | func CheckSPKI(pin string, cert *x509.Certificate) error {
// Check that the format of the pin is valid.
parts := strings.Split(pin, ":")
if len(parts) != 2 {
return trace.BadParameter("invalid format for certificate pin, expected algorithm:pin")
}
if parts[0] != "sha256" {
return trace.BadParameter("sha256 only supported hashing algorithm for certificate pin")
}
// Check that that pin itself matches that value calculated from the passed
// in certificate.
if subtle.ConstantTimeCompare([]byte(CalculateSPKI(cert)), []byte(pin)) != 1 {
return trace.BadParameter(errorMessage)
}
return nil
} | go | func CheckSPKI(pin string, cert *x509.Certificate) error {
// Check that the format of the pin is valid.
parts := strings.Split(pin, ":")
if len(parts) != 2 {
return trace.BadParameter("invalid format for certificate pin, expected algorithm:pin")
}
if parts[0] != "sha256" {
return trace.BadParameter("sha256 only supported hashing algorithm for certificate pin")
}
// Check that that pin itself matches that value calculated from the passed
// in certificate.
if subtle.ConstantTimeCompare([]byte(CalculateSPKI(cert)), []byte(pin)) != 1 {
return trace.BadParameter(errorMessage)
}
return nil
} | [
"func",
"CheckSPKI",
"(",
"pin",
"string",
",",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"error",
"{",
"parts",
":=",
"strings",
".",
"Split",
"(",
"pin",
",",
"\":\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"invalid format for certificate pin, expected algorithm:pin\"",
")",
"\n",
"}",
"\n",
"if",
"parts",
"[",
"0",
"]",
"!=",
"\"sha256\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"sha256 only supported hashing algorithm for certificate pin\"",
")",
"\n",
"}",
"\n",
"if",
"subtle",
".",
"ConstantTimeCompare",
"(",
"[",
"]",
"byte",
"(",
"CalculateSPKI",
"(",
"cert",
")",
")",
",",
"[",
"]",
"byte",
"(",
"pin",
")",
")",
"!=",
"1",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"errorMessage",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckSPKI the passed in pin against the calculated value from a certificate. | [
"CheckSPKI",
"the",
"passed",
"in",
"pin",
"against",
"the",
"calculated",
"value",
"from",
"a",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/spki.go#L36-L53 | train |
gravitational/teleport | lib/httplib/httplib.go | MakeHandler | func MakeHandler(fn HandlerFunc) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r, p)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | go | func MakeHandler(fn HandlerFunc) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r, p)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | [
"func",
"MakeHandler",
"(",
"fn",
"HandlerFunc",
")",
"httprouter",
".",
"Handle",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"{",
"SetNoCacheHeaders",
"(",
"w",
".",
"Header",
"(",
")",
")",
"\n",
"out",
",",
"err",
":=",
"fn",
"(",
"w",
",",
"r",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"trace",
".",
"WriteError",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"out",
"!=",
"nil",
"{",
"roundtrip",
".",
"ReplyJSON",
"(",
"w",
",",
"http",
".",
"StatusOK",
",",
"out",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // MakeHandler returns a new httprouter.Handle func from a handler func | [
"MakeHandler",
"returns",
"a",
"new",
"httprouter",
".",
"Handle",
"func",
"from",
"a",
"handler",
"func"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L45-L59 | train |
gravitational/teleport | lib/httplib/httplib.go | MakeStdHandler | func MakeStdHandler(fn StdHandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | go | func MakeStdHandler(fn StdHandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | [
"func",
"MakeStdHandler",
"(",
"fn",
"StdHandlerFunc",
")",
"http",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"SetNoCacheHeaders",
"(",
"w",
".",
"Header",
"(",
")",
")",
"\n",
"out",
",",
"err",
":=",
"fn",
"(",
"w",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"trace",
".",
"WriteError",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"out",
"!=",
"nil",
"{",
"roundtrip",
".",
"ReplyJSON",
"(",
"w",
",",
"http",
".",
"StatusOK",
",",
"out",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // MakeStdHandler returns a new http.Handle func from http.HandlerFunc | [
"MakeStdHandler",
"returns",
"a",
"new",
"http",
".",
"Handle",
"func",
"from",
"http",
".",
"HandlerFunc"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L62-L76 | train |
gravitational/teleport | lib/httplib/httplib.go | WithCSRFProtection | func WithCSRFProtection(fn HandlerFunc) httprouter.Handle {
hanlderFn := MakeHandler(fn)
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
err := csrf.VerifyHTTPHeader(r)
if err != nil {
log.Warningf("unable to validate CSRF token %v", err)
trace.WriteError(w, trace.AccessDenied("access denied"))
return
}
hanlderFn(w, r, p)
}
} | go | func WithCSRFProtection(fn HandlerFunc) httprouter.Handle {
hanlderFn := MakeHandler(fn)
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
err := csrf.VerifyHTTPHeader(r)
if err != nil {
log.Warningf("unable to validate CSRF token %v", err)
trace.WriteError(w, trace.AccessDenied("access denied"))
return
}
hanlderFn(w, r, p)
}
} | [
"func",
"WithCSRFProtection",
"(",
"fn",
"HandlerFunc",
")",
"httprouter",
".",
"Handle",
"{",
"hanlderFn",
":=",
"MakeHandler",
"(",
"fn",
")",
"\n",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"{",
"err",
":=",
"csrf",
".",
"VerifyHTTPHeader",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"unable to validate CSRF token %v\"",
",",
"err",
")",
"\n",
"trace",
".",
"WriteError",
"(",
"w",
",",
"trace",
".",
"AccessDenied",
"(",
"\"access denied\"",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"hanlderFn",
"(",
"w",
",",
"r",
",",
"p",
")",
"\n",
"}",
"\n",
"}"
] | // WithCSRFProtection ensures that request to unauthenticated API is checked against CSRF attacks | [
"WithCSRFProtection",
"ensures",
"that",
"request",
"to",
"unauthenticated",
"API",
"is",
"checked",
"against",
"CSRF",
"attacks"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L79-L90 | train |
gravitational/teleport | lib/httplib/httplib.go | ConvertResponse | func ConvertResponse(re *roundtrip.Response, err error) (*roundtrip.Response, error) {
if err != nil {
if uerr, ok := err.(*url.Error); ok && uerr != nil && uerr.Err != nil {
return nil, trace.ConnectionProblem(uerr.Err, uerr.Error())
}
return nil, trace.ConvertSystemError(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | go | func ConvertResponse(re *roundtrip.Response, err error) (*roundtrip.Response, error) {
if err != nil {
if uerr, ok := err.(*url.Error); ok && uerr != nil && uerr.Err != nil {
return nil, trace.ConnectionProblem(uerr.Err, uerr.Error())
}
return nil, trace.ConvertSystemError(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | [
"func",
"ConvertResponse",
"(",
"re",
"*",
"roundtrip",
".",
"Response",
",",
"err",
"error",
")",
"(",
"*",
"roundtrip",
".",
"Response",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"if",
"uerr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"url",
".",
"Error",
")",
";",
"ok",
"&&",
"uerr",
"!=",
"nil",
"&&",
"uerr",
".",
"Err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"uerr",
".",
"Err",
",",
"uerr",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"trace",
".",
"ReadError",
"(",
"re",
".",
"Code",
"(",
")",
",",
"re",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // ConvertResponse converts http error to internal error type
// based on HTTP response code and HTTP body contents | [
"ConvertResponse",
"converts",
"http",
"error",
"to",
"internal",
"error",
"type",
"based",
"on",
"HTTP",
"response",
"code",
"and",
"HTTP",
"body",
"contents"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L107-L115 | train |
gravitational/teleport | lib/httplib/httplib.go | ParseBool | func ParseBool(q url.Values, name string) (bool, bool, error) {
stringVal := q.Get(name)
if stringVal == "" {
return false, false, nil
}
val, err := strconv.ParseBool(stringVal)
if err != nil {
return false, false, trace.BadParameter(
"'%v': expected 'true' or 'false', got %v", name, stringVal)
}
return val, true, nil
} | go | func ParseBool(q url.Values, name string) (bool, bool, error) {
stringVal := q.Get(name)
if stringVal == "" {
return false, false, nil
}
val, err := strconv.ParseBool(stringVal)
if err != nil {
return false, false, trace.BadParameter(
"'%v': expected 'true' or 'false', got %v", name, stringVal)
}
return val, true, nil
} | [
"func",
"ParseBool",
"(",
"q",
"url",
".",
"Values",
",",
"name",
"string",
")",
"(",
"bool",
",",
"bool",
",",
"error",
")",
"{",
"stringVal",
":=",
"q",
".",
"Get",
"(",
"name",
")",
"\n",
"if",
"stringVal",
"==",
"\"\"",
"{",
"return",
"false",
",",
"false",
",",
"nil",
"\n",
"}",
"\n",
"val",
",",
"err",
":=",
"strconv",
".",
"ParseBool",
"(",
"stringVal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"false",
",",
"trace",
".",
"BadParameter",
"(",
"\"'%v': expected 'true' or 'false', got %v\"",
",",
"name",
",",
"stringVal",
")",
"\n",
"}",
"\n",
"return",
"val",
",",
"true",
",",
"nil",
"\n",
"}"
] | // ParseBool will parse boolean variable from url query
// returns value, ok, error | [
"ParseBool",
"will",
"parse",
"boolean",
"variable",
"from",
"url",
"query",
"returns",
"value",
"ok",
"error"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L119-L131 | train |
gravitational/teleport | lib/httplib/httplib.go | Rewrite | func Rewrite(in, out string) RewritePair {
return RewritePair{
Expr: regexp.MustCompile(in),
Replacement: out,
}
} | go | func Rewrite(in, out string) RewritePair {
return RewritePair{
Expr: regexp.MustCompile(in),
Replacement: out,
}
} | [
"func",
"Rewrite",
"(",
"in",
",",
"out",
"string",
")",
"RewritePair",
"{",
"return",
"RewritePair",
"{",
"Expr",
":",
"regexp",
".",
"MustCompile",
"(",
"in",
")",
",",
"Replacement",
":",
"out",
",",
"}",
"\n",
"}"
] | // Rewrite creates a rewrite pair, panics if in epxression
// is not a valid regular expressoin | [
"Rewrite",
"creates",
"a",
"rewrite",
"pair",
"panics",
"if",
"in",
"epxression",
"is",
"not",
"a",
"valid",
"regular",
"expressoin"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L143-L148 | train |
gravitational/teleport | lib/httplib/httplib.go | RewritePaths | func RewritePaths(next http.Handler, rewrites ...RewritePair) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
for _, rewrite := range rewrites {
req.URL.Path = rewrite.Expr.ReplaceAllString(req.URL.Path, rewrite.Replacement)
}
next.ServeHTTP(w, req)
})
} | go | func RewritePaths(next http.Handler, rewrites ...RewritePair) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
for _, rewrite := range rewrites {
req.URL.Path = rewrite.Expr.ReplaceAllString(req.URL.Path, rewrite.Replacement)
}
next.ServeHTTP(w, req)
})
} | [
"func",
"RewritePaths",
"(",
"next",
"http",
".",
"Handler",
",",
"rewrites",
"...",
"RewritePair",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"for",
"_",
",",
"rewrite",
":=",
"range",
"rewrites",
"{",
"req",
".",
"URL",
".",
"Path",
"=",
"rewrite",
".",
"Expr",
".",
"ReplaceAllString",
"(",
"req",
".",
"URL",
".",
"Path",
",",
"rewrite",
".",
"Replacement",
")",
"\n",
"}",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"req",
")",
"\n",
"}",
")",
"\n",
"}"
] | // RewritePaths creates a middleware that rewrites paths in incoming request | [
"RewritePaths",
"creates",
"a",
"middleware",
"that",
"rewrites",
"paths",
"in",
"incoming",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L151-L158 | train |
gravitational/teleport | lib/httplib/httplib.go | SafeRedirect | func SafeRedirect(w http.ResponseWriter, r *http.Request, redirectURL string) error {
parsedURL, err := url.Parse(redirectURL)
if err != nil {
return trace.Wrap(err)
}
http.Redirect(w, r, parsedURL.RequestURI(), http.StatusFound)
return nil
} | go | func SafeRedirect(w http.ResponseWriter, r *http.Request, redirectURL string) error {
parsedURL, err := url.Parse(redirectURL)
if err != nil {
return trace.Wrap(err)
}
http.Redirect(w, r, parsedURL.RequestURI(), http.StatusFound)
return nil
} | [
"func",
"SafeRedirect",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"redirectURL",
"string",
")",
"error",
"{",
"parsedURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"redirectURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"parsedURL",
".",
"RequestURI",
"(",
")",
",",
"http",
".",
"StatusFound",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // SafeRedirect performs a relative redirect to the URI part of the provided redirect URL | [
"SafeRedirect",
"performs",
"a",
"relative",
"redirect",
"to",
"the",
"URI",
"part",
"of",
"the",
"provided",
"redirect",
"URL"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L161-L168 | train |
gravitational/teleport | lib/srv/ctx.go | CreateOrJoinSession | func (c *ServerContext) CreateOrJoinSession(reg *SessionRegistry) error {
// As SSH conversation progresses, at some point a session will be created and
// its ID will be added to the environment
ssid, found := c.GetEnv(sshutils.SessionEnvVar)
if !found {
return nil
}
// make sure whatever session is requested is a valid session
_, err := rsession.ParseID(ssid)
if err != nil {
return trace.BadParameter("invalid session id")
}
findSession := func() (*session, bool) {
reg.Lock()
defer reg.Unlock()
return reg.findSession(rsession.ID(ssid))
}
// update ctx with a session ID
c.session, _ = findSession()
if c.session == nil {
log.Debugf("Will create new session for SSH connection %v.", c.Conn.RemoteAddr())
} else {
log.Debugf("Will join session %v for SSH connection %v.", c.session, c.Conn.RemoteAddr())
}
return nil
} | go | func (c *ServerContext) CreateOrJoinSession(reg *SessionRegistry) error {
// As SSH conversation progresses, at some point a session will be created and
// its ID will be added to the environment
ssid, found := c.GetEnv(sshutils.SessionEnvVar)
if !found {
return nil
}
// make sure whatever session is requested is a valid session
_, err := rsession.ParseID(ssid)
if err != nil {
return trace.BadParameter("invalid session id")
}
findSession := func() (*session, bool) {
reg.Lock()
defer reg.Unlock()
return reg.findSession(rsession.ID(ssid))
}
// update ctx with a session ID
c.session, _ = findSession()
if c.session == nil {
log.Debugf("Will create new session for SSH connection %v.", c.Conn.RemoteAddr())
} else {
log.Debugf("Will join session %v for SSH connection %v.", c.session, c.Conn.RemoteAddr())
}
return nil
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"CreateOrJoinSession",
"(",
"reg",
"*",
"SessionRegistry",
")",
"error",
"{",
"ssid",
",",
"found",
":=",
"c",
".",
"GetEnv",
"(",
"sshutils",
".",
"SessionEnvVar",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"rsession",
".",
"ParseID",
"(",
"ssid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"invalid session id\"",
")",
"\n",
"}",
"\n",
"findSession",
":=",
"func",
"(",
")",
"(",
"*",
"session",
",",
"bool",
")",
"{",
"reg",
".",
"Lock",
"(",
")",
"\n",
"defer",
"reg",
".",
"Unlock",
"(",
")",
"\n",
"return",
"reg",
".",
"findSession",
"(",
"rsession",
".",
"ID",
"(",
"ssid",
")",
")",
"\n",
"}",
"\n",
"c",
".",
"session",
",",
"_",
"=",
"findSession",
"(",
")",
"\n",
"if",
"c",
".",
"session",
"==",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"Will create new session for SSH connection %v.\"",
",",
"c",
".",
"Conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Debugf",
"(",
"\"Will join session %v for SSH connection %v.\"",
",",
"c",
".",
"session",
",",
"c",
".",
"Conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CreateOrJoinSession will look in the SessionRegistry for the session ID. If
// no session is found, a new one is created. If one is found, it is returned. | [
"CreateOrJoinSession",
"will",
"look",
"in",
"the",
"SessionRegistry",
"for",
"the",
"session",
"ID",
".",
"If",
"no",
"session",
"is",
"found",
"a",
"new",
"one",
"is",
"created",
".",
"If",
"one",
"is",
"found",
"it",
"is",
"returned",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L332-L360 | train |
gravitational/teleport | lib/srv/ctx.go | UpdateClientActivity | func (c *ServerContext) UpdateClientActivity() {
c.Lock()
defer c.Unlock()
c.clientLastActive = c.srv.GetClock().Now().UTC()
} | go | func (c *ServerContext) UpdateClientActivity() {
c.Lock()
defer c.Unlock()
c.clientLastActive = c.srv.GetClock().Now().UTC()
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"UpdateClientActivity",
"(",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"clientLastActive",
"=",
"c",
".",
"srv",
".",
"GetClock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] | // UpdateClientActivity sets last recorded client activity associated with this context
// either channel or session | [
"UpdateClientActivity",
"sets",
"last",
"recorded",
"client",
"activity",
"associated",
"with",
"this",
"context",
"either",
"channel",
"or",
"session"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L371-L375 | train |
gravitational/teleport | lib/srv/ctx.go | GetAgent | func (c *ServerContext) GetAgent() agent.Agent {
c.RLock()
defer c.RUnlock()
return c.agent
} | go | func (c *ServerContext) GetAgent() agent.Agent {
c.RLock()
defer c.RUnlock()
return c.agent
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetAgent",
"(",
")",
"agent",
".",
"Agent",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"agent",
"\n",
"}"
] | // GetAgent returns a agent.Agent which represents the capabilities of an SSH agent. | [
"GetAgent",
"returns",
"a",
"agent",
".",
"Agent",
"which",
"represents",
"the",
"capabilities",
"of",
"an",
"SSH",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L386-L390 | train |
gravitational/teleport | lib/srv/ctx.go | GetAgentChannel | func (c *ServerContext) GetAgentChannel() ssh.Channel {
c.RLock()
defer c.RUnlock()
return c.agentChannel
} | go | func (c *ServerContext) GetAgentChannel() ssh.Channel {
c.RLock()
defer c.RUnlock()
return c.agentChannel
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetAgentChannel",
"(",
")",
"ssh",
".",
"Channel",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"agentChannel",
"\n",
"}"
] | // GetAgentChannel returns the channel over which communication with the agent occurs. | [
"GetAgentChannel",
"returns",
"the",
"channel",
"over",
"which",
"communication",
"with",
"the",
"agent",
"occurs",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L393-L397 | train |
gravitational/teleport | lib/srv/ctx.go | SetAgent | func (c *ServerContext) SetAgent(a agent.Agent, channel ssh.Channel) {
c.Lock()
defer c.Unlock()
if c.agentChannel != nil {
c.Infof("closing previous agent channel")
c.agentChannel.Close()
}
c.agentChannel = channel
c.agent = a
} | go | func (c *ServerContext) SetAgent(a agent.Agent, channel ssh.Channel) {
c.Lock()
defer c.Unlock()
if c.agentChannel != nil {
c.Infof("closing previous agent channel")
c.agentChannel.Close()
}
c.agentChannel = channel
c.agent = a
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SetAgent",
"(",
"a",
"agent",
".",
"Agent",
",",
"channel",
"ssh",
".",
"Channel",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"if",
"c",
".",
"agentChannel",
"!=",
"nil",
"{",
"c",
".",
"Infof",
"(",
"\"closing previous agent channel\"",
")",
"\n",
"c",
".",
"agentChannel",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"c",
".",
"agentChannel",
"=",
"channel",
"\n",
"c",
".",
"agent",
"=",
"a",
"\n",
"}"
] | // SetAgent sets the agent and channel over which communication with the agent occurs. | [
"SetAgent",
"sets",
"the",
"agent",
"and",
"channel",
"over",
"which",
"communication",
"with",
"the",
"agent",
"occurs",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L400-L409 | train |
gravitational/teleport | lib/srv/ctx.go | GetTerm | func (c *ServerContext) GetTerm() Terminal {
c.RLock()
defer c.RUnlock()
return c.term
} | go | func (c *ServerContext) GetTerm() Terminal {
c.RLock()
defer c.RUnlock()
return c.term
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetTerm",
"(",
")",
"Terminal",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"term",
"\n",
"}"
] | // GetTerm returns a Terminal. | [
"GetTerm",
"returns",
"a",
"Terminal",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L412-L417 | train |
gravitational/teleport | lib/srv/ctx.go | SetTerm | func (c *ServerContext) SetTerm(t Terminal) {
c.Lock()
defer c.Unlock()
c.term = t
} | go | func (c *ServerContext) SetTerm(t Terminal) {
c.Lock()
defer c.Unlock()
c.term = t
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SetTerm",
"(",
"t",
"Terminal",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"term",
"=",
"t",
"\n",
"}"
] | // SetTerm set a Terminal. | [
"SetTerm",
"set",
"a",
"Terminal",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L420-L425 | train |
gravitational/teleport | lib/srv/ctx.go | SetEnv | func (c *ServerContext) SetEnv(key, val string) {
c.env[key] = val
} | go | func (c *ServerContext) SetEnv(key, val string) {
c.env[key] = val
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SetEnv",
"(",
"key",
",",
"val",
"string",
")",
"{",
"c",
".",
"env",
"[",
"key",
"]",
"=",
"val",
"\n",
"}"
] | // SetEnv sets a environment variable within this context. | [
"SetEnv",
"sets",
"a",
"environment",
"variable",
"within",
"this",
"context",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L428-L430 | train |
gravitational/teleport | lib/srv/ctx.go | GetEnv | func (c *ServerContext) GetEnv(key string) (string, bool) {
val, ok := c.env[key]
return val, ok
} | go | func (c *ServerContext) GetEnv(key string) (string, bool) {
val, ok := c.env[key]
return val, ok
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetEnv",
"(",
"key",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"val",
",",
"ok",
":=",
"c",
".",
"env",
"[",
"key",
"]",
"\n",
"return",
"val",
",",
"ok",
"\n",
"}"
] | // GetEnv returns a environment variable within this context. | [
"GetEnv",
"returns",
"a",
"environment",
"variable",
"within",
"this",
"context",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L433-L436 | train |
gravitational/teleport | lib/srv/ctx.go | SendExecResult | func (c *ServerContext) SendExecResult(r ExecResult) {
select {
case c.ExecResultCh <- r:
default:
log.Infof("blocked on sending exec result %v", r)
}
} | go | func (c *ServerContext) SendExecResult(r ExecResult) {
select {
case c.ExecResultCh <- r:
default:
log.Infof("blocked on sending exec result %v", r)
}
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SendExecResult",
"(",
"r",
"ExecResult",
")",
"{",
"select",
"{",
"case",
"c",
".",
"ExecResultCh",
"<-",
"r",
":",
"default",
":",
"log",
".",
"Infof",
"(",
"\"blocked on sending exec result %v\"",
",",
"r",
")",
"\n",
"}",
"\n",
"}"
] | // SendExecResult sends the result of execution of the "exec" command over the
// ExecResultCh. | [
"SendExecResult",
"sends",
"the",
"result",
"of",
"execution",
"of",
"the",
"exec",
"command",
"over",
"the",
"ExecResultCh",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L520-L526 | train |
gravitational/teleport | lib/srv/ctx.go | SendSubsystemResult | func (c *ServerContext) SendSubsystemResult(r SubsystemResult) {
select {
case c.SubsystemResultCh <- r:
default:
c.Infof("blocked on sending subsystem result")
}
} | go | func (c *ServerContext) SendSubsystemResult(r SubsystemResult) {
select {
case c.SubsystemResultCh <- r:
default:
c.Infof("blocked on sending subsystem result")
}
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SendSubsystemResult",
"(",
"r",
"SubsystemResult",
")",
"{",
"select",
"{",
"case",
"c",
".",
"SubsystemResultCh",
"<-",
"r",
":",
"default",
":",
"c",
".",
"Infof",
"(",
"\"blocked on sending subsystem result\"",
")",
"\n",
"}",
"\n",
"}"
] | // SendSubsystemResult sends the result of running the subsystem over the
// SubsystemResultCh. | [
"SendSubsystemResult",
"sends",
"the",
"result",
"of",
"running",
"the",
"subsystem",
"over",
"the",
"SubsystemResultCh",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L530-L536 | train |
gravitational/teleport | lib/srv/ctx.go | ProxyPublicAddress | func (c *ServerContext) ProxyPublicAddress() string {
proxyHost := "<proxyhost>:3080"
if c.srv == nil {
return proxyHost
}
proxies, err := c.srv.GetAccessPoint().GetProxies()
if err != nil {
c.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHost = fmt.Sprintf("%v:%v", proxies[0].GetHostname(), defaults.HTTPListenPort)
c.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
return proxyHost
} | go | func (c *ServerContext) ProxyPublicAddress() string {
proxyHost := "<proxyhost>:3080"
if c.srv == nil {
return proxyHost
}
proxies, err := c.srv.GetAccessPoint().GetProxies()
if err != nil {
c.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHost = fmt.Sprintf("%v:%v", proxies[0].GetHostname(), defaults.HTTPListenPort)
c.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
return proxyHost
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"ProxyPublicAddress",
"(",
")",
"string",
"{",
"proxyHost",
":=",
"\"<proxyhost>:3080\"",
"\n",
"if",
"c",
".",
"srv",
"==",
"nil",
"{",
"return",
"proxyHost",
"\n",
"}",
"\n",
"proxies",
",",
"err",
":=",
"c",
".",
"srv",
".",
"GetAccessPoint",
"(",
")",
".",
"GetProxies",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"Errorf",
"(",
"\"Unable to retrieve proxy list: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"proxies",
")",
">",
"0",
"{",
"proxyHost",
"=",
"proxies",
"[",
"0",
"]",
".",
"GetPublicAddr",
"(",
")",
"\n",
"if",
"proxyHost",
"==",
"\"\"",
"{",
"proxyHost",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%v:%v\"",
",",
"proxies",
"[",
"0",
"]",
".",
"GetHostname",
"(",
")",
",",
"defaults",
".",
"HTTPListenPort",
")",
"\n",
"c",
".",
"Debugf",
"(",
"\"public_address not set for proxy, returning proxyHost: %q\"",
",",
"proxyHost",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"proxyHost",
"\n",
"}"
] | // ProxyPublicAddress tries to get the public address from the first
// available proxy. if public_address is not set, fall back to the hostname
// of the first proxy we get back. | [
"ProxyPublicAddress",
"tries",
"to",
"get",
"the",
"public",
"address",
"from",
"the",
"first",
"available",
"proxy",
".",
"if",
"public_address",
"is",
"not",
"set",
"fall",
"back",
"to",
"the",
"hostname",
"of",
"the",
"first",
"proxy",
"we",
"get",
"back",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L541-L562 | train |
gravitational/teleport | lib/srv/ctx.go | NewTrackingReader | func NewTrackingReader(ctx *ServerContext, r io.Reader) *TrackingReader {
return &TrackingReader{ctx: ctx, r: r}
} | go | func NewTrackingReader(ctx *ServerContext, r io.Reader) *TrackingReader {
return &TrackingReader{ctx: ctx, r: r}
} | [
"func",
"NewTrackingReader",
"(",
"ctx",
"*",
"ServerContext",
",",
"r",
"io",
".",
"Reader",
")",
"*",
"TrackingReader",
"{",
"return",
"&",
"TrackingReader",
"{",
"ctx",
":",
"ctx",
",",
"r",
":",
"r",
"}",
"\n",
"}"
] | // NewTrackingReader returns a new instance of
// activity tracking reader. | [
"NewTrackingReader",
"returns",
"a",
"new",
"instance",
"of",
"activity",
"tracking",
"reader",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L595-L597 | train |
gravitational/teleport | lib/srv/ctx.go | Read | func (a *TrackingReader) Read(b []byte) (int, error) {
a.ctx.UpdateClientActivity()
return a.r.Read(b)
} | go | func (a *TrackingReader) Read(b []byte) (int, error) {
a.ctx.UpdateClientActivity()
return a.r.Read(b)
} | [
"func",
"(",
"a",
"*",
"TrackingReader",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"a",
".",
"ctx",
".",
"UpdateClientActivity",
"(",
")",
"\n",
"return",
"a",
".",
"r",
".",
"Read",
"(",
"b",
")",
"\n",
"}"
] | // Read passes the read through to internal
// reader, and updates activity of the server context | [
"Read",
"passes",
"the",
"read",
"through",
"to",
"internal",
"reader",
"and",
"updates",
"activity",
"of",
"the",
"server",
"context"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L609-L612 | train |
gravitational/teleport | lib/pam/config.go | CheckDefaults | func (c *Config) CheckDefaults() error {
if c.ServiceName == "" {
return trace.BadParameter("required parameter ServiceName missing")
}
if c.Username == "" {
return trace.BadParameter("required parameter Username missing")
}
if c.Stdin == nil {
return trace.BadParameter("required parameter Stdin missing")
}
if c.Stdout == nil {
return trace.BadParameter("required parameter Stdout missing")
}
if c.Stderr == nil {
return trace.BadParameter("required parameter Stderr missing")
}
return nil
} | go | func (c *Config) CheckDefaults() error {
if c.ServiceName == "" {
return trace.BadParameter("required parameter ServiceName missing")
}
if c.Username == "" {
return trace.BadParameter("required parameter Username missing")
}
if c.Stdin == nil {
return trace.BadParameter("required parameter Stdin missing")
}
if c.Stdout == nil {
return trace.BadParameter("required parameter Stdout missing")
}
if c.Stderr == nil {
return trace.BadParameter("required parameter Stderr missing")
}
return nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"CheckDefaults",
"(",
")",
"error",
"{",
"if",
"c",
".",
"ServiceName",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"required parameter ServiceName missing\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Username",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"required parameter Username missing\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Stdin",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"required parameter Stdin missing\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Stdout",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"required parameter Stdout missing\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Stderr",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"required parameter Stderr missing\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckDefaults makes sure the Config structure has minimum required values. | [
"CheckDefaults",
"makes",
"sure",
"the",
"Config",
"structure",
"has",
"minimum",
"required",
"values",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/config.go#L53-L71 | train |
gravitational/teleport | lib/auth/permissions.go | NewAdminContext | func NewAdminContext() (*AuthContext, error) {
authContext, err := contextForBuiltinRole("", nil, teleport.RoleAdmin, fmt.Sprintf("%v", teleport.RoleAdmin))
if err != nil {
return nil, trace.Wrap(err)
}
return authContext, nil
} | go | func NewAdminContext() (*AuthContext, error) {
authContext, err := contextForBuiltinRole("", nil, teleport.RoleAdmin, fmt.Sprintf("%v", teleport.RoleAdmin))
if err != nil {
return nil, trace.Wrap(err)
}
return authContext, nil
} | [
"func",
"NewAdminContext",
"(",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"contextForBuiltinRole",
"(",
"\"\"",
",",
"nil",
",",
"teleport",
".",
"RoleAdmin",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"teleport",
".",
"RoleAdmin",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"authContext",
",",
"nil",
"\n",
"}"
] | // NewAdminContext returns new admin auth context | [
"NewAdminContext",
"returns",
"new",
"admin",
"auth",
"context"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L31-L37 | train |
gravitational/teleport | lib/auth/permissions.go | NewRoleAuthorizer | func NewRoleAuthorizer(clusterName string, clusterConfig services.ClusterConfig, r teleport.Role) (Authorizer, error) {
authContext, err := contextForBuiltinRole(clusterName, clusterConfig, r, fmt.Sprintf("%v", r))
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | go | func NewRoleAuthorizer(clusterName string, clusterConfig services.ClusterConfig, r teleport.Role) (Authorizer, error) {
authContext, err := contextForBuiltinRole(clusterName, clusterConfig, r, fmt.Sprintf("%v", r))
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | [
"func",
"NewRoleAuthorizer",
"(",
"clusterName",
"string",
",",
"clusterConfig",
"services",
".",
"ClusterConfig",
",",
"r",
"teleport",
".",
"Role",
")",
"(",
"Authorizer",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"contextForBuiltinRole",
"(",
"clusterName",
",",
"clusterConfig",
",",
"r",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"r",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"contextAuthorizer",
"{",
"authContext",
":",
"*",
"authContext",
"}",
",",
"nil",
"\n",
"}"
] | // NewRoleAuthorizer authorizes everyone as predefined role, used in tests | [
"NewRoleAuthorizer",
"authorizes",
"everyone",
"as",
"predefined",
"role",
"used",
"in",
"tests"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L40-L46 | train |
gravitational/teleport | lib/auth/permissions.go | NewUserAuthorizer | func NewUserAuthorizer(username string, identity services.UserGetter, access services.Access) (Authorizer, error) {
authContext, err := contextForLocalUser(username, identity, access)
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | go | func NewUserAuthorizer(username string, identity services.UserGetter, access services.Access) (Authorizer, error) {
authContext, err := contextForLocalUser(username, identity, access)
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | [
"func",
"NewUserAuthorizer",
"(",
"username",
"string",
",",
"identity",
"services",
".",
"UserGetter",
",",
"access",
"services",
".",
"Access",
")",
"(",
"Authorizer",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"contextForLocalUser",
"(",
"username",
",",
"identity",
",",
"access",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"contextAuthorizer",
"{",
"authContext",
":",
"*",
"authContext",
"}",
",",
"nil",
"\n",
"}"
] | // NewUserAuthorizer authorizes everyone as predefined local user | [
"NewUserAuthorizer",
"authorizes",
"everyone",
"as",
"predefined",
"local",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L60-L66 | train |
gravitational/teleport | lib/auth/permissions.go | NewAuthorizer | func NewAuthorizer(access services.Access, identity services.UserGetter, trust services.Trust) (Authorizer, error) {
if access == nil {
return nil, trace.BadParameter("missing parameter access")
}
if identity == nil {
return nil, trace.BadParameter("missing parameter identity")
}
if trust == nil {
return nil, trace.BadParameter("missing parameter trust")
}
return &authorizer{access: access, identity: identity, trust: trust}, nil
} | go | func NewAuthorizer(access services.Access, identity services.UserGetter, trust services.Trust) (Authorizer, error) {
if access == nil {
return nil, trace.BadParameter("missing parameter access")
}
if identity == nil {
return nil, trace.BadParameter("missing parameter identity")
}
if trust == nil {
return nil, trace.BadParameter("missing parameter trust")
}
return &authorizer{access: access, identity: identity, trust: trust}, nil
} | [
"func",
"NewAuthorizer",
"(",
"access",
"services",
".",
"Access",
",",
"identity",
"services",
".",
"UserGetter",
",",
"trust",
"services",
".",
"Trust",
")",
"(",
"Authorizer",
",",
"error",
")",
"{",
"if",
"access",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter access\"",
")",
"\n",
"}",
"\n",
"if",
"identity",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter identity\"",
")",
"\n",
"}",
"\n",
"if",
"trust",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter trust\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"authorizer",
"{",
"access",
":",
"access",
",",
"identity",
":",
"identity",
",",
"trust",
":",
"trust",
"}",
",",
"nil",
"\n",
"}"
] | // NewAuthorizer returns new authorizer using backends | [
"NewAuthorizer",
"returns",
"new",
"authorizer",
"using",
"backends"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L69-L80 | train |
gravitational/teleport | lib/auth/permissions.go | authorizeLocalUser | func (a *authorizer) authorizeLocalUser(u LocalUser) (*AuthContext, error) {
return contextForLocalUser(u.Username, a.identity, a.access)
} | go | func (a *authorizer) authorizeLocalUser(u LocalUser) (*AuthContext, error) {
return contextForLocalUser(u.Username, a.identity, a.access)
} | [
"func",
"(",
"a",
"*",
"authorizer",
")",
"authorizeLocalUser",
"(",
"u",
"LocalUser",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"return",
"contextForLocalUser",
"(",
"u",
".",
"Username",
",",
"a",
".",
"identity",
",",
"a",
".",
"access",
")",
"\n",
"}"
] | // authorizeLocalUser returns authz context based on the username | [
"authorizeLocalUser",
"returns",
"authz",
"context",
"based",
"on",
"the",
"username"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L124-L126 | train |
gravitational/teleport | lib/auth/permissions.go | authorizeRemoteUser | func (a *authorizer) authorizeRemoteUser(u RemoteUser) (*AuthContext, error) {
ca, err := a.trust.GetCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: u.ClusterName}, false)
if err != nil {
return nil, trace.Wrap(err)
}
roleNames, err := ca.CombinedMapping().Map(u.RemoteRoles)
if err != nil {
return nil, trace.AccessDenied("failed to map roles for remote user %q from cluster %q", u.Username, u.ClusterName)
}
if len(roleNames) == 0 {
return nil, trace.AccessDenied("no roles mapped for remote user %q from cluster %q", u.Username, u.ClusterName)
}
// Set "logins" trait and "kubernetes_groups" for the remote user. This allows Teleport to work by
// passing exact logins and kubernetes groups to the remote cluster. Note that claims (OIDC/SAML)
// are not passed, but rather the exact logins, this is done to prevent
// leaking too much of identity to the remote cluster, and instead of focus
// on main cluster's interpretation of this identity
traits := map[string][]string{
teleport.TraitLogins: u.Principals,
teleport.TraitKubeGroups: u.KubernetesGroups,
}
log.Debugf("Mapped roles %v of remote user %q to local roles %v and traits %v.", u.RemoteRoles, u.Username, roleNames, traits)
checker, err := services.FetchRoles(roleNames, a.access, traits)
if err != nil {
return nil, trace.Wrap(err)
}
// The user is prefixed with "remote-" and suffixed with cluster name with
// the hope that it does not match a real local user.
user, err := services.NewUser(fmt.Sprintf("remote-%v-%v", u.Username, u.ClusterName))
if err != nil {
return nil, trace.Wrap(err)
}
user.SetTraits(traits)
// Set the list of roles this user has in the remote cluster.
user.SetRoles(roleNames)
return &AuthContext{
User: user,
Checker: checker,
}, nil
} | go | func (a *authorizer) authorizeRemoteUser(u RemoteUser) (*AuthContext, error) {
ca, err := a.trust.GetCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: u.ClusterName}, false)
if err != nil {
return nil, trace.Wrap(err)
}
roleNames, err := ca.CombinedMapping().Map(u.RemoteRoles)
if err != nil {
return nil, trace.AccessDenied("failed to map roles for remote user %q from cluster %q", u.Username, u.ClusterName)
}
if len(roleNames) == 0 {
return nil, trace.AccessDenied("no roles mapped for remote user %q from cluster %q", u.Username, u.ClusterName)
}
// Set "logins" trait and "kubernetes_groups" for the remote user. This allows Teleport to work by
// passing exact logins and kubernetes groups to the remote cluster. Note that claims (OIDC/SAML)
// are not passed, but rather the exact logins, this is done to prevent
// leaking too much of identity to the remote cluster, and instead of focus
// on main cluster's interpretation of this identity
traits := map[string][]string{
teleport.TraitLogins: u.Principals,
teleport.TraitKubeGroups: u.KubernetesGroups,
}
log.Debugf("Mapped roles %v of remote user %q to local roles %v and traits %v.", u.RemoteRoles, u.Username, roleNames, traits)
checker, err := services.FetchRoles(roleNames, a.access, traits)
if err != nil {
return nil, trace.Wrap(err)
}
// The user is prefixed with "remote-" and suffixed with cluster name with
// the hope that it does not match a real local user.
user, err := services.NewUser(fmt.Sprintf("remote-%v-%v", u.Username, u.ClusterName))
if err != nil {
return nil, trace.Wrap(err)
}
user.SetTraits(traits)
// Set the list of roles this user has in the remote cluster.
user.SetRoles(roleNames)
return &AuthContext{
User: user,
Checker: checker,
}, nil
} | [
"func",
"(",
"a",
"*",
"authorizer",
")",
"authorizeRemoteUser",
"(",
"u",
"RemoteUser",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"ca",
",",
"err",
":=",
"a",
".",
"trust",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"UserCA",
",",
"DomainName",
":",
"u",
".",
"ClusterName",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roleNames",
",",
"err",
":=",
"ca",
".",
"CombinedMapping",
"(",
")",
".",
"Map",
"(",
"u",
".",
"RemoteRoles",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"failed to map roles for remote user %q from cluster %q\"",
",",
"u",
".",
"Username",
",",
"u",
".",
"ClusterName",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"roleNames",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"no roles mapped for remote user %q from cluster %q\"",
",",
"u",
".",
"Username",
",",
"u",
".",
"ClusterName",
")",
"\n",
"}",
"\n",
"traits",
":=",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"teleport",
".",
"TraitLogins",
":",
"u",
".",
"Principals",
",",
"teleport",
".",
"TraitKubeGroups",
":",
"u",
".",
"KubernetesGroups",
",",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Mapped roles %v of remote user %q to local roles %v and traits %v.\"",
",",
"u",
".",
"RemoteRoles",
",",
"u",
".",
"Username",
",",
"roleNames",
",",
"traits",
")",
"\n",
"checker",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"roleNames",
",",
"a",
".",
"access",
",",
"traits",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"services",
".",
"NewUser",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"remote-%v-%v\"",
",",
"u",
".",
"Username",
",",
"u",
".",
"ClusterName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
".",
"SetTraits",
"(",
"traits",
")",
"\n",
"user",
".",
"SetRoles",
"(",
"roleNames",
")",
"\n",
"return",
"&",
"AuthContext",
"{",
"User",
":",
"user",
",",
"Checker",
":",
"checker",
",",
"}",
",",
"nil",
"\n",
"}"
] | // authorizeRemoteUser returns checker based on cert authority roles | [
"authorizeRemoteUser",
"returns",
"checker",
"based",
"on",
"cert",
"authority",
"roles"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L129-L170 | train |
gravitational/teleport | lib/auth/permissions.go | authorizeBuiltinRole | func (a *authorizer) authorizeBuiltinRole(r BuiltinRole) (*AuthContext, error) {
config, err := r.GetClusterConfig()
if err != nil {
return nil, trace.Wrap(err)
}
return contextForBuiltinRole(r.ClusterName, config, r.Role, r.Username)
} | go | func (a *authorizer) authorizeBuiltinRole(r BuiltinRole) (*AuthContext, error) {
config, err := r.GetClusterConfig()
if err != nil {
return nil, trace.Wrap(err)
}
return contextForBuiltinRole(r.ClusterName, config, r.Role, r.Username)
} | [
"func",
"(",
"a",
"*",
"authorizer",
")",
"authorizeBuiltinRole",
"(",
"r",
"BuiltinRole",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"config",
",",
"err",
":=",
"r",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"contextForBuiltinRole",
"(",
"r",
".",
"ClusterName",
",",
"config",
",",
"r",
".",
"Role",
",",
"r",
".",
"Username",
")",
"\n",
"}"
] | // authorizeBuiltinRole authorizes builtin role | [
"authorizeBuiltinRole",
"authorizes",
"builtin",
"role"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L173-L179 | train |
gravitational/teleport | tool/tctl/common/user_command.go | Initialize | func (u *UserCommand) Initialize(app *kingpin.Application, config *service.Config) {
u.config = config
users := app.Command("users", "Manage user accounts")
u.userAdd = users.Command("add", "Generate a user invitation token")
u.userAdd.Arg("account", "Teleport user account name").Required().StringVar(&u.login)
u.userAdd.Arg("local-logins", "Local UNIX users this account can log in as [login]").
Default("").StringVar(&u.allowedLogins)
u.userAdd.Flag("k8s-groups", "Kubernetes groups to assign to a user.").
Default("").StringVar(&u.kubeGroups)
u.userAdd.Flag("ttl", fmt.Sprintf("Set expiration time for token, default is %v hour, maximum is %v hours",
int(defaults.SignupTokenTTL/time.Hour), int(defaults.MaxSignupTokenTTL/time.Hour))).
Default(fmt.Sprintf("%v", defaults.SignupTokenTTL)).DurationVar(&u.ttl)
u.userAdd.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userAdd.Alias(AddUserHelp)
u.userUpdate = users.Command("update", "Update properties for existing user").Hidden()
u.userUpdate.Arg("login", "Teleport user login").Required().StringVar(&u.login)
u.userUpdate.Flag("set-roles", "Roles to assign to this user").
Default("").StringVar(&u.roles)
u.userList = users.Command("ls", "List all user accounts")
u.userList.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userDelete = users.Command("rm", "Deletes user accounts").Alias("del")
u.userDelete.Arg("logins", "Comma-separated list of user logins to delete").
Required().StringVar(&u.login)
} | go | func (u *UserCommand) Initialize(app *kingpin.Application, config *service.Config) {
u.config = config
users := app.Command("users", "Manage user accounts")
u.userAdd = users.Command("add", "Generate a user invitation token")
u.userAdd.Arg("account", "Teleport user account name").Required().StringVar(&u.login)
u.userAdd.Arg("local-logins", "Local UNIX users this account can log in as [login]").
Default("").StringVar(&u.allowedLogins)
u.userAdd.Flag("k8s-groups", "Kubernetes groups to assign to a user.").
Default("").StringVar(&u.kubeGroups)
u.userAdd.Flag("ttl", fmt.Sprintf("Set expiration time for token, default is %v hour, maximum is %v hours",
int(defaults.SignupTokenTTL/time.Hour), int(defaults.MaxSignupTokenTTL/time.Hour))).
Default(fmt.Sprintf("%v", defaults.SignupTokenTTL)).DurationVar(&u.ttl)
u.userAdd.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userAdd.Alias(AddUserHelp)
u.userUpdate = users.Command("update", "Update properties for existing user").Hidden()
u.userUpdate.Arg("login", "Teleport user login").Required().StringVar(&u.login)
u.userUpdate.Flag("set-roles", "Roles to assign to this user").
Default("").StringVar(&u.roles)
u.userList = users.Command("ls", "List all user accounts")
u.userList.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userDelete = users.Command("rm", "Deletes user accounts").Alias("del")
u.userDelete.Arg("logins", "Comma-separated list of user logins to delete").
Required().StringVar(&u.login)
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"Initialize",
"(",
"app",
"*",
"kingpin",
".",
"Application",
",",
"config",
"*",
"service",
".",
"Config",
")",
"{",
"u",
".",
"config",
"=",
"config",
"\n",
"users",
":=",
"app",
".",
"Command",
"(",
"\"users\"",
",",
"\"Manage user accounts\"",
")",
"\n",
"u",
".",
"userAdd",
"=",
"users",
".",
"Command",
"(",
"\"add\"",
",",
"\"Generate a user invitation token\"",
")",
"\n",
"u",
".",
"userAdd",
".",
"Arg",
"(",
"\"account\"",
",",
"\"Teleport user account name\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"login",
")",
"\n",
"u",
".",
"userAdd",
".",
"Arg",
"(",
"\"local-logins\"",
",",
"\"Local UNIX users this account can log in as [login]\"",
")",
".",
"Default",
"(",
"\"\"",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"allowedLogins",
")",
"\n",
"u",
".",
"userAdd",
".",
"Flag",
"(",
"\"k8s-groups\"",
",",
"\"Kubernetes groups to assign to a user.\"",
")",
".",
"Default",
"(",
"\"\"",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"kubeGroups",
")",
"\n",
"u",
".",
"userAdd",
".",
"Flag",
"(",
"\"ttl\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"Set expiration time for token, default is %v hour, maximum is %v hours\"",
",",
"int",
"(",
"defaults",
".",
"SignupTokenTTL",
"/",
"time",
".",
"Hour",
")",
",",
"int",
"(",
"defaults",
".",
"MaxSignupTokenTTL",
"/",
"time",
".",
"Hour",
")",
")",
")",
".",
"Default",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"defaults",
".",
"SignupTokenTTL",
")",
")",
".",
"DurationVar",
"(",
"&",
"u",
".",
"ttl",
")",
"\n",
"u",
".",
"userAdd",
".",
"Flag",
"(",
"\"format\"",
",",
"\"Output format, 'text' or 'json'\"",
")",
".",
"Hidden",
"(",
")",
".",
"Default",
"(",
"teleport",
".",
"Text",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"format",
")",
"\n",
"u",
".",
"userAdd",
".",
"Alias",
"(",
"AddUserHelp",
")",
"\n",
"u",
".",
"userUpdate",
"=",
"users",
".",
"Command",
"(",
"\"update\"",
",",
"\"Update properties for existing user\"",
")",
".",
"Hidden",
"(",
")",
"\n",
"u",
".",
"userUpdate",
".",
"Arg",
"(",
"\"login\"",
",",
"\"Teleport user login\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"login",
")",
"\n",
"u",
".",
"userUpdate",
".",
"Flag",
"(",
"\"set-roles\"",
",",
"\"Roles to assign to this user\"",
")",
".",
"Default",
"(",
"\"\"",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"roles",
")",
"\n",
"u",
".",
"userList",
"=",
"users",
".",
"Command",
"(",
"\"ls\"",
",",
"\"List all user accounts\"",
")",
"\n",
"u",
".",
"userList",
".",
"Flag",
"(",
"\"format\"",
",",
"\"Output format, 'text' or 'json'\"",
")",
".",
"Hidden",
"(",
")",
".",
"Default",
"(",
"teleport",
".",
"Text",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"format",
")",
"\n",
"u",
".",
"userDelete",
"=",
"users",
".",
"Command",
"(",
"\"rm\"",
",",
"\"Deletes user accounts\"",
")",
".",
"Alias",
"(",
"\"del\"",
")",
"\n",
"u",
".",
"userDelete",
".",
"Arg",
"(",
"\"logins\"",
",",
"\"Comma-separated list of user logins to delete\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"login",
")",
"\n",
"}"
] | // Initialize allows UserCommand to plug itself into the CLI parser | [
"Initialize",
"allows",
"UserCommand",
"to",
"plug",
"itself",
"into",
"the",
"CLI",
"parser"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L57-L84 | train |
gravitational/teleport | tool/tctl/common/user_command.go | Add | func (u *UserCommand) Add(client auth.ClientI) error {
// if no local logins were specified, default to 'login'
if u.allowedLogins == "" {
u.allowedLogins = u.login
}
var kubeGroups []string
if u.kubeGroups != "" {
kubeGroups = strings.Split(u.kubeGroups, ",")
}
user := services.UserV1{
Name: u.login,
AllowedLogins: strings.Split(u.allowedLogins, ","),
KubeGroups: kubeGroups,
}
token, err := client.CreateSignupToken(user, u.ttl)
if err != nil {
return err
}
// try to auto-suggest the activation link
return u.PrintSignupURL(client, token, u.ttl, u.format)
} | go | func (u *UserCommand) Add(client auth.ClientI) error {
// if no local logins were specified, default to 'login'
if u.allowedLogins == "" {
u.allowedLogins = u.login
}
var kubeGroups []string
if u.kubeGroups != "" {
kubeGroups = strings.Split(u.kubeGroups, ",")
}
user := services.UserV1{
Name: u.login,
AllowedLogins: strings.Split(u.allowedLogins, ","),
KubeGroups: kubeGroups,
}
token, err := client.CreateSignupToken(user, u.ttl)
if err != nil {
return err
}
// try to auto-suggest the activation link
return u.PrintSignupURL(client, token, u.ttl, u.format)
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"Add",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"if",
"u",
".",
"allowedLogins",
"==",
"\"\"",
"{",
"u",
".",
"allowedLogins",
"=",
"u",
".",
"login",
"\n",
"}",
"\n",
"var",
"kubeGroups",
"[",
"]",
"string",
"\n",
"if",
"u",
".",
"kubeGroups",
"!=",
"\"\"",
"{",
"kubeGroups",
"=",
"strings",
".",
"Split",
"(",
"u",
".",
"kubeGroups",
",",
"\",\"",
")",
"\n",
"}",
"\n",
"user",
":=",
"services",
".",
"UserV1",
"{",
"Name",
":",
"u",
".",
"login",
",",
"AllowedLogins",
":",
"strings",
".",
"Split",
"(",
"u",
".",
"allowedLogins",
",",
"\",\"",
")",
",",
"KubeGroups",
":",
"kubeGroups",
",",
"}",
"\n",
"token",
",",
"err",
":=",
"client",
".",
"CreateSignupToken",
"(",
"user",
",",
"u",
".",
"ttl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"u",
".",
"PrintSignupURL",
"(",
"client",
",",
"token",
",",
"u",
".",
"ttl",
",",
"u",
".",
"format",
")",
"\n",
"}"
] | // Add creates a new sign-up token and prints a token URL to stdout.
// A user is not created until he visits the sign-up URL and completes the process | [
"Add",
"creates",
"a",
"new",
"sign",
"-",
"up",
"token",
"and",
"prints",
"a",
"token",
"URL",
"to",
"stdout",
".",
"A",
"user",
"is",
"not",
"created",
"until",
"he",
"visits",
"the",
"sign",
"-",
"up",
"URL",
"and",
"completes",
"the",
"process"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L105-L126 | train |
gravitational/teleport | tool/tctl/common/user_command.go | PrintSignupURL | func (u *UserCommand) PrintSignupURL(client auth.ClientI, token string, ttl time.Duration, format string) error {
signupURL, proxyHost := web.CreateSignupLink(client, token)
if format == teleport.Text {
fmt.Printf("Signup token has been created and is valid for %v hours. Share this URL with the user:\n%v\n\n",
int(ttl/time.Hour), signupURL)
fmt.Printf("NOTE: Make sure %v points at a Teleport proxy which users can access.\n", proxyHost)
} else {
out, err := json.MarshalIndent(services.NewInviteToken(token, signupURL, time.Now().Add(ttl).UTC()), "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal signup infos")
}
fmt.Printf(string(out))
}
return nil
} | go | func (u *UserCommand) PrintSignupURL(client auth.ClientI, token string, ttl time.Duration, format string) error {
signupURL, proxyHost := web.CreateSignupLink(client, token)
if format == teleport.Text {
fmt.Printf("Signup token has been created and is valid for %v hours. Share this URL with the user:\n%v\n\n",
int(ttl/time.Hour), signupURL)
fmt.Printf("NOTE: Make sure %v points at a Teleport proxy which users can access.\n", proxyHost)
} else {
out, err := json.MarshalIndent(services.NewInviteToken(token, signupURL, time.Now().Add(ttl).UTC()), "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal signup infos")
}
fmt.Printf(string(out))
}
return nil
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"PrintSignupURL",
"(",
"client",
"auth",
".",
"ClientI",
",",
"token",
"string",
",",
"ttl",
"time",
".",
"Duration",
",",
"format",
"string",
")",
"error",
"{",
"signupURL",
",",
"proxyHost",
":=",
"web",
".",
"CreateSignupLink",
"(",
"client",
",",
"token",
")",
"\n",
"if",
"format",
"==",
"teleport",
".",
"Text",
"{",
"fmt",
".",
"Printf",
"(",
"\"Signup token has been created and is valid for %v hours. Share this URL with the user:\\n%v\\n\\n\"",
",",
"\\n",
",",
"\\n",
")",
"\n",
"\\n",
"\n",
"}",
"else",
"int",
"(",
"ttl",
"/",
"time",
".",
"Hour",
")",
"\n",
"signupURL",
"\n",
"}"
] | // PrintSignupURL prints signup URL | [
"PrintSignupURL",
"prints",
"signup",
"URL"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L129-L144 | train |
gravitational/teleport | tool/tctl/common/user_command.go | Update | func (u *UserCommand) Update(client auth.ClientI) error {
user, err := client.GetUser(u.login)
if err != nil {
return trace.Wrap(err)
}
roles := strings.Split(u.roles, ",")
for _, role := range roles {
if _, err := client.GetRole(role); err != nil {
return trace.Wrap(err)
}
}
user.SetRoles(roles)
if err := client.UpsertUser(user); err != nil {
return trace.Wrap(err)
}
fmt.Printf("%v has been updated with roles %v\n", user.GetName(), strings.Join(user.GetRoles(), ","))
return nil
} | go | func (u *UserCommand) Update(client auth.ClientI) error {
user, err := client.GetUser(u.login)
if err != nil {
return trace.Wrap(err)
}
roles := strings.Split(u.roles, ",")
for _, role := range roles {
if _, err := client.GetRole(role); err != nil {
return trace.Wrap(err)
}
}
user.SetRoles(roles)
if err := client.UpsertUser(user); err != nil {
return trace.Wrap(err)
}
fmt.Printf("%v has been updated with roles %v\n", user.GetName(), strings.Join(user.GetRoles(), ","))
return nil
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"Update",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"user",
",",
"err",
":=",
"client",
".",
"GetUser",
"(",
"u",
".",
"login",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roles",
":=",
"strings",
".",
"Split",
"(",
"u",
".",
"roles",
",",
"\",\"",
")",
"\n",
"for",
"_",
",",
"role",
":=",
"range",
"roles",
"{",
"if",
"_",
",",
"err",
":=",
"client",
".",
"GetRole",
"(",
"role",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"user",
".",
"SetRoles",
"(",
"roles",
")",
"\n",
"if",
"err",
":=",
"client",
".",
"UpsertUser",
"(",
"user",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"%v has been updated with roles %v\\n\"",
",",
"\\n",
",",
"user",
".",
"GetName",
"(",
")",
")",
"\n",
"strings",
".",
"Join",
"(",
"user",
".",
"GetRoles",
"(",
")",
",",
"\",\"",
")",
"\n",
"}"
] | // Update updates existing user | [
"Update",
"updates",
"existing",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L147-L164 | train |
gravitational/teleport | tool/tctl/common/user_command.go | List | func (u *UserCommand) List(client auth.ClientI) error {
users, err := client.GetUsers()
if err != nil {
return trace.Wrap(err)
}
if u.format == teleport.Text {
if len(users) == 0 {
fmt.Println("No users found")
return nil
}
t := asciitable.MakeTable([]string{"User", "Allowed logins"})
for _, u := range users {
logins, _ := u.GetTraits()[teleport.TraitLogins]
t.AddRow([]string{u.GetName(), strings.Join(logins, ",")})
}
fmt.Println(t.AsBuffer().String())
} else {
out, err := json.MarshalIndent(users, "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal users")
}
fmt.Printf(string(out))
}
return nil
} | go | func (u *UserCommand) List(client auth.ClientI) error {
users, err := client.GetUsers()
if err != nil {
return trace.Wrap(err)
}
if u.format == teleport.Text {
if len(users) == 0 {
fmt.Println("No users found")
return nil
}
t := asciitable.MakeTable([]string{"User", "Allowed logins"})
for _, u := range users {
logins, _ := u.GetTraits()[teleport.TraitLogins]
t.AddRow([]string{u.GetName(), strings.Join(logins, ",")})
}
fmt.Println(t.AsBuffer().String())
} else {
out, err := json.MarshalIndent(users, "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal users")
}
fmt.Printf(string(out))
}
return nil
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"List",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"users",
",",
"err",
":=",
"client",
".",
"GetUsers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"format",
"==",
"teleport",
".",
"Text",
"{",
"if",
"len",
"(",
"users",
")",
"==",
"0",
"{",
"fmt",
".",
"Println",
"(",
"\"No users found\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"t",
":=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"User\"",
",",
"\"Allowed logins\"",
"}",
")",
"\n",
"for",
"_",
",",
"u",
":=",
"range",
"users",
"{",
"logins",
",",
"_",
":=",
"u",
".",
"GetTraits",
"(",
")",
"[",
"teleport",
".",
"TraitLogins",
"]",
"\n",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"u",
".",
"GetName",
"(",
")",
",",
"strings",
".",
"Join",
"(",
"logins",
",",
"\",\"",
")",
"}",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"t",
".",
"AsBuffer",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"out",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"users",
",",
"\"\"",
",",
"\" \"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"failed to marshal users\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"string",
"(",
"out",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // List prints all existing user accounts | [
"List",
"prints",
"all",
"existing",
"user",
"accounts"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L167-L191 | train |
gravitational/teleport | lib/teleagent/agent.go | ListenUnixSocket | func (a *AgentServer) ListenUnixSocket(path string, uid, gid int, mode os.FileMode) error {
l, err := net.Listen("unix", path)
if err != nil {
return trace.Wrap(err)
}
if err := os.Chown(path, uid, gid); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
if err := os.Chmod(path, mode); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
a.listener = l
a.path = path
return nil
} | go | func (a *AgentServer) ListenUnixSocket(path string, uid, gid int, mode os.FileMode) error {
l, err := net.Listen("unix", path)
if err != nil {
return trace.Wrap(err)
}
if err := os.Chown(path, uid, gid); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
if err := os.Chmod(path, mode); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
a.listener = l
a.path = path
return nil
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"ListenUnixSocket",
"(",
"path",
"string",
",",
"uid",
",",
"gid",
"int",
",",
"mode",
"os",
".",
"FileMode",
")",
"error",
"{",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"unix\"",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"Chown",
"(",
"path",
",",
"uid",
",",
"gid",
")",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"Close",
"(",
")",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"Chmod",
"(",
"path",
",",
"mode",
")",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"Close",
"(",
")",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"listener",
"=",
"l",
"\n",
"a",
".",
"path",
"=",
"path",
"\n",
"return",
"nil",
"\n",
"}"
] | // ListenUnixSocket starts listening and serving agent assuming that | [
"ListenUnixSocket",
"starts",
"listening",
"and",
"serving",
"agent",
"assuming",
"that"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L30-L46 | train |
gravitational/teleport | lib/teleagent/agent.go | Serve | func (a *AgentServer) Serve() error {
if a.listener == nil {
return trace.BadParameter("Serve needs a Listen call first")
}
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := a.listener.Accept()
if err != nil {
neterr, ok := err.(net.Error)
if !ok {
return trace.Wrap(err, "unknown error")
}
if !neterr.Temporary() {
if !strings.Contains(neterr.Error(), "use of closed network connection") {
log.Errorf("got permanent error: %v", err)
}
return err
}
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
log.Errorf("got temp error: %v, will sleep %v", err, tempDelay)
time.Sleep(tempDelay)
continue
}
tempDelay = 0
go func() {
if err := agent.ServeAgent(a.Agent, conn); err != nil {
if err != io.EOF {
log.Errorf(err.Error())
}
}
}()
}
} | go | func (a *AgentServer) Serve() error {
if a.listener == nil {
return trace.BadParameter("Serve needs a Listen call first")
}
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := a.listener.Accept()
if err != nil {
neterr, ok := err.(net.Error)
if !ok {
return trace.Wrap(err, "unknown error")
}
if !neterr.Temporary() {
if !strings.Contains(neterr.Error(), "use of closed network connection") {
log.Errorf("got permanent error: %v", err)
}
return err
}
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
log.Errorf("got temp error: %v, will sleep %v", err, tempDelay)
time.Sleep(tempDelay)
continue
}
tempDelay = 0
go func() {
if err := agent.ServeAgent(a.Agent, conn); err != nil {
if err != io.EOF {
log.Errorf(err.Error())
}
}
}()
}
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"Serve",
"(",
")",
"error",
"{",
"if",
"a",
".",
"listener",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"Serve needs a Listen call first\"",
")",
"\n",
"}",
"\n",
"var",
"tempDelay",
"time",
".",
"Duration",
"\n",
"for",
"{",
"conn",
",",
"err",
":=",
"a",
".",
"listener",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"neterr",
",",
"ok",
":=",
"err",
".",
"(",
"net",
".",
"Error",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"unknown error\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"neterr",
".",
"Temporary",
"(",
")",
"{",
"if",
"!",
"strings",
".",
"Contains",
"(",
"neterr",
".",
"Error",
"(",
")",
",",
"\"use of closed network connection\"",
")",
"{",
"log",
".",
"Errorf",
"(",
"\"got permanent error: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"tempDelay",
"==",
"0",
"{",
"tempDelay",
"=",
"5",
"*",
"time",
".",
"Millisecond",
"\n",
"}",
"else",
"{",
"tempDelay",
"*=",
"2",
"\n",
"}",
"\n",
"if",
"max",
":=",
"1",
"*",
"time",
".",
"Second",
";",
"tempDelay",
">",
"max",
"{",
"tempDelay",
"=",
"max",
"\n",
"}",
"\n",
"log",
".",
"Errorf",
"(",
"\"got temp error: %v, will sleep %v\"",
",",
"err",
",",
"tempDelay",
")",
"\n",
"time",
".",
"Sleep",
"(",
"tempDelay",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"tempDelay",
"=",
"0",
"\n",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"agent",
".",
"ServeAgent",
"(",
"a",
".",
"Agent",
",",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"io",
".",
"EOF",
"{",
"log",
".",
"Errorf",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Serve starts serving on the listener, assumes that Listen was called before | [
"Serve",
"starts",
"serving",
"on",
"the",
"listener",
"assumes",
"that",
"Listen",
"was",
"called",
"before"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L49-L88 | train |
gravitational/teleport | lib/teleagent/agent.go | ListenAndServe | func (a *AgentServer) ListenAndServe(addr utils.NetAddr) error {
l, err := net.Listen(addr.AddrNetwork, addr.Addr)
if err != nil {
return trace.Wrap(err)
}
a.listener = l
return a.Serve()
} | go | func (a *AgentServer) ListenAndServe(addr utils.NetAddr) error {
l, err := net.Listen(addr.AddrNetwork, addr.Addr)
if err != nil {
return trace.Wrap(err)
}
a.listener = l
return a.Serve()
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"ListenAndServe",
"(",
"addr",
"utils",
".",
"NetAddr",
")",
"error",
"{",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"addr",
".",
"AddrNetwork",
",",
"addr",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"listener",
"=",
"l",
"\n",
"return",
"a",
".",
"Serve",
"(",
")",
"\n",
"}"
] | // ListenAndServe is similar http.ListenAndServe | [
"ListenAndServe",
"is",
"similar",
"http",
".",
"ListenAndServe"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L91-L98 | train |
gravitational/teleport | lib/teleagent/agent.go | Close | func (a *AgentServer) Close() error {
var errors []error
if a.listener != nil {
log.Debugf("AgentServer(%v) is closing", a.listener.Addr())
if err := a.listener.Close(); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
if a.path != "" {
if err := os.Remove(a.path); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
return trace.NewAggregate(errors...)
} | go | func (a *AgentServer) Close() error {
var errors []error
if a.listener != nil {
log.Debugf("AgentServer(%v) is closing", a.listener.Addr())
if err := a.listener.Close(); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
if a.path != "" {
if err := os.Remove(a.path); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
return trace.NewAggregate(errors...)
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"Close",
"(",
")",
"error",
"{",
"var",
"errors",
"[",
"]",
"error",
"\n",
"if",
"a",
".",
"listener",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"AgentServer(%v) is closing\"",
",",
"a",
".",
"listener",
".",
"Addr",
"(",
")",
")",
"\n",
"if",
"err",
":=",
"a",
".",
"listener",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"a",
".",
"path",
"!=",
"\"\"",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"a",
".",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] | // Close closes listener and stops serving agent | [
"Close",
"closes",
"listener",
"and",
"stops",
"serving",
"agent"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L101-L115 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | VerifyHTTPHeader | func VerifyHTTPHeader(r *http.Request) error {
token := r.Header.Get(HeaderName)
if len(token) == 0 {
return trace.BadParameter("cannot retrieve CSRF token from HTTP header %q", HeaderName)
}
err := VerifyToken(token, r)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func VerifyHTTPHeader(r *http.Request) error {
token := r.Header.Get(HeaderName)
if len(token) == 0 {
return trace.BadParameter("cannot retrieve CSRF token from HTTP header %q", HeaderName)
}
err := VerifyToken(token, r)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"VerifyHTTPHeader",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"token",
":=",
"r",
".",
"Header",
".",
"Get",
"(",
"HeaderName",
")",
"\n",
"if",
"len",
"(",
"token",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"cannot retrieve CSRF token from HTTP header %q\"",
",",
"HeaderName",
")",
"\n",
"}",
"\n",
"err",
":=",
"VerifyToken",
"(",
"token",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // VerifyHTTPHeader checks if HTTP header value matches the cookie. | [
"VerifyHTTPHeader",
"checks",
"if",
"HTTP",
"header",
"value",
"matches",
"the",
"cookie",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L56-L68 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | VerifyToken | func VerifyToken(token string, r *http.Request) error {
realToken, err := ExtractTokenFromCookie(r)
if err != nil {
return trace.Wrap(err, "unable to extract CSRF token from cookie")
}
decodedTokenA, err := decode(token)
if err != nil {
return trace.Wrap(err, "unable to decode CSRF token")
}
decodedTokenB, err := decode(realToken)
if err != nil {
return trace.Wrap(err, "unable to decode cookie CSRF token")
}
if !compareTokens(decodedTokenA, decodedTokenB) {
return trace.BadParameter("CSRF tokens do not match")
}
return nil
} | go | func VerifyToken(token string, r *http.Request) error {
realToken, err := ExtractTokenFromCookie(r)
if err != nil {
return trace.Wrap(err, "unable to extract CSRF token from cookie")
}
decodedTokenA, err := decode(token)
if err != nil {
return trace.Wrap(err, "unable to decode CSRF token")
}
decodedTokenB, err := decode(realToken)
if err != nil {
return trace.Wrap(err, "unable to decode cookie CSRF token")
}
if !compareTokens(decodedTokenA, decodedTokenB) {
return trace.BadParameter("CSRF tokens do not match")
}
return nil
} | [
"func",
"VerifyToken",
"(",
"token",
"string",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"realToken",
",",
"err",
":=",
"ExtractTokenFromCookie",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"unable to extract CSRF token from cookie\"",
")",
"\n",
"}",
"\n",
"decodedTokenA",
",",
"err",
":=",
"decode",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"unable to decode CSRF token\"",
")",
"\n",
"}",
"\n",
"decodedTokenB",
",",
"err",
":=",
"decode",
"(",
"realToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"unable to decode cookie CSRF token\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"compareTokens",
"(",
"decodedTokenA",
",",
"decodedTokenB",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"CSRF tokens do not match\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // VerifyToken validates given token based on HTTP request cookie | [
"VerifyToken",
"validates",
"given",
"token",
"based",
"on",
"HTTP",
"request",
"cookie"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L71-L92 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | ExtractTokenFromCookie | func ExtractTokenFromCookie(r *http.Request) (string, error) {
cookie, err := r.Cookie(CookieName)
if err != nil {
return "", trace.Wrap(err)
}
return cookie.Value, nil
} | go | func ExtractTokenFromCookie(r *http.Request) (string, error) {
cookie, err := r.Cookie(CookieName)
if err != nil {
return "", trace.Wrap(err)
}
return cookie.Value, nil
} | [
"func",
"ExtractTokenFromCookie",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"error",
")",
"{",
"cookie",
",",
"err",
":=",
"r",
".",
"Cookie",
"(",
"CookieName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cookie",
".",
"Value",
",",
"nil",
"\n",
"}"
] | // ExtractTokenFromCookie retrieves a CSRF token from the session cookie. | [
"ExtractTokenFromCookie",
"retrieves",
"a",
"CSRF",
"token",
"from",
"the",
"session",
"cookie",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L95-L102 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | save | func save(encodedToken string, w http.ResponseWriter) string {
cookie := &http.Cookie{
Name: CookieName,
Value: encodedToken,
MaxAge: defaultMaxAge,
HttpOnly: true,
Secure: true,
Path: "/",
}
// write the authenticated cookie to the response.
http.SetCookie(w, cookie)
w.Header().Add("Vary", "Cookie")
return encodedToken
} | go | func save(encodedToken string, w http.ResponseWriter) string {
cookie := &http.Cookie{
Name: CookieName,
Value: encodedToken,
MaxAge: defaultMaxAge,
HttpOnly: true,
Secure: true,
Path: "/",
}
// write the authenticated cookie to the response.
http.SetCookie(w, cookie)
w.Header().Add("Vary", "Cookie")
return encodedToken
} | [
"func",
"save",
"(",
"encodedToken",
"string",
",",
"w",
"http",
".",
"ResponseWriter",
")",
"string",
"{",
"cookie",
":=",
"&",
"http",
".",
"Cookie",
"{",
"Name",
":",
"CookieName",
",",
"Value",
":",
"encodedToken",
",",
"MaxAge",
":",
"defaultMaxAge",
",",
"HttpOnly",
":",
"true",
",",
"Secure",
":",
"true",
",",
"Path",
":",
"\"/\"",
",",
"}",
"\n",
"http",
".",
"SetCookie",
"(",
"w",
",",
"cookie",
")",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Add",
"(",
"\"Vary\"",
",",
"\"Cookie\"",
")",
"\n",
"return",
"encodedToken",
"\n",
"}"
] | // save stores encoded CSRF token in the session cookie. | [
"save",
"stores",
"encoded",
"CSRF",
"token",
"in",
"the",
"session",
"cookie",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L124-L138 | train |
gravitational/teleport | lib/auth/oidc.go | ValidateOIDCAuthCallback | func (a *AuthServer) ValidateOIDCAuthCallback(q url.Values) (*OIDCAuthResponse, error) {
re, err := a.validateOIDCAuthCallback(q)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptSuccess: false,
// log the original internal error in audit log
events.AuthAttemptErr: trace.Unwrap(err).Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodOIDC,
})
}
return re, err
} | go | func (a *AuthServer) ValidateOIDCAuthCallback(q url.Values) (*OIDCAuthResponse, error) {
re, err := a.validateOIDCAuthCallback(q)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptSuccess: false,
// log the original internal error in audit log
events.AuthAttemptErr: trace.Unwrap(err).Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodOIDC,
})
}
return re, err
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"ValidateOIDCAuthCallback",
"(",
"q",
"url",
".",
"Values",
")",
"(",
"*",
"OIDCAuthResponse",
",",
"error",
")",
"{",
"re",
",",
"err",
":=",
"a",
".",
"validateOIDCAuthCallback",
"(",
"q",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodOIDC",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"false",
",",
"events",
".",
"AuthAttemptErr",
":",
"trace",
".",
"Unwrap",
"(",
"err",
")",
".",
"Error",
"(",
")",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLogin",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"re",
".",
"Username",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"true",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodOIDC",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"err",
"\n",
"}"
] | // ValidateOIDCAuthCallback is called by the proxy to check OIDC query parameters
// returned by OIDC Provider, if everything checks out, auth server
// will respond with OIDCAuthResponse, otherwise it will return error | [
"ValidateOIDCAuthCallback",
"is",
"called",
"by",
"the",
"proxy",
"to",
"check",
"OIDC",
"query",
"parameters",
"returned",
"by",
"OIDC",
"Provider",
"if",
"everything",
"checks",
"out",
"auth",
"server",
"will",
"respond",
"with",
"OIDCAuthResponse",
"otherwise",
"it",
"will",
"return",
"error"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L128-L145 | train |
gravitational/teleport | lib/auth/oidc.go | buildOIDCRoles | func (a *AuthServer) buildOIDCRoles(connector services.OIDCConnector, claims jose.Claims) ([]string, error) {
roles := connector.MapClaims(claims)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map claims to role for connector: %v", connector.GetName())
}
return roles, nil
} | go | func (a *AuthServer) buildOIDCRoles(connector services.OIDCConnector, claims jose.Claims) ([]string, error) {
roles := connector.MapClaims(claims)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map claims to role for connector: %v", connector.GetName())
}
return roles, nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"buildOIDCRoles",
"(",
"connector",
"services",
".",
"OIDCConnector",
",",
"claims",
"jose",
".",
"Claims",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"roles",
":=",
"connector",
".",
"MapClaims",
"(",
"claims",
")",
"\n",
"if",
"len",
"(",
"roles",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"unable to map claims to role for connector: %v\"",
",",
"connector",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"roles",
",",
"nil",
"\n",
"}"
] | // buildOIDCRoles takes a connector and claims and returns a slice of roles. | [
"buildOIDCRoles",
"takes",
"a",
"connector",
"and",
"claims",
"and",
"returns",
"a",
"slice",
"of",
"roles",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L301-L308 | train |
gravitational/teleport | lib/auth/oidc.go | claimsToTraitMap | func claimsToTraitMap(claims jose.Claims) map[string][]string {
traits := make(map[string][]string)
for claimName := range claims {
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
traits[claimName] = []string{claimValue}
}
claimValues, ok, _ := claims.StringsClaim(claimName)
if ok {
traits[claimName] = claimValues
}
}
return traits
} | go | func claimsToTraitMap(claims jose.Claims) map[string][]string {
traits := make(map[string][]string)
for claimName := range claims {
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
traits[claimName] = []string{claimValue}
}
claimValues, ok, _ := claims.StringsClaim(claimName)
if ok {
traits[claimName] = claimValues
}
}
return traits
} | [
"func",
"claimsToTraitMap",
"(",
"claims",
"jose",
".",
"Claims",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"traits",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"for",
"claimName",
":=",
"range",
"claims",
"{",
"claimValue",
",",
"ok",
",",
"_",
":=",
"claims",
".",
"StringClaim",
"(",
"claimName",
")",
"\n",
"if",
"ok",
"{",
"traits",
"[",
"claimName",
"]",
"=",
"[",
"]",
"string",
"{",
"claimValue",
"}",
"\n",
"}",
"\n",
"claimValues",
",",
"ok",
",",
"_",
":=",
"claims",
".",
"StringsClaim",
"(",
"claimName",
")",
"\n",
"if",
"ok",
"{",
"traits",
"[",
"claimName",
"]",
"=",
"claimValues",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"traits",
"\n",
"}"
] | // claimsToTraitMap extracts all string claims and creates a map of traits
// that can be used to populate role variables. | [
"claimsToTraitMap",
"extracts",
"all",
"string",
"claims",
"and",
"creates",
"a",
"map",
"of",
"traits",
"that",
"can",
"be",
"used",
"to",
"populate",
"role",
"variables",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L312-L327 | train |
gravitational/teleport | lib/auth/oidc.go | claimsFromIDToken | func claimsFromIDToken(oidcClient *oidc.Client, idToken string) (jose.Claims, error) {
jwt, err := jose.ParseJWT(idToken)
if err != nil {
return nil, trace.Wrap(err)
}
err = oidcClient.VerifyJWT(jwt)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("Extracting OIDC claims from ID token.")
claims, err := jwt.Claims()
if err != nil {
return nil, trace.Wrap(err)
}
return claims, nil
} | go | func claimsFromIDToken(oidcClient *oidc.Client, idToken string) (jose.Claims, error) {
jwt, err := jose.ParseJWT(idToken)
if err != nil {
return nil, trace.Wrap(err)
}
err = oidcClient.VerifyJWT(jwt)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("Extracting OIDC claims from ID token.")
claims, err := jwt.Claims()
if err != nil {
return nil, trace.Wrap(err)
}
return claims, nil
} | [
"func",
"claimsFromIDToken",
"(",
"oidcClient",
"*",
"oidc",
".",
"Client",
",",
"idToken",
"string",
")",
"(",
"jose",
".",
"Claims",
",",
"error",
")",
"{",
"jwt",
",",
"err",
":=",
"jose",
".",
"ParseJWT",
"(",
"idToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"oidcClient",
".",
"VerifyJWT",
"(",
"jwt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Extracting OIDC claims from ID token.\"",
")",
"\n",
"claims",
",",
"err",
":=",
"jwt",
".",
"Claims",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"claims",
",",
"nil",
"\n",
"}"
] | // claimsFromIDToken extracts claims from the ID token. | [
"claimsFromIDToken",
"extracts",
"claims",
"from",
"the",
"ID",
"token",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L422-L441 | train |
gravitational/teleport | lib/auth/oidc.go | fetchGroups | func (g *gsuiteClient) fetchGroups() (jose.Claims, error) {
count := 0
var groups []string
var nextPageToken string
collect:
for {
if count > MaxPages {
warningMessage := "Truncating list of teams used to populate claims: " +
"hit maximum number pages that can be fetched from GSuite."
// Print warning to Teleport logs as well as the Audit Log.
log.Warnf(warningMessage)
g.auditLog.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptMessage: warningMessage,
})
break collect
}
response, err := g.fetchGroupsPage(nextPageToken)
if err != nil {
return nil, trace.Wrap(err)
}
groups = append(groups, response.groups()...)
if response.NextPageToken == "" {
break collect
}
count++
nextPageToken = response.NextPageToken
}
return jose.Claims{"groups": groups}, nil
} | go | func (g *gsuiteClient) fetchGroups() (jose.Claims, error) {
count := 0
var groups []string
var nextPageToken string
collect:
for {
if count > MaxPages {
warningMessage := "Truncating list of teams used to populate claims: " +
"hit maximum number pages that can be fetched from GSuite."
// Print warning to Teleport logs as well as the Audit Log.
log.Warnf(warningMessage)
g.auditLog.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptMessage: warningMessage,
})
break collect
}
response, err := g.fetchGroupsPage(nextPageToken)
if err != nil {
return nil, trace.Wrap(err)
}
groups = append(groups, response.groups()...)
if response.NextPageToken == "" {
break collect
}
count++
nextPageToken = response.NextPageToken
}
return jose.Claims{"groups": groups}, nil
} | [
"func",
"(",
"g",
"*",
"gsuiteClient",
")",
"fetchGroups",
"(",
")",
"(",
"jose",
".",
"Claims",
",",
"error",
")",
"{",
"count",
":=",
"0",
"\n",
"var",
"groups",
"[",
"]",
"string",
"\n",
"var",
"nextPageToken",
"string",
"\n",
"collect",
":",
"for",
"{",
"if",
"count",
">",
"MaxPages",
"{",
"warningMessage",
":=",
"\"Truncating list of teams used to populate claims: \"",
"+",
"\"hit maximum number pages that can be fetched from GSuite.\"",
"\n",
"log",
".",
"Warnf",
"(",
"warningMessage",
")",
"\n",
"g",
".",
"auditLog",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodOIDC",
",",
"events",
".",
"AuthAttemptMessage",
":",
"warningMessage",
",",
"}",
")",
"\n",
"break",
"collect",
"\n",
"}",
"\n",
"response",
",",
"err",
":=",
"g",
".",
"fetchGroupsPage",
"(",
"nextPageToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"groups",
"=",
"append",
"(",
"groups",
",",
"response",
".",
"groups",
"(",
")",
"...",
")",
"\n",
"if",
"response",
".",
"NextPageToken",
"==",
"\"\"",
"{",
"break",
"collect",
"\n",
"}",
"\n",
"count",
"++",
"\n",
"nextPageToken",
"=",
"response",
".",
"NextPageToken",
"\n",
"}",
"\n",
"return",
"jose",
".",
"Claims",
"{",
"\"groups\"",
":",
"groups",
"}",
",",
"nil",
"\n",
"}"
] | // fetchGroups fetches GSuite groups a user belongs to and returns
// "groups" claim with | [
"fetchGroups",
"fetches",
"GSuite",
"groups",
"a",
"user",
"belongs",
"to",
"and",
"returns",
"groups",
"claim",
"with"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L545-L575 | train |
gravitational/teleport | lib/auth/oidc.go | mergeClaims | func mergeClaims(a jose.Claims, b jose.Claims) (jose.Claims, error) {
for k, v := range b {
_, ok := a[k]
if !ok {
a[k] = v
}
}
return a, nil
} | go | func mergeClaims(a jose.Claims, b jose.Claims) (jose.Claims, error) {
for k, v := range b {
_, ok := a[k]
if !ok {
a[k] = v
}
}
return a, nil
} | [
"func",
"mergeClaims",
"(",
"a",
"jose",
".",
"Claims",
",",
"b",
"jose",
".",
"Claims",
")",
"(",
"jose",
".",
"Claims",
",",
"error",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"b",
"{",
"_",
",",
"ok",
":=",
"a",
"[",
"k",
"]",
"\n",
"if",
"!",
"ok",
"{",
"a",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"a",
",",
"nil",
"\n",
"}"
] | // mergeClaims merges b into a. | [
"mergeClaims",
"merges",
"b",
"into",
"a",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L635-L644 | train |
gravitational/teleport | lib/auth/oidc.go | validateACRValues | func (a *AuthServer) validateACRValues(acrValue string, identityProvider string, claims jose.Claims) error {
switch identityProvider {
case teleport.NetIQ:
log.Debugf("Validating OIDC ACR values with '%v' rules.", identityProvider)
tokenAcr, ok := claims["acr"]
if !ok {
return trace.BadParameter("acr not found in claims")
}
tokenAcrMap, ok := tokenAcr.(map[string]interface{})
if !ok {
return trace.BadParameter("acr unexpected type: %T", tokenAcr)
}
tokenAcrValues, ok := tokenAcrMap["values"]
if !ok {
return trace.BadParameter("acr.values not found in claims")
}
tokenAcrValuesSlice, ok := tokenAcrValues.([]interface{})
if !ok {
return trace.BadParameter("acr.values unexpected type: %T", tokenAcr)
}
acrValueMatched := false
for _, v := range tokenAcrValuesSlice {
vv, ok := v.(string)
if !ok {
continue
}
if acrValue == vv {
acrValueMatched = true
break
}
}
if !acrValueMatched {
log.Debugf("No OIDC ACR match found for '%v' in '%v'.", acrValue, tokenAcrValues)
return trace.BadParameter("acr claim does not match")
}
default:
log.Debugf("Validating OIDC ACR values with default rules.")
claimValue, exists, err := claims.StringClaim("acr")
if !exists {
return trace.BadParameter("acr claim does not exist")
}
if err != nil {
return trace.Wrap(err)
}
if claimValue != acrValue {
log.Debugf("No OIDC ACR match found '%v' != '%v'.", acrValue, claimValue)
return trace.BadParameter("acr claim does not match")
}
}
return nil
} | go | func (a *AuthServer) validateACRValues(acrValue string, identityProvider string, claims jose.Claims) error {
switch identityProvider {
case teleport.NetIQ:
log.Debugf("Validating OIDC ACR values with '%v' rules.", identityProvider)
tokenAcr, ok := claims["acr"]
if !ok {
return trace.BadParameter("acr not found in claims")
}
tokenAcrMap, ok := tokenAcr.(map[string]interface{})
if !ok {
return trace.BadParameter("acr unexpected type: %T", tokenAcr)
}
tokenAcrValues, ok := tokenAcrMap["values"]
if !ok {
return trace.BadParameter("acr.values not found in claims")
}
tokenAcrValuesSlice, ok := tokenAcrValues.([]interface{})
if !ok {
return trace.BadParameter("acr.values unexpected type: %T", tokenAcr)
}
acrValueMatched := false
for _, v := range tokenAcrValuesSlice {
vv, ok := v.(string)
if !ok {
continue
}
if acrValue == vv {
acrValueMatched = true
break
}
}
if !acrValueMatched {
log.Debugf("No OIDC ACR match found for '%v' in '%v'.", acrValue, tokenAcrValues)
return trace.BadParameter("acr claim does not match")
}
default:
log.Debugf("Validating OIDC ACR values with default rules.")
claimValue, exists, err := claims.StringClaim("acr")
if !exists {
return trace.BadParameter("acr claim does not exist")
}
if err != nil {
return trace.Wrap(err)
}
if claimValue != acrValue {
log.Debugf("No OIDC ACR match found '%v' != '%v'.", acrValue, claimValue)
return trace.BadParameter("acr claim does not match")
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"validateACRValues",
"(",
"acrValue",
"string",
",",
"identityProvider",
"string",
",",
"claims",
"jose",
".",
"Claims",
")",
"error",
"{",
"switch",
"identityProvider",
"{",
"case",
"teleport",
".",
"NetIQ",
":",
"log",
".",
"Debugf",
"(",
"\"Validating OIDC ACR values with '%v' rules.\"",
",",
"identityProvider",
")",
"\n",
"tokenAcr",
",",
"ok",
":=",
"claims",
"[",
"\"acr\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr not found in claims\"",
")",
"\n",
"}",
"\n",
"tokenAcrMap",
",",
"ok",
":=",
"tokenAcr",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr unexpected type: %T\"",
",",
"tokenAcr",
")",
"\n",
"}",
"\n",
"tokenAcrValues",
",",
"ok",
":=",
"tokenAcrMap",
"[",
"\"values\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr.values not found in claims\"",
")",
"\n",
"}",
"\n",
"tokenAcrValuesSlice",
",",
"ok",
":=",
"tokenAcrValues",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr.values unexpected type: %T\"",
",",
"tokenAcr",
")",
"\n",
"}",
"\n",
"acrValueMatched",
":=",
"false",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"tokenAcrValuesSlice",
"{",
"vv",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"acrValue",
"==",
"vv",
"{",
"acrValueMatched",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"acrValueMatched",
"{",
"log",
".",
"Debugf",
"(",
"\"No OIDC ACR match found for '%v' in '%v'.\"",
",",
"acrValue",
",",
"tokenAcrValues",
")",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr claim does not match\"",
")",
"\n",
"}",
"\n",
"default",
":",
"log",
".",
"Debugf",
"(",
"\"Validating OIDC ACR values with default rules.\"",
")",
"\n",
"claimValue",
",",
"exists",
",",
"err",
":=",
"claims",
".",
"StringClaim",
"(",
"\"acr\"",
")",
"\n",
"if",
"!",
"exists",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr claim does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"claimValue",
"!=",
"acrValue",
"{",
"log",
".",
"Debugf",
"(",
"\"No OIDC ACR match found '%v' != '%v'.\"",
",",
"acrValue",
",",
"claimValue",
")",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"acr claim does not match\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // validateACRValues validates that we get an appropriate response for acr values. By default
// we expect the same value we send, but this function also handles Identity Provider specific
// forms of validation. | [
"validateACRValues",
"validates",
"that",
"we",
"get",
"an",
"appropriate",
"response",
"for",
"acr",
"values",
".",
"By",
"default",
"we",
"expect",
"the",
"same",
"value",
"we",
"send",
"but",
"this",
"function",
"also",
"handles",
"Identity",
"Provider",
"specific",
"forms",
"of",
"validation",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L733-L787 | train |
gravitational/teleport | lib/client/bench.go | Benchmark | func (tc *TeleportClient) Benchmark(ctx context.Context, bench Benchmark) (*BenchmarkResult, error) {
tc.Stdout = ioutil.Discard
tc.Stderr = ioutil.Discard
tc.Stdin = &bytes.Buffer{}
ctx, cancel := context.WithTimeout(ctx, bench.Duration)
defer cancel()
requestC := make(chan *benchMeasure)
responseC := make(chan *benchMeasure, bench.Threads)
// create goroutines for concurrency
for i := 0; i < bench.Threads; i++ {
thread := &benchmarkThread{
id: i,
ctx: ctx,
client: tc,
command: bench.Command,
interactive: bench.Interactive,
receiveC: requestC,
sendC: responseC,
}
go thread.run()
}
// producer goroutine
go func() {
interval := time.Duration(float64(1) / float64(bench.Rate) * float64(time.Second))
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
// notice how we start the timer regardless of whether any goroutine can process it
// this is to account for coordinated omission,
// http://psy-lob-saw.blogspot.com/2015/03/fixing-ycsb-coordinated-omission.html
measure := &benchMeasure{
Start: time.Now(),
}
select {
case requestC <- measure:
case <-ctx.Done():
return
}
case <-ctx.Done():
return
}
}
}()
var result BenchmarkResult
// from one millisecond to 60000 milliseconds (minute) with 3 digits precision
result.Histogram = hdrhistogram.New(1, 60000, 3)
var doneThreads int
var timeoutC <-chan time.Time
doneC := ctx.Done()
for {
select {
case <-timeoutC:
result.LastError = trace.BadParameter("several requests hang: timeout waiting for %v threads to finish", bench.Threads-doneThreads)
return &result, nil
case <-doneC:
// give it a couple of seconds to wrap up the goroutines,
// set up the timer that will fire up if the all goroutines were not finished
doneC = nil
waitTime := time.Duration(result.Histogram.Max()) * time.Millisecond
// going to wait latency + buffer to give requests in flight to wrap up
waitTime = time.Duration(1.2 * float64(waitTime))
timeoutC = time.After(waitTime)
case measure := <-responseC:
if measure.ThreadCompleted {
doneThreads += 1
if doneThreads == bench.Threads {
return &result, nil
}
} else {
if measure.Error != nil {
result.RequestsFailed += 1
result.LastError = measure.Error
}
result.RequestsOriginated += 1
result.Histogram.RecordValue(int64(measure.End.Sub(measure.Start) / time.Millisecond))
}
}
}
} | go | func (tc *TeleportClient) Benchmark(ctx context.Context, bench Benchmark) (*BenchmarkResult, error) {
tc.Stdout = ioutil.Discard
tc.Stderr = ioutil.Discard
tc.Stdin = &bytes.Buffer{}
ctx, cancel := context.WithTimeout(ctx, bench.Duration)
defer cancel()
requestC := make(chan *benchMeasure)
responseC := make(chan *benchMeasure, bench.Threads)
// create goroutines for concurrency
for i := 0; i < bench.Threads; i++ {
thread := &benchmarkThread{
id: i,
ctx: ctx,
client: tc,
command: bench.Command,
interactive: bench.Interactive,
receiveC: requestC,
sendC: responseC,
}
go thread.run()
}
// producer goroutine
go func() {
interval := time.Duration(float64(1) / float64(bench.Rate) * float64(time.Second))
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
// notice how we start the timer regardless of whether any goroutine can process it
// this is to account for coordinated omission,
// http://psy-lob-saw.blogspot.com/2015/03/fixing-ycsb-coordinated-omission.html
measure := &benchMeasure{
Start: time.Now(),
}
select {
case requestC <- measure:
case <-ctx.Done():
return
}
case <-ctx.Done():
return
}
}
}()
var result BenchmarkResult
// from one millisecond to 60000 milliseconds (minute) with 3 digits precision
result.Histogram = hdrhistogram.New(1, 60000, 3)
var doneThreads int
var timeoutC <-chan time.Time
doneC := ctx.Done()
for {
select {
case <-timeoutC:
result.LastError = trace.BadParameter("several requests hang: timeout waiting for %v threads to finish", bench.Threads-doneThreads)
return &result, nil
case <-doneC:
// give it a couple of seconds to wrap up the goroutines,
// set up the timer that will fire up if the all goroutines were not finished
doneC = nil
waitTime := time.Duration(result.Histogram.Max()) * time.Millisecond
// going to wait latency + buffer to give requests in flight to wrap up
waitTime = time.Duration(1.2 * float64(waitTime))
timeoutC = time.After(waitTime)
case measure := <-responseC:
if measure.ThreadCompleted {
doneThreads += 1
if doneThreads == bench.Threads {
return &result, nil
}
} else {
if measure.Error != nil {
result.RequestsFailed += 1
result.LastError = measure.Error
}
result.RequestsOriginated += 1
result.Histogram.RecordValue(int64(measure.End.Sub(measure.Start) / time.Millisecond))
}
}
}
} | [
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"Benchmark",
"(",
"ctx",
"context",
".",
"Context",
",",
"bench",
"Benchmark",
")",
"(",
"*",
"BenchmarkResult",
",",
"error",
")",
"{",
"tc",
".",
"Stdout",
"=",
"ioutil",
".",
"Discard",
"\n",
"tc",
".",
"Stderr",
"=",
"ioutil",
".",
"Discard",
"\n",
"tc",
".",
"Stdin",
"=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"bench",
".",
"Duration",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"requestC",
":=",
"make",
"(",
"chan",
"*",
"benchMeasure",
")",
"\n",
"responseC",
":=",
"make",
"(",
"chan",
"*",
"benchMeasure",
",",
"bench",
".",
"Threads",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"bench",
".",
"Threads",
";",
"i",
"++",
"{",
"thread",
":=",
"&",
"benchmarkThread",
"{",
"id",
":",
"i",
",",
"ctx",
":",
"ctx",
",",
"client",
":",
"tc",
",",
"command",
":",
"bench",
".",
"Command",
",",
"interactive",
":",
"bench",
".",
"Interactive",
",",
"receiveC",
":",
"requestC",
",",
"sendC",
":",
"responseC",
",",
"}",
"\n",
"go",
"thread",
".",
"run",
"(",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"interval",
":=",
"time",
".",
"Duration",
"(",
"float64",
"(",
"1",
")",
"/",
"float64",
"(",
"bench",
".",
"Rate",
")",
"*",
"float64",
"(",
"time",
".",
"Second",
")",
")",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"interval",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"measure",
":=",
"&",
"benchMeasure",
"{",
"Start",
":",
"time",
".",
"Now",
"(",
")",
",",
"}",
"\n",
"select",
"{",
"case",
"requestC",
"<-",
"measure",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"var",
"result",
"BenchmarkResult",
"\n",
"result",
".",
"Histogram",
"=",
"hdrhistogram",
".",
"New",
"(",
"1",
",",
"60000",
",",
"3",
")",
"\n",
"var",
"doneThreads",
"int",
"\n",
"var",
"timeoutC",
"<-",
"chan",
"time",
".",
"Time",
"\n",
"doneC",
":=",
"ctx",
".",
"Done",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"timeoutC",
":",
"result",
".",
"LastError",
"=",
"trace",
".",
"BadParameter",
"(",
"\"several requests hang: timeout waiting for %v threads to finish\"",
",",
"bench",
".",
"Threads",
"-",
"doneThreads",
")",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"case",
"<-",
"doneC",
":",
"doneC",
"=",
"nil",
"\n",
"waitTime",
":=",
"time",
".",
"Duration",
"(",
"result",
".",
"Histogram",
".",
"Max",
"(",
")",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"waitTime",
"=",
"time",
".",
"Duration",
"(",
"1.2",
"*",
"float64",
"(",
"waitTime",
")",
")",
"\n",
"timeoutC",
"=",
"time",
".",
"After",
"(",
"waitTime",
")",
"\n",
"case",
"measure",
":=",
"<-",
"responseC",
":",
"if",
"measure",
".",
"ThreadCompleted",
"{",
"doneThreads",
"+=",
"1",
"\n",
"if",
"doneThreads",
"==",
"bench",
".",
"Threads",
"{",
"return",
"&",
"result",
",",
"nil",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"measure",
".",
"Error",
"!=",
"nil",
"{",
"result",
".",
"RequestsFailed",
"+=",
"1",
"\n",
"result",
".",
"LastError",
"=",
"measure",
".",
"Error",
"\n",
"}",
"\n",
"result",
".",
"RequestsOriginated",
"+=",
"1",
"\n",
"result",
".",
"Histogram",
".",
"RecordValue",
"(",
"int64",
"(",
"measure",
".",
"End",
".",
"Sub",
"(",
"measure",
".",
"Start",
")",
"/",
"time",
".",
"Millisecond",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Benchmark connects to remote server and executes requests in parallel according
// to benchmark spec. It returns benchmark result when completed.
// This is a blocking function that can be cancelled via context argument. | [
"Benchmark",
"connects",
"to",
"remote",
"server",
"and",
"executes",
"requests",
"in",
"parallel",
"according",
"to",
"benchmark",
"spec",
".",
"It",
"returns",
"benchmark",
"result",
"when",
"completed",
".",
"This",
"is",
"a",
"blocking",
"function",
"that",
"can",
"be",
"cancelled",
"via",
"context",
"argument",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/bench.go#L60-L147 | train |
gravitational/teleport | lib/utils/conn.go | NewCloserConn | func NewCloserConn(conn net.Conn, closers ...io.Closer) *CloserConn {
return &CloserConn{
Conn: conn,
closers: closers,
}
} | go | func NewCloserConn(conn net.Conn, closers ...io.Closer) *CloserConn {
return &CloserConn{
Conn: conn,
closers: closers,
}
} | [
"func",
"NewCloserConn",
"(",
"conn",
"net",
".",
"Conn",
",",
"closers",
"...",
"io",
".",
"Closer",
")",
"*",
"CloserConn",
"{",
"return",
"&",
"CloserConn",
"{",
"Conn",
":",
"conn",
",",
"closers",
":",
"closers",
",",
"}",
"\n",
"}"
] | // NewCloserConn returns new connection wrapper that
// when closed will also close passed closers | [
"NewCloserConn",
"returns",
"new",
"connection",
"wrapper",
"that",
"when",
"closed",
"will",
"also",
"close",
"passed",
"closers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/conn.go#L33-L38 | train |
gravitational/teleport | lib/client/interfaces.go | ClientTLSConfig | func (k *Key) ClientTLSConfig() (*tls.Config, error) {
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
pool := x509.NewCertPool()
for _, ca := range k.TrustedCA {
for _, certPEM := range ca.TLSCertificates {
if !pool.AppendCertsFromPEM(certPEM) {
return nil, trace.BadParameter("failed to parse certificate received from the proxy")
}
}
}
tlsConfig.RootCAs = pool
tlsCert, err := tls.X509KeyPair(k.TLSCert, k.Priv)
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
return tlsConfig, nil
} | go | func (k *Key) ClientTLSConfig() (*tls.Config, error) {
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
pool := x509.NewCertPool()
for _, ca := range k.TrustedCA {
for _, certPEM := range ca.TLSCertificates {
if !pool.AppendCertsFromPEM(certPEM) {
return nil, trace.BadParameter("failed to parse certificate received from the proxy")
}
}
}
tlsConfig.RootCAs = pool
tlsCert, err := tls.X509KeyPair(k.TLSCert, k.Priv)
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
return tlsConfig, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"ClientTLSConfig",
"(",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"tlsConfig",
":=",
"utils",
".",
"TLSConfig",
"(",
"nil",
")",
"\n",
"pool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"for",
"_",
",",
"ca",
":=",
"range",
"k",
".",
"TrustedCA",
"{",
"for",
"_",
",",
"certPEM",
":=",
"range",
"ca",
".",
"TLSCertificates",
"{",
"if",
"!",
"pool",
".",
"AppendCertsFromPEM",
"(",
"certPEM",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse certificate received from the proxy\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"tlsConfig",
".",
"RootCAs",
"=",
"pool",
"\n",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"k",
".",
"TLSCert",
",",
"k",
".",
"Priv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"failed to parse TLS cert and key\"",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"Certificates",
"=",
"append",
"(",
"tlsConfig",
".",
"Certificates",
",",
"tlsCert",
")",
"\n",
"return",
"tlsConfig",
",",
"nil",
"\n",
"}"
] | // TLSConfig returns client TLS configuration used
// to authenticate against API servers | [
"TLSConfig",
"returns",
"client",
"TLS",
"configuration",
"used",
"to",
"authenticate",
"against",
"API",
"servers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L62-L82 | train |
gravitational/teleport | lib/client/interfaces.go | CertUsername | func (k *Key) CertUsername() (string, error) {
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return "", trace.Wrap(err)
}
cert, ok := pubKey.(*ssh.Certificate)
if !ok {
return "", trace.BadParameter("expected SSH certificate, got public key")
}
return cert.KeyId, nil
} | go | func (k *Key) CertUsername() (string, error) {
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return "", trace.Wrap(err)
}
cert, ok := pubKey.(*ssh.Certificate)
if !ok {
return "", trace.BadParameter("expected SSH certificate, got public key")
}
return cert.KeyId, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CertUsername",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"pubKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"pubKey",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"expected SSH certificate, got public key\"",
")",
"\n",
"}",
"\n",
"return",
"cert",
".",
"KeyId",
",",
"nil",
"\n",
"}"
] | // CertUsername returns the name of the Teleport user encoded in the SSH certificate. | [
"CertUsername",
"returns",
"the",
"name",
"of",
"the",
"Teleport",
"user",
"encoded",
"in",
"the",
"SSH",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L85-L95 | train |
gravitational/teleport | lib/client/interfaces.go | CertPrincipals | func (k *Key) CertPrincipals() ([]string, error) {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("no certificate found")
}
return cert.ValidPrincipals, nil
} | go | func (k *Key) CertPrincipals() ([]string, error) {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("no certificate found")
}
return cert.ValidPrincipals, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CertPrincipals",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"publicKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"publicKey",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"no certificate found\"",
")",
"\n",
"}",
"\n",
"return",
"cert",
".",
"ValidPrincipals",
",",
"nil",
"\n",
"}"
] | // CertPrincipals returns the principals listed on the SSH certificate. | [
"CertPrincipals",
"returns",
"the",
"principals",
"listed",
"on",
"the",
"SSH",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L98-L108 | train |
gravitational/teleport | lib/client/interfaces.go | EqualsTo | func (k *Key) EqualsTo(other *Key) bool {
if k == other {
return true
}
return bytes.Equal(k.Cert, other.Cert) &&
bytes.Equal(k.Priv, other.Priv) &&
bytes.Equal(k.Pub, other.Pub) &&
bytes.Equal(k.TLSCert, other.TLSCert)
} | go | func (k *Key) EqualsTo(other *Key) bool {
if k == other {
return true
}
return bytes.Equal(k.Cert, other.Cert) &&
bytes.Equal(k.Priv, other.Priv) &&
bytes.Equal(k.Pub, other.Pub) &&
bytes.Equal(k.TLSCert, other.TLSCert)
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"EqualsTo",
"(",
"other",
"*",
"Key",
")",
"bool",
"{",
"if",
"k",
"==",
"other",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"bytes",
".",
"Equal",
"(",
"k",
".",
"Cert",
",",
"other",
".",
"Cert",
")",
"&&",
"bytes",
".",
"Equal",
"(",
"k",
".",
"Priv",
",",
"other",
".",
"Priv",
")",
"&&",
"bytes",
".",
"Equal",
"(",
"k",
".",
"Pub",
",",
"other",
".",
"Pub",
")",
"&&",
"bytes",
".",
"Equal",
"(",
"k",
".",
"TLSCert",
",",
"other",
".",
"TLSCert",
")",
"\n",
"}"
] | // EqualsTo returns true if this key is the same as the other.
// Primarily used in tests | [
"EqualsTo",
"returns",
"true",
"if",
"this",
"key",
"is",
"the",
"same",
"as",
"the",
"other",
".",
"Primarily",
"used",
"in",
"tests"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L173-L181 | train |
gravitational/teleport | lib/client/interfaces.go | TLSCertValidBefore | func (k *Key) TLSCertValidBefore() (t time.Time, err error) {
cert, err := tlsca.ParseCertificatePEM(k.TLSCert)
if err != nil {
return t, trace.Wrap(err)
}
return cert.NotAfter, nil
} | go | func (k *Key) TLSCertValidBefore() (t time.Time, err error) {
cert, err := tlsca.ParseCertificatePEM(k.TLSCert)
if err != nil {
return t, trace.Wrap(err)
}
return cert.NotAfter, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"TLSCertValidBefore",
"(",
")",
"(",
"t",
"time",
".",
"Time",
",",
"err",
"error",
")",
"{",
"cert",
",",
"err",
":=",
"tlsca",
".",
"ParseCertificatePEM",
"(",
"k",
".",
"TLSCert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"t",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cert",
".",
"NotAfter",
",",
"nil",
"\n",
"}"
] | // TLSCertValidBefore returns the time of the TLS cert expiration | [
"TLSCertValidBefore",
"returns",
"the",
"time",
"of",
"the",
"TLS",
"cert",
"expiration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L184-L190 | train |
gravitational/teleport | lib/client/interfaces.go | CertValidBefore | func (k *Key) CertValidBefore() (t time.Time, err error) {
pcert, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return t, trace.Wrap(err)
}
cert, ok := pcert.(*ssh.Certificate)
if !ok {
return t, trace.Errorf("not supported certificate type")
}
return time.Unix(int64(cert.ValidBefore), 0), nil
} | go | func (k *Key) CertValidBefore() (t time.Time, err error) {
pcert, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return t, trace.Wrap(err)
}
cert, ok := pcert.(*ssh.Certificate)
if !ok {
return t, trace.Errorf("not supported certificate type")
}
return time.Unix(int64(cert.ValidBefore), 0), nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CertValidBefore",
"(",
")",
"(",
"t",
"time",
".",
"Time",
",",
"err",
"error",
")",
"{",
"pcert",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"t",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"pcert",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"t",
",",
"trace",
".",
"Errorf",
"(",
"\"not supported certificate type\"",
")",
"\n",
"}",
"\n",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"cert",
".",
"ValidBefore",
")",
",",
"0",
")",
",",
"nil",
"\n",
"}"
] | // CertValidBefore returns the time of the cert expiration | [
"CertValidBefore",
"returns",
"the",
"time",
"of",
"the",
"cert",
"expiration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L193-L203 | train |
gravitational/teleport | lib/client/interfaces.go | AsAuthMethod | func (k *Key) AsAuthMethod() (ssh.AuthMethod, error) {
keys, err := k.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
signer, err := ssh.NewSignerFromKey(keys[0].PrivateKey)
if err != nil {
return nil, trace.Wrap(err)
}
if signer, err = ssh.NewCertSigner(keys[0].Certificate, signer); err != nil {
return nil, trace.Wrap(err)
}
return NewAuthMethodForCert(signer), nil
} | go | func (k *Key) AsAuthMethod() (ssh.AuthMethod, error) {
keys, err := k.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
signer, err := ssh.NewSignerFromKey(keys[0].PrivateKey)
if err != nil {
return nil, trace.Wrap(err)
}
if signer, err = ssh.NewCertSigner(keys[0].Certificate, signer); err != nil {
return nil, trace.Wrap(err)
}
return NewAuthMethodForCert(signer), nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"AsAuthMethod",
"(",
")",
"(",
"ssh",
".",
"AuthMethod",
",",
"error",
")",
"{",
"keys",
",",
"err",
":=",
"k",
".",
"AsAgentKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"signer",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"keys",
"[",
"0",
"]",
".",
"PrivateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"signer",
",",
"err",
"=",
"ssh",
".",
"NewCertSigner",
"(",
"keys",
"[",
"0",
"]",
".",
"Certificate",
",",
"signer",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"NewAuthMethodForCert",
"(",
"signer",
")",
",",
"nil",
"\n",
"}"
] | // AsAuthMethod returns an "auth method" interface, a common abstraction
// used by Golang SSH library. This is how you actually use a Key to feed
// it into the SSH lib. | [
"AsAuthMethod",
"returns",
"an",
"auth",
"method",
"interface",
"a",
"common",
"abstraction",
"used",
"by",
"Golang",
"SSH",
"library",
".",
"This",
"is",
"how",
"you",
"actually",
"use",
"a",
"Key",
"to",
"feed",
"it",
"into",
"the",
"SSH",
"lib",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L208-L221 | train |
gravitational/teleport | lib/client/interfaces.go | CheckCert | func (k *Key) CheckCert() error {
key, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return trace.Wrap(err)
}
cert, ok := key.(*ssh.Certificate)
if !ok {
return trace.BadParameter("found key, not certificate")
}
if len(cert.ValidPrincipals) == 0 {
return trace.BadParameter("principals are required")
}
// A valid principal is always passed in because the principals are not being
// checked here, but rather the validity period, signature, and algorithms.
certChecker := utils.CertChecker{}
err = certChecker.CheckCert(cert.ValidPrincipals[0], cert)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (k *Key) CheckCert() error {
key, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return trace.Wrap(err)
}
cert, ok := key.(*ssh.Certificate)
if !ok {
return trace.BadParameter("found key, not certificate")
}
if len(cert.ValidPrincipals) == 0 {
return trace.BadParameter("principals are required")
}
// A valid principal is always passed in because the principals are not being
// checked here, but rather the validity period, signature, and algorithms.
certChecker := utils.CertChecker{}
err = certChecker.CheckCert(cert.ValidPrincipals[0], cert)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CheckCert",
"(",
")",
"error",
"{",
"key",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"key",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"found key, not certificate\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"cert",
".",
"ValidPrincipals",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"principals are required\"",
")",
"\n",
"}",
"\n",
"certChecker",
":=",
"utils",
".",
"CertChecker",
"{",
"}",
"\n",
"err",
"=",
"certChecker",
".",
"CheckCert",
"(",
"cert",
".",
"ValidPrincipals",
"[",
"0",
"]",
",",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckCert makes sure the SSH certificate is valid. | [
"CheckCert",
"makes",
"sure",
"the",
"SSH",
"certificate",
"is",
"valid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L224-L247 | train |
gravitational/teleport | lib/backend/dynamo/shards.go | collectActiveShards | func (b *DynamoDBBackend) collectActiveShards(ctx context.Context, streamArn *string) ([]*dynamodbstreams.Shard, error) {
var out []*dynamodbstreams.Shard
input := &dynamodbstreams.DescribeStreamInput{
StreamArn: streamArn,
}
for {
streamInfo, err := b.streams.DescribeStreamWithContext(ctx, input)
if err != nil {
return nil, convertError(err)
}
out = append(out, streamInfo.StreamDescription.Shards...)
if streamInfo.StreamDescription.LastEvaluatedShardId == nil {
return filterActiveShards(out), nil
}
input.ExclusiveStartShardId = streamInfo.StreamDescription.LastEvaluatedShardId
}
} | go | func (b *DynamoDBBackend) collectActiveShards(ctx context.Context, streamArn *string) ([]*dynamodbstreams.Shard, error) {
var out []*dynamodbstreams.Shard
input := &dynamodbstreams.DescribeStreamInput{
StreamArn: streamArn,
}
for {
streamInfo, err := b.streams.DescribeStreamWithContext(ctx, input)
if err != nil {
return nil, convertError(err)
}
out = append(out, streamInfo.StreamDescription.Shards...)
if streamInfo.StreamDescription.LastEvaluatedShardId == nil {
return filterActiveShards(out), nil
}
input.ExclusiveStartShardId = streamInfo.StreamDescription.LastEvaluatedShardId
}
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"collectActiveShards",
"(",
"ctx",
"context",
".",
"Context",
",",
"streamArn",
"*",
"string",
")",
"(",
"[",
"]",
"*",
"dynamodbstreams",
".",
"Shard",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"dynamodbstreams",
".",
"Shard",
"\n",
"input",
":=",
"&",
"dynamodbstreams",
".",
"DescribeStreamInput",
"{",
"StreamArn",
":",
"streamArn",
",",
"}",
"\n",
"for",
"{",
"streamInfo",
",",
"err",
":=",
"b",
".",
"streams",
".",
"DescribeStreamWithContext",
"(",
"ctx",
",",
"input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"convertError",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"streamInfo",
".",
"StreamDescription",
".",
"Shards",
"...",
")",
"\n",
"if",
"streamInfo",
".",
"StreamDescription",
".",
"LastEvaluatedShardId",
"==",
"nil",
"{",
"return",
"filterActiveShards",
"(",
"out",
")",
",",
"nil",
"\n",
"}",
"\n",
"input",
".",
"ExclusiveStartShardId",
"=",
"streamInfo",
".",
"StreamDescription",
".",
"LastEvaluatedShardId",
"\n",
"}",
"\n",
"}"
] | // collectActiveShards collects shards | [
"collectActiveShards",
"collects",
"shards"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/shards.go#L202-L219 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.