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/trustedcluster.go
|
NewTrustedCluster
|
func NewTrustedCluster(name string, spec TrustedClusterSpecV2) (TrustedCluster, error) {
return &TrustedClusterV2{
Kind: KindTrustedCluster,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
}
|
go
|
func NewTrustedCluster(name string, spec TrustedClusterSpecV2) (TrustedCluster, error) {
return &TrustedClusterV2{
Kind: KindTrustedCluster,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
}
|
[
"func",
"NewTrustedCluster",
"(",
"name",
"string",
",",
"spec",
"TrustedClusterSpecV2",
")",
"(",
"TrustedCluster",
",",
"error",
")",
"{",
"return",
"&",
"TrustedClusterV2",
"{",
"Kind",
":",
"KindTrustedCluster",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewTrustedCluster is a convenience wa to create a TrustedCluster resource.
|
[
"NewTrustedCluster",
"is",
"a",
"convenience",
"wa",
"to",
"create",
"a",
"TrustedCluster",
"resource",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L71-L81
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
Equals
|
func (r RoleMap) Equals(o RoleMap) bool {
if len(r) != len(o) {
return false
}
for i := range r {
if !r[i].Equals(o[i]) {
return false
}
}
return true
}
|
go
|
func (r RoleMap) Equals(o RoleMap) bool {
if len(r) != len(o) {
return false
}
for i := range r {
if !r[i].Equals(o[i]) {
return false
}
}
return true
}
|
[
"func",
"(",
"r",
"RoleMap",
")",
"Equals",
"(",
"o",
"RoleMap",
")",
"bool",
"{",
"if",
"len",
"(",
"r",
")",
"!=",
"len",
"(",
"o",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"r",
"{",
"if",
"!",
"r",
"[",
"i",
"]",
".",
"Equals",
"(",
"o",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// Equals checks if the two role maps are equal.
|
[
"Equals",
"checks",
"if",
"the",
"two",
"role",
"maps",
"are",
"equal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L131-L141
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
String
|
func (r RoleMap) String() string {
values, err := r.parse()
if err != nil {
return fmt.Sprintf("<failed to parse: %v", err)
}
if len(values) != 0 {
return fmt.Sprintf("%v", values)
}
return "<empty>"
}
|
go
|
func (r RoleMap) String() string {
values, err := r.parse()
if err != nil {
return fmt.Sprintf("<failed to parse: %v", err)
}
if len(values) != 0 {
return fmt.Sprintf("%v", values)
}
return "<empty>"
}
|
[
"func",
"(",
"r",
"RoleMap",
")",
"String",
"(",
")",
"string",
"{",
"values",
",",
"err",
":=",
"r",
".",
"parse",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"<failed to parse: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"values",
")",
"!=",
"0",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"values",
")",
"\n",
"}",
"\n",
"return",
"\"<empty>\"",
"\n",
"}"
] |
// String prints user friendly representation of role mapping
|
[
"String",
"prints",
"user",
"friendly",
"representation",
"of",
"role",
"mapping"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L144-L153
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
Map
|
func (r RoleMap) Map(remoteRoles []string) ([]string, error) {
_, err := r.parse()
if err != nil {
return nil, trace.Wrap(err)
}
var outRoles []string
// when no remote roles is specified, assume that
// there is a single empty remote role (that should match wildcards)
if len(remoteRoles) == 0 {
remoteRoles = []string{""}
}
for _, mapping := range r {
expression := mapping.Remote
for _, remoteRole := range remoteRoles {
// never map default implicit role, it is always
// added by default
if remoteRole == teleport.DefaultImplicitRole {
continue
}
for _, replacementRole := range mapping.Local {
replacement, err := utils.ReplaceRegexp(expression, replacementRole, remoteRole)
switch {
case err == nil:
// empty replacement can occur when $2 expand refers
// to non-existing capture group in match expression
if replacement != "" {
outRoles = append(outRoles, replacement)
}
case trace.IsNotFound(err):
continue
default:
return nil, trace.Wrap(err)
}
}
}
}
return outRoles, nil
}
|
go
|
func (r RoleMap) Map(remoteRoles []string) ([]string, error) {
_, err := r.parse()
if err != nil {
return nil, trace.Wrap(err)
}
var outRoles []string
// when no remote roles is specified, assume that
// there is a single empty remote role (that should match wildcards)
if len(remoteRoles) == 0 {
remoteRoles = []string{""}
}
for _, mapping := range r {
expression := mapping.Remote
for _, remoteRole := range remoteRoles {
// never map default implicit role, it is always
// added by default
if remoteRole == teleport.DefaultImplicitRole {
continue
}
for _, replacementRole := range mapping.Local {
replacement, err := utils.ReplaceRegexp(expression, replacementRole, remoteRole)
switch {
case err == nil:
// empty replacement can occur when $2 expand refers
// to non-existing capture group in match expression
if replacement != "" {
outRoles = append(outRoles, replacement)
}
case trace.IsNotFound(err):
continue
default:
return nil, trace.Wrap(err)
}
}
}
}
return outRoles, nil
}
|
[
"func",
"(",
"r",
"RoleMap",
")",
"Map",
"(",
"remoteRoles",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"r",
".",
"parse",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"outRoles",
"[",
"]",
"string",
"\n",
"if",
"len",
"(",
"remoteRoles",
")",
"==",
"0",
"{",
"remoteRoles",
"=",
"[",
"]",
"string",
"{",
"\"\"",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"mapping",
":=",
"range",
"r",
"{",
"expression",
":=",
"mapping",
".",
"Remote",
"\n",
"for",
"_",
",",
"remoteRole",
":=",
"range",
"remoteRoles",
"{",
"if",
"remoteRole",
"==",
"teleport",
".",
"DefaultImplicitRole",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"replacementRole",
":=",
"range",
"mapping",
".",
"Local",
"{",
"replacement",
",",
"err",
":=",
"utils",
".",
"ReplaceRegexp",
"(",
"expression",
",",
"replacementRole",
",",
"remoteRole",
")",
"\n",
"switch",
"{",
"case",
"err",
"==",
"nil",
":",
"if",
"replacement",
"!=",
"\"\"",
"{",
"outRoles",
"=",
"append",
"(",
"outRoles",
",",
"replacement",
")",
"\n",
"}",
"\n",
"case",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
":",
"continue",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"outRoles",
",",
"nil",
"\n",
"}"
] |
// Map maps local roles to remote roles
|
[
"Map",
"maps",
"local",
"roles",
"to",
"remote",
"roles"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L187-L224
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
Check
|
func (r RoleMap) Check() error {
_, err := r.parse()
return trace.Wrap(err)
}
|
go
|
func (r RoleMap) Check() error {
_, err := r.parse()
return trace.Wrap(err)
}
|
[
"func",
"(",
"r",
"RoleMap",
")",
"Check",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"r",
".",
"parse",
"(",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// Check checks RoleMap for errors
|
[
"Check",
"checks",
"RoleMap",
"for",
"errors"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L227-L230
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
Equals
|
func (r RoleMapping) Equals(o RoleMapping) bool {
if r.Remote != o.Remote {
return false
}
if !utils.StringSlicesEqual(r.Local, r.Local) {
return false
}
return true
}
|
go
|
func (r RoleMapping) Equals(o RoleMapping) bool {
if r.Remote != o.Remote {
return false
}
if !utils.StringSlicesEqual(r.Local, r.Local) {
return false
}
return true
}
|
[
"func",
"(",
"r",
"RoleMapping",
")",
"Equals",
"(",
"o",
"RoleMapping",
")",
"bool",
"{",
"if",
"r",
".",
"Remote",
"!=",
"o",
".",
"Remote",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
"utils",
".",
"StringSlicesEqual",
"(",
"r",
".",
"Local",
",",
"r",
".",
"Local",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// Equals checks if the two role mappings are equal.
|
[
"Equals",
"checks",
"if",
"the",
"two",
"role",
"mappings",
"are",
"equal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L233-L241
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
CanChangeStateTo
|
func (c *TrustedClusterV2) CanChangeStateTo(t TrustedCluster) error {
if c.GetToken() != t.GetToken() {
return trace.BadParameter("can not update token for existing trusted cluster")
}
if c.GetProxyAddress() != t.GetProxyAddress() {
return trace.BadParameter("can not update proxy address for existing trusted cluster")
}
if c.GetReverseTunnelAddress() != t.GetReverseTunnelAddress() {
return trace.BadParameter("can not update proxy address for existing trusted cluster")
}
if !utils.StringSlicesEqual(c.GetRoles(), t.GetRoles()) {
return trace.BadParameter("can not update roles for existing trusted cluster")
}
if !c.GetRoleMap().Equals(t.GetRoleMap()) {
return trace.BadParameter("can not update role map for existing trusted cluster")
}
if c.GetEnabled() == t.GetEnabled() {
if t.GetEnabled() == true {
return trace.AlreadyExists("trusted cluster is already enabled")
}
return trace.AlreadyExists("trusted cluster state is already disabled")
}
return nil
}
|
go
|
func (c *TrustedClusterV2) CanChangeStateTo(t TrustedCluster) error {
if c.GetToken() != t.GetToken() {
return trace.BadParameter("can not update token for existing trusted cluster")
}
if c.GetProxyAddress() != t.GetProxyAddress() {
return trace.BadParameter("can not update proxy address for existing trusted cluster")
}
if c.GetReverseTunnelAddress() != t.GetReverseTunnelAddress() {
return trace.BadParameter("can not update proxy address for existing trusted cluster")
}
if !utils.StringSlicesEqual(c.GetRoles(), t.GetRoles()) {
return trace.BadParameter("can not update roles for existing trusted cluster")
}
if !c.GetRoleMap().Equals(t.GetRoleMap()) {
return trace.BadParameter("can not update role map for existing trusted cluster")
}
if c.GetEnabled() == t.GetEnabled() {
if t.GetEnabled() == true {
return trace.AlreadyExists("trusted cluster is already enabled")
}
return trace.AlreadyExists("trusted cluster state is already disabled")
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"TrustedClusterV2",
")",
"CanChangeStateTo",
"(",
"t",
"TrustedCluster",
")",
"error",
"{",
"if",
"c",
".",
"GetToken",
"(",
")",
"!=",
"t",
".",
"GetToken",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"can not update token for existing trusted cluster\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"GetProxyAddress",
"(",
")",
"!=",
"t",
".",
"GetProxyAddress",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"can not update proxy address for existing trusted cluster\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"GetReverseTunnelAddress",
"(",
")",
"!=",
"t",
".",
"GetReverseTunnelAddress",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"can not update proxy address for existing trusted cluster\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"utils",
".",
"StringSlicesEqual",
"(",
"c",
".",
"GetRoles",
"(",
")",
",",
"t",
".",
"GetRoles",
"(",
")",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"can not update roles for existing trusted cluster\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"c",
".",
"GetRoleMap",
"(",
")",
".",
"Equals",
"(",
"t",
".",
"GetRoleMap",
"(",
")",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"can not update role map for existing trusted cluster\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"GetEnabled",
"(",
")",
"==",
"t",
".",
"GetEnabled",
"(",
")",
"{",
"if",
"t",
".",
"GetEnabled",
"(",
")",
"==",
"true",
"{",
"return",
"trace",
".",
"AlreadyExists",
"(",
"\"trusted cluster is already enabled\"",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"AlreadyExists",
"(",
"\"trusted cluster state is already disabled\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CanChangeState checks if the state change is allowed or not. If not, returns
// an error explaining the reason.
|
[
"CanChangeState",
"checks",
"if",
"the",
"state",
"change",
"is",
"allowed",
"or",
"not",
".",
"If",
"not",
"returns",
"an",
"error",
"explaining",
"the",
"reason",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L408-L433
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
String
|
func (c *TrustedClusterV2) String() string {
return fmt.Sprintf("TrustedCluster(Enabled=%v,Roles=%v,Token=%v,ProxyAddress=%v,ReverseTunnelAddress=%v)",
c.Spec.Enabled, c.Spec.Roles, c.Spec.Token, c.Spec.ProxyAddress, c.Spec.ReverseTunnelAddress)
}
|
go
|
func (c *TrustedClusterV2) String() string {
return fmt.Sprintf("TrustedCluster(Enabled=%v,Roles=%v,Token=%v,ProxyAddress=%v,ReverseTunnelAddress=%v)",
c.Spec.Enabled, c.Spec.Roles, c.Spec.Token, c.Spec.ProxyAddress, c.Spec.ReverseTunnelAddress)
}
|
[
"func",
"(",
"c",
"*",
"TrustedClusterV2",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"TrustedCluster(Enabled=%v,Roles=%v,Token=%v,ProxyAddress=%v,ReverseTunnelAddress=%v)\"",
",",
"c",
".",
"Spec",
".",
"Enabled",
",",
"c",
".",
"Spec",
".",
"Roles",
",",
"c",
".",
"Spec",
".",
"Token",
",",
"c",
".",
"Spec",
".",
"ProxyAddress",
",",
"c",
".",
"Spec",
".",
"ReverseTunnelAddress",
")",
"\n",
"}"
] |
// String represents a human readable version of trusted cluster settings.
|
[
"String",
"represents",
"a",
"human",
"readable",
"version",
"of",
"trusted",
"cluster",
"settings",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L436-L439
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
GetTrustedClusterSchema
|
func GetTrustedClusterSchema(extensionSchema string) string {
var trustedClusterSchema string
if extensionSchema == "" {
trustedClusterSchema = fmt.Sprintf(TrustedClusterSpecSchemaTemplate, RoleMapSchema, "")
} else {
trustedClusterSchema = fmt.Sprintf(TrustedClusterSpecSchemaTemplate, RoleMapSchema, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, trustedClusterSchema, DefaultDefinitions)
}
|
go
|
func GetTrustedClusterSchema(extensionSchema string) string {
var trustedClusterSchema string
if extensionSchema == "" {
trustedClusterSchema = fmt.Sprintf(TrustedClusterSpecSchemaTemplate, RoleMapSchema, "")
} else {
trustedClusterSchema = fmt.Sprintf(TrustedClusterSpecSchemaTemplate, RoleMapSchema, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, trustedClusterSchema, DefaultDefinitions)
}
|
[
"func",
"GetTrustedClusterSchema",
"(",
"extensionSchema",
"string",
")",
"string",
"{",
"var",
"trustedClusterSchema",
"string",
"\n",
"if",
"extensionSchema",
"==",
"\"\"",
"{",
"trustedClusterSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"TrustedClusterSpecSchemaTemplate",
",",
"RoleMapSchema",
",",
"\"\"",
")",
"\n",
"}",
"else",
"{",
"trustedClusterSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"TrustedClusterSpecSchemaTemplate",
",",
"RoleMapSchema",
",",
"\",\"",
"+",
"extensionSchema",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"trustedClusterSchema",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] |
// GetTrustedClusterSchema returns the schema with optionally injected
// schema for extensions.
|
[
"GetTrustedClusterSchema",
"returns",
"the",
"schema",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L480-L488
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
Less
|
func (s SortedTrustedCluster) Less(i, j int) bool {
return s[i].GetName() < s[j].GetName()
}
|
go
|
func (s SortedTrustedCluster) Less(i, j int) bool {
return s[i].GetName() < s[j].GetName()
}
|
[
"func",
"(",
"s",
"SortedTrustedCluster",
")",
"Less",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"s",
"[",
"i",
"]",
".",
"GetName",
"(",
")",
"<",
"s",
"[",
"j",
"]",
".",
"GetName",
"(",
")",
"\n",
"}"
] |
// Less compares items by name.
|
[
"Less",
"compares",
"items",
"by",
"name",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L579-L581
|
train
|
gravitational/teleport
|
lib/services/trustedcluster.go
|
Swap
|
func (s SortedTrustedCluster) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
|
go
|
func (s SortedTrustedCluster) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
|
[
"func",
"(",
"s",
"SortedTrustedCluster",
")",
"Swap",
"(",
"i",
",",
"j",
"int",
")",
"{",
"s",
"[",
"i",
"]",
",",
"s",
"[",
"j",
"]",
"=",
"s",
"[",
"j",
"]",
",",
"s",
"[",
"i",
"]",
"\n",
"}"
] |
// Swap swaps two items in a list.
|
[
"Swap",
"swaps",
"two",
"items",
"in",
"a",
"list",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trustedcluster.go#L584-L586
|
train
|
gravitational/teleport
|
lib/client/profile.go
|
Name
|
func (c *ClientProfile) Name() string {
if c.ProxyHost != "" {
return c.ProxyHost
}
addr, _, err := net.SplitHostPort(c.WebProxyAddr)
if err != nil {
return c.WebProxyAddr
}
return addr
}
|
go
|
func (c *ClientProfile) Name() string {
if c.ProxyHost != "" {
return c.ProxyHost
}
addr, _, err := net.SplitHostPort(c.WebProxyAddr)
if err != nil {
return c.WebProxyAddr
}
return addr
}
|
[
"func",
"(",
"c",
"*",
"ClientProfile",
")",
"Name",
"(",
")",
"string",
"{",
"if",
"c",
".",
"ProxyHost",
"!=",
"\"\"",
"{",
"return",
"c",
".",
"ProxyHost",
"\n",
"}",
"\n",
"addr",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"c",
".",
"WebProxyAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"WebProxyAddr",
"\n",
"}",
"\n",
"return",
"addr",
"\n",
"}"
] |
// Name returns the name of the profile.
|
[
"Name",
"returns",
"the",
"name",
"of",
"the",
"profile",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/profile.go#L72-L83
|
train
|
gravitational/teleport
|
lib/client/profile.go
|
UnlinkCurrentProfile
|
func UnlinkCurrentProfile() error {
return trace.Wrap(os.Remove(filepath.Join(FullProfilePath(""), CurrentProfileSymlink)))
}
|
go
|
func UnlinkCurrentProfile() error {
return trace.Wrap(os.Remove(filepath.Join(FullProfilePath(""), CurrentProfileSymlink)))
}
|
[
"func",
"UnlinkCurrentProfile",
"(",
")",
"error",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"os",
".",
"Remove",
"(",
"filepath",
".",
"Join",
"(",
"FullProfilePath",
"(",
"\"\"",
")",
",",
"CurrentProfileSymlink",
")",
")",
")",
"\n",
"}"
] |
// If there's a current profile symlink, remove it
|
[
"If",
"there",
"s",
"a",
"current",
"profile",
"symlink",
"remove",
"it"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/profile.go#L103-L105
|
train
|
gravitational/teleport
|
lib/client/profile.go
|
ProfileFromFile
|
func ProfileFromFile(filePath string) (*ClientProfile, error) {
bytes, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
var cp *ClientProfile
if err = yaml.Unmarshal(bytes, &cp); err != nil {
return nil, trace.Wrap(err)
}
return cp, nil
}
|
go
|
func ProfileFromFile(filePath string) (*ClientProfile, error) {
bytes, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
var cp *ClientProfile
if err = yaml.Unmarshal(bytes, &cp); err != nil {
return nil, trace.Wrap(err)
}
return cp, nil
}
|
[
"func",
"ProfileFromFile",
"(",
"filePath",
"string",
")",
"(",
"*",
"ClientProfile",
",",
"error",
")",
"{",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"cp",
"*",
"ClientProfile",
"\n",
"if",
"err",
"=",
"yaml",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"cp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cp",
",",
"nil",
"\n",
"}"
] |
// ProfileFromFile loads the profile from a YAML file
|
[
"ProfileFromFile",
"loads",
"the",
"profile",
"from",
"a",
"YAML",
"file"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/profile.go#L121-L131
|
train
|
gravitational/teleport
|
lib/client/profile.go
|
SaveTo
|
func (cp *ClientProfile) SaveTo(loc ProfileLocation) error {
bytes, err := yaml.Marshal(&cp)
if err != nil {
return trace.Wrap(err)
}
if err = ioutil.WriteFile(loc.Path, bytes, 0660); err != nil {
return trace.Wrap(err)
}
if loc.AliasPath != "" && filepath.Base(loc.AliasPath) != filepath.Base(loc.Path) {
if err := os.Remove(loc.AliasPath); err != nil {
log.Warningf("Failed to remove symlink alias: %v", err)
}
err := os.Symlink(filepath.Base(loc.Path), loc.AliasPath)
if err != nil {
log.Warningf("Failed to create profile alias: %v", err)
}
}
// set 'current' symlink:
if loc.Options&ProfileMakeCurrent != 0 {
symlink := filepath.Join(filepath.Dir(loc.Path), CurrentProfileSymlink)
if err := os.Remove(symlink); err != nil {
log.Warningf("Failed to remove symlink: %v", err)
}
err = os.Symlink(filepath.Base(loc.Path), symlink)
}
return trace.Wrap(err)
}
|
go
|
func (cp *ClientProfile) SaveTo(loc ProfileLocation) error {
bytes, err := yaml.Marshal(&cp)
if err != nil {
return trace.Wrap(err)
}
if err = ioutil.WriteFile(loc.Path, bytes, 0660); err != nil {
return trace.Wrap(err)
}
if loc.AliasPath != "" && filepath.Base(loc.AliasPath) != filepath.Base(loc.Path) {
if err := os.Remove(loc.AliasPath); err != nil {
log.Warningf("Failed to remove symlink alias: %v", err)
}
err := os.Symlink(filepath.Base(loc.Path), loc.AliasPath)
if err != nil {
log.Warningf("Failed to create profile alias: %v", err)
}
}
// set 'current' symlink:
if loc.Options&ProfileMakeCurrent != 0 {
symlink := filepath.Join(filepath.Dir(loc.Path), CurrentProfileSymlink)
if err := os.Remove(symlink); err != nil {
log.Warningf("Failed to remove symlink: %v", err)
}
err = os.Symlink(filepath.Base(loc.Path), symlink)
}
return trace.Wrap(err)
}
|
[
"func",
"(",
"cp",
"*",
"ClientProfile",
")",
"SaveTo",
"(",
"loc",
"ProfileLocation",
")",
"error",
"{",
"bytes",
",",
"err",
":=",
"yaml",
".",
"Marshal",
"(",
"&",
"cp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"loc",
".",
"Path",
",",
"bytes",
",",
"0660",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"loc",
".",
"AliasPath",
"!=",
"\"\"",
"&&",
"filepath",
".",
"Base",
"(",
"loc",
".",
"AliasPath",
")",
"!=",
"filepath",
".",
"Base",
"(",
"loc",
".",
"Path",
")",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"loc",
".",
"AliasPath",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"Failed to remove symlink alias: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
":=",
"os",
".",
"Symlink",
"(",
"filepath",
".",
"Base",
"(",
"loc",
".",
"Path",
")",
",",
"loc",
".",
"AliasPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"Failed to create profile alias: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"loc",
".",
"Options",
"&",
"ProfileMakeCurrent",
"!=",
"0",
"{",
"symlink",
":=",
"filepath",
".",
"Join",
"(",
"filepath",
".",
"Dir",
"(",
"loc",
".",
"Path",
")",
",",
"CurrentProfileSymlink",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"symlink",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"Failed to remove symlink: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"Symlink",
"(",
"filepath",
".",
"Base",
"(",
"loc",
".",
"Path",
")",
",",
"symlink",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// SaveTo saves the profile into a given filename, optionally overwriting it.
|
[
"SaveTo",
"saves",
"the",
"profile",
"into",
"a",
"given",
"filename",
"optionally",
"overwriting",
"it",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/profile.go#L145-L171
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
CreateUploaderDir
|
func CreateUploaderDir(dir string) error {
err := os.MkdirAll(filepath.Join(dir, teleport.LogsDir, teleport.ComponentUpload,
events.SessionLogsDir, defaults.Namespace), teleport.SharedDirMode)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
}
|
go
|
func CreateUploaderDir(dir string) error {
err := os.MkdirAll(filepath.Join(dir, teleport.LogsDir, teleport.ComponentUpload,
events.SessionLogsDir, defaults.Namespace), teleport.SharedDirMode)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
}
|
[
"func",
"CreateUploaderDir",
"(",
"dir",
"string",
")",
"error",
"{",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"teleport",
".",
"LogsDir",
",",
"teleport",
".",
"ComponentUpload",
",",
"events",
".",
"SessionLogsDir",
",",
"defaults",
".",
"Namespace",
")",
",",
"teleport",
".",
"SharedDirMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CreateUploaderDir creates directory for file uploader service
|
[
"CreateUploaderDir",
"creates",
"directory",
"for",
"file",
"uploader",
"service"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L78-L86
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
GenerateCertificate
|
func GenerateCertificate(authServer *AuthServer, identity TestIdentity) ([]byte, []byte, error) {
switch id := identity.I.(type) {
case LocalUser:
user, err := authServer.GetUser(id.Username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), authServer, user.GetTraits())
if err != nil {
return nil, nil, trace.Wrap(err)
}
if identity.TTL == 0 {
identity.TTL = time.Hour
}
priv, pub, err := authServer.GenerateKeyPair("")
if err != nil {
return nil, nil, trace.Wrap(err)
}
certs, err := authServer.generateUserCert(certRequest{
publicKey: pub,
user: user,
roles: roles,
ttl: identity.TTL,
usage: identity.AcceptedUsage,
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return certs.tls, priv, nil
case BuiltinRole:
keys, err := authServer.GenerateServerKeys(GenerateServerKeysRequest{
HostID: id.Username,
NodeName: id.Username,
Roles: teleport.Roles{id.Role},
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return keys.TLSCert, keys.Key, nil
default:
return nil, nil, trace.BadParameter("identity of unknown type %T is unsupported", identity)
}
}
|
go
|
func GenerateCertificate(authServer *AuthServer, identity TestIdentity) ([]byte, []byte, error) {
switch id := identity.I.(type) {
case LocalUser:
user, err := authServer.GetUser(id.Username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), authServer, user.GetTraits())
if err != nil {
return nil, nil, trace.Wrap(err)
}
if identity.TTL == 0 {
identity.TTL = time.Hour
}
priv, pub, err := authServer.GenerateKeyPair("")
if err != nil {
return nil, nil, trace.Wrap(err)
}
certs, err := authServer.generateUserCert(certRequest{
publicKey: pub,
user: user,
roles: roles,
ttl: identity.TTL,
usage: identity.AcceptedUsage,
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return certs.tls, priv, nil
case BuiltinRole:
keys, err := authServer.GenerateServerKeys(GenerateServerKeysRequest{
HostID: id.Username,
NodeName: id.Username,
Roles: teleport.Roles{id.Role},
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return keys.TLSCert, keys.Key, nil
default:
return nil, nil, trace.BadParameter("identity of unknown type %T is unsupported", identity)
}
}
|
[
"func",
"GenerateCertificate",
"(",
"authServer",
"*",
"AuthServer",
",",
"identity",
"TestIdentity",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"switch",
"id",
":=",
"identity",
".",
"I",
".",
"(",
"type",
")",
"{",
"case",
"LocalUser",
":",
"user",
",",
"err",
":=",
"authServer",
".",
"GetUser",
"(",
"id",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roles",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"user",
".",
"GetRoles",
"(",
")",
",",
"authServer",
",",
"user",
".",
"GetTraits",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"identity",
".",
"TTL",
"==",
"0",
"{",
"identity",
".",
"TTL",
"=",
"time",
".",
"Hour",
"\n",
"}",
"\n",
"priv",
",",
"pub",
",",
"err",
":=",
"authServer",
".",
"GenerateKeyPair",
"(",
"\"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certs",
",",
"err",
":=",
"authServer",
".",
"generateUserCert",
"(",
"certRequest",
"{",
"publicKey",
":",
"pub",
",",
"user",
":",
"user",
",",
"roles",
":",
"roles",
",",
"ttl",
":",
"identity",
".",
"TTL",
",",
"usage",
":",
"identity",
".",
"AcceptedUsage",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"certs",
".",
"tls",
",",
"priv",
",",
"nil",
"\n",
"case",
"BuiltinRole",
":",
"keys",
",",
"err",
":=",
"authServer",
".",
"GenerateServerKeys",
"(",
"GenerateServerKeysRequest",
"{",
"HostID",
":",
"id",
".",
"Username",
",",
"NodeName",
":",
"id",
".",
"Username",
",",
"Roles",
":",
"teleport",
".",
"Roles",
"{",
"id",
".",
"Role",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"keys",
".",
"TLSCert",
",",
"keys",
".",
"Key",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"identity of unknown type %T is unsupported\"",
",",
"identity",
")",
"\n",
"}",
"\n",
"}"
] |
// GenerateCertificate generates certificate for identity,
// returns private public key pair
|
[
"GenerateCertificate",
"generates",
"certificate",
"for",
"identity",
"returns",
"private",
"public",
"key",
"pair"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L251-L293
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
NewCertificate
|
func (a *TestAuthServer) NewCertificate(identity TestIdentity) (*tls.Certificate, error) {
cert, key, err := GenerateCertificate(a.AuthServer, identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsCert, err := tls.X509KeyPair(cert, key)
if err != nil {
return nil, trace.Wrap(err)
}
return &tlsCert, nil
}
|
go
|
func (a *TestAuthServer) NewCertificate(identity TestIdentity) (*tls.Certificate, error) {
cert, key, err := GenerateCertificate(a.AuthServer, identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsCert, err := tls.X509KeyPair(cert, key)
if err != nil {
return nil, trace.Wrap(err)
}
return &tlsCert, nil
}
|
[
"func",
"(",
"a",
"*",
"TestAuthServer",
")",
"NewCertificate",
"(",
"identity",
"TestIdentity",
")",
"(",
"*",
"tls",
".",
"Certificate",
",",
"error",
")",
"{",
"cert",
",",
"key",
",",
"err",
":=",
"GenerateCertificate",
"(",
"a",
".",
"AuthServer",
",",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"cert",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"tlsCert",
",",
"nil",
"\n",
"}"
] |
// NewCertificate returns new TLS credentials generated by test auth server
|
[
"NewCertificate",
"returns",
"new",
"TLS",
"credentials",
"generated",
"by",
"test",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L296-L306
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
Trust
|
func (a *TestAuthServer) Trust(remote *TestAuthServer, roleMap services.RoleMap) error {
remoteCA, err := remote.AuthServer.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: remote.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = a.AuthServer.UpsertCertAuthority(remoteCA)
if err != nil {
return trace.Wrap(err)
}
remoteCA, err = remote.AuthServer.GetCertAuthority(services.CertAuthID{
Type: services.UserCA,
DomainName: remote.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
remoteCA.SetRoleMap(roleMap)
err = a.AuthServer.UpsertCertAuthority(remoteCA)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (a *TestAuthServer) Trust(remote *TestAuthServer, roleMap services.RoleMap) error {
remoteCA, err := remote.AuthServer.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: remote.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = a.AuthServer.UpsertCertAuthority(remoteCA)
if err != nil {
return trace.Wrap(err)
}
remoteCA, err = remote.AuthServer.GetCertAuthority(services.CertAuthID{
Type: services.UserCA,
DomainName: remote.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
remoteCA.SetRoleMap(roleMap)
err = a.AuthServer.UpsertCertAuthority(remoteCA)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"a",
"*",
"TestAuthServer",
")",
"Trust",
"(",
"remote",
"*",
"TestAuthServer",
",",
"roleMap",
"services",
".",
"RoleMap",
")",
"error",
"{",
"remoteCA",
",",
"err",
":=",
"remote",
".",
"AuthServer",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"HostCA",
",",
"DomainName",
":",
"remote",
".",
"ClusterName",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"a",
".",
"AuthServer",
".",
"UpsertCertAuthority",
"(",
"remoteCA",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"remoteCA",
",",
"err",
"=",
"remote",
".",
"AuthServer",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"UserCA",
",",
"DomainName",
":",
"remote",
".",
"ClusterName",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"remoteCA",
".",
"SetRoleMap",
"(",
"roleMap",
")",
"\n",
"err",
"=",
"a",
".",
"AuthServer",
".",
"UpsertCertAuthority",
"(",
"remoteCA",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Trust adds other server host certificate authority as trusted
|
[
"Trust",
"adds",
"other",
"server",
"host",
"certificate",
"authority",
"as",
"trusted"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L314-L339
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
NewRemoteClient
|
func (a *TestAuthServer) NewRemoteClient(identity TestIdentity, addr net.Addr, pool *x509.CertPool) (*Client, error) {
tlsConfig := utils.TLSConfig(a.CipherSuites)
cert, err := a.NewCertificate(identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.Certificates = []tls.Certificate{*cert}
tlsConfig.RootCAs = pool
addrs := []utils.NetAddr{{
AddrNetwork: addr.Network(),
Addr: addr.String()}}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
}
|
go
|
func (a *TestAuthServer) NewRemoteClient(identity TestIdentity, addr net.Addr, pool *x509.CertPool) (*Client, error) {
tlsConfig := utils.TLSConfig(a.CipherSuites)
cert, err := a.NewCertificate(identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.Certificates = []tls.Certificate{*cert}
tlsConfig.RootCAs = pool
addrs := []utils.NetAddr{{
AddrNetwork: addr.Network(),
Addr: addr.String()}}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
}
|
[
"func",
"(",
"a",
"*",
"TestAuthServer",
")",
"NewRemoteClient",
"(",
"identity",
"TestIdentity",
",",
"addr",
"net",
".",
"Addr",
",",
"pool",
"*",
"x509",
".",
"CertPool",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"tlsConfig",
":=",
"utils",
".",
"TLSConfig",
"(",
"a",
".",
"CipherSuites",
")",
"\n",
"cert",
",",
"err",
":=",
"a",
".",
"NewCertificate",
"(",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"Certificates",
"=",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"*",
"cert",
"}",
"\n",
"tlsConfig",
".",
"RootCAs",
"=",
"pool",
"\n",
"addrs",
":=",
"[",
"]",
"utils",
".",
"NetAddr",
"{",
"{",
"AddrNetwork",
":",
"addr",
".",
"Network",
"(",
")",
",",
"Addr",
":",
"addr",
".",
"String",
"(",
")",
"}",
"}",
"\n",
"return",
"NewTLSClient",
"(",
"ClientConfig",
"{",
"Addrs",
":",
"addrs",
",",
"TLS",
":",
"tlsConfig",
"}",
")",
"\n",
"}"
] |
// NewRemoteClient creates new client to the remote server using identity
// generated for this certificate authority
|
[
"NewRemoteClient",
"creates",
"new",
"client",
"to",
"the",
"remote",
"server",
"using",
"identity",
"generated",
"for",
"this",
"certificate",
"authority"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L362-L374
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
CheckAndSetDefaults
|
func (cfg *TestTLSServerConfig) CheckAndSetDefaults() error {
if cfg.APIConfig == nil {
return trace.BadParameter("missing parameter APIConfig")
}
if cfg.AuthServer == nil {
return trace.BadParameter("missing parameter AuthServer")
}
// use very permissive limiter configuration by default
if cfg.Limiter == nil {
cfg.Limiter = &limiter.LimiterConfig{
MaxConnections: 1000,
MaxNumberOfUsers: 1000,
}
}
return nil
}
|
go
|
func (cfg *TestTLSServerConfig) CheckAndSetDefaults() error {
if cfg.APIConfig == nil {
return trace.BadParameter("missing parameter APIConfig")
}
if cfg.AuthServer == nil {
return trace.BadParameter("missing parameter AuthServer")
}
// use very permissive limiter configuration by default
if cfg.Limiter == nil {
cfg.Limiter = &limiter.LimiterConfig{
MaxConnections: 1000,
MaxNumberOfUsers: 1000,
}
}
return nil
}
|
[
"func",
"(",
"cfg",
"*",
"TestTLSServerConfig",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"cfg",
".",
"APIConfig",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter APIConfig\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"AuthServer",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter AuthServer\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Limiter",
"==",
"nil",
"{",
"cfg",
".",
"Limiter",
"=",
"&",
"limiter",
".",
"LimiterConfig",
"{",
"MaxConnections",
":",
"1000",
",",
"MaxNumberOfUsers",
":",
"1000",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckAndSetDefaults checks and sets limiter defaults
|
[
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"limiter",
"defaults"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L416-L431
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
NewClientFromWebSession
|
func (t *TestTLSServer) NewClientFromWebSession(sess services.WebSession) (*Client, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
tlsCert, err := tls.X509KeyPair(sess.GetTLSCert(), sess.GetPriv())
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = []tls.Certificate{tlsCert}
addrs := []utils.NetAddr{utils.FromAddr(t.Listener.Addr())}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
}
|
go
|
func (t *TestTLSServer) NewClientFromWebSession(sess services.WebSession) (*Client, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
tlsCert, err := tls.X509KeyPair(sess.GetTLSCert(), sess.GetPriv())
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = []tls.Certificate{tlsCert}
addrs := []utils.NetAddr{utils.FromAddr(t.Listener.Addr())}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"NewClientFromWebSession",
"(",
"sess",
"services",
".",
"WebSession",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"tlsConfig",
",",
"err",
":=",
"t",
".",
"Identity",
".",
"TLSConfig",
"(",
"t",
".",
"AuthServer",
".",
"CipherSuites",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"sess",
".",
"GetTLSCert",
"(",
")",
",",
"sess",
".",
"GetPriv",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"failed to parse TLS cert and key\"",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"Certificates",
"=",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"tlsCert",
"}",
"\n",
"addrs",
":=",
"[",
"]",
"utils",
".",
"NetAddr",
"{",
"utils",
".",
"FromAddr",
"(",
"t",
".",
"Listener",
".",
"Addr",
"(",
")",
")",
"}",
"\n",
"return",
"NewTLSClient",
"(",
"ClientConfig",
"{",
"Addrs",
":",
"addrs",
",",
"TLS",
":",
"tlsConfig",
"}",
")",
"\n",
"}"
] |
// NewClientFromWebSession returns new authenticated client from web session
|
[
"NewClientFromWebSession",
"returns",
"new",
"authenticated",
"client",
"from",
"web",
"session"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L513-L525
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
CertPool
|
func (t *TestTLSServer) CertPool() (*x509.CertPool, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
return tlsConfig.RootCAs, nil
}
|
go
|
func (t *TestTLSServer) CertPool() (*x509.CertPool, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
return tlsConfig.RootCAs, nil
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"CertPool",
"(",
")",
"(",
"*",
"x509",
".",
"CertPool",
",",
"error",
")",
"{",
"tlsConfig",
",",
"err",
":=",
"t",
".",
"Identity",
".",
"TLSConfig",
"(",
"t",
".",
"AuthServer",
".",
"CipherSuites",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"tlsConfig",
".",
"RootCAs",
",",
"nil",
"\n",
"}"
] |
// CertPool returns cert pool that auth server represents
|
[
"CertPool",
"returns",
"cert",
"pool",
"that",
"auth",
"server",
"represents"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L528-L534
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
ClientTLSConfig
|
func (t *TestTLSServer) ClientTLSConfig(identity TestIdentity) (*tls.Config, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
if identity.I != nil {
cert, err := t.AuthServer.NewCertificate(identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.Certificates = []tls.Certificate{*cert}
} else {
// this client is not authenticated, which means that auth
// server should apply Nop builtin role
tlsConfig.Certificates = nil
}
return tlsConfig, nil
}
|
go
|
func (t *TestTLSServer) ClientTLSConfig(identity TestIdentity) (*tls.Config, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
if identity.I != nil {
cert, err := t.AuthServer.NewCertificate(identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.Certificates = []tls.Certificate{*cert}
} else {
// this client is not authenticated, which means that auth
// server should apply Nop builtin role
tlsConfig.Certificates = nil
}
return tlsConfig, nil
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"ClientTLSConfig",
"(",
"identity",
"TestIdentity",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"tlsConfig",
",",
"err",
":=",
"t",
".",
"Identity",
".",
"TLSConfig",
"(",
"t",
".",
"AuthServer",
".",
"CipherSuites",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"identity",
".",
"I",
"!=",
"nil",
"{",
"cert",
",",
"err",
":=",
"t",
".",
"AuthServer",
".",
"NewCertificate",
"(",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"Certificates",
"=",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"*",
"cert",
"}",
"\n",
"}",
"else",
"{",
"tlsConfig",
".",
"Certificates",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"tlsConfig",
",",
"nil",
"\n",
"}"
] |
// ClientTLSConfig returns client TLS config based on the identity
|
[
"ClientTLSConfig",
"returns",
"client",
"TLS",
"config",
"based",
"on",
"the",
"identity"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L537-L554
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
CloneClient
|
func (t *TestTLSServer) CloneClient(clt *Client) *Client {
addr := []utils.NetAddr{{Addr: t.Addr().String(), AddrNetwork: t.Addr().Network()}}
newClient, err := NewTLSClient(ClientConfig{Addrs: addr, TLS: clt.TLSConfig()})
if err != nil {
panic(err)
}
return newClient
}
|
go
|
func (t *TestTLSServer) CloneClient(clt *Client) *Client {
addr := []utils.NetAddr{{Addr: t.Addr().String(), AddrNetwork: t.Addr().Network()}}
newClient, err := NewTLSClient(ClientConfig{Addrs: addr, TLS: clt.TLSConfig()})
if err != nil {
panic(err)
}
return newClient
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"CloneClient",
"(",
"clt",
"*",
"Client",
")",
"*",
"Client",
"{",
"addr",
":=",
"[",
"]",
"utils",
".",
"NetAddr",
"{",
"{",
"Addr",
":",
"t",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
",",
"AddrNetwork",
":",
"t",
".",
"Addr",
"(",
")",
".",
"Network",
"(",
")",
"}",
"}",
"\n",
"newClient",
",",
"err",
":=",
"NewTLSClient",
"(",
"ClientConfig",
"{",
"Addrs",
":",
"addr",
",",
"TLS",
":",
"clt",
".",
"TLSConfig",
"(",
")",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"newClient",
"\n",
"}"
] |
// CloneClient uses the same credentials as the passed client
// but forces the client to be recreated
|
[
"CloneClient",
"uses",
"the",
"same",
"credentials",
"as",
"the",
"passed",
"client",
"but",
"forces",
"the",
"client",
"to",
"be",
"recreated"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L558-L565
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
NewClient
|
func (t *TestTLSServer) NewClient(identity TestIdentity) (*Client, error) {
tlsConfig, err := t.ClientTLSConfig(identity)
if err != nil {
return nil, trace.Wrap(err)
}
addrs := []utils.NetAddr{utils.FromAddr(t.Listener.Addr())}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
}
|
go
|
func (t *TestTLSServer) NewClient(identity TestIdentity) (*Client, error) {
tlsConfig, err := t.ClientTLSConfig(identity)
if err != nil {
return nil, trace.Wrap(err)
}
addrs := []utils.NetAddr{utils.FromAddr(t.Listener.Addr())}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"NewClient",
"(",
"identity",
"TestIdentity",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"tlsConfig",
",",
"err",
":=",
"t",
".",
"ClientTLSConfig",
"(",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"addrs",
":=",
"[",
"]",
"utils",
".",
"NetAddr",
"{",
"utils",
".",
"FromAddr",
"(",
"t",
".",
"Listener",
".",
"Addr",
"(",
")",
")",
"}",
"\n",
"return",
"NewTLSClient",
"(",
"ClientConfig",
"{",
"Addrs",
":",
"addrs",
",",
"TLS",
":",
"tlsConfig",
"}",
")",
"\n",
"}"
] |
// NewClient returns new client to test server authenticated with identity
|
[
"NewClient",
"returns",
"new",
"client",
"to",
"test",
"server",
"authenticated",
"with",
"identity"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L568-L575
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
Start
|
func (t *TestTLSServer) Start() error {
var err error
if t.Listener == nil {
t.Listener, err = net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return trace.Wrap(err)
}
}
go t.TLSServer.Serve(t.Listener)
return nil
}
|
go
|
func (t *TestTLSServer) Start() error {
var err error
if t.Listener == nil {
t.Listener, err = net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return trace.Wrap(err)
}
}
go t.TLSServer.Serve(t.Listener)
return nil
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"Start",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"t",
".",
"Listener",
"==",
"nil",
"{",
"t",
".",
"Listener",
",",
"err",
"=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"\"127.0.0.1:0\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"t",
".",
"TLSServer",
".",
"Serve",
"(",
"t",
".",
"Listener",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Start starts TLS server on loopback address on the first lisenting socket
|
[
"Start",
"starts",
"TLS",
"server",
"on",
"loopback",
"address",
"on",
"the",
"first",
"lisenting",
"socket"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L583-L593
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
Close
|
func (t *TestTLSServer) Close() error {
err := t.TLSServer.Close()
if t.Listener != nil {
t.Listener.Close()
}
if t.AuthServer.Backend != nil {
t.AuthServer.Backend.Close()
}
return err
}
|
go
|
func (t *TestTLSServer) Close() error {
err := t.TLSServer.Close()
if t.Listener != nil {
t.Listener.Close()
}
if t.AuthServer.Backend != nil {
t.AuthServer.Backend.Close()
}
return err
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"Close",
"(",
")",
"error",
"{",
"err",
":=",
"t",
".",
"TLSServer",
".",
"Close",
"(",
")",
"\n",
"if",
"t",
".",
"Listener",
"!=",
"nil",
"{",
"t",
".",
"Listener",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
"t",
".",
"AuthServer",
".",
"Backend",
"!=",
"nil",
"{",
"t",
".",
"AuthServer",
".",
"Backend",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Close closes the listener and HTTP server
|
[
"Close",
"closes",
"the",
"listener",
"and",
"HTTP",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L596-L605
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
Stop
|
func (t *TestTLSServer) Stop() error {
err := t.TLSServer.Close()
if t.Listener != nil {
t.Listener.Close()
}
return err
}
|
go
|
func (t *TestTLSServer) Stop() error {
err := t.TLSServer.Close()
if t.Listener != nil {
t.Listener.Close()
}
return err
}
|
[
"func",
"(",
"t",
"*",
"TestTLSServer",
")",
"Stop",
"(",
")",
"error",
"{",
"err",
":=",
"t",
".",
"TLSServer",
".",
"Close",
"(",
")",
"\n",
"if",
"t",
".",
"Listener",
"!=",
"nil",
"{",
"t",
".",
"Listener",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Stop stops listening server, but does not close the auth backend
|
[
"Stop",
"stops",
"listening",
"server",
"but",
"does",
"not",
"close",
"the",
"auth",
"backend"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L608-L614
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
NewServerIdentity
|
func NewServerIdentity(clt *AuthServer, hostID string, role teleport.Role) (*Identity, error) {
keys, err := clt.GenerateServerKeys(GenerateServerKeysRequest{
HostID: hostID,
NodeName: hostID,
Roles: teleport.Roles{teleport.RoleAuth},
})
if err != nil {
return nil, trace.Wrap(err)
}
return ReadIdentityFromKeyPair(keys)
}
|
go
|
func NewServerIdentity(clt *AuthServer, hostID string, role teleport.Role) (*Identity, error) {
keys, err := clt.GenerateServerKeys(GenerateServerKeysRequest{
HostID: hostID,
NodeName: hostID,
Roles: teleport.Roles{teleport.RoleAuth},
})
if err != nil {
return nil, trace.Wrap(err)
}
return ReadIdentityFromKeyPair(keys)
}
|
[
"func",
"NewServerIdentity",
"(",
"clt",
"*",
"AuthServer",
",",
"hostID",
"string",
",",
"role",
"teleport",
".",
"Role",
")",
"(",
"*",
"Identity",
",",
"error",
")",
"{",
"keys",
",",
"err",
":=",
"clt",
".",
"GenerateServerKeys",
"(",
"GenerateServerKeysRequest",
"{",
"HostID",
":",
"hostID",
",",
"NodeName",
":",
"hostID",
",",
"Roles",
":",
"teleport",
".",
"Roles",
"{",
"teleport",
".",
"RoleAuth",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ReadIdentityFromKeyPair",
"(",
"keys",
")",
"\n",
"}"
] |
// NewServerIdentity generates new server identity, used in tests
|
[
"NewServerIdentity",
"generates",
"new",
"server",
"identity",
"used",
"in",
"tests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L617-L627
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
CreateUserAndRole
|
func CreateUserAndRole(clt clt, username string, allowedLogins []string) (services.User, services.Role, error) {
user, err := services.NewUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
role := services.RoleForUser(user)
role.SetLogins(services.Allow, []string{user.GetName()})
err = clt.UpsertRole(role)
if err != nil {
return nil, nil, trace.Wrap(err)
}
user.AddRole(role.GetName())
err = clt.UpsertUser(user)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return user, role, nil
}
|
go
|
func CreateUserAndRole(clt clt, username string, allowedLogins []string) (services.User, services.Role, error) {
user, err := services.NewUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
role := services.RoleForUser(user)
role.SetLogins(services.Allow, []string{user.GetName()})
err = clt.UpsertRole(role)
if err != nil {
return nil, nil, trace.Wrap(err)
}
user.AddRole(role.GetName())
err = clt.UpsertUser(user)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return user, role, nil
}
|
[
"func",
"CreateUserAndRole",
"(",
"clt",
"clt",
",",
"username",
"string",
",",
"allowedLogins",
"[",
"]",
"string",
")",
"(",
"services",
".",
"User",
",",
"services",
".",
"Role",
",",
"error",
")",
"{",
"user",
",",
"err",
":=",
"services",
".",
"NewUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"role",
":=",
"services",
".",
"RoleForUser",
"(",
"user",
")",
"\n",
"role",
".",
"SetLogins",
"(",
"services",
".",
"Allow",
",",
"[",
"]",
"string",
"{",
"user",
".",
"GetName",
"(",
")",
"}",
")",
"\n",
"err",
"=",
"clt",
".",
"UpsertRole",
"(",
"role",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
".",
"AddRole",
"(",
"role",
".",
"GetName",
"(",
")",
")",
"\n",
"err",
"=",
"clt",
".",
"UpsertUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"user",
",",
"role",
",",
"nil",
"\n",
"}"
] |
// CreateUserAndRole creates user and role and assignes role to a user, used in tests
|
[
"CreateUserAndRole",
"creates",
"user",
"and",
"role",
"and",
"assignes",
"role",
"to",
"a",
"user",
"used",
"in",
"tests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L637-L654
|
train
|
gravitational/teleport
|
lib/auth/helpers.go
|
CreateUserAndRoleWithoutRoles
|
func CreateUserAndRoleWithoutRoles(clt clt, username string, allowedLogins []string) (services.User, services.Role, error) {
user, err := services.NewUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
role := services.RoleForUser(user)
set := services.MakeRuleSet(role.GetRules(services.Allow))
delete(set, services.KindRole)
role.SetRules(services.Allow, set.Slice())
role.SetLogins(services.Allow, []string{user.GetName()})
err = clt.UpsertRole(role)
if err != nil {
return nil, nil, trace.Wrap(err)
}
user.AddRole(role.GetName())
err = clt.UpsertUser(user)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return user, role, nil
}
|
go
|
func CreateUserAndRoleWithoutRoles(clt clt, username string, allowedLogins []string) (services.User, services.Role, error) {
user, err := services.NewUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
role := services.RoleForUser(user)
set := services.MakeRuleSet(role.GetRules(services.Allow))
delete(set, services.KindRole)
role.SetRules(services.Allow, set.Slice())
role.SetLogins(services.Allow, []string{user.GetName()})
err = clt.UpsertRole(role)
if err != nil {
return nil, nil, trace.Wrap(err)
}
user.AddRole(role.GetName())
err = clt.UpsertUser(user)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return user, role, nil
}
|
[
"func",
"CreateUserAndRoleWithoutRoles",
"(",
"clt",
"clt",
",",
"username",
"string",
",",
"allowedLogins",
"[",
"]",
"string",
")",
"(",
"services",
".",
"User",
",",
"services",
".",
"Role",
",",
"error",
")",
"{",
"user",
",",
"err",
":=",
"services",
".",
"NewUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"role",
":=",
"services",
".",
"RoleForUser",
"(",
"user",
")",
"\n",
"set",
":=",
"services",
".",
"MakeRuleSet",
"(",
"role",
".",
"GetRules",
"(",
"services",
".",
"Allow",
")",
")",
"\n",
"delete",
"(",
"set",
",",
"services",
".",
"KindRole",
")",
"\n",
"role",
".",
"SetRules",
"(",
"services",
".",
"Allow",
",",
"set",
".",
"Slice",
"(",
")",
")",
"\n",
"role",
".",
"SetLogins",
"(",
"services",
".",
"Allow",
",",
"[",
"]",
"string",
"{",
"user",
".",
"GetName",
"(",
")",
"}",
")",
"\n",
"err",
"=",
"clt",
".",
"UpsertRole",
"(",
"role",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
".",
"AddRole",
"(",
"role",
".",
"GetName",
"(",
")",
")",
"\n",
"err",
"=",
"clt",
".",
"UpsertUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"user",
",",
"role",
",",
"nil",
"\n",
"}"
] |
// CreateUserAndRoleWithoutRoles creates user and role, but does not assign user to a role, used in tests
|
[
"CreateUserAndRoleWithoutRoles",
"creates",
"user",
"and",
"role",
"but",
"does",
"not",
"assign",
"user",
"to",
"a",
"role",
"used",
"in",
"tests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/helpers.go#L657-L680
|
train
|
gravitational/teleport
|
lib/events/uploader.go
|
CheckAndSetDefaults
|
func (cfg *UploaderConfig) CheckAndSetDefaults() error {
if cfg.ServerID == "" {
return trace.BadParameter("missing parameter ServerID")
}
if cfg.AuditLog == nil {
return trace.BadParameter("missing parameter AuditLog")
}
if cfg.DataDir == "" {
return trace.BadParameter("missing parameter DataDir")
}
if cfg.Namespace == "" {
return trace.BadParameter("missing parameter Namespace")
}
if cfg.ConcurrentUploads <= 0 {
cfg.ConcurrentUploads = defaults.UploaderConcurrentUploads
}
if cfg.ScanPeriod <= 0 {
cfg.ScanPeriod = defaults.UploaderScanPeriod
}
if cfg.Context == nil {
cfg.Context = context.TODO()
}
if cfg.Clock == nil {
cfg.Clock = clockwork.NewRealClock()
}
return nil
}
|
go
|
func (cfg *UploaderConfig) CheckAndSetDefaults() error {
if cfg.ServerID == "" {
return trace.BadParameter("missing parameter ServerID")
}
if cfg.AuditLog == nil {
return trace.BadParameter("missing parameter AuditLog")
}
if cfg.DataDir == "" {
return trace.BadParameter("missing parameter DataDir")
}
if cfg.Namespace == "" {
return trace.BadParameter("missing parameter Namespace")
}
if cfg.ConcurrentUploads <= 0 {
cfg.ConcurrentUploads = defaults.UploaderConcurrentUploads
}
if cfg.ScanPeriod <= 0 {
cfg.ScanPeriod = defaults.UploaderScanPeriod
}
if cfg.Context == nil {
cfg.Context = context.TODO()
}
if cfg.Clock == nil {
cfg.Clock = clockwork.NewRealClock()
}
return nil
}
|
[
"func",
"(",
"cfg",
"*",
"UploaderConfig",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"cfg",
".",
"ServerID",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter ServerID\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"AuditLog",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter AuditLog\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"DataDir",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter DataDir\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Namespace\"",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ConcurrentUploads",
"<=",
"0",
"{",
"cfg",
".",
"ConcurrentUploads",
"=",
"defaults",
".",
"UploaderConcurrentUploads",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ScanPeriod",
"<=",
"0",
"{",
"cfg",
".",
"ScanPeriod",
"=",
"defaults",
".",
"UploaderScanPeriod",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Context",
"==",
"nil",
"{",
"cfg",
".",
"Context",
"=",
"context",
".",
"TODO",
"(",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Clock",
"==",
"nil",
"{",
"cfg",
".",
"Clock",
"=",
"clockwork",
".",
"NewRealClock",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckAndSetDefaults checks and sets default values of UploaderConfig
|
[
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"values",
"of",
"UploaderConfig"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/uploader.go#L80-L106
|
train
|
gravitational/teleport
|
lib/events/uploader.go
|
NewUploader
|
func NewUploader(cfg UploaderConfig) (*Uploader, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
uploader := &Uploader{
UploaderConfig: cfg,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentAuditLog,
}),
cancel: cancel,
ctx: ctx,
semaphore: make(chan struct{}, cfg.ConcurrentUploads),
scanDir: filepath.Join(cfg.DataDir, cfg.ServerID, SessionLogsDir, cfg.Namespace),
}
return uploader, nil
}
|
go
|
func NewUploader(cfg UploaderConfig) (*Uploader, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
uploader := &Uploader{
UploaderConfig: cfg,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentAuditLog,
}),
cancel: cancel,
ctx: ctx,
semaphore: make(chan struct{}, cfg.ConcurrentUploads),
scanDir: filepath.Join(cfg.DataDir, cfg.ServerID, SessionLogsDir, cfg.Namespace),
}
return uploader, nil
}
|
[
"func",
"NewUploader",
"(",
"cfg",
"UploaderConfig",
")",
"(",
"*",
"Uploader",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"cfg",
".",
"Context",
")",
"\n",
"uploader",
":=",
"&",
"Uploader",
"{",
"UploaderConfig",
":",
"cfg",
",",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentAuditLog",
",",
"}",
")",
",",
"cancel",
":",
"cancel",
",",
"ctx",
":",
"ctx",
",",
"semaphore",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"cfg",
".",
"ConcurrentUploads",
")",
",",
"scanDir",
":",
"filepath",
".",
"Join",
"(",
"cfg",
".",
"DataDir",
",",
"cfg",
".",
"ServerID",
",",
"SessionLogsDir",
",",
"cfg",
".",
"Namespace",
")",
",",
"}",
"\n",
"return",
"uploader",
",",
"nil",
"\n",
"}"
] |
// NewUploader creates new disk based session logger
|
[
"NewUploader",
"creates",
"new",
"disk",
"based",
"session",
"logger"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/uploader.go#L109-L126
|
train
|
gravitational/teleport
|
lib/events/uploader.go
|
Scan
|
func (u *Uploader) Scan() error {
df, err := os.Open(u.scanDir)
err = trace.ConvertSystemError(err)
if err != nil {
return trace.Wrap(err)
}
defer df.Close()
entries, err := df.Readdir(-1)
if err != nil {
return trace.ConvertSystemError(err)
}
var count int
for i := range entries {
fi := entries[i]
if fi.IsDir() {
continue
}
if !strings.HasSuffix(fi.Name(), "completed") {
continue
}
parts := strings.Split(fi.Name(), ".")
if len(parts) < 2 {
u.Debugf("Uploader, skipping unknown file: %v", fi.Name())
continue
}
sessionID := session.ID(parts[0])
lockFilePath := filepath.Join(u.scanDir, fi.Name())
if err := u.uploadFile(lockFilePath, sessionID); err != nil {
if trace.IsCompareFailed(err) {
u.Debugf("Uploader detected locked file %v, another process is uploading it.", lockFilePath)
continue
}
return trace.Wrap(err)
}
count += 1
}
return nil
}
|
go
|
func (u *Uploader) Scan() error {
df, err := os.Open(u.scanDir)
err = trace.ConvertSystemError(err)
if err != nil {
return trace.Wrap(err)
}
defer df.Close()
entries, err := df.Readdir(-1)
if err != nil {
return trace.ConvertSystemError(err)
}
var count int
for i := range entries {
fi := entries[i]
if fi.IsDir() {
continue
}
if !strings.HasSuffix(fi.Name(), "completed") {
continue
}
parts := strings.Split(fi.Name(), ".")
if len(parts) < 2 {
u.Debugf("Uploader, skipping unknown file: %v", fi.Name())
continue
}
sessionID := session.ID(parts[0])
lockFilePath := filepath.Join(u.scanDir, fi.Name())
if err := u.uploadFile(lockFilePath, sessionID); err != nil {
if trace.IsCompareFailed(err) {
u.Debugf("Uploader detected locked file %v, another process is uploading it.", lockFilePath)
continue
}
return trace.Wrap(err)
}
count += 1
}
return nil
}
|
[
"func",
"(",
"u",
"*",
"Uploader",
")",
"Scan",
"(",
")",
"error",
"{",
"df",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"u",
".",
"scanDir",
")",
"\n",
"err",
"=",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"df",
".",
"Close",
"(",
")",
"\n",
"entries",
",",
"err",
":=",
"df",
".",
"Readdir",
"(",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"count",
"int",
"\n",
"for",
"i",
":=",
"range",
"entries",
"{",
"fi",
":=",
"entries",
"[",
"i",
"]",
"\n",
"if",
"fi",
".",
"IsDir",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"fi",
".",
"Name",
"(",
")",
",",
"\"completed\"",
")",
"{",
"continue",
"\n",
"}",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"fi",
".",
"Name",
"(",
")",
",",
"\".\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"<",
"2",
"{",
"u",
".",
"Debugf",
"(",
"\"Uploader, skipping unknown file: %v\"",
",",
"fi",
".",
"Name",
"(",
")",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"sessionID",
":=",
"session",
".",
"ID",
"(",
"parts",
"[",
"0",
"]",
")",
"\n",
"lockFilePath",
":=",
"filepath",
".",
"Join",
"(",
"u",
".",
"scanDir",
",",
"fi",
".",
"Name",
"(",
")",
")",
"\n",
"if",
"err",
":=",
"u",
".",
"uploadFile",
"(",
"lockFilePath",
",",
"sessionID",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsCompareFailed",
"(",
"err",
")",
"{",
"u",
".",
"Debugf",
"(",
"\"Uploader detected locked file %v, another process is uploading it.\"",
",",
"lockFilePath",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"count",
"+=",
"1",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Scan scans the directory and uploads recordings
|
[
"Scan",
"scans",
"the",
"directory",
"and",
"uploads",
"recordings"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/uploader.go#L272-L309
|
train
|
gravitational/teleport
|
lib/client/api.go
|
MakeDefaultConfig
|
func MakeDefaultConfig() *Config {
return &Config{
Stdout: os.Stdout,
Stderr: os.Stderr,
Stdin: os.Stdin,
}
}
|
go
|
func MakeDefaultConfig() *Config {
return &Config{
Stdout: os.Stdout,
Stderr: os.Stderr,
Stdin: os.Stdin,
}
}
|
[
"func",
"MakeDefaultConfig",
"(",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"Stdout",
":",
"os",
".",
"Stdout",
",",
"Stderr",
":",
"os",
".",
"Stderr",
",",
"Stdin",
":",
"os",
".",
"Stdin",
",",
"}",
"\n",
"}"
] |
// MakeDefaultConfig returns default client config
|
[
"MakeDefaultConfig",
"returns",
"default",
"client",
"config"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L255-L261
|
train
|
gravitational/teleport
|
lib/client/api.go
|
IsExpired
|
func (p *ProfileStatus) IsExpired(clock clockwork.Clock) bool {
return p.ValidUntil.Sub(clock.Now()) <= 0
}
|
go
|
func (p *ProfileStatus) IsExpired(clock clockwork.Clock) bool {
return p.ValidUntil.Sub(clock.Now()) <= 0
}
|
[
"func",
"(",
"p",
"*",
"ProfileStatus",
")",
"IsExpired",
"(",
"clock",
"clockwork",
".",
"Clock",
")",
"bool",
"{",
"return",
"p",
".",
"ValidUntil",
".",
"Sub",
"(",
"clock",
".",
"Now",
"(",
")",
")",
"<=",
"0",
"\n",
"}"
] |
// IsExpired returns true if profile is not expired yet
|
[
"IsExpired",
"returns",
"true",
"if",
"profile",
"is",
"not",
"expired",
"yet"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L289-L291
|
train
|
gravitational/teleport
|
lib/client/api.go
|
RetryWithRelogin
|
func RetryWithRelogin(ctx context.Context, tc *TeleportClient, fn func() error) error {
err := fn()
if err == nil {
return nil
}
// Assume that failed handshake is a result of expired credentials,
// retry the login procedure
if !utils.IsHandshakeFailedError(err) && !utils.IsCertExpiredError(err) && !trace.IsBadParameter(err) && trace.IsTrustError(err) {
return err
}
key, err := tc.Login(ctx, true)
if err != nil {
if trace.IsTrustError(err) {
return trace.Wrap(err, "refusing to connect to untrusted proxy %v without --insecure flag\n", tc.Config.SSHProxyAddr)
}
return trace.Wrap(err)
}
// Save profile to record proxy credentials
if err := tc.SaveProfile(key.ProxyHost, "", ProfileCreateNew|ProfileMakeCurrent); err != nil {
log.Warningf("Failed to save profile: %v", err)
return trace.Wrap(err)
}
// Override client's auth methods, current cluster and user name
authMethod, err := key.AsAuthMethod()
if err != nil {
return trace.Wrap(err)
}
// After successful login we have local agent updated with latest
// and greatest auth information, setup client to try only this new
// method fetched from key, to isolate the retry
tc.Config.AuthMethods = []ssh.AuthMethod{authMethod}
return fn()
}
|
go
|
func RetryWithRelogin(ctx context.Context, tc *TeleportClient, fn func() error) error {
err := fn()
if err == nil {
return nil
}
// Assume that failed handshake is a result of expired credentials,
// retry the login procedure
if !utils.IsHandshakeFailedError(err) && !utils.IsCertExpiredError(err) && !trace.IsBadParameter(err) && trace.IsTrustError(err) {
return err
}
key, err := tc.Login(ctx, true)
if err != nil {
if trace.IsTrustError(err) {
return trace.Wrap(err, "refusing to connect to untrusted proxy %v without --insecure flag\n", tc.Config.SSHProxyAddr)
}
return trace.Wrap(err)
}
// Save profile to record proxy credentials
if err := tc.SaveProfile(key.ProxyHost, "", ProfileCreateNew|ProfileMakeCurrent); err != nil {
log.Warningf("Failed to save profile: %v", err)
return trace.Wrap(err)
}
// Override client's auth methods, current cluster and user name
authMethod, err := key.AsAuthMethod()
if err != nil {
return trace.Wrap(err)
}
// After successful login we have local agent updated with latest
// and greatest auth information, setup client to try only this new
// method fetched from key, to isolate the retry
tc.Config.AuthMethods = []ssh.AuthMethod{authMethod}
return fn()
}
|
[
"func",
"RetryWithRelogin",
"(",
"ctx",
"context",
".",
"Context",
",",
"tc",
"*",
"TeleportClient",
",",
"fn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"err",
":=",
"fn",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"utils",
".",
"IsHandshakeFailedError",
"(",
"err",
")",
"&&",
"!",
"utils",
".",
"IsCertExpiredError",
"(",
"err",
")",
"&&",
"!",
"trace",
".",
"IsBadParameter",
"(",
"err",
")",
"&&",
"trace",
".",
"IsTrustError",
"(",
"err",
")",
"{",
"return",
"err",
"\n",
"}",
"\n",
"key",
",",
"err",
":=",
"tc",
".",
"Login",
"(",
"ctx",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsTrustError",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"refusing to connect to untrusted proxy %v without --insecure flag\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"tc",
".",
"Config",
".",
"SSHProxyAddr",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"if",
"err",
":=",
"tc",
".",
"SaveProfile",
"(",
"key",
".",
"ProxyHost",
",",
"\"\"",
",",
"ProfileCreateNew",
"|",
"ProfileMakeCurrent",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"Failed to save profile: %v\"",
",",
"err",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authMethod",
",",
"err",
":=",
"key",
".",
"AsAuthMethod",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tc",
".",
"Config",
".",
"AuthMethods",
"=",
"[",
"]",
"ssh",
".",
"AuthMethod",
"{",
"authMethod",
"}",
"\n",
"}"
] |
// RetryWithRelogin is a helper error handling method,
// attempts to relogin and retry the function once
|
[
"RetryWithRelogin",
"is",
"a",
"helper",
"error",
"handling",
"method",
"attempts",
"to",
"relogin",
"and",
"retry",
"the",
"function",
"once"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L295-L327
|
train
|
gravitational/teleport
|
lib/client/api.go
|
fullProfileName
|
func fullProfileName(profileDir string, proxyHost string) (string, error) {
var err error
var profileName string
// If no profile name was passed in, try and extract the active profile from
// the ~/.tsh/profile symlink. If one was passed in, append .yaml to name.
if proxyHost == "" {
profileName, err = os.Readlink(filepath.Join(profileDir, "profile"))
if err != nil {
return "", trace.ConvertSystemError(err)
}
} else {
profileName = proxyHost + ".yaml"
}
// Make sure the profile requested actually exists.
_, err = os.Stat(filepath.Join(profileDir, profileName))
if err != nil {
return "", trace.ConvertSystemError(err)
}
return profileName, nil
}
|
go
|
func fullProfileName(profileDir string, proxyHost string) (string, error) {
var err error
var profileName string
// If no profile name was passed in, try and extract the active profile from
// the ~/.tsh/profile symlink. If one was passed in, append .yaml to name.
if proxyHost == "" {
profileName, err = os.Readlink(filepath.Join(profileDir, "profile"))
if err != nil {
return "", trace.ConvertSystemError(err)
}
} else {
profileName = proxyHost + ".yaml"
}
// Make sure the profile requested actually exists.
_, err = os.Stat(filepath.Join(profileDir, profileName))
if err != nil {
return "", trace.ConvertSystemError(err)
}
return profileName, nil
}
|
[
"func",
"fullProfileName",
"(",
"profileDir",
"string",
",",
"proxyHost",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"profileName",
"string",
"\n",
"if",
"proxyHost",
"==",
"\"\"",
"{",
"profileName",
",",
"err",
"=",
"os",
".",
"Readlink",
"(",
"filepath",
".",
"Join",
"(",
"profileDir",
",",
"\"profile\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"profileName",
"=",
"proxyHost",
"+",
"\".yaml\"",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"profileDir",
",",
"profileName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"profileName",
",",
"nil",
"\n",
"}"
] |
// fullProfileName takes a profile directory and the host the user is trying
// to connect to and returns the name of the profile file.
|
[
"fullProfileName",
"takes",
"a",
"profile",
"directory",
"and",
"the",
"host",
"the",
"user",
"is",
"trying",
"to",
"connect",
"to",
"and",
"returns",
"the",
"name",
"of",
"the",
"profile",
"file",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L401-L423
|
train
|
gravitational/teleport
|
lib/client/api.go
|
Status
|
func Status(profileDir string, proxyHost string) (*ProfileStatus, []*ProfileStatus, error) {
var err error
var profile *ProfileStatus
var others []*ProfileStatus
// remove ports from proxy host, because profile name is stored
// by host name
if proxyHost != "" {
proxyHost, err = utils.Host(proxyHost)
if err != nil {
return nil, nil, trace.Wrap(err)
}
}
// Construct the full path to the profile requested and make sure it exists.
profileDir = FullProfilePath(profileDir)
stat, err := os.Stat(profileDir)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if !stat.IsDir() {
return nil, nil, trace.BadParameter("profile path not a directory")
}
// Construct the name of the profile requested. If an empty string was
// passed in, the name of the active profile will be extracted from the
// ~/.tsh/profile symlink.
profileName, err := fullProfileName(profileDir, proxyHost)
if err != nil {
if trace.IsNotFound(err) {
return nil, nil, trace.NotFound("not logged in")
}
return nil, nil, trace.Wrap(err)
}
// Read in the active profile first. If readProfile returns trace.NotFound,
// that means the profile may have been corrupted (for example keys were
// deleted but profile exists), treat this as the user not being logged in.
profile, err = readProfile(profileDir, profileName)
if err != nil {
if !trace.IsNotFound(err) {
return nil, nil, trace.Wrap(err)
}
// Make sure the profile is nil, which tsh uses to detect that no
// active profile exists.
profile = nil
}
// Next, get list of all other available profiles. Filter out logged in
// profile if it exists and return a slice of *ProfileStatus.
files, err := ioutil.ReadDir(profileDir)
if err != nil {
return nil, nil, trace.Wrap(err)
}
for _, file := range files {
if file.IsDir() {
continue
}
if file.Mode()&os.ModeSymlink != 0 {
continue
}
if !strings.HasSuffix(file.Name(), ".yaml") {
continue
}
if file.Name() == profileName {
continue
}
ps, err := readProfile(profileDir, file.Name())
if err != nil {
// parts of profile are missing?
// status skips these files
if trace.IsNotFound(err) {
continue
}
return nil, nil, trace.Wrap(err)
}
others = append(others, ps)
}
return profile, others, nil
}
|
go
|
func Status(profileDir string, proxyHost string) (*ProfileStatus, []*ProfileStatus, error) {
var err error
var profile *ProfileStatus
var others []*ProfileStatus
// remove ports from proxy host, because profile name is stored
// by host name
if proxyHost != "" {
proxyHost, err = utils.Host(proxyHost)
if err != nil {
return nil, nil, trace.Wrap(err)
}
}
// Construct the full path to the profile requested and make sure it exists.
profileDir = FullProfilePath(profileDir)
stat, err := os.Stat(profileDir)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if !stat.IsDir() {
return nil, nil, trace.BadParameter("profile path not a directory")
}
// Construct the name of the profile requested. If an empty string was
// passed in, the name of the active profile will be extracted from the
// ~/.tsh/profile symlink.
profileName, err := fullProfileName(profileDir, proxyHost)
if err != nil {
if trace.IsNotFound(err) {
return nil, nil, trace.NotFound("not logged in")
}
return nil, nil, trace.Wrap(err)
}
// Read in the active profile first. If readProfile returns trace.NotFound,
// that means the profile may have been corrupted (for example keys were
// deleted but profile exists), treat this as the user not being logged in.
profile, err = readProfile(profileDir, profileName)
if err != nil {
if !trace.IsNotFound(err) {
return nil, nil, trace.Wrap(err)
}
// Make sure the profile is nil, which tsh uses to detect that no
// active profile exists.
profile = nil
}
// Next, get list of all other available profiles. Filter out logged in
// profile if it exists and return a slice of *ProfileStatus.
files, err := ioutil.ReadDir(profileDir)
if err != nil {
return nil, nil, trace.Wrap(err)
}
for _, file := range files {
if file.IsDir() {
continue
}
if file.Mode()&os.ModeSymlink != 0 {
continue
}
if !strings.HasSuffix(file.Name(), ".yaml") {
continue
}
if file.Name() == profileName {
continue
}
ps, err := readProfile(profileDir, file.Name())
if err != nil {
// parts of profile are missing?
// status skips these files
if trace.IsNotFound(err) {
continue
}
return nil, nil, trace.Wrap(err)
}
others = append(others, ps)
}
return profile, others, nil
}
|
[
"func",
"Status",
"(",
"profileDir",
"string",
",",
"proxyHost",
"string",
")",
"(",
"*",
"ProfileStatus",
",",
"[",
"]",
"*",
"ProfileStatus",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"profile",
"*",
"ProfileStatus",
"\n",
"var",
"others",
"[",
"]",
"*",
"ProfileStatus",
"\n",
"if",
"proxyHost",
"!=",
"\"\"",
"{",
"proxyHost",
",",
"err",
"=",
"utils",
".",
"Host",
"(",
"proxyHost",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"profileDir",
"=",
"FullProfilePath",
"(",
"profileDir",
")",
"\n",
"stat",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"profileDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"stat",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"profile path not a directory\"",
")",
"\n",
"}",
"\n",
"profileName",
",",
"err",
":=",
"fullProfileName",
"(",
"profileDir",
",",
"proxyHost",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"not logged in\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"profile",
",",
"err",
"=",
"readProfile",
"(",
"profileDir",
",",
"profileName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"profile",
"=",
"nil",
"\n",
"}",
"\n",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"profileDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"if",
"file",
".",
"IsDir",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"file",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"!=",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"file",
".",
"Name",
"(",
")",
",",
"\".yaml\"",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"file",
".",
"Name",
"(",
")",
"==",
"profileName",
"{",
"continue",
"\n",
"}",
"\n",
"ps",
",",
"err",
":=",
"readProfile",
"(",
"profileDir",
",",
"file",
".",
"Name",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"others",
"=",
"append",
"(",
"others",
",",
"ps",
")",
"\n",
"}",
"\n",
"return",
"profile",
",",
"others",
",",
"nil",
"\n",
"}"
] |
// Status returns the active profile as well as a list of available profiles.
|
[
"Status",
"returns",
"the",
"active",
"profile",
"as",
"well",
"as",
"a",
"list",
"of",
"available",
"profiles",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L426-L506
|
train
|
gravitational/teleport
|
lib/client/api.go
|
KubeProxyHostPort
|
func (c *Config) KubeProxyHostPort() (string, int) {
if c.KubeProxyAddr != "" {
addr, err := utils.ParseAddr(c.KubeProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.KubeProxyListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.KubeProxyListenPort
}
|
go
|
func (c *Config) KubeProxyHostPort() (string, int) {
if c.KubeProxyAddr != "" {
addr, err := utils.ParseAddr(c.KubeProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.KubeProxyListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.KubeProxyListenPort
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"KubeProxyHostPort",
"(",
")",
"(",
"string",
",",
"int",
")",
"{",
"if",
"c",
".",
"KubeProxyAddr",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"c",
".",
"KubeProxyAddr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"addr",
".",
"Host",
"(",
")",
",",
"addr",
".",
"Port",
"(",
"defaults",
".",
"KubeProxyListenPort",
")",
"\n",
"}",
"\n",
"}",
"\n",
"webProxyHost",
",",
"_",
":=",
"c",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"return",
"webProxyHost",
",",
"defaults",
".",
"KubeProxyListenPort",
"\n",
"}"
] |
// KubeProxyHostPort returns the host and port of the Kubernetes proxy.
|
[
"KubeProxyHostPort",
"returns",
"the",
"host",
"and",
"port",
"of",
"the",
"Kubernetes",
"proxy",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L656-L666
|
train
|
gravitational/teleport
|
lib/client/api.go
|
WebProxyHostPort
|
func (c *Config) WebProxyHostPort() (string, int) {
if c.WebProxyAddr != "" {
addr, err := utils.ParseAddr(c.WebProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.HTTPListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.HTTPListenPort
}
|
go
|
func (c *Config) WebProxyHostPort() (string, int) {
if c.WebProxyAddr != "" {
addr, err := utils.ParseAddr(c.WebProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.HTTPListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.HTTPListenPort
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"WebProxyHostPort",
"(",
")",
"(",
"string",
",",
"int",
")",
"{",
"if",
"c",
".",
"WebProxyAddr",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"c",
".",
"WebProxyAddr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"addr",
".",
"Host",
"(",
")",
",",
"addr",
".",
"Port",
"(",
"defaults",
".",
"HTTPListenPort",
")",
"\n",
"}",
"\n",
"}",
"\n",
"webProxyHost",
",",
"_",
":=",
"c",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"return",
"webProxyHost",
",",
"defaults",
".",
"HTTPListenPort",
"\n",
"}"
] |
// WebProxyHostPort returns the host and port of the web proxy.
|
[
"WebProxyHostPort",
"returns",
"the",
"host",
"and",
"port",
"of",
"the",
"web",
"proxy",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L669-L679
|
train
|
gravitational/teleport
|
lib/client/api.go
|
SSHProxyHostPort
|
func (c *Config) SSHProxyHostPort() (string, int) {
if c.SSHProxyAddr != "" {
addr, err := utils.ParseAddr(c.SSHProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.SSHProxyListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.SSHProxyListenPort
}
|
go
|
func (c *Config) SSHProxyHostPort() (string, int) {
if c.SSHProxyAddr != "" {
addr, err := utils.ParseAddr(c.SSHProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.SSHProxyListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.SSHProxyListenPort
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"SSHProxyHostPort",
"(",
")",
"(",
"string",
",",
"int",
")",
"{",
"if",
"c",
".",
"SSHProxyAddr",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"c",
".",
"SSHProxyAddr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"addr",
".",
"Host",
"(",
")",
",",
"addr",
".",
"Port",
"(",
"defaults",
".",
"SSHProxyListenPort",
")",
"\n",
"}",
"\n",
"}",
"\n",
"webProxyHost",
",",
"_",
":=",
"c",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"return",
"webProxyHost",
",",
"defaults",
".",
"SSHProxyListenPort",
"\n",
"}"
] |
// SSHProxyHostPort returns the host and port of the SSH proxy.
|
[
"SSHProxyHostPort",
"returns",
"the",
"host",
"and",
"port",
"of",
"the",
"SSH",
"proxy",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L682-L692
|
train
|
gravitational/teleport
|
lib/client/api.go
|
NewClient
|
func NewClient(c *Config) (tc *TeleportClient, err error) {
// validate configuration
if c.Username == "" {
c.Username, err = Username()
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof("No teleport login given. defaulting to %s", c.Username)
}
if c.WebProxyAddr == "" {
return nil, trace.BadParameter("No proxy address specified, missed --proxy flag?")
}
if c.HostLogin == "" {
c.HostLogin, err = Username()
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof("no host login given. defaulting to %s", c.HostLogin)
}
if c.KeyTTL == 0 {
c.KeyTTL = defaults.CertDuration
}
c.Namespace = services.ProcessNamespace(c.Namespace)
tc = &TeleportClient{Config: *c}
if tc.Stdout == nil {
tc.Stdout = os.Stdout
}
if tc.Stderr == nil {
tc.Stderr = os.Stderr
}
if tc.Stdin == nil {
tc.Stdin = os.Stdin
}
// Create a buffered channel to hold events that occurred during this session.
// This channel must be buffered because the SSH connection directly feeds
// into it. Delays in pulling messages off the global SSH request channel
// could lead to the connection hanging.
tc.eventsCh = make(chan events.EventFields, 1024)
// Create a client that can be used for the initial fetch of credentials.
tc.credClient, err = NewCredentialsClient(
c.WebProxyAddr,
c.InsecureSkipVerify,
loopbackPool(c.WebProxyAddr))
if err != nil {
return nil, trace.Wrap(err)
}
// sometimes we need to use external auth without using local auth
// methods, e.g. in automation daemons
if c.SkipLocalAuth {
if len(c.AuthMethods) == 0 {
return nil, trace.BadParameter("SkipLocalAuth is true but no AuthMethods provided")
}
// if the client was passed an agent in the configuration and skip local auth, use
// the passed in agent.
if c.Agent != nil {
tc.localAgent = &LocalKeyAgent{Agent: c.Agent}
}
} else {
// initialize the local agent (auth agent which uses local SSH keys signed by the CA):
webProxyHost, _ := tc.WebProxyHostPort()
tc.localAgent, err = NewLocalAgent(c.KeysDir, webProxyHost, c.Username)
if err != nil {
return nil, trace.Wrap(err)
}
if tc.HostKeyCallback == nil {
tc.HostKeyCallback = tc.localAgent.CheckHostSignature
}
}
return tc, nil
}
|
go
|
func NewClient(c *Config) (tc *TeleportClient, err error) {
// validate configuration
if c.Username == "" {
c.Username, err = Username()
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof("No teleport login given. defaulting to %s", c.Username)
}
if c.WebProxyAddr == "" {
return nil, trace.BadParameter("No proxy address specified, missed --proxy flag?")
}
if c.HostLogin == "" {
c.HostLogin, err = Username()
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof("no host login given. defaulting to %s", c.HostLogin)
}
if c.KeyTTL == 0 {
c.KeyTTL = defaults.CertDuration
}
c.Namespace = services.ProcessNamespace(c.Namespace)
tc = &TeleportClient{Config: *c}
if tc.Stdout == nil {
tc.Stdout = os.Stdout
}
if tc.Stderr == nil {
tc.Stderr = os.Stderr
}
if tc.Stdin == nil {
tc.Stdin = os.Stdin
}
// Create a buffered channel to hold events that occurred during this session.
// This channel must be buffered because the SSH connection directly feeds
// into it. Delays in pulling messages off the global SSH request channel
// could lead to the connection hanging.
tc.eventsCh = make(chan events.EventFields, 1024)
// Create a client that can be used for the initial fetch of credentials.
tc.credClient, err = NewCredentialsClient(
c.WebProxyAddr,
c.InsecureSkipVerify,
loopbackPool(c.WebProxyAddr))
if err != nil {
return nil, trace.Wrap(err)
}
// sometimes we need to use external auth without using local auth
// methods, e.g. in automation daemons
if c.SkipLocalAuth {
if len(c.AuthMethods) == 0 {
return nil, trace.BadParameter("SkipLocalAuth is true but no AuthMethods provided")
}
// if the client was passed an agent in the configuration and skip local auth, use
// the passed in agent.
if c.Agent != nil {
tc.localAgent = &LocalKeyAgent{Agent: c.Agent}
}
} else {
// initialize the local agent (auth agent which uses local SSH keys signed by the CA):
webProxyHost, _ := tc.WebProxyHostPort()
tc.localAgent, err = NewLocalAgent(c.KeysDir, webProxyHost, c.Username)
if err != nil {
return nil, trace.Wrap(err)
}
if tc.HostKeyCallback == nil {
tc.HostKeyCallback = tc.localAgent.CheckHostSignature
}
}
return tc, nil
}
|
[
"func",
"NewClient",
"(",
"c",
"*",
"Config",
")",
"(",
"tc",
"*",
"TeleportClient",
",",
"err",
"error",
")",
"{",
"if",
"c",
".",
"Username",
"==",
"\"\"",
"{",
"c",
".",
"Username",
",",
"err",
"=",
"Username",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"No teleport login given. defaulting to %s\"",
",",
"c",
".",
"Username",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"WebProxyAddr",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"No proxy address specified, missed --proxy flag?\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"HostLogin",
"==",
"\"\"",
"{",
"c",
".",
"HostLogin",
",",
"err",
"=",
"Username",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"no host login given. defaulting to %s\"",
",",
"c",
".",
"HostLogin",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"KeyTTL",
"==",
"0",
"{",
"c",
".",
"KeyTTL",
"=",
"defaults",
".",
"CertDuration",
"\n",
"}",
"\n",
"c",
".",
"Namespace",
"=",
"services",
".",
"ProcessNamespace",
"(",
"c",
".",
"Namespace",
")",
"\n",
"tc",
"=",
"&",
"TeleportClient",
"{",
"Config",
":",
"*",
"c",
"}",
"\n",
"if",
"tc",
".",
"Stdout",
"==",
"nil",
"{",
"tc",
".",
"Stdout",
"=",
"os",
".",
"Stdout",
"\n",
"}",
"\n",
"if",
"tc",
".",
"Stderr",
"==",
"nil",
"{",
"tc",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"}",
"\n",
"if",
"tc",
".",
"Stdin",
"==",
"nil",
"{",
"tc",
".",
"Stdin",
"=",
"os",
".",
"Stdin",
"\n",
"}",
"\n",
"tc",
".",
"eventsCh",
"=",
"make",
"(",
"chan",
"events",
".",
"EventFields",
",",
"1024",
")",
"\n",
"tc",
".",
"credClient",
",",
"err",
"=",
"NewCredentialsClient",
"(",
"c",
".",
"WebProxyAddr",
",",
"c",
".",
"InsecureSkipVerify",
",",
"loopbackPool",
"(",
"c",
".",
"WebProxyAddr",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"SkipLocalAuth",
"{",
"if",
"len",
"(",
"c",
".",
"AuthMethods",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"SkipLocalAuth is true but no AuthMethods provided\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Agent",
"!=",
"nil",
"{",
"tc",
".",
"localAgent",
"=",
"&",
"LocalKeyAgent",
"{",
"Agent",
":",
"c",
".",
"Agent",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"webProxyHost",
",",
"_",
":=",
"tc",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"tc",
".",
"localAgent",
",",
"err",
"=",
"NewLocalAgent",
"(",
"c",
".",
"KeysDir",
",",
"webProxyHost",
",",
"c",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"tc",
".",
"HostKeyCallback",
"==",
"nil",
"{",
"tc",
".",
"HostKeyCallback",
"=",
"tc",
".",
"localAgent",
".",
"CheckHostSignature",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"tc",
",",
"nil",
"\n",
"}"
] |
// NewClient creates a TeleportClient object and fully configures it
|
[
"NewClient",
"creates",
"a",
"TeleportClient",
"object",
"and",
"fully",
"configures",
"it"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L735-L810
|
train
|
gravitational/teleport
|
lib/client/api.go
|
accessPoint
|
func (tc *TeleportClient) accessPoint(clt auth.AccessPoint, proxyHostPort string, clusterName string) (auth.AccessPoint, error) {
// If no caching policy was set or on Windows (where Teleport does not
// support file locking at the moment), return direct access to the access
// point.
if tc.CachePolicy == nil || runtime.GOOS == teleport.WindowsOS {
log.Debugf("not using caching access point")
return clt, nil
}
return clt, nil
}
|
go
|
func (tc *TeleportClient) accessPoint(clt auth.AccessPoint, proxyHostPort string, clusterName string) (auth.AccessPoint, error) {
// If no caching policy was set or on Windows (where Teleport does not
// support file locking at the moment), return direct access to the access
// point.
if tc.CachePolicy == nil || runtime.GOOS == teleport.WindowsOS {
log.Debugf("not using caching access point")
return clt, nil
}
return clt, nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"accessPoint",
"(",
"clt",
"auth",
".",
"AccessPoint",
",",
"proxyHostPort",
"string",
",",
"clusterName",
"string",
")",
"(",
"auth",
".",
"AccessPoint",
",",
"error",
")",
"{",
"if",
"tc",
".",
"CachePolicy",
"==",
"nil",
"||",
"runtime",
".",
"GOOS",
"==",
"teleport",
".",
"WindowsOS",
"{",
"log",
".",
"Debugf",
"(",
"\"not using caching access point\"",
")",
"\n",
"return",
"clt",
",",
"nil",
"\n",
"}",
"\n",
"return",
"clt",
",",
"nil",
"\n",
"}"
] |
// accessPoint returns access point based on the cache policy
|
[
"accessPoint",
"returns",
"access",
"point",
"based",
"on",
"the",
"cache",
"policy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L813-L822
|
train
|
gravitational/teleport
|
lib/client/api.go
|
getTargetNodes
|
func (tc *TeleportClient) getTargetNodes(ctx context.Context, proxy *ProxyClient) ([]string, error) {
var (
err error
nodes []services.Server
retval = make([]string, 0)
)
if tc.Labels != nil && len(tc.Labels) > 0 {
nodes, err = proxy.FindServersByLabels(ctx, tc.Namespace, tc.Labels)
if err != nil {
return nil, trace.Wrap(err)
}
for i := 0; i < len(nodes); i++ {
retval = append(retval, nodes[i].GetAddr())
}
}
if len(nodes) == 0 {
retval = append(retval, net.JoinHostPort(tc.Host, strconv.Itoa(tc.HostPort)))
}
return retval, nil
}
|
go
|
func (tc *TeleportClient) getTargetNodes(ctx context.Context, proxy *ProxyClient) ([]string, error) {
var (
err error
nodes []services.Server
retval = make([]string, 0)
)
if tc.Labels != nil && len(tc.Labels) > 0 {
nodes, err = proxy.FindServersByLabels(ctx, tc.Namespace, tc.Labels)
if err != nil {
return nil, trace.Wrap(err)
}
for i := 0; i < len(nodes); i++ {
retval = append(retval, nodes[i].GetAddr())
}
}
if len(nodes) == 0 {
retval = append(retval, net.JoinHostPort(tc.Host, strconv.Itoa(tc.HostPort)))
}
return retval, nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"getTargetNodes",
"(",
"ctx",
"context",
".",
"Context",
",",
"proxy",
"*",
"ProxyClient",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"(",
"err",
"error",
"\n",
"nodes",
"[",
"]",
"services",
".",
"Server",
"\n",
"retval",
"=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
")",
"\n",
"if",
"tc",
".",
"Labels",
"!=",
"nil",
"&&",
"len",
"(",
"tc",
".",
"Labels",
")",
">",
"0",
"{",
"nodes",
",",
"err",
"=",
"proxy",
".",
"FindServersByLabels",
"(",
"ctx",
",",
"tc",
".",
"Namespace",
",",
"tc",
".",
"Labels",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"nodes",
")",
";",
"i",
"++",
"{",
"retval",
"=",
"append",
"(",
"retval",
",",
"nodes",
"[",
"i",
"]",
".",
"GetAddr",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"nodes",
")",
"==",
"0",
"{",
"retval",
"=",
"append",
"(",
"retval",
",",
"net",
".",
"JoinHostPort",
"(",
"tc",
".",
"Host",
",",
"strconv",
".",
"Itoa",
"(",
"tc",
".",
"HostPort",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"retval",
",",
"nil",
"\n",
"}"
] |
// getTargetNodes returns a list of node addresses this SSH command needs to
// operate on.
|
[
"getTargetNodes",
"returns",
"a",
"list",
"of",
"node",
"addresses",
"this",
"SSH",
"command",
"needs",
"to",
"operate",
"on",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L830-L849
|
train
|
gravitational/teleport
|
lib/client/api.go
|
Play
|
func (tc *TeleportClient) Play(ctx context.Context, namespace, sessionId string) (err error) {
if namespace == "" {
return trace.BadParameter(auth.MissingNamespaceError)
}
sid, err := session.ParseID(sessionId)
if err != nil {
return fmt.Errorf("'%v' is not a valid session ID (must be GUID)", sid)
}
// connect to the auth server (site) who made the recording
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return trace.Wrap(err)
}
site, err := proxyClient.ConnectToCurrentCluster(ctx, false)
if err != nil {
return trace.Wrap(err)
}
// request events for that session (to get timing data)
sessionEvents, err := site.GetSessionEvents(namespace, *sid, 0, true)
if err != nil {
return trace.Wrap(err)
}
// read the stream into a buffer:
var stream []byte
for err == nil {
tmp, err := site.GetSessionChunk(namespace, *sid, len(stream), events.MaxChunkBytes)
if err != nil {
return trace.Wrap(err)
}
if len(tmp) == 0 {
err = io.EOF
break
}
stream = append(stream, tmp...)
}
// configure terminal for direct unbuffered echo-less input:
if term.IsTerminal(0) {
state, err := term.SetRawTerminal(0)
if err != nil {
return nil
}
defer term.RestoreTerminal(0, state)
}
player := newSessionPlayer(sessionEvents, stream)
// keys:
const (
keyCtrlC = 3
keyCtrlD = 4
keySpace = 32
keyLeft = 68
keyRight = 67
keyUp = 65
keyDown = 66
)
// playback control goroutine
go func() {
defer player.Stop()
key := make([]byte, 1)
for {
_, err = os.Stdin.Read(key)
if err != nil {
return
}
switch key[0] {
// Ctrl+C or Ctrl+D
case keyCtrlC, keyCtrlD:
return
// Space key
case keySpace:
player.TogglePause()
// <- arrow
case keyLeft, keyDown:
player.Rewind()
// -> arrow
case keyRight, keyUp:
player.Forward()
}
}
}()
// player starts playing in its own goroutine
player.Play()
// wait for keypresses loop to end
<-player.stopC
fmt.Println("\n\nend of session playback")
return trace.Wrap(err)
}
|
go
|
func (tc *TeleportClient) Play(ctx context.Context, namespace, sessionId string) (err error) {
if namespace == "" {
return trace.BadParameter(auth.MissingNamespaceError)
}
sid, err := session.ParseID(sessionId)
if err != nil {
return fmt.Errorf("'%v' is not a valid session ID (must be GUID)", sid)
}
// connect to the auth server (site) who made the recording
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return trace.Wrap(err)
}
site, err := proxyClient.ConnectToCurrentCluster(ctx, false)
if err != nil {
return trace.Wrap(err)
}
// request events for that session (to get timing data)
sessionEvents, err := site.GetSessionEvents(namespace, *sid, 0, true)
if err != nil {
return trace.Wrap(err)
}
// read the stream into a buffer:
var stream []byte
for err == nil {
tmp, err := site.GetSessionChunk(namespace, *sid, len(stream), events.MaxChunkBytes)
if err != nil {
return trace.Wrap(err)
}
if len(tmp) == 0 {
err = io.EOF
break
}
stream = append(stream, tmp...)
}
// configure terminal for direct unbuffered echo-less input:
if term.IsTerminal(0) {
state, err := term.SetRawTerminal(0)
if err != nil {
return nil
}
defer term.RestoreTerminal(0, state)
}
player := newSessionPlayer(sessionEvents, stream)
// keys:
const (
keyCtrlC = 3
keyCtrlD = 4
keySpace = 32
keyLeft = 68
keyRight = 67
keyUp = 65
keyDown = 66
)
// playback control goroutine
go func() {
defer player.Stop()
key := make([]byte, 1)
for {
_, err = os.Stdin.Read(key)
if err != nil {
return
}
switch key[0] {
// Ctrl+C or Ctrl+D
case keyCtrlC, keyCtrlD:
return
// Space key
case keySpace:
player.TogglePause()
// <- arrow
case keyLeft, keyDown:
player.Rewind()
// -> arrow
case keyRight, keyUp:
player.Forward()
}
}
}()
// player starts playing in its own goroutine
player.Play()
// wait for keypresses loop to end
<-player.stopC
fmt.Println("\n\nend of session playback")
return trace.Wrap(err)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"Play",
"(",
"ctx",
"context",
".",
"Context",
",",
"namespace",
",",
"sessionId",
"string",
")",
"(",
"err",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"auth",
".",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"sid",
",",
"err",
":=",
"session",
".",
"ParseID",
"(",
"sessionId",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"'%v' is not a valid session ID (must be GUID)\"",
",",
"sid",
")",
"\n",
"}",
"\n",
"proxyClient",
",",
"err",
":=",
"tc",
".",
"ConnectToProxy",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"site",
",",
"err",
":=",
"proxyClient",
".",
"ConnectToCurrentCluster",
"(",
"ctx",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sessionEvents",
",",
"err",
":=",
"site",
".",
"GetSessionEvents",
"(",
"namespace",
",",
"*",
"sid",
",",
"0",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"stream",
"[",
"]",
"byte",
"\n",
"for",
"err",
"==",
"nil",
"{",
"tmp",
",",
"err",
":=",
"site",
".",
"GetSessionChunk",
"(",
"namespace",
",",
"*",
"sid",
",",
"len",
"(",
"stream",
")",
",",
"events",
".",
"MaxChunkBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"tmp",
")",
"==",
"0",
"{",
"err",
"=",
"io",
".",
"EOF",
"\n",
"break",
"\n",
"}",
"\n",
"stream",
"=",
"append",
"(",
"stream",
",",
"tmp",
"...",
")",
"\n",
"}",
"\n",
"if",
"term",
".",
"IsTerminal",
"(",
"0",
")",
"{",
"state",
",",
"err",
":=",
"term",
".",
"SetRawTerminal",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"defer",
"term",
".",
"RestoreTerminal",
"(",
"0",
",",
"state",
")",
"\n",
"}",
"\n",
"player",
":=",
"newSessionPlayer",
"(",
"sessionEvents",
",",
"stream",
")",
"\n",
"const",
"(",
"keyCtrlC",
"=",
"3",
"\n",
"keyCtrlD",
"=",
"4",
"\n",
"keySpace",
"=",
"32",
"\n",
"keyLeft",
"=",
"68",
"\n",
"keyRight",
"=",
"67",
"\n",
"keyUp",
"=",
"65",
"\n",
"keyDown",
"=",
"66",
"\n",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"player",
".",
"Stop",
"(",
")",
"\n",
"key",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"1",
")",
"\n",
"for",
"{",
"_",
",",
"err",
"=",
"os",
".",
"Stdin",
".",
"Read",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"switch",
"key",
"[",
"0",
"]",
"{",
"case",
"keyCtrlC",
",",
"keyCtrlD",
":",
"return",
"\n",
"case",
"keySpace",
":",
"player",
".",
"TogglePause",
"(",
")",
"\n",
"case",
"keyLeft",
",",
"keyDown",
":",
"player",
".",
"Rewind",
"(",
")",
"\n",
"case",
"keyRight",
",",
"keyUp",
":",
"player",
".",
"Forward",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"player",
".",
"Play",
"(",
")",
"\n",
"<-",
"player",
".",
"stopC",
"\n",
"fmt",
".",
"Println",
"(",
"\"\\n\\nend of session playback\"",
")",
"\n",
"\\n",
"\n",
"}"
] |
// Play replays the recorded session
|
[
"Play",
"replays",
"the",
"recorded",
"session"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1019-L1108
|
train
|
gravitational/teleport
|
lib/client/api.go
|
ExecuteSCP
|
func (tc *TeleportClient) ExecuteSCP(ctx context.Context, cmd scp.Command) (err error) {
// connect to proxy first:
if !tc.Config.ProxySpecified() {
return trace.BadParameter("proxy server is not specified")
}
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return trace.Wrap(err)
}
defer proxyClient.Close()
clusterInfo, err := proxyClient.currentCluster()
if err != nil {
return trace.Wrap(err)
}
// which nodes are we executing this commands on?
nodeAddrs, err := tc.getTargetNodes(ctx, proxyClient)
if err != nil {
return trace.Wrap(err)
}
if len(nodeAddrs) == 0 {
return trace.BadParameter("no target host specified")
}
nodeClient, err := proxyClient.ConnectToNode(
ctx,
nodeAddrs[0]+"@"+tc.Namespace+"@"+clusterInfo.Name,
tc.Config.HostLogin,
false)
if err != nil {
tc.ExitStatus = 1
return trace.Wrap(err)
}
err = nodeClient.ExecuteSCP(cmd)
if err != nil {
// converts SSH error code to tc.ExitStatus
exitError, _ := trace.Unwrap(err).(*ssh.ExitError)
if exitError != nil {
tc.ExitStatus = exitError.ExitStatus()
}
return err
}
return nil
}
|
go
|
func (tc *TeleportClient) ExecuteSCP(ctx context.Context, cmd scp.Command) (err error) {
// connect to proxy first:
if !tc.Config.ProxySpecified() {
return trace.BadParameter("proxy server is not specified")
}
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return trace.Wrap(err)
}
defer proxyClient.Close()
clusterInfo, err := proxyClient.currentCluster()
if err != nil {
return trace.Wrap(err)
}
// which nodes are we executing this commands on?
nodeAddrs, err := tc.getTargetNodes(ctx, proxyClient)
if err != nil {
return trace.Wrap(err)
}
if len(nodeAddrs) == 0 {
return trace.BadParameter("no target host specified")
}
nodeClient, err := proxyClient.ConnectToNode(
ctx,
nodeAddrs[0]+"@"+tc.Namespace+"@"+clusterInfo.Name,
tc.Config.HostLogin,
false)
if err != nil {
tc.ExitStatus = 1
return trace.Wrap(err)
}
err = nodeClient.ExecuteSCP(cmd)
if err != nil {
// converts SSH error code to tc.ExitStatus
exitError, _ := trace.Unwrap(err).(*ssh.ExitError)
if exitError != nil {
tc.ExitStatus = exitError.ExitStatus()
}
return err
}
return nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"ExecuteSCP",
"(",
"ctx",
"context",
".",
"Context",
",",
"cmd",
"scp",
".",
"Command",
")",
"(",
"err",
"error",
")",
"{",
"if",
"!",
"tc",
".",
"Config",
".",
"ProxySpecified",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"proxy server is not specified\"",
")",
"\n",
"}",
"\n",
"proxyClient",
",",
"err",
":=",
"tc",
".",
"ConnectToProxy",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"proxyClient",
".",
"Close",
"(",
")",
"\n",
"clusterInfo",
",",
"err",
":=",
"proxyClient",
".",
"currentCluster",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"nodeAddrs",
",",
"err",
":=",
"tc",
".",
"getTargetNodes",
"(",
"ctx",
",",
"proxyClient",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"nodeAddrs",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"no target host specified\"",
")",
"\n",
"}",
"\n",
"nodeClient",
",",
"err",
":=",
"proxyClient",
".",
"ConnectToNode",
"(",
"ctx",
",",
"nodeAddrs",
"[",
"0",
"]",
"+",
"\"@\"",
"+",
"tc",
".",
"Namespace",
"+",
"\"@\"",
"+",
"clusterInfo",
".",
"Name",
",",
"tc",
".",
"Config",
".",
"HostLogin",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"tc",
".",
"ExitStatus",
"=",
"1",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"nodeClient",
".",
"ExecuteSCP",
"(",
"cmd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"exitError",
",",
"_",
":=",
"trace",
".",
"Unwrap",
"(",
"err",
")",
".",
"(",
"*",
"ssh",
".",
"ExitError",
")",
"\n",
"if",
"exitError",
"!=",
"nil",
"{",
"tc",
".",
"ExitStatus",
"=",
"exitError",
".",
"ExitStatus",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ExecuteSCP executes SCP command. It executes scp.Command using
// lower-level API integrations that mimic SCP CLI command behavior
|
[
"ExecuteSCP",
"executes",
"SCP",
"command",
".",
"It",
"executes",
"scp",
".",
"Command",
"using",
"lower",
"-",
"level",
"API",
"integrations",
"that",
"mimic",
"SCP",
"CLI",
"command",
"behavior"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1112-L1160
|
train
|
gravitational/teleport
|
lib/client/api.go
|
ListNodes
|
func (tc *TeleportClient) ListNodes(ctx context.Context) ([]services.Server, error) {
var err error
// userhost is specified? that must be labels
if tc.Host != "" {
tc.Labels, err = ParseLabelSpec(tc.Host)
if err != nil {
return nil, trace.Wrap(err)
}
}
// connect to the proxy and ask it to return a full list of servers
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return nil, trace.Wrap(err)
}
defer proxyClient.Close()
return proxyClient.FindServersByLabels(ctx, tc.Namespace, tc.Labels)
}
|
go
|
func (tc *TeleportClient) ListNodes(ctx context.Context) ([]services.Server, error) {
var err error
// userhost is specified? that must be labels
if tc.Host != "" {
tc.Labels, err = ParseLabelSpec(tc.Host)
if err != nil {
return nil, trace.Wrap(err)
}
}
// connect to the proxy and ask it to return a full list of servers
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return nil, trace.Wrap(err)
}
defer proxyClient.Close()
return proxyClient.FindServersByLabels(ctx, tc.Namespace, tc.Labels)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"ListNodes",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"tc",
".",
"Host",
"!=",
"\"\"",
"{",
"tc",
".",
"Labels",
",",
"err",
"=",
"ParseLabelSpec",
"(",
"tc",
".",
"Host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"proxyClient",
",",
"err",
":=",
"tc",
".",
"ConnectToProxy",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"proxyClient",
".",
"Close",
"(",
")",
"\n",
"return",
"proxyClient",
".",
"FindServersByLabels",
"(",
"ctx",
",",
"tc",
".",
"Namespace",
",",
"tc",
".",
"Labels",
")",
"\n",
"}"
] |
// ListNodes returns a list of nodes connected to a proxy
|
[
"ListNodes",
"returns",
"a",
"list",
"of",
"nodes",
"connected",
"to",
"a",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1295-L1313
|
train
|
gravitational/teleport
|
lib/client/api.go
|
runCommand
|
func (tc *TeleportClient) runCommand(
ctx context.Context, siteName string, nodeAddresses []string, proxyClient *ProxyClient, command []string) error {
resultsC := make(chan error, len(nodeAddresses))
for _, address := range nodeAddresses {
go func(address string) {
var (
err error
nodeSession *NodeSession
)
defer func() {
resultsC <- err
}()
var nodeClient *NodeClient
nodeClient, err = proxyClient.ConnectToNode(ctx, address+"@"+tc.Namespace+"@"+siteName, tc.Config.HostLogin, false)
if err != nil {
fmt.Fprintln(tc.Stderr, err)
return
}
defer nodeClient.Close()
// run the command on one node:
if len(nodeAddresses) > 1 {
fmt.Printf("Running command on %v:\n", address)
}
nodeSession, err = newSession(nodeClient, nil, tc.Config.Env, tc.Stdin, tc.Stdout, tc.Stderr)
if err != nil {
log.Error(err)
return
}
defer nodeSession.Close()
if err = nodeSession.runCommand(ctx, command, tc.OnShellCreated, tc.Config.Interactive); err != nil {
originErr := trace.Unwrap(err)
exitErr, ok := originErr.(*ssh.ExitError)
if ok {
tc.ExitStatus = exitErr.ExitStatus()
} else {
// if an error occurs, but no exit status is passed back, GoSSH returns
// a generic error like this. in this case the error message is printed
// to stderr by the remote process so we have to quietly return 1:
if strings.Contains(originErr.Error(), "exited without exit status") {
tc.ExitStatus = 1
}
}
}
}(address)
}
var lastError error
for range nodeAddresses {
if err := <-resultsC; err != nil {
lastError = err
}
}
return trace.Wrap(lastError)
}
|
go
|
func (tc *TeleportClient) runCommand(
ctx context.Context, siteName string, nodeAddresses []string, proxyClient *ProxyClient, command []string) error {
resultsC := make(chan error, len(nodeAddresses))
for _, address := range nodeAddresses {
go func(address string) {
var (
err error
nodeSession *NodeSession
)
defer func() {
resultsC <- err
}()
var nodeClient *NodeClient
nodeClient, err = proxyClient.ConnectToNode(ctx, address+"@"+tc.Namespace+"@"+siteName, tc.Config.HostLogin, false)
if err != nil {
fmt.Fprintln(tc.Stderr, err)
return
}
defer nodeClient.Close()
// run the command on one node:
if len(nodeAddresses) > 1 {
fmt.Printf("Running command on %v:\n", address)
}
nodeSession, err = newSession(nodeClient, nil, tc.Config.Env, tc.Stdin, tc.Stdout, tc.Stderr)
if err != nil {
log.Error(err)
return
}
defer nodeSession.Close()
if err = nodeSession.runCommand(ctx, command, tc.OnShellCreated, tc.Config.Interactive); err != nil {
originErr := trace.Unwrap(err)
exitErr, ok := originErr.(*ssh.ExitError)
if ok {
tc.ExitStatus = exitErr.ExitStatus()
} else {
// if an error occurs, but no exit status is passed back, GoSSH returns
// a generic error like this. in this case the error message is printed
// to stderr by the remote process so we have to quietly return 1:
if strings.Contains(originErr.Error(), "exited without exit status") {
tc.ExitStatus = 1
}
}
}
}(address)
}
var lastError error
for range nodeAddresses {
if err := <-resultsC; err != nil {
lastError = err
}
}
return trace.Wrap(lastError)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"runCommand",
"(",
"ctx",
"context",
".",
"Context",
",",
"siteName",
"string",
",",
"nodeAddresses",
"[",
"]",
"string",
",",
"proxyClient",
"*",
"ProxyClient",
",",
"command",
"[",
"]",
"string",
")",
"error",
"{",
"resultsC",
":=",
"make",
"(",
"chan",
"error",
",",
"len",
"(",
"nodeAddresses",
")",
")",
"\n",
"for",
"_",
",",
"address",
":=",
"range",
"nodeAddresses",
"{",
"go",
"func",
"(",
"address",
"string",
")",
"{",
"var",
"(",
"err",
"error",
"\n",
"nodeSession",
"*",
"NodeSession",
"\n",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"resultsC",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"var",
"nodeClient",
"*",
"NodeClient",
"\n",
"nodeClient",
",",
"err",
"=",
"proxyClient",
".",
"ConnectToNode",
"(",
"ctx",
",",
"address",
"+",
"\"@\"",
"+",
"tc",
".",
"Namespace",
"+",
"\"@\"",
"+",
"siteName",
",",
"tc",
".",
"Config",
".",
"HostLogin",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"tc",
".",
"Stderr",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"nodeClient",
".",
"Close",
"(",
")",
"\n",
"if",
"len",
"(",
"nodeAddresses",
")",
">",
"1",
"{",
"fmt",
".",
"Printf",
"(",
"\"Running command on %v:\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"address",
"\n",
"nodeSession",
",",
"err",
"=",
"newSession",
"(",
"nodeClient",
",",
"nil",
",",
"tc",
".",
"Config",
".",
"Env",
",",
"tc",
".",
"Stdin",
",",
"tc",
".",
"Stdout",
",",
"tc",
".",
"Stderr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"nodeSession",
".",
"Close",
"(",
")",
"\n",
"}",
"if",
"err",
"=",
"nodeSession",
".",
"runCommand",
"(",
"ctx",
",",
"command",
",",
"tc",
".",
"OnShellCreated",
",",
"tc",
".",
"Config",
".",
"Interactive",
")",
";",
"err",
"!=",
"nil",
"{",
"originErr",
":=",
"trace",
".",
"Unwrap",
"(",
"err",
")",
"\n",
"exitErr",
",",
"ok",
":=",
"originErr",
".",
"(",
"*",
"ssh",
".",
"ExitError",
")",
"\n",
"if",
"ok",
"{",
"tc",
".",
"ExitStatus",
"=",
"exitErr",
".",
"ExitStatus",
"(",
")",
"\n",
"}",
"else",
"{",
"if",
"strings",
".",
"Contains",
"(",
"originErr",
".",
"Error",
"(",
")",
",",
"\"exited without exit status\"",
")",
"{",
"tc",
".",
"ExitStatus",
"=",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"(",
"address",
")",
"\n",
"var",
"lastError",
"error",
"\n",
"for",
"range",
"nodeAddresses",
"{",
"if",
"err",
":=",
"<-",
"resultsC",
";",
"err",
"!=",
"nil",
"{",
"lastError",
"=",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// runCommand executes a given bash command on a bunch of remote nodes
|
[
"runCommand",
"executes",
"a",
"given",
"bash",
"command",
"on",
"a",
"bunch",
"of",
"remote",
"nodes"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1316-L1370
|
train
|
gravitational/teleport
|
lib/client/api.go
|
getProxySSHPrincipal
|
func (tc *TeleportClient) getProxySSHPrincipal() string {
proxyPrincipal := tc.Config.HostLogin
if tc.DefaultPrincipal != "" {
proxyPrincipal = tc.DefaultPrincipal
}
// see if we already have a signed key in the cache, we'll use that instead
if !tc.Config.SkipLocalAuth && tc.LocalAgent() != nil {
signers, err := tc.LocalAgent().Signers()
if err != nil || len(signers) == 0 {
return proxyPrincipal
}
cert, ok := signers[0].PublicKey().(*ssh.Certificate)
if ok && len(cert.ValidPrincipals) > 0 {
return cert.ValidPrincipals[0]
}
}
return proxyPrincipal
}
|
go
|
func (tc *TeleportClient) getProxySSHPrincipal() string {
proxyPrincipal := tc.Config.HostLogin
if tc.DefaultPrincipal != "" {
proxyPrincipal = tc.DefaultPrincipal
}
// see if we already have a signed key in the cache, we'll use that instead
if !tc.Config.SkipLocalAuth && tc.LocalAgent() != nil {
signers, err := tc.LocalAgent().Signers()
if err != nil || len(signers) == 0 {
return proxyPrincipal
}
cert, ok := signers[0].PublicKey().(*ssh.Certificate)
if ok && len(cert.ValidPrincipals) > 0 {
return cert.ValidPrincipals[0]
}
}
return proxyPrincipal
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"getProxySSHPrincipal",
"(",
")",
"string",
"{",
"proxyPrincipal",
":=",
"tc",
".",
"Config",
".",
"HostLogin",
"\n",
"if",
"tc",
".",
"DefaultPrincipal",
"!=",
"\"\"",
"{",
"proxyPrincipal",
"=",
"tc",
".",
"DefaultPrincipal",
"\n",
"}",
"\n",
"if",
"!",
"tc",
".",
"Config",
".",
"SkipLocalAuth",
"&&",
"tc",
".",
"LocalAgent",
"(",
")",
"!=",
"nil",
"{",
"signers",
",",
"err",
":=",
"tc",
".",
"LocalAgent",
"(",
")",
".",
"Signers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"len",
"(",
"signers",
")",
"==",
"0",
"{",
"return",
"proxyPrincipal",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"signers",
"[",
"0",
"]",
".",
"PublicKey",
"(",
")",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"ok",
"&&",
"len",
"(",
"cert",
".",
"ValidPrincipals",
")",
">",
"0",
"{",
"return",
"cert",
".",
"ValidPrincipals",
"[",
"0",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"proxyPrincipal",
"\n",
"}"
] |
// getProxyLogin determines which SSH principal to use when connecting to proxy.
|
[
"getProxyLogin",
"determines",
"which",
"SSH",
"principal",
"to",
"use",
"when",
"connecting",
"to",
"proxy",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1391-L1408
|
train
|
gravitational/teleport
|
lib/client/api.go
|
ConnectToProxy
|
func (tc *TeleportClient) ConnectToProxy(ctx context.Context) (*ProxyClient, error) {
var err error
var proxyClient *ProxyClient
// Use connectContext and the cancel function to signal when a response is
// returned from connectToProxy.
connectContext, cancel := context.WithCancel(context.Background())
go func() {
defer cancel()
proxyClient, err = tc.connectToProxy(ctx)
}()
select {
// ConnectToProxy returned a result, return that back to the caller.
case <-connectContext.Done():
return proxyClient, trace.Wrap(err)
// The passed in context timed out. This is often due to the network being
// down and the user hitting Ctrl-C.
case <-ctx.Done():
return nil, trace.ConnectionProblem(ctx.Err(), "connection canceled")
}
}
|
go
|
func (tc *TeleportClient) ConnectToProxy(ctx context.Context) (*ProxyClient, error) {
var err error
var proxyClient *ProxyClient
// Use connectContext and the cancel function to signal when a response is
// returned from connectToProxy.
connectContext, cancel := context.WithCancel(context.Background())
go func() {
defer cancel()
proxyClient, err = tc.connectToProxy(ctx)
}()
select {
// ConnectToProxy returned a result, return that back to the caller.
case <-connectContext.Done():
return proxyClient, trace.Wrap(err)
// The passed in context timed out. This is often due to the network being
// down and the user hitting Ctrl-C.
case <-ctx.Done():
return nil, trace.ConnectionProblem(ctx.Err(), "connection canceled")
}
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"ConnectToProxy",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"ProxyClient",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"proxyClient",
"*",
"ProxyClient",
"\n",
"connectContext",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"cancel",
"(",
")",
"\n",
"proxyClient",
",",
"err",
"=",
"tc",
".",
"connectToProxy",
"(",
"ctx",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"connectContext",
".",
"Done",
"(",
")",
":",
"return",
"proxyClient",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"ctx",
".",
"Err",
"(",
")",
",",
"\"connection canceled\"",
")",
"\n",
"}",
"\n",
"}"
] |
// ConnectToProxy will dial to the proxy server and return a ProxyClient when
// successful. If the passed in context is canceled, this function will return
// a trace.ConnectionProblem right away.
|
[
"ConnectToProxy",
"will",
"dial",
"to",
"the",
"proxy",
"server",
"and",
"return",
"a",
"ProxyClient",
"when",
"successful",
".",
"If",
"the",
"passed",
"in",
"context",
"is",
"canceled",
"this",
"function",
"will",
"return",
"a",
"trace",
".",
"ConnectionProblem",
"right",
"away",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1423-L1444
|
train
|
gravitational/teleport
|
lib/client/api.go
|
connectToProxy
|
func (tc *TeleportClient) connectToProxy(ctx context.Context) (*ProxyClient, error) {
var err error
proxyPrincipal := tc.getProxySSHPrincipal()
sshConfig := &ssh.ClientConfig{
User: proxyPrincipal,
HostKeyCallback: tc.HostKeyCallback,
}
// helper to create a ProxyClient struct
makeProxyClient := func(sshClient *ssh.Client, m ssh.AuthMethod) *ProxyClient {
return &ProxyClient{
teleportClient: tc,
Client: sshClient,
proxyAddress: tc.Config.SSHProxyAddr,
proxyPrincipal: proxyPrincipal,
hostKeyCallback: sshConfig.HostKeyCallback,
authMethod: m,
hostLogin: tc.Config.HostLogin,
siteName: tc.Config.SiteName,
clientAddr: tc.ClientAddr,
}
}
successMsg := fmt.Sprintf("Successful auth with proxy %v", tc.Config.SSHProxyAddr)
// try to authenticate using every non interactive auth method we have:
for i, m := range tc.authMethods() {
log.Infof("Connecting proxy=%v login='%v' method=%d", tc.Config.SSHProxyAddr, sshConfig.User, i)
var sshClient *ssh.Client
sshConfig.Auth = []ssh.AuthMethod{m}
sshClient, err = ssh.Dial("tcp", tc.Config.SSHProxyAddr, sshConfig)
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof(successMsg)
return makeProxyClient(sshClient, m), nil
}
// we have exhausted all auth existing auth methods and local login
// is disabled in configuration, or the user refused connecting to untrusted hosts
if err == nil {
err = trace.BadParameter("failed to authenticate with proxy %v", tc.Config.SSHProxyAddr)
}
return nil, trace.Wrap(err)
}
|
go
|
func (tc *TeleportClient) connectToProxy(ctx context.Context) (*ProxyClient, error) {
var err error
proxyPrincipal := tc.getProxySSHPrincipal()
sshConfig := &ssh.ClientConfig{
User: proxyPrincipal,
HostKeyCallback: tc.HostKeyCallback,
}
// helper to create a ProxyClient struct
makeProxyClient := func(sshClient *ssh.Client, m ssh.AuthMethod) *ProxyClient {
return &ProxyClient{
teleportClient: tc,
Client: sshClient,
proxyAddress: tc.Config.SSHProxyAddr,
proxyPrincipal: proxyPrincipal,
hostKeyCallback: sshConfig.HostKeyCallback,
authMethod: m,
hostLogin: tc.Config.HostLogin,
siteName: tc.Config.SiteName,
clientAddr: tc.ClientAddr,
}
}
successMsg := fmt.Sprintf("Successful auth with proxy %v", tc.Config.SSHProxyAddr)
// try to authenticate using every non interactive auth method we have:
for i, m := range tc.authMethods() {
log.Infof("Connecting proxy=%v login='%v' method=%d", tc.Config.SSHProxyAddr, sshConfig.User, i)
var sshClient *ssh.Client
sshConfig.Auth = []ssh.AuthMethod{m}
sshClient, err = ssh.Dial("tcp", tc.Config.SSHProxyAddr, sshConfig)
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof(successMsg)
return makeProxyClient(sshClient, m), nil
}
// we have exhausted all auth existing auth methods and local login
// is disabled in configuration, or the user refused connecting to untrusted hosts
if err == nil {
err = trace.BadParameter("failed to authenticate with proxy %v", tc.Config.SSHProxyAddr)
}
return nil, trace.Wrap(err)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"connectToProxy",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"ProxyClient",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"proxyPrincipal",
":=",
"tc",
".",
"getProxySSHPrincipal",
"(",
")",
"\n",
"sshConfig",
":=",
"&",
"ssh",
".",
"ClientConfig",
"{",
"User",
":",
"proxyPrincipal",
",",
"HostKeyCallback",
":",
"tc",
".",
"HostKeyCallback",
",",
"}",
"\n",
"makeProxyClient",
":=",
"func",
"(",
"sshClient",
"*",
"ssh",
".",
"Client",
",",
"m",
"ssh",
".",
"AuthMethod",
")",
"*",
"ProxyClient",
"{",
"return",
"&",
"ProxyClient",
"{",
"teleportClient",
":",
"tc",
",",
"Client",
":",
"sshClient",
",",
"proxyAddress",
":",
"tc",
".",
"Config",
".",
"SSHProxyAddr",
",",
"proxyPrincipal",
":",
"proxyPrincipal",
",",
"hostKeyCallback",
":",
"sshConfig",
".",
"HostKeyCallback",
",",
"authMethod",
":",
"m",
",",
"hostLogin",
":",
"tc",
".",
"Config",
".",
"HostLogin",
",",
"siteName",
":",
"tc",
".",
"Config",
".",
"SiteName",
",",
"clientAddr",
":",
"tc",
".",
"ClientAddr",
",",
"}",
"\n",
"}",
"\n",
"successMsg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"Successful auth with proxy %v\"",
",",
"tc",
".",
"Config",
".",
"SSHProxyAddr",
")",
"\n",
"for",
"i",
",",
"m",
":=",
"range",
"tc",
".",
"authMethods",
"(",
")",
"{",
"log",
".",
"Infof",
"(",
"\"Connecting proxy=%v login='%v' method=%d\"",
",",
"tc",
".",
"Config",
".",
"SSHProxyAddr",
",",
"sshConfig",
".",
"User",
",",
"i",
")",
"\n",
"var",
"sshClient",
"*",
"ssh",
".",
"Client",
"\n",
"sshConfig",
".",
"Auth",
"=",
"[",
"]",
"ssh",
".",
"AuthMethod",
"{",
"m",
"}",
"\n",
"sshClient",
",",
"err",
"=",
"ssh",
".",
"Dial",
"(",
"\"tcp\"",
",",
"tc",
".",
"Config",
".",
"SSHProxyAddr",
",",
"sshConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"successMsg",
")",
"\n",
"return",
"makeProxyClient",
"(",
"sshClient",
",",
"m",
")",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"trace",
".",
"BadParameter",
"(",
"\"failed to authenticate with proxy %v\"",
",",
"tc",
".",
"Config",
".",
"SSHProxyAddr",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// connectToProxy will dial to the proxy server and return a ProxyClient when
// successful.
|
[
"connectToProxy",
"will",
"dial",
"to",
"the",
"proxy",
"server",
"and",
"return",
"a",
"ProxyClient",
"when",
"successful",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1448-L1491
|
train
|
gravitational/teleport
|
lib/client/api.go
|
Logout
|
func (tc *TeleportClient) Logout() error {
err := tc.localAgent.DeleteKey()
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (tc *TeleportClient) Logout() error {
err := tc.localAgent.DeleteKey()
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"Logout",
"(",
")",
"error",
"{",
"err",
":=",
"tc",
".",
"localAgent",
".",
"DeleteKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Logout removes certificate and key for the currently logged in user from
// the filesystem and agent.
|
[
"Logout",
"removes",
"certificate",
"and",
"key",
"for",
"the",
"currently",
"logged",
"in",
"user",
"from",
"the",
"filesystem",
"and",
"agent",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1495-L1502
|
train
|
gravitational/teleport
|
lib/client/api.go
|
LogoutAll
|
func (tc *TeleportClient) LogoutAll() error {
err := tc.localAgent.DeleteKeys()
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (tc *TeleportClient) LogoutAll() error {
err := tc.localAgent.DeleteKeys()
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"LogoutAll",
"(",
")",
"error",
"{",
"err",
":=",
"tc",
".",
"localAgent",
".",
"DeleteKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LogoutAll removes all certificates for all users from the filesystem
// and agent.
|
[
"LogoutAll",
"removes",
"all",
"certificates",
"for",
"all",
"users",
"from",
"the",
"filesystem",
"and",
"agent",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1506-L1512
|
train
|
gravitational/teleport
|
lib/client/api.go
|
GetTrustedCA
|
func (tc *TeleportClient) GetTrustedCA(ctx context.Context, clusterName string) ([]services.CertAuthority, error) {
// Connect to the proxy.
if !tc.Config.ProxySpecified() {
return nil, trace.BadParameter("proxy server is not specified")
}
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return nil, trace.Wrap(err)
}
defer proxyClient.Close()
// Get a client to the Auth Server.
clt, err := proxyClient.ClusterAccessPoint(ctx, clusterName, true)
if err != nil {
return nil, trace.Wrap(err)
}
// Get the list of host certificates that this cluster knows about.
return clt.GetCertAuthorities(services.HostCA, false)
}
|
go
|
func (tc *TeleportClient) GetTrustedCA(ctx context.Context, clusterName string) ([]services.CertAuthority, error) {
// Connect to the proxy.
if !tc.Config.ProxySpecified() {
return nil, trace.BadParameter("proxy server is not specified")
}
proxyClient, err := tc.ConnectToProxy(ctx)
if err != nil {
return nil, trace.Wrap(err)
}
defer proxyClient.Close()
// Get a client to the Auth Server.
clt, err := proxyClient.ClusterAccessPoint(ctx, clusterName, true)
if err != nil {
return nil, trace.Wrap(err)
}
// Get the list of host certificates that this cluster knows about.
return clt.GetCertAuthorities(services.HostCA, false)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"GetTrustedCA",
"(",
"ctx",
"context",
".",
"Context",
",",
"clusterName",
"string",
")",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
",",
"error",
")",
"{",
"if",
"!",
"tc",
".",
"Config",
".",
"ProxySpecified",
"(",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"proxy server is not specified\"",
")",
"\n",
"}",
"\n",
"proxyClient",
",",
"err",
":=",
"tc",
".",
"ConnectToProxy",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"proxyClient",
".",
"Close",
"(",
")",
"\n",
"clt",
",",
"err",
":=",
"proxyClient",
".",
"ClusterAccessPoint",
"(",
"ctx",
",",
"clusterName",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"clt",
".",
"GetCertAuthorities",
"(",
"services",
".",
"HostCA",
",",
"false",
")",
"\n",
"}"
] |
// GetTrustedCA returns a list of host certificate authorities
// trusted by the cluster client is authenticated with.
|
[
"GetTrustedCA",
"returns",
"a",
"list",
"of",
"host",
"certificate",
"authorities",
"trusted",
"by",
"the",
"cluster",
"client",
"is",
"authenticated",
"with",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1631-L1650
|
train
|
gravitational/teleport
|
lib/client/api.go
|
applyProxySettings
|
func (tc *TeleportClient) applyProxySettings(proxySettings ProxySettings) error {
// Kubernetes proxy settings.
if proxySettings.Kube.Enabled && proxySettings.Kube.PublicAddr != "" && tc.KubeProxyAddr == "" {
_, err := utils.ParseAddr(proxySettings.Kube.PublicAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.Kube.PublicAddr)
}
tc.KubeProxyAddr = proxySettings.Kube.PublicAddr
} else if proxySettings.Kube.Enabled && tc.KubeProxyAddr == "" {
webProxyHost, _ := tc.WebProxyHostPort()
tc.KubeProxyAddr = fmt.Sprintf("%s:%d", webProxyHost, defaults.KubeProxyListenPort)
}
// Read in settings for HTTP endpoint of the proxy.
if proxySettings.SSH.PublicAddr != "" {
addr, err := utils.ParseAddr(proxySettings.SSH.PublicAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.SSH.PublicAddr)
}
tc.WebProxyAddr = net.JoinHostPort(addr.Host(), strconv.Itoa(addr.Port(defaults.HTTPListenPort)))
// Update local agent (that reads/writes to ~/.tsh) with the new address
// of the web proxy. This will control where the keys are stored on disk
// after login.
tc.localAgent.UpdateProxyHost(addr.Host())
}
// Read in settings for the SSH endpoint of the proxy.
//
// If listen_addr is set, take host from ProxyWebHost and port from what
// was set. This is to maintain backward compatibility when Teleport only
// supported public_addr.
if proxySettings.SSH.ListenAddr != "" {
addr, err := utils.ParseAddr(proxySettings.SSH.ListenAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.SSH.ListenAddr)
}
webProxyHost, _ := tc.WebProxyHostPort()
tc.SSHProxyAddr = net.JoinHostPort(webProxyHost, strconv.Itoa(addr.Port(defaults.SSHProxyListenPort)))
}
// If ssh_public_addr is set, override settings from listen_addr.
if proxySettings.SSH.SSHPublicAddr != "" {
addr, err := utils.ParseAddr(proxySettings.SSH.SSHPublicAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.SSH.ListenAddr)
}
tc.SSHProxyAddr = net.JoinHostPort(addr.Host(), strconv.Itoa(addr.Port(defaults.SSHProxyListenPort)))
}
return nil
}
|
go
|
func (tc *TeleportClient) applyProxySettings(proxySettings ProxySettings) error {
// Kubernetes proxy settings.
if proxySettings.Kube.Enabled && proxySettings.Kube.PublicAddr != "" && tc.KubeProxyAddr == "" {
_, err := utils.ParseAddr(proxySettings.Kube.PublicAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.Kube.PublicAddr)
}
tc.KubeProxyAddr = proxySettings.Kube.PublicAddr
} else if proxySettings.Kube.Enabled && tc.KubeProxyAddr == "" {
webProxyHost, _ := tc.WebProxyHostPort()
tc.KubeProxyAddr = fmt.Sprintf("%s:%d", webProxyHost, defaults.KubeProxyListenPort)
}
// Read in settings for HTTP endpoint of the proxy.
if proxySettings.SSH.PublicAddr != "" {
addr, err := utils.ParseAddr(proxySettings.SSH.PublicAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.SSH.PublicAddr)
}
tc.WebProxyAddr = net.JoinHostPort(addr.Host(), strconv.Itoa(addr.Port(defaults.HTTPListenPort)))
// Update local agent (that reads/writes to ~/.tsh) with the new address
// of the web proxy. This will control where the keys are stored on disk
// after login.
tc.localAgent.UpdateProxyHost(addr.Host())
}
// Read in settings for the SSH endpoint of the proxy.
//
// If listen_addr is set, take host from ProxyWebHost and port from what
// was set. This is to maintain backward compatibility when Teleport only
// supported public_addr.
if proxySettings.SSH.ListenAddr != "" {
addr, err := utils.ParseAddr(proxySettings.SSH.ListenAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.SSH.ListenAddr)
}
webProxyHost, _ := tc.WebProxyHostPort()
tc.SSHProxyAddr = net.JoinHostPort(webProxyHost, strconv.Itoa(addr.Port(defaults.SSHProxyListenPort)))
}
// If ssh_public_addr is set, override settings from listen_addr.
if proxySettings.SSH.SSHPublicAddr != "" {
addr, err := utils.ParseAddr(proxySettings.SSH.SSHPublicAddr)
if err != nil {
return trace.BadParameter(
"failed to parse value received from the server: %q, contact your administrator for help",
proxySettings.SSH.ListenAddr)
}
tc.SSHProxyAddr = net.JoinHostPort(addr.Host(), strconv.Itoa(addr.Port(defaults.SSHProxyListenPort)))
}
return nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"applyProxySettings",
"(",
"proxySettings",
"ProxySettings",
")",
"error",
"{",
"if",
"proxySettings",
".",
"Kube",
".",
"Enabled",
"&&",
"proxySettings",
".",
"Kube",
".",
"PublicAddr",
"!=",
"\"\"",
"&&",
"tc",
".",
"KubeProxyAddr",
"==",
"\"\"",
"{",
"_",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"proxySettings",
".",
"Kube",
".",
"PublicAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse value received from the server: %q, contact your administrator for help\"",
",",
"proxySettings",
".",
"Kube",
".",
"PublicAddr",
")",
"\n",
"}",
"\n",
"tc",
".",
"KubeProxyAddr",
"=",
"proxySettings",
".",
"Kube",
".",
"PublicAddr",
"\n",
"}",
"else",
"if",
"proxySettings",
".",
"Kube",
".",
"Enabled",
"&&",
"tc",
".",
"KubeProxyAddr",
"==",
"\"\"",
"{",
"webProxyHost",
",",
"_",
":=",
"tc",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"tc",
".",
"KubeProxyAddr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%s:%d\"",
",",
"webProxyHost",
",",
"defaults",
".",
"KubeProxyListenPort",
")",
"\n",
"}",
"\n",
"if",
"proxySettings",
".",
"SSH",
".",
"PublicAddr",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"proxySettings",
".",
"SSH",
".",
"PublicAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse value received from the server: %q, contact your administrator for help\"",
",",
"proxySettings",
".",
"SSH",
".",
"PublicAddr",
")",
"\n",
"}",
"\n",
"tc",
".",
"WebProxyAddr",
"=",
"net",
".",
"JoinHostPort",
"(",
"addr",
".",
"Host",
"(",
")",
",",
"strconv",
".",
"Itoa",
"(",
"addr",
".",
"Port",
"(",
"defaults",
".",
"HTTPListenPort",
")",
")",
")",
"\n",
"tc",
".",
"localAgent",
".",
"UpdateProxyHost",
"(",
"addr",
".",
"Host",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"proxySettings",
".",
"SSH",
".",
"ListenAddr",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"proxySettings",
".",
"SSH",
".",
"ListenAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse value received from the server: %q, contact your administrator for help\"",
",",
"proxySettings",
".",
"SSH",
".",
"ListenAddr",
")",
"\n",
"}",
"\n",
"webProxyHost",
",",
"_",
":=",
"tc",
".",
"WebProxyHostPort",
"(",
")",
"\n",
"tc",
".",
"SSHProxyAddr",
"=",
"net",
".",
"JoinHostPort",
"(",
"webProxyHost",
",",
"strconv",
".",
"Itoa",
"(",
"addr",
".",
"Port",
"(",
"defaults",
".",
"SSHProxyListenPort",
")",
")",
")",
"\n",
"}",
"\n",
"if",
"proxySettings",
".",
"SSH",
".",
"SSHPublicAddr",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"proxySettings",
".",
"SSH",
".",
"SSHPublicAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse value received from the server: %q, contact your administrator for help\"",
",",
"proxySettings",
".",
"SSH",
".",
"ListenAddr",
")",
"\n",
"}",
"\n",
"tc",
".",
"SSHProxyAddr",
"=",
"net",
".",
"JoinHostPort",
"(",
"addr",
".",
"Host",
"(",
")",
",",
"strconv",
".",
"Itoa",
"(",
"addr",
".",
"Port",
"(",
"defaults",
".",
"SSHProxyListenPort",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// applyProxySettings updates configuration changes based on the advertised
// proxy settings, user supplied values take precedence - will be preserved
// if set
|
[
"applyProxySettings",
"updates",
"configuration",
"changes",
"based",
"on",
"the",
"advertised",
"proxy",
"settings",
"user",
"supplied",
"values",
"take",
"precedence",
"-",
"will",
"be",
"preserved",
"if",
"set"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1681-L1738
|
train
|
gravitational/teleport
|
lib/client/api.go
|
AddTrustedCA
|
func (tc *TeleportClient) AddTrustedCA(ca services.CertAuthority) error {
err := tc.LocalAgent().AddHostSignersToCache(auth.AuthoritiesToTrustedCerts([]services.CertAuthority{ca}))
if err != nil {
return trace.Wrap(err)
}
// only host CA has TLS certificates, user CA will overwrite trusted certs
// to empty file if called
if ca.GetType() == services.HostCA {
err = tc.LocalAgent().SaveCerts(auth.AuthoritiesToTrustedCerts([]services.CertAuthority{ca}))
if err != nil {
return trace.Wrap(err)
}
}
return nil
}
|
go
|
func (tc *TeleportClient) AddTrustedCA(ca services.CertAuthority) error {
err := tc.LocalAgent().AddHostSignersToCache(auth.AuthoritiesToTrustedCerts([]services.CertAuthority{ca}))
if err != nil {
return trace.Wrap(err)
}
// only host CA has TLS certificates, user CA will overwrite trusted certs
// to empty file if called
if ca.GetType() == services.HostCA {
err = tc.LocalAgent().SaveCerts(auth.AuthoritiesToTrustedCerts([]services.CertAuthority{ca}))
if err != nil {
return trace.Wrap(err)
}
}
return nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"AddTrustedCA",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"err",
":=",
"tc",
".",
"LocalAgent",
"(",
")",
".",
"AddHostSignersToCache",
"(",
"auth",
".",
"AuthoritiesToTrustedCerts",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
"{",
"ca",
"}",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ca",
".",
"GetType",
"(",
")",
"==",
"services",
".",
"HostCA",
"{",
"err",
"=",
"tc",
".",
"LocalAgent",
"(",
")",
".",
"SaveCerts",
"(",
"auth",
".",
"AuthoritiesToTrustedCerts",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
"{",
"ca",
"}",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Adds a new CA as trusted CA for this client, used in tests
|
[
"Adds",
"a",
"new",
"CA",
"as",
"trusted",
"CA",
"for",
"this",
"client",
"used",
"in",
"tests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1763-L1779
|
train
|
gravitational/teleport
|
lib/client/api.go
|
directLogin
|
func (tc *TeleportClient) directLogin(ctx context.Context, secondFactorType string, pub []byte) (*auth.SSHLoginResponse, error) {
var err error
var password string
var otpToken string
password, err = tc.AskPassword()
if err != nil {
return nil, trace.Wrap(err)
}
// only ask for a second factor if it's enabled
if secondFactorType != teleport.OFF {
otpToken, err = tc.AskOTP()
if err != nil {
return nil, trace.Wrap(err)
}
}
// ask the CA (via proxy) to sign our public key:
response, err := tc.credClient.SSHAgentLogin(
ctx,
tc.Config.Username,
password,
otpToken,
pub,
tc.KeyTTL,
tc.CertificateFormat)
return response, trace.Wrap(err)
}
|
go
|
func (tc *TeleportClient) directLogin(ctx context.Context, secondFactorType string, pub []byte) (*auth.SSHLoginResponse, error) {
var err error
var password string
var otpToken string
password, err = tc.AskPassword()
if err != nil {
return nil, trace.Wrap(err)
}
// only ask for a second factor if it's enabled
if secondFactorType != teleport.OFF {
otpToken, err = tc.AskOTP()
if err != nil {
return nil, trace.Wrap(err)
}
}
// ask the CA (via proxy) to sign our public key:
response, err := tc.credClient.SSHAgentLogin(
ctx,
tc.Config.Username,
password,
otpToken,
pub,
tc.KeyTTL,
tc.CertificateFormat)
return response, trace.Wrap(err)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"directLogin",
"(",
"ctx",
"context",
".",
"Context",
",",
"secondFactorType",
"string",
",",
"pub",
"[",
"]",
"byte",
")",
"(",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"password",
"string",
"\n",
"var",
"otpToken",
"string",
"\n",
"password",
",",
"err",
"=",
"tc",
".",
"AskPassword",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"secondFactorType",
"!=",
"teleport",
".",
"OFF",
"{",
"otpToken",
",",
"err",
"=",
"tc",
".",
"AskOTP",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"response",
",",
"err",
":=",
"tc",
".",
"credClient",
".",
"SSHAgentLogin",
"(",
"ctx",
",",
"tc",
".",
"Config",
".",
"Username",
",",
"password",
",",
"otpToken",
",",
"pub",
",",
"tc",
".",
"KeyTTL",
",",
"tc",
".",
"CertificateFormat",
")",
"\n",
"return",
"response",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// directLogin asks for a password + HOTP token, makes a request to CA via proxy
|
[
"directLogin",
"asks",
"for",
"a",
"password",
"+",
"HOTP",
"token",
"makes",
"a",
"request",
"to",
"CA",
"via",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1786-L1816
|
train
|
gravitational/teleport
|
lib/client/api.go
|
ssoLogin
|
func (tc *TeleportClient) ssoLogin(ctx context.Context, connectorID string, pub []byte, protocol string) (*auth.SSHLoginResponse, error) {
log.Debugf("samlLogin start")
// ask the CA (via proxy) to sign our public key:
response, err := tc.credClient.SSHAgentSSOLogin(SSHLogin{
Context: ctx,
ConnectorID: connectorID,
PubKey: pub,
TTL: tc.KeyTTL,
Protocol: protocol,
Compatibility: tc.CertificateFormat,
BindAddr: tc.BindAddr,
})
return response, trace.Wrap(err)
}
|
go
|
func (tc *TeleportClient) ssoLogin(ctx context.Context, connectorID string, pub []byte, protocol string) (*auth.SSHLoginResponse, error) {
log.Debugf("samlLogin start")
// ask the CA (via proxy) to sign our public key:
response, err := tc.credClient.SSHAgentSSOLogin(SSHLogin{
Context: ctx,
ConnectorID: connectorID,
PubKey: pub,
TTL: tc.KeyTTL,
Protocol: protocol,
Compatibility: tc.CertificateFormat,
BindAddr: tc.BindAddr,
})
return response, trace.Wrap(err)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"ssoLogin",
"(",
"ctx",
"context",
".",
"Context",
",",
"connectorID",
"string",
",",
"pub",
"[",
"]",
"byte",
",",
"protocol",
"string",
")",
"(",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"error",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"samlLogin start\"",
")",
"\n",
"response",
",",
"err",
":=",
"tc",
".",
"credClient",
".",
"SSHAgentSSOLogin",
"(",
"SSHLogin",
"{",
"Context",
":",
"ctx",
",",
"ConnectorID",
":",
"connectorID",
",",
"PubKey",
":",
"pub",
",",
"TTL",
":",
"tc",
".",
"KeyTTL",
",",
"Protocol",
":",
"protocol",
",",
"Compatibility",
":",
"tc",
".",
"CertificateFormat",
",",
"BindAddr",
":",
"tc",
".",
"BindAddr",
",",
"}",
")",
"\n",
"return",
"response",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// samlLogin opens browser window and uses OIDC or SAML redirect cycle with browser
|
[
"samlLogin",
"opens",
"browser",
"window",
"and",
"uses",
"OIDC",
"or",
"SAML",
"redirect",
"cycle",
"with",
"browser"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1819-L1832
|
train
|
gravitational/teleport
|
lib/client/api.go
|
u2fLogin
|
func (tc *TeleportClient) u2fLogin(ctx context.Context, pub []byte) (*auth.SSHLoginResponse, error) {
// U2F login requires the official u2f-host executable
_, err := exec.LookPath("u2f-host")
if err != nil {
return nil, trace.Wrap(err)
}
password, err := tc.AskPassword()
if err != nil {
return nil, trace.Wrap(err)
}
response, err := tc.credClient.SSHAgentU2FLogin(
ctx,
tc.Config.Username,
password,
pub,
tc.KeyTTL,
tc.CertificateFormat)
return response, trace.Wrap(err)
}
|
go
|
func (tc *TeleportClient) u2fLogin(ctx context.Context, pub []byte) (*auth.SSHLoginResponse, error) {
// U2F login requires the official u2f-host executable
_, err := exec.LookPath("u2f-host")
if err != nil {
return nil, trace.Wrap(err)
}
password, err := tc.AskPassword()
if err != nil {
return nil, trace.Wrap(err)
}
response, err := tc.credClient.SSHAgentU2FLogin(
ctx,
tc.Config.Username,
password,
pub,
tc.KeyTTL,
tc.CertificateFormat)
return response, trace.Wrap(err)
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"u2fLogin",
"(",
"ctx",
"context",
".",
"Context",
",",
"pub",
"[",
"]",
"byte",
")",
"(",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"error",
")",
"{",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"u2f-host\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"password",
",",
"err",
":=",
"tc",
".",
"AskPassword",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"response",
",",
"err",
":=",
"tc",
".",
"credClient",
".",
"SSHAgentU2FLogin",
"(",
"ctx",
",",
"tc",
".",
"Config",
".",
"Username",
",",
"password",
",",
"pub",
",",
"tc",
".",
"KeyTTL",
",",
"tc",
".",
"CertificateFormat",
")",
"\n",
"return",
"response",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// directLogin asks for a password and performs the challenge-response authentication
|
[
"directLogin",
"asks",
"for",
"a",
"password",
"and",
"performs",
"the",
"challenge",
"-",
"response",
"authentication"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1835-L1856
|
train
|
gravitational/teleport
|
lib/client/api.go
|
SendEvent
|
func (tc *TeleportClient) SendEvent(ctx context.Context, e events.EventFields) error {
// Try and send the event to the eventsCh. If blocking, keep blocking until
// the passed in context in canceled.
select {
case tc.eventsCh <- e:
return nil
case <-ctx.Done():
return trace.Wrap(ctx.Err())
}
}
|
go
|
func (tc *TeleportClient) SendEvent(ctx context.Context, e events.EventFields) error {
// Try and send the event to the eventsCh. If blocking, keep blocking until
// the passed in context in canceled.
select {
case tc.eventsCh <- e:
return nil
case <-ctx.Done():
return trace.Wrap(ctx.Err())
}
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"SendEvent",
"(",
"ctx",
"context",
".",
"Context",
",",
"e",
"events",
".",
"EventFields",
")",
"error",
"{",
"select",
"{",
"case",
"tc",
".",
"eventsCh",
"<-",
"e",
":",
"return",
"nil",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"trace",
".",
"Wrap",
"(",
"ctx",
".",
"Err",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// SendEvent adds a events.EventFields to the channel.
|
[
"SendEvent",
"adds",
"a",
"events",
".",
"EventFields",
"to",
"the",
"channel",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1859-L1868
|
train
|
gravitational/teleport
|
lib/client/api.go
|
loopbackPool
|
func loopbackPool(proxyAddr string) *x509.CertPool {
if !utils.IsLoopback(proxyAddr) {
log.Debugf("not using loopback pool for remote proxy addr: %v", proxyAddr)
return nil
}
log.Debugf("attempting to use loopback pool for local proxy addr: %v", proxyAddr)
certPool := x509.NewCertPool()
certPath := filepath.Join(defaults.DataDir, defaults.SelfSignedCertPath)
pemByte, err := ioutil.ReadFile(certPath)
if err != nil {
log.Debugf("could not open any path in: %v", certPath)
return nil
}
for {
var block *pem.Block
block, pemByte = pem.Decode(pemByte)
if block == nil {
break
}
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
log.Debugf("could not parse cert in: %v, err: %v", certPath, err)
return nil
}
certPool.AddCert(cert)
}
log.Debugf("using local pool for loopback proxy: %v, err: %v", certPath, err)
return certPool
}
|
go
|
func loopbackPool(proxyAddr string) *x509.CertPool {
if !utils.IsLoopback(proxyAddr) {
log.Debugf("not using loopback pool for remote proxy addr: %v", proxyAddr)
return nil
}
log.Debugf("attempting to use loopback pool for local proxy addr: %v", proxyAddr)
certPool := x509.NewCertPool()
certPath := filepath.Join(defaults.DataDir, defaults.SelfSignedCertPath)
pemByte, err := ioutil.ReadFile(certPath)
if err != nil {
log.Debugf("could not open any path in: %v", certPath)
return nil
}
for {
var block *pem.Block
block, pemByte = pem.Decode(pemByte)
if block == nil {
break
}
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
log.Debugf("could not parse cert in: %v, err: %v", certPath, err)
return nil
}
certPool.AddCert(cert)
}
log.Debugf("using local pool for loopback proxy: %v, err: %v", certPath, err)
return certPool
}
|
[
"func",
"loopbackPool",
"(",
"proxyAddr",
"string",
")",
"*",
"x509",
".",
"CertPool",
"{",
"if",
"!",
"utils",
".",
"IsLoopback",
"(",
"proxyAddr",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"not using loopback pool for remote proxy addr: %v\"",
",",
"proxyAddr",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"attempting to use loopback pool for local proxy addr: %v\"",
",",
"proxyAddr",
")",
"\n",
"certPool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"certPath",
":=",
"filepath",
".",
"Join",
"(",
"defaults",
".",
"DataDir",
",",
"defaults",
".",
"SelfSignedCertPath",
")",
"\n",
"pemByte",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"certPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"could not open any path in: %v\"",
",",
"certPath",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"{",
"var",
"block",
"*",
"pem",
".",
"Block",
"\n",
"block",
",",
"pemByte",
"=",
"pem",
".",
"Decode",
"(",
"pemByte",
")",
"\n",
"if",
"block",
"==",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"cert",
",",
"err",
":=",
"x509",
".",
"ParseCertificate",
"(",
"block",
".",
"Bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"could not parse cert in: %v, err: %v\"",
",",
"certPath",
",",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"certPool",
".",
"AddCert",
"(",
"cert",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"using local pool for loopback proxy: %v, err: %v\"",
",",
"certPath",
",",
"err",
")",
"\n",
"return",
"certPool",
"\n",
"}"
] |
// loopbackPool reads trusted CAs if it finds it in a predefined location
// and will work only if target proxy address is loopback
|
[
"loopbackPool",
"reads",
"trusted",
"CAs",
"if",
"it",
"finds",
"it",
"in",
"a",
"predefined",
"location",
"and",
"will",
"work",
"only",
"if",
"target",
"proxy",
"address",
"is",
"loopback"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1878-L1908
|
train
|
gravitational/teleport
|
lib/client/api.go
|
connectToSSHAgent
|
func connectToSSHAgent() agent.Agent {
socketPath := os.Getenv(teleport.SSHAuthSock)
conn, err := agentconn.Dial(socketPath)
if err != nil {
log.Errorf("[KEY AGENT] Unable to connect to SSH agent on socket: %q.", socketPath)
return nil
}
log.Infof("[KEY AGENT] Connected to the system agent: %q", socketPath)
return agent.NewClient(conn)
}
|
go
|
func connectToSSHAgent() agent.Agent {
socketPath := os.Getenv(teleport.SSHAuthSock)
conn, err := agentconn.Dial(socketPath)
if err != nil {
log.Errorf("[KEY AGENT] Unable to connect to SSH agent on socket: %q.", socketPath)
return nil
}
log.Infof("[KEY AGENT] Connected to the system agent: %q", socketPath)
return agent.NewClient(conn)
}
|
[
"func",
"connectToSSHAgent",
"(",
")",
"agent",
".",
"Agent",
"{",
"socketPath",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"SSHAuthSock",
")",
"\n",
"conn",
",",
"err",
":=",
"agentconn",
".",
"Dial",
"(",
"socketPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"[KEY AGENT] Unable to connect to SSH agent on socket: %q.\"",
",",
"socketPath",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"[KEY AGENT] Connected to the system agent: %q\"",
",",
"socketPath",
")",
"\n",
"return",
"agent",
".",
"NewClient",
"(",
"conn",
")",
"\n",
"}"
] |
// connectToSSHAgent connects to the local SSH agent and returns a agent.Agent.
|
[
"connectToSSHAgent",
"connects",
"to",
"the",
"local",
"SSH",
"agent",
"and",
"returns",
"a",
"agent",
".",
"Agent",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1911-L1921
|
train
|
gravitational/teleport
|
lib/client/api.go
|
Username
|
func Username() (string, error) {
u, err := user.Current()
if err != nil {
return "", trace.Wrap(err)
}
return u.Username, nil
}
|
go
|
func Username() (string, error) {
u, err := user.Current()
if err != nil {
return "", trace.Wrap(err)
}
return u.Username, nil
}
|
[
"func",
"Username",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"user",
".",
"Current",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"u",
".",
"Username",
",",
"nil",
"\n",
"}"
] |
// Username returns the current user's username
|
[
"Username",
"returns",
"the",
"current",
"user",
"s",
"username"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1924-L1930
|
train
|
gravitational/teleport
|
lib/client/api.go
|
AskOTP
|
func (tc *TeleportClient) AskOTP() (token string, err error) {
fmt.Printf("Enter your OTP token:\n")
token, err = lineFromConsole()
if err != nil {
fmt.Fprintln(tc.Stderr, err)
return "", trace.Wrap(err)
}
return token, nil
}
|
go
|
func (tc *TeleportClient) AskOTP() (token string, err error) {
fmt.Printf("Enter your OTP token:\n")
token, err = lineFromConsole()
if err != nil {
fmt.Fprintln(tc.Stderr, err)
return "", trace.Wrap(err)
}
return token, nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"AskOTP",
"(",
")",
"(",
"token",
"string",
",",
"err",
"error",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"Enter your OTP token:\\n\"",
")",
"\n",
"\\n",
"\n",
"token",
",",
"err",
"=",
"lineFromConsole",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"tc",
".",
"Stderr",
",",
"err",
")",
"\n",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// AskOTP prompts the user to enter the OTP token.
|
[
"AskOTP",
"prompts",
"the",
"user",
"to",
"enter",
"the",
"OTP",
"token",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1933-L1941
|
train
|
gravitational/teleport
|
lib/client/api.go
|
AskPassword
|
func (tc *TeleportClient) AskPassword() (pwd string, err error) {
fmt.Printf("Enter password for Teleport user %v:\n", tc.Config.Username)
pwd, err = passwordFromConsole()
if err != nil {
fmt.Fprintln(tc.Stderr, err)
return "", trace.Wrap(err)
}
return pwd, nil
}
|
go
|
func (tc *TeleportClient) AskPassword() (pwd string, err error) {
fmt.Printf("Enter password for Teleport user %v:\n", tc.Config.Username)
pwd, err = passwordFromConsole()
if err != nil {
fmt.Fprintln(tc.Stderr, err)
return "", trace.Wrap(err)
}
return pwd, nil
}
|
[
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"AskPassword",
"(",
")",
"(",
"pwd",
"string",
",",
"err",
"error",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"Enter password for Teleport user %v:\\n\"",
",",
"\\n",
")",
"\n",
"tc",
".",
"Config",
".",
"Username",
"\n",
"pwd",
",",
"err",
"=",
"passwordFromConsole",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Fprintln",
"(",
"tc",
".",
"Stderr",
",",
"err",
")",
"\n",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// AskPassword prompts the user to enter the password
|
[
"AskPassword",
"prompts",
"the",
"user",
"to",
"enter",
"the",
"password"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1944-L1953
|
train
|
gravitational/teleport
|
lib/client/api.go
|
passwordFromConsole
|
func passwordFromConsole() (string, error) {
fd := syscall.Stdin
state, err := terminal.GetState(int(fd))
// intercept Ctr+C and restore terminal
sigCh := make(chan os.Signal, 1)
closeCh := make(chan int)
if err != nil {
log.Warnf("failed reading terminal state: %v", err)
} else {
signal.Notify(sigCh, syscall.SIGINT)
go func() {
select {
case <-sigCh:
terminal.Restore(int(fd), state)
os.Exit(1)
case <-closeCh:
}
}()
}
defer func() {
close(closeCh)
}()
bytes, err := terminal.ReadPassword(int(fd))
return string(bytes), err
}
|
go
|
func passwordFromConsole() (string, error) {
fd := syscall.Stdin
state, err := terminal.GetState(int(fd))
// intercept Ctr+C and restore terminal
sigCh := make(chan os.Signal, 1)
closeCh := make(chan int)
if err != nil {
log.Warnf("failed reading terminal state: %v", err)
} else {
signal.Notify(sigCh, syscall.SIGINT)
go func() {
select {
case <-sigCh:
terminal.Restore(int(fd), state)
os.Exit(1)
case <-closeCh:
}
}()
}
defer func() {
close(closeCh)
}()
bytes, err := terminal.ReadPassword(int(fd))
return string(bytes), err
}
|
[
"func",
"passwordFromConsole",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"fd",
":=",
"syscall",
".",
"Stdin",
"\n",
"state",
",",
"err",
":=",
"terminal",
".",
"GetState",
"(",
"int",
"(",
"fd",
")",
")",
"\n",
"sigCh",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"closeCh",
":=",
"make",
"(",
"chan",
"int",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"failed reading terminal state: %v\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"signal",
".",
"Notify",
"(",
"sigCh",
",",
"syscall",
".",
"SIGINT",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"select",
"{",
"case",
"<-",
"sigCh",
":",
"terminal",
".",
"Restore",
"(",
"int",
"(",
"fd",
")",
",",
"state",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"case",
"<-",
"closeCh",
":",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"defer",
"func",
"(",
")",
"{",
"close",
"(",
"closeCh",
")",
"\n",
"}",
"(",
")",
"\n",
"bytes",
",",
"err",
":=",
"terminal",
".",
"ReadPassword",
"(",
"int",
"(",
"fd",
")",
")",
"\n",
"return",
"string",
"(",
"bytes",
")",
",",
"err",
"\n",
"}"
] |
// passwordFromConsole reads from stdin without echoing typed characters to stdout
|
[
"passwordFromConsole",
"reads",
"from",
"stdin",
"without",
"echoing",
"typed",
"characters",
"to",
"stdout"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1956-L1982
|
train
|
gravitational/teleport
|
lib/client/api.go
|
lineFromConsole
|
func lineFromConsole() (string, error) {
bytes, _, err := bufio.NewReader(os.Stdin).ReadLine()
return string(bytes), err
}
|
go
|
func lineFromConsole() (string, error) {
bytes, _, err := bufio.NewReader(os.Stdin).ReadLine()
return string(bytes), err
}
|
[
"func",
"lineFromConsole",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"bytes",
",",
"_",
",",
"err",
":=",
"bufio",
".",
"NewReader",
"(",
"os",
".",
"Stdin",
")",
".",
"ReadLine",
"(",
")",
"\n",
"return",
"string",
"(",
"bytes",
")",
",",
"err",
"\n",
"}"
] |
// lineFromConsole reads a line from stdin
|
[
"lineFromConsole",
"reads",
"a",
"line",
"from",
"stdin"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L1985-L1988
|
train
|
gravitational/teleport
|
lib/client/api.go
|
String
|
func (fp DynamicForwardedPorts) String() (retval []string) {
for _, p := range fp {
retval = append(retval, p.ToString())
}
return retval
}
|
go
|
func (fp DynamicForwardedPorts) String() (retval []string) {
for _, p := range fp {
retval = append(retval, p.ToString())
}
return retval
}
|
[
"func",
"(",
"fp",
"DynamicForwardedPorts",
")",
"String",
"(",
")",
"(",
"retval",
"[",
"]",
"string",
")",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"fp",
"{",
"retval",
"=",
"append",
"(",
"retval",
",",
"p",
".",
"ToString",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"retval",
"\n",
"}"
] |
// String returns the same string spec which can be parsed by
// ParseDynamicPortForwardSpec.
|
[
"String",
"returns",
"the",
"same",
"string",
"spec",
"which",
"can",
"be",
"parsed",
"by",
"ParseDynamicPortForwardSpec",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L2097-L2102
|
train
|
gravitational/teleport
|
lib/client/api.go
|
InsecureSkipHostKeyChecking
|
func InsecureSkipHostKeyChecking(host string, remote net.Addr, key ssh.PublicKey) error {
return nil
}
|
go
|
func InsecureSkipHostKeyChecking(host string, remote net.Addr, key ssh.PublicKey) error {
return nil
}
|
[
"func",
"InsecureSkipHostKeyChecking",
"(",
"host",
"string",
",",
"remote",
"net",
".",
"Addr",
",",
"key",
"ssh",
".",
"PublicKey",
")",
"error",
"{",
"return",
"nil",
"\n",
"}"
] |
// InsecureSkipHostKeyChecking is used when the user passes in
// "StrictHostKeyChecking yes".
|
[
"InsecureSkipHostKeyChecking",
"is",
"used",
"when",
"the",
"user",
"passes",
"in",
"StrictHostKeyChecking",
"yes",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/api.go#L2137-L2139
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
OpenChannel
|
func (c *remoteConn) OpenChannel(name string, data []byte) (ssh.Channel, error) {
channel, _, err := c.sconn.OpenChannel(name, data)
if err != nil {
return nil, trace.Wrap(err)
}
return channel, nil
}
|
go
|
func (c *remoteConn) OpenChannel(name string, data []byte) (ssh.Channel, error) {
channel, _, err := c.sconn.OpenChannel(name, data)
if err != nil {
return nil, trace.Wrap(err)
}
return channel, nil
}
|
[
"func",
"(",
"c",
"*",
"remoteConn",
")",
"OpenChannel",
"(",
"name",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"ssh",
".",
"Channel",
",",
"error",
")",
"{",
"channel",
",",
"_",
",",
"err",
":=",
"c",
".",
"sconn",
".",
"OpenChannel",
"(",
"name",
",",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"channel",
",",
"nil",
"\n",
"}"
] |
// OpenChannel will open a SSH channel to the remote side.
|
[
"OpenChannel",
"will",
"open",
"a",
"SSH",
"channel",
"to",
"the",
"remote",
"side",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L149-L156
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
ChannelConn
|
func (c *remoteConn) ChannelConn(channel ssh.Channel) net.Conn {
return utils.NewChConn(c.sconn, channel)
}
|
go
|
func (c *remoteConn) ChannelConn(channel ssh.Channel) net.Conn {
return utils.NewChConn(c.sconn, channel)
}
|
[
"func",
"(",
"c",
"*",
"remoteConn",
")",
"ChannelConn",
"(",
"channel",
"ssh",
".",
"Channel",
")",
"net",
".",
"Conn",
"{",
"return",
"utils",
".",
"NewChConn",
"(",
"c",
".",
"sconn",
",",
"channel",
")",
"\n",
"}"
] |
// ChannelConn creates a net.Conn over a SSH channel.
|
[
"ChannelConn",
"creates",
"a",
"net",
".",
"Conn",
"over",
"a",
"SSH",
"channel",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L159-L161
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
findAndSend
|
func (c *remoteConn) findAndSend() error {
// Find all proxies that don't have a connection to a remote agent. If all
// proxies have connections, return right away.
disconnectedProxies, err := c.findDisconnectedProxies()
if err != nil {
return trace.Wrap(err)
}
if len(disconnectedProxies) == 0 {
return nil
}
c.log.Debugf("Proxy %v sending %v discovery request with tunnel ID: %v and disconnected proxies: %v.",
c.proxyName, string(c.tunnelType), c.tunnelID, Proxies(disconnectedProxies))
req := discoveryRequest{
TunnelID: c.tunnelID,
Type: string(c.tunnelType),
Proxies: disconnectedProxies,
}
err = c.sendDiscoveryRequests(req)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (c *remoteConn) findAndSend() error {
// Find all proxies that don't have a connection to a remote agent. If all
// proxies have connections, return right away.
disconnectedProxies, err := c.findDisconnectedProxies()
if err != nil {
return trace.Wrap(err)
}
if len(disconnectedProxies) == 0 {
return nil
}
c.log.Debugf("Proxy %v sending %v discovery request with tunnel ID: %v and disconnected proxies: %v.",
c.proxyName, string(c.tunnelType), c.tunnelID, Proxies(disconnectedProxies))
req := discoveryRequest{
TunnelID: c.tunnelID,
Type: string(c.tunnelType),
Proxies: disconnectedProxies,
}
err = c.sendDiscoveryRequests(req)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"remoteConn",
")",
"findAndSend",
"(",
")",
"error",
"{",
"disconnectedProxies",
",",
"err",
":=",
"c",
".",
"findDisconnectedProxies",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"disconnectedProxies",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"c",
".",
"log",
".",
"Debugf",
"(",
"\"Proxy %v sending %v discovery request with tunnel ID: %v and disconnected proxies: %v.\"",
",",
"c",
".",
"proxyName",
",",
"string",
"(",
"c",
".",
"tunnelType",
")",
",",
"c",
".",
"tunnelID",
",",
"Proxies",
"(",
"disconnectedProxies",
")",
")",
"\n",
"req",
":=",
"discoveryRequest",
"{",
"TunnelID",
":",
"c",
".",
"tunnelID",
",",
"Type",
":",
"string",
"(",
"c",
".",
"tunnelType",
")",
",",
"Proxies",
":",
"disconnectedProxies",
",",
"}",
"\n",
"err",
"=",
"c",
".",
"sendDiscoveryRequests",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// sendDiscovery requests sends special "Discovery Requests" back to the
// connected agent. Discovery request consists of the proxies that are part
// of the cluster, but did not receive the connection from the agent. Agent
// will act on a discovery request attempting to establish connection to the
// proxies that were not discovered.
|
[
"sendDiscovery",
"requests",
"sends",
"special",
"Discovery",
"Requests",
"back",
"to",
"the",
"connected",
"agent",
".",
"Discovery",
"request",
"consists",
"of",
"the",
"proxies",
"that",
"are",
"part",
"of",
"the",
"cluster",
"but",
"did",
"not",
"receive",
"the",
"connection",
"from",
"the",
"agent",
".",
"Agent",
"will",
"act",
"on",
"a",
"discovery",
"request",
"attempting",
"to",
"establish",
"connection",
"to",
"the",
"proxies",
"that",
"were",
"not",
"discovered",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L232-L258
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
findDisconnectedProxies
|
func (c *remoteConn) findDisconnectedProxies() ([]services.Server, error) {
// Find all proxies that have connection from the remote domain.
conns, err := c.accessPoint.GetTunnelConnections(c.clusterName, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
connected := make(map[string]bool)
for _, conn := range conns {
if c.isOnline(conn) {
connected[conn.GetProxyName()] = true
}
}
// Build a list of local proxies that do not have a remote connection to them.
var missing []services.Server
proxies, err := c.accessPoint.GetProxies()
if err != nil {
return nil, trace.Wrap(err)
}
for i := range proxies {
proxy := proxies[i]
// A proxy should never add itself to the list of missing proxies.
if proxy.GetName() == c.proxyName {
continue
}
if !connected[proxy.GetName()] {
missing = append(missing, proxy)
}
}
return missing, nil
}
|
go
|
func (c *remoteConn) findDisconnectedProxies() ([]services.Server, error) {
// Find all proxies that have connection from the remote domain.
conns, err := c.accessPoint.GetTunnelConnections(c.clusterName, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
connected := make(map[string]bool)
for _, conn := range conns {
if c.isOnline(conn) {
connected[conn.GetProxyName()] = true
}
}
// Build a list of local proxies that do not have a remote connection to them.
var missing []services.Server
proxies, err := c.accessPoint.GetProxies()
if err != nil {
return nil, trace.Wrap(err)
}
for i := range proxies {
proxy := proxies[i]
// A proxy should never add itself to the list of missing proxies.
if proxy.GetName() == c.proxyName {
continue
}
if !connected[proxy.GetName()] {
missing = append(missing, proxy)
}
}
return missing, nil
}
|
[
"func",
"(",
"c",
"*",
"remoteConn",
")",
"findDisconnectedProxies",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"conns",
",",
"err",
":=",
"c",
".",
"accessPoint",
".",
"GetTunnelConnections",
"(",
"c",
".",
"clusterName",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"connected",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"conn",
":=",
"range",
"conns",
"{",
"if",
"c",
".",
"isOnline",
"(",
"conn",
")",
"{",
"connected",
"[",
"conn",
".",
"GetProxyName",
"(",
")",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"missing",
"[",
"]",
"services",
".",
"Server",
"\n",
"proxies",
",",
"err",
":=",
"c",
".",
"accessPoint",
".",
"GetProxies",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"proxies",
"{",
"proxy",
":=",
"proxies",
"[",
"i",
"]",
"\n",
"if",
"proxy",
".",
"GetName",
"(",
")",
"==",
"c",
".",
"proxyName",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"connected",
"[",
"proxy",
".",
"GetName",
"(",
")",
"]",
"{",
"missing",
"=",
"append",
"(",
"missing",
",",
"proxy",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"missing",
",",
"nil",
"\n",
"}"
] |
// findDisconnectedProxies finds proxies that do not have inbound reverse tunnel
// connections.
|
[
"findDisconnectedProxies",
"finds",
"proxies",
"that",
"do",
"not",
"have",
"inbound",
"reverse",
"tunnel",
"connections",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L262-L295
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
sendDiscoveryRequests
|
func (c *remoteConn) sendDiscoveryRequests(req discoveryRequest) error {
discoveryCh, err := c.openDiscoveryChannel()
if err != nil {
return trace.Wrap(err)
}
// Marshal and send the request. If the connection failed, mark the
// connection as invalid so it will be removed later.
payload, err := marshalDiscoveryRequest(req)
if err != nil {
return trace.Wrap(err)
}
_, err = discoveryCh.SendRequest(chanDiscoveryReq, false, payload)
if err != nil {
c.markInvalid(err)
return trace.Wrap(err)
}
return nil
}
|
go
|
func (c *remoteConn) sendDiscoveryRequests(req discoveryRequest) error {
discoveryCh, err := c.openDiscoveryChannel()
if err != nil {
return trace.Wrap(err)
}
// Marshal and send the request. If the connection failed, mark the
// connection as invalid so it will be removed later.
payload, err := marshalDiscoveryRequest(req)
if err != nil {
return trace.Wrap(err)
}
_, err = discoveryCh.SendRequest(chanDiscoveryReq, false, payload)
if err != nil {
c.markInvalid(err)
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"remoteConn",
")",
"sendDiscoveryRequests",
"(",
"req",
"discoveryRequest",
")",
"error",
"{",
"discoveryCh",
",",
"err",
":=",
"c",
".",
"openDiscoveryChannel",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"payload",
",",
"err",
":=",
"marshalDiscoveryRequest",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"discoveryCh",
".",
"SendRequest",
"(",
"chanDiscoveryReq",
",",
"false",
",",
"payload",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"markInvalid",
"(",
"err",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// sendDiscoveryRequests sends a discovery request with missing proxies.
|
[
"sendDiscoveryRequests",
"sends",
"a",
"discovery",
"request",
"with",
"missing",
"proxies",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L298-L317
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
TunnelAuthDialer
|
func TunnelAuthDialer(proxyAddr string, sshConfig *ssh.ClientConfig) auth.DialContext {
return func(ctx context.Context, network string, addr string) (net.Conn, error) {
// Connect to the reverse tunnel server.
dialer := proxy.DialerFromEnvironment(proxyAddr)
sconn, err := dialer.Dial("tcp", proxyAddr, sshConfig)
if err != nil {
return nil, trace.Wrap(err)
}
conn, err := connectProxyTransport(sconn.Conn, RemoteAuthServer)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
}
}
|
go
|
func TunnelAuthDialer(proxyAddr string, sshConfig *ssh.ClientConfig) auth.DialContext {
return func(ctx context.Context, network string, addr string) (net.Conn, error) {
// Connect to the reverse tunnel server.
dialer := proxy.DialerFromEnvironment(proxyAddr)
sconn, err := dialer.Dial("tcp", proxyAddr, sshConfig)
if err != nil {
return nil, trace.Wrap(err)
}
conn, err := connectProxyTransport(sconn.Conn, RemoteAuthServer)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
}
}
|
[
"func",
"TunnelAuthDialer",
"(",
"proxyAddr",
"string",
",",
"sshConfig",
"*",
"ssh",
".",
"ClientConfig",
")",
"auth",
".",
"DialContext",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"network",
"string",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"dialer",
":=",
"proxy",
".",
"DialerFromEnvironment",
"(",
"proxyAddr",
")",
"\n",
"sconn",
",",
"err",
":=",
"dialer",
".",
"Dial",
"(",
"\"tcp\"",
",",
"proxyAddr",
",",
"sshConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"connectProxyTransport",
"(",
"sconn",
".",
"Conn",
",",
"RemoteAuthServer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// TunnelAuthDialer connects to the Auth Server through the reverse tunnel.
|
[
"TunnelAuthDialer",
"connects",
"to",
"the",
"Auth",
"Server",
"through",
"the",
"reverse",
"tunnel",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L341-L356
|
train
|
gravitational/teleport
|
lib/reversetunnel/conn.go
|
connectProxyTransport
|
func connectProxyTransport(sconn ssh.Conn, addr string) (net.Conn, error) {
channel, _, err := sconn.OpenChannel(chanTransport, nil)
if err != nil {
return nil, trace.Wrap(err)
}
// Send a special SSH out-of-band request called "teleport-transport"
// the agent on the other side will create a new TCP/IP connection to
// 'addr' on its network and will start proxying that connection over
// this SSH channel.
ok, err := channel.SendRequest(chanTransportDialReq, true, []byte(addr))
if err != nil {
return nil, trace.Wrap(err)
}
if !ok {
defer channel.Close()
// Pull the error message from the tunnel client (remote cluster)
// passed to us via stderr.
errMessage, _ := ioutil.ReadAll(channel.Stderr())
if errMessage == nil {
errMessage = []byte("failed connecting to " + addr)
}
return nil, trace.Errorf(strings.TrimSpace(string(errMessage)))
}
return utils.NewChConn(sconn, channel), nil
}
|
go
|
func connectProxyTransport(sconn ssh.Conn, addr string) (net.Conn, error) {
channel, _, err := sconn.OpenChannel(chanTransport, nil)
if err != nil {
return nil, trace.Wrap(err)
}
// Send a special SSH out-of-band request called "teleport-transport"
// the agent on the other side will create a new TCP/IP connection to
// 'addr' on its network and will start proxying that connection over
// this SSH channel.
ok, err := channel.SendRequest(chanTransportDialReq, true, []byte(addr))
if err != nil {
return nil, trace.Wrap(err)
}
if !ok {
defer channel.Close()
// Pull the error message from the tunnel client (remote cluster)
// passed to us via stderr.
errMessage, _ := ioutil.ReadAll(channel.Stderr())
if errMessage == nil {
errMessage = []byte("failed connecting to " + addr)
}
return nil, trace.Errorf(strings.TrimSpace(string(errMessage)))
}
return utils.NewChConn(sconn, channel), nil
}
|
[
"func",
"connectProxyTransport",
"(",
"sconn",
"ssh",
".",
"Conn",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"channel",
",",
"_",
",",
"err",
":=",
"sconn",
".",
"OpenChannel",
"(",
"chanTransport",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ok",
",",
"err",
":=",
"channel",
".",
"SendRequest",
"(",
"chanTransportDialReq",
",",
"true",
",",
"[",
"]",
"byte",
"(",
"addr",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"defer",
"channel",
".",
"Close",
"(",
")",
"\n",
"errMessage",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"channel",
".",
"Stderr",
"(",
")",
")",
"\n",
"if",
"errMessage",
"==",
"nil",
"{",
"errMessage",
"=",
"[",
"]",
"byte",
"(",
"\"failed connecting to \"",
"+",
"addr",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Errorf",
"(",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"errMessage",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"NewChConn",
"(",
"sconn",
",",
"channel",
")",
",",
"nil",
"\n",
"}"
] |
// connectProxyTransport opens a channel over the remote tunnel and connects
// to the requested host.
|
[
"connectProxyTransport",
"opens",
"a",
"channel",
"over",
"the",
"remote",
"tunnel",
"and",
"connects",
"to",
"the",
"requested",
"host",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/conn.go#L360-L387
|
train
|
gravitational/teleport
|
lib/service/service.go
|
Close
|
func (c *Connector) Close() error {
if c.Client != nil {
return c.Close()
}
return nil
}
|
go
|
func (c *Connector) Close() error {
if c.Client != nil {
return c.Close()
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Connector",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Client",
"!=",
"nil",
"{",
"return",
"c",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close closes resources associated with connector
|
[
"Close",
"closes",
"resources",
"associated",
"with",
"connector"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L179-L184
|
train
|
gravitational/teleport
|
lib/service/service.go
|
getConnectors
|
func (process *TeleportProcess) getConnectors() []*Connector {
process.Lock()
defer process.Unlock()
out := make([]*Connector, 0, len(process.connectors))
for role := range process.connectors {
out = append(out, process.connectors[role])
}
return out
}
|
go
|
func (process *TeleportProcess) getConnectors() []*Connector {
process.Lock()
defer process.Unlock()
out := make([]*Connector, 0, len(process.connectors))
for role := range process.connectors {
out = append(out, process.connectors[role])
}
return out
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"getConnectors",
"(",
")",
"[",
"]",
"*",
"Connector",
"{",
"process",
".",
"Lock",
"(",
")",
"\n",
"defer",
"process",
".",
"Unlock",
"(",
")",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"*",
"Connector",
",",
"0",
",",
"len",
"(",
"process",
".",
"connectors",
")",
")",
"\n",
"for",
"role",
":=",
"range",
"process",
".",
"connectors",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"process",
".",
"connectors",
"[",
"role",
"]",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] |
// getConnectors returns a copy of the identities registered for auth server
|
[
"getConnectors",
"returns",
"a",
"copy",
"of",
"the",
"identities",
"registered",
"for",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L279-L288
|
train
|
gravitational/teleport
|
lib/service/service.go
|
addConnector
|
func (process *TeleportProcess) addConnector(connector *Connector) {
process.Lock()
defer process.Unlock()
process.connectors[connector.ClientIdentity.ID.Role] = connector
}
|
go
|
func (process *TeleportProcess) addConnector(connector *Connector) {
process.Lock()
defer process.Unlock()
process.connectors[connector.ClientIdentity.ID.Role] = connector
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"addConnector",
"(",
"connector",
"*",
"Connector",
")",
"{",
"process",
".",
"Lock",
"(",
")",
"\n",
"defer",
"process",
".",
"Unlock",
"(",
")",
"\n",
"process",
".",
"connectors",
"[",
"connector",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"]",
"=",
"connector",
"\n",
"}"
] |
// addConnector adds connector to registered connectors list,
// it will overwrite the connector for the same role
|
[
"addConnector",
"adds",
"connector",
"to",
"registered",
"connectors",
"list",
"it",
"will",
"overwrite",
"the",
"connector",
"for",
"the",
"same",
"role"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L292-L297
|
train
|
gravitational/teleport
|
lib/service/service.go
|
Run
|
func Run(ctx context.Context, cfg Config, newTeleport NewProcess) error {
if newTeleport == nil {
newTeleport = newTeleportProcess
}
copyCfg := cfg
srv, err := newTeleport(©Cfg)
if err != nil {
return trace.Wrap(err, "initialization failed")
}
if srv == nil {
return trace.BadParameter("process has returned nil server")
}
if err := srv.Start(); err != nil {
return trace.Wrap(err, "startup failed")
}
// Wait and reload until called exit.
for {
srv, err = waitAndReload(ctx, cfg, srv, newTeleport)
if err != nil {
// This error means that was a clean shutdown
// and no reload is necessary.
if err == ErrTeleportExited {
return nil
}
return trace.Wrap(err)
}
}
}
|
go
|
func Run(ctx context.Context, cfg Config, newTeleport NewProcess) error {
if newTeleport == nil {
newTeleport = newTeleportProcess
}
copyCfg := cfg
srv, err := newTeleport(©Cfg)
if err != nil {
return trace.Wrap(err, "initialization failed")
}
if srv == nil {
return trace.BadParameter("process has returned nil server")
}
if err := srv.Start(); err != nil {
return trace.Wrap(err, "startup failed")
}
// Wait and reload until called exit.
for {
srv, err = waitAndReload(ctx, cfg, srv, newTeleport)
if err != nil {
// This error means that was a clean shutdown
// and no reload is necessary.
if err == ErrTeleportExited {
return nil
}
return trace.Wrap(err)
}
}
}
|
[
"func",
"Run",
"(",
"ctx",
"context",
".",
"Context",
",",
"cfg",
"Config",
",",
"newTeleport",
"NewProcess",
")",
"error",
"{",
"if",
"newTeleport",
"==",
"nil",
"{",
"newTeleport",
"=",
"newTeleportProcess",
"\n",
"}",
"\n",
"copyCfg",
":=",
"cfg",
"\n",
"srv",
",",
"err",
":=",
"newTeleport",
"(",
"&",
"copyCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"initialization failed\"",
")",
"\n",
"}",
"\n",
"if",
"srv",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"process has returned nil server\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"srv",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"startup failed\"",
")",
"\n",
"}",
"\n",
"for",
"{",
"srv",
",",
"err",
"=",
"waitAndReload",
"(",
"ctx",
",",
"cfg",
",",
"srv",
",",
"newTeleport",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"ErrTeleportExited",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Run starts teleport processes, waits for signals
// and handles internal process reloads.
|
[
"Run",
"starts",
"teleport",
"processes",
"waits",
"for",
"signals",
"and",
"handles",
"internal",
"process",
"reloads",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L379-L406
|
train
|
gravitational/teleport
|
lib/service/service.go
|
notifyParent
|
func (process *TeleportProcess) notifyParent() {
signalPipe, err := process.importSignalPipe()
if err != nil {
if !trace.IsNotFound(err) {
process.Warningf("Failed to import signal pipe")
}
process.Debugf("No signal pipe to import, must be first Teleport process.")
return
}
defer signalPipe.Close()
ctx, cancel := context.WithTimeout(process.ExitContext(), signalPipeTimeout)
defer cancel()
eventC := make(chan Event, 1)
process.WaitForEvent(ctx, TeleportReadyEvent, eventC)
select {
case <-eventC:
process.Infof("New service has started successfully.")
case <-ctx.Done():
process.Errorf("Timeout waiting for a forked process to start: %v. Initiating self-shutdown.", ctx.Err())
if err := process.Close(); err != nil {
process.Warningf("Failed to shutdown process: %v.", err)
}
return
}
if err := process.writeToSignalPipe(signalPipe, fmt.Sprintf("Process %v has started.", os.Getpid())); err != nil {
process.Warningf("Failed to write to signal pipe: %v", err)
// despite the failure, it's ok to proceed,
// it could mean that the parent process has crashed and the pipe
// is no longer valid.
}
}
|
go
|
func (process *TeleportProcess) notifyParent() {
signalPipe, err := process.importSignalPipe()
if err != nil {
if !trace.IsNotFound(err) {
process.Warningf("Failed to import signal pipe")
}
process.Debugf("No signal pipe to import, must be first Teleport process.")
return
}
defer signalPipe.Close()
ctx, cancel := context.WithTimeout(process.ExitContext(), signalPipeTimeout)
defer cancel()
eventC := make(chan Event, 1)
process.WaitForEvent(ctx, TeleportReadyEvent, eventC)
select {
case <-eventC:
process.Infof("New service has started successfully.")
case <-ctx.Done():
process.Errorf("Timeout waiting for a forked process to start: %v. Initiating self-shutdown.", ctx.Err())
if err := process.Close(); err != nil {
process.Warningf("Failed to shutdown process: %v.", err)
}
return
}
if err := process.writeToSignalPipe(signalPipe, fmt.Sprintf("Process %v has started.", os.Getpid())); err != nil {
process.Warningf("Failed to write to signal pipe: %v", err)
// despite the failure, it's ok to proceed,
// it could mean that the parent process has crashed and the pipe
// is no longer valid.
}
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"notifyParent",
"(",
")",
"{",
"signalPipe",
",",
"err",
":=",
"process",
".",
"importSignalPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"process",
".",
"Warningf",
"(",
"\"Failed to import signal pipe\"",
")",
"\n",
"}",
"\n",
"process",
".",
"Debugf",
"(",
"\"No signal pipe to import, must be first Teleport process.\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"defer",
"signalPipe",
".",
"Close",
"(",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"signalPipeTimeout",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"eventC",
":=",
"make",
"(",
"chan",
"Event",
",",
"1",
")",
"\n",
"process",
".",
"WaitForEvent",
"(",
"ctx",
",",
"TeleportReadyEvent",
",",
"eventC",
")",
"\n",
"select",
"{",
"case",
"<-",
"eventC",
":",
"process",
".",
"Infof",
"(",
"\"New service has started successfully.\"",
")",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"process",
".",
"Errorf",
"(",
"\"Timeout waiting for a forked process to start: %v. Initiating self-shutdown.\"",
",",
"ctx",
".",
"Err",
"(",
")",
")",
"\n",
"if",
"err",
":=",
"process",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"process",
".",
"Warningf",
"(",
"\"Failed to shutdown process: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"err",
":=",
"process",
".",
"writeToSignalPipe",
"(",
"signalPipe",
",",
"fmt",
".",
"Sprintf",
"(",
"\"Process %v has started.\"",
",",
"os",
".",
"Getpid",
"(",
")",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"process",
".",
"Warningf",
"(",
"\"Failed to write to signal pipe: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// notifyParent notifies parent process that this process has started
// by writing to in-memory pipe used by communication channel.
|
[
"notifyParent",
"notifies",
"parent",
"process",
"that",
"this",
"process",
"has",
"started",
"by",
"writing",
"to",
"in",
"-",
"memory",
"pipe",
"used",
"by",
"communication",
"channel",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L666-L699
|
train
|
gravitational/teleport
|
lib/service/service.go
|
adminCreds
|
func adminCreds() (*int, *int, error) {
if runtime.GOOS != teleport.LinuxOS {
return nil, nil, nil
}
// if the user member of adm linux group,
// make audit log folder readable by admins
isAdmin, err := utils.IsGroupMember(teleport.LinuxAdminGID)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if !isAdmin {
return nil, nil, nil
}
uid := os.Getuid()
gid := teleport.LinuxAdminGID
return &uid, &gid, nil
}
|
go
|
func adminCreds() (*int, *int, error) {
if runtime.GOOS != teleport.LinuxOS {
return nil, nil, nil
}
// if the user member of adm linux group,
// make audit log folder readable by admins
isAdmin, err := utils.IsGroupMember(teleport.LinuxAdminGID)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if !isAdmin {
return nil, nil, nil
}
uid := os.Getuid()
gid := teleport.LinuxAdminGID
return &uid, &gid, nil
}
|
[
"func",
"adminCreds",
"(",
")",
"(",
"*",
"int",
",",
"*",
"int",
",",
"error",
")",
"{",
"if",
"runtime",
".",
"GOOS",
"!=",
"teleport",
".",
"LinuxOS",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"isAdmin",
",",
"err",
":=",
"utils",
".",
"IsGroupMember",
"(",
"teleport",
".",
"LinuxAdminGID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"isAdmin",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"uid",
":=",
"os",
".",
"Getuid",
"(",
")",
"\n",
"gid",
":=",
"teleport",
".",
"LinuxAdminGID",
"\n",
"return",
"&",
"uid",
",",
"&",
"gid",
",",
"nil",
"\n",
"}"
] |
// adminCreds returns admin UID and GID settings based on the OS
|
[
"adminCreds",
"returns",
"admin",
"UID",
"and",
"GID",
"settings",
"based",
"on",
"the",
"OS"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L714-L730
|
train
|
gravitational/teleport
|
lib/service/service.go
|
initUploadHandler
|
func initUploadHandler(auditConfig services.AuditConfig) (events.UploadHandler, error) {
if auditConfig.AuditSessionsURI == "" {
return nil, trace.NotFound("no upload handler is setup")
}
uri, err := utils.ParseSessionsURI(auditConfig.AuditSessionsURI)
if err != nil {
return nil, trace.Wrap(err)
}
switch uri.Scheme {
case teleport.SchemeS3:
region := auditConfig.Region
if uriRegion := uri.Query().Get(teleport.Region); uriRegion != "" {
region = uriRegion
}
handler, err := s3sessions.NewHandler(s3sessions.Config{
Bucket: uri.Host,
Region: region,
Path: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
return handler, nil
case teleport.SchemeFile:
if err := os.MkdirAll(uri.Path, teleport.SharedDirMode); err != nil {
return nil, trace.ConvertSystemError(err)
}
handler, err := filesessions.NewHandler(filesessions.Config{
Directory: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
return handler, nil
default:
return nil, trace.BadParameter(
"unsupported scheme for audit_sesions_uri: %q, currently supported schemes are %q and %q",
uri.Scheme, teleport.SchemeS3, teleport.SchemeFile)
}
}
|
go
|
func initUploadHandler(auditConfig services.AuditConfig) (events.UploadHandler, error) {
if auditConfig.AuditSessionsURI == "" {
return nil, trace.NotFound("no upload handler is setup")
}
uri, err := utils.ParseSessionsURI(auditConfig.AuditSessionsURI)
if err != nil {
return nil, trace.Wrap(err)
}
switch uri.Scheme {
case teleport.SchemeS3:
region := auditConfig.Region
if uriRegion := uri.Query().Get(teleport.Region); uriRegion != "" {
region = uriRegion
}
handler, err := s3sessions.NewHandler(s3sessions.Config{
Bucket: uri.Host,
Region: region,
Path: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
return handler, nil
case teleport.SchemeFile:
if err := os.MkdirAll(uri.Path, teleport.SharedDirMode); err != nil {
return nil, trace.ConvertSystemError(err)
}
handler, err := filesessions.NewHandler(filesessions.Config{
Directory: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
return handler, nil
default:
return nil, trace.BadParameter(
"unsupported scheme for audit_sesions_uri: %q, currently supported schemes are %q and %q",
uri.Scheme, teleport.SchemeS3, teleport.SchemeFile)
}
}
|
[
"func",
"initUploadHandler",
"(",
"auditConfig",
"services",
".",
"AuditConfig",
")",
"(",
"events",
".",
"UploadHandler",
",",
"error",
")",
"{",
"if",
"auditConfig",
".",
"AuditSessionsURI",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"no upload handler is setup\"",
")",
"\n",
"}",
"\n",
"uri",
",",
"err",
":=",
"utils",
".",
"ParseSessionsURI",
"(",
"auditConfig",
".",
"AuditSessionsURI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"uri",
".",
"Scheme",
"{",
"case",
"teleport",
".",
"SchemeS3",
":",
"region",
":=",
"auditConfig",
".",
"Region",
"\n",
"if",
"uriRegion",
":=",
"uri",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"teleport",
".",
"Region",
")",
";",
"uriRegion",
"!=",
"\"\"",
"{",
"region",
"=",
"uriRegion",
"\n",
"}",
"\n",
"handler",
",",
"err",
":=",
"s3sessions",
".",
"NewHandler",
"(",
"s3sessions",
".",
"Config",
"{",
"Bucket",
":",
"uri",
".",
"Host",
",",
"Region",
":",
"region",
",",
"Path",
":",
"uri",
".",
"Path",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"handler",
",",
"nil",
"\n",
"case",
"teleport",
".",
"SchemeFile",
":",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"uri",
".",
"Path",
",",
"teleport",
".",
"SharedDirMode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"handler",
",",
"err",
":=",
"filesessions",
".",
"NewHandler",
"(",
"filesessions",
".",
"Config",
"{",
"Directory",
":",
"uri",
".",
"Path",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"handler",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unsupported scheme for audit_sesions_uri: %q, currently supported schemes are %q and %q\"",
",",
"uri",
".",
"Scheme",
",",
"teleport",
".",
"SchemeS3",
",",
"teleport",
".",
"SchemeFile",
")",
"\n",
"}",
"\n",
"}"
] |
// initUploadHandler initializes upload handler based on the config settings,
// currently the only upload handler supported is S3
// the call can return trace.NotFOund if no upload handler is setup
|
[
"initUploadHandler",
"initializes",
"upload",
"handler",
"based",
"on",
"the",
"config",
"settings",
"currently",
"the",
"only",
"upload",
"handler",
"supported",
"is",
"S3",
"the",
"call",
"can",
"return",
"trace",
".",
"NotFOund",
"if",
"no",
"upload",
"handler",
"is",
"setup"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L735-L775
|
train
|
gravitational/teleport
|
lib/service/service.go
|
initExternalLog
|
func initExternalLog(auditConfig services.AuditConfig) (events.IAuditLog, error) {
if auditConfig.AuditTableName != "" {
log.Warningf("Please note that 'audit_table_name' is deprecated and will be removed in several releases. Use audit_events_uri: '%v://%v' instead.", dynamo.GetName(), auditConfig.AuditTableName)
if len(auditConfig.AuditEventsURI) != 0 {
return nil, trace.BadParameter("Detected configuration specifying 'audit_table_name' and 'audit_events_uri' at the same time. Please migrate your config to use 'audit_events_uri' only.")
}
auditConfig.AuditEventsURI = []string{fmt.Sprintf("%v://%v", dynamo.GetName(), auditConfig.AuditTableName)}
}
if len(auditConfig.AuditEventsURI) > 0 && !auditConfig.ShouldUploadSessions() {
return nil, trace.BadParameter("please specify audit_sessions_uri when using external audit backends")
}
var hasNonFileLog bool
var loggers []events.IAuditLog
for _, eventsURI := range auditConfig.AuditEventsURI {
uri, err := utils.ParseSessionsURI(eventsURI)
if err != nil {
return nil, trace.Wrap(err)
}
switch uri.Scheme {
case dynamo.GetName():
hasNonFileLog = true
logger, err := dynamoevents.New(dynamoevents.Config{
Tablename: uri.Host,
Region: auditConfig.Region,
})
if err != nil {
return nil, trace.Wrap(err)
}
loggers = append(loggers, logger)
case teleport.SchemeFile:
if err := os.MkdirAll(uri.Path, teleport.SharedDirMode); err != nil {
return nil, trace.ConvertSystemError(err)
}
logger, err := events.NewFileLog(events.FileLogConfig{
Dir: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
loggers = append(loggers, logger)
default:
return nil, trace.BadParameter(
"unsupported scheme for audit_events_uri: %q, currently supported schemes are %q and %q",
uri.Scheme, dynamo.GetName(), teleport.SchemeFile)
}
}
// only file external loggers are prohibited (they are not supposed
// to be used on their own, only in combo with external loggers)
// they also don't implement certain features, so they are going
// to be inefficient
switch len(loggers) {
case 0:
return nil, trace.NotFound("no external log is defined")
case 1:
if !hasNonFileLog {
return nil, trace.BadParameter("file:// log can not be used on it's own, can be only used in combination with external session logs, e.g. dynamodb://")
}
return loggers[0], nil
default:
if !hasNonFileLog {
return nil, trace.BadParameter("file:// log can not be used on it's own, can be only used in combination with external session logs, e.g. dynamodb://")
}
return events.NewMultiLog(loggers...), nil
}
}
|
go
|
func initExternalLog(auditConfig services.AuditConfig) (events.IAuditLog, error) {
if auditConfig.AuditTableName != "" {
log.Warningf("Please note that 'audit_table_name' is deprecated and will be removed in several releases. Use audit_events_uri: '%v://%v' instead.", dynamo.GetName(), auditConfig.AuditTableName)
if len(auditConfig.AuditEventsURI) != 0 {
return nil, trace.BadParameter("Detected configuration specifying 'audit_table_name' and 'audit_events_uri' at the same time. Please migrate your config to use 'audit_events_uri' only.")
}
auditConfig.AuditEventsURI = []string{fmt.Sprintf("%v://%v", dynamo.GetName(), auditConfig.AuditTableName)}
}
if len(auditConfig.AuditEventsURI) > 0 && !auditConfig.ShouldUploadSessions() {
return nil, trace.BadParameter("please specify audit_sessions_uri when using external audit backends")
}
var hasNonFileLog bool
var loggers []events.IAuditLog
for _, eventsURI := range auditConfig.AuditEventsURI {
uri, err := utils.ParseSessionsURI(eventsURI)
if err != nil {
return nil, trace.Wrap(err)
}
switch uri.Scheme {
case dynamo.GetName():
hasNonFileLog = true
logger, err := dynamoevents.New(dynamoevents.Config{
Tablename: uri.Host,
Region: auditConfig.Region,
})
if err != nil {
return nil, trace.Wrap(err)
}
loggers = append(loggers, logger)
case teleport.SchemeFile:
if err := os.MkdirAll(uri.Path, teleport.SharedDirMode); err != nil {
return nil, trace.ConvertSystemError(err)
}
logger, err := events.NewFileLog(events.FileLogConfig{
Dir: uri.Path,
})
if err != nil {
return nil, trace.Wrap(err)
}
loggers = append(loggers, logger)
default:
return nil, trace.BadParameter(
"unsupported scheme for audit_events_uri: %q, currently supported schemes are %q and %q",
uri.Scheme, dynamo.GetName(), teleport.SchemeFile)
}
}
// only file external loggers are prohibited (they are not supposed
// to be used on their own, only in combo with external loggers)
// they also don't implement certain features, so they are going
// to be inefficient
switch len(loggers) {
case 0:
return nil, trace.NotFound("no external log is defined")
case 1:
if !hasNonFileLog {
return nil, trace.BadParameter("file:// log can not be used on it's own, can be only used in combination with external session logs, e.g. dynamodb://")
}
return loggers[0], nil
default:
if !hasNonFileLog {
return nil, trace.BadParameter("file:// log can not be used on it's own, can be only used in combination with external session logs, e.g. dynamodb://")
}
return events.NewMultiLog(loggers...), nil
}
}
|
[
"func",
"initExternalLog",
"(",
"auditConfig",
"services",
".",
"AuditConfig",
")",
"(",
"events",
".",
"IAuditLog",
",",
"error",
")",
"{",
"if",
"auditConfig",
".",
"AuditTableName",
"!=",
"\"\"",
"{",
"log",
".",
"Warningf",
"(",
"\"Please note that 'audit_table_name' is deprecated and will be removed in several releases. Use audit_events_uri: '%v://%v' instead.\"",
",",
"dynamo",
".",
"GetName",
"(",
")",
",",
"auditConfig",
".",
"AuditTableName",
")",
"\n",
"if",
"len",
"(",
"auditConfig",
".",
"AuditEventsURI",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"Detected configuration specifying 'audit_table_name' and 'audit_events_uri' at the same time. Please migrate your config to use 'audit_events_uri' only.\"",
")",
"\n",
"}",
"\n",
"auditConfig",
".",
"AuditEventsURI",
"=",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%v://%v\"",
",",
"dynamo",
".",
"GetName",
"(",
")",
",",
"auditConfig",
".",
"AuditTableName",
")",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"auditConfig",
".",
"AuditEventsURI",
")",
">",
"0",
"&&",
"!",
"auditConfig",
".",
"ShouldUploadSessions",
"(",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"please specify audit_sessions_uri when using external audit backends\"",
")",
"\n",
"}",
"\n",
"var",
"hasNonFileLog",
"bool",
"\n",
"var",
"loggers",
"[",
"]",
"events",
".",
"IAuditLog",
"\n",
"for",
"_",
",",
"eventsURI",
":=",
"range",
"auditConfig",
".",
"AuditEventsURI",
"{",
"uri",
",",
"err",
":=",
"utils",
".",
"ParseSessionsURI",
"(",
"eventsURI",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"uri",
".",
"Scheme",
"{",
"case",
"dynamo",
".",
"GetName",
"(",
")",
":",
"hasNonFileLog",
"=",
"true",
"\n",
"logger",
",",
"err",
":=",
"dynamoevents",
".",
"New",
"(",
"dynamoevents",
".",
"Config",
"{",
"Tablename",
":",
"uri",
".",
"Host",
",",
"Region",
":",
"auditConfig",
".",
"Region",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"loggers",
"=",
"append",
"(",
"loggers",
",",
"logger",
")",
"\n",
"case",
"teleport",
".",
"SchemeFile",
":",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"uri",
".",
"Path",
",",
"teleport",
".",
"SharedDirMode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"logger",
",",
"err",
":=",
"events",
".",
"NewFileLog",
"(",
"events",
".",
"FileLogConfig",
"{",
"Dir",
":",
"uri",
".",
"Path",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"loggers",
"=",
"append",
"(",
"loggers",
",",
"logger",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unsupported scheme for audit_events_uri: %q, currently supported schemes are %q and %q\"",
",",
"uri",
".",
"Scheme",
",",
"dynamo",
".",
"GetName",
"(",
")",
",",
"teleport",
".",
"SchemeFile",
")",
"\n",
"}",
"\n",
"}",
"\n",
"switch",
"len",
"(",
"loggers",
")",
"{",
"case",
"0",
":",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"no external log is defined\"",
")",
"\n",
"case",
"1",
":",
"if",
"!",
"hasNonFileLog",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"file:// log can not be used on it's own, can be only used in combination with external session logs, e.g. dynamodb://\"",
")",
"\n",
"}",
"\n",
"return",
"loggers",
"[",
"0",
"]",
",",
"nil",
"\n",
"default",
":",
"if",
"!",
"hasNonFileLog",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"file:// log can not be used on it's own, can be only used in combination with external session logs, e.g. dynamodb://\"",
")",
"\n",
"}",
"\n",
"return",
"events",
".",
"NewMultiLog",
"(",
"loggers",
"...",
")",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// initExternalLog initializes external storage, if the storage is not
// setup, returns nil
|
[
"initExternalLog",
"initializes",
"external",
"storage",
"if",
"the",
"storage",
"is",
"not",
"setup",
"returns",
"nil"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L779-L843
|
train
|
gravitational/teleport
|
lib/service/service.go
|
onExit
|
func (process *TeleportProcess) onExit(serviceName string, callback func(interface{})) {
process.RegisterFunc(serviceName, func() error {
eventC := make(chan Event)
process.WaitForEvent(context.TODO(), TeleportExitEvent, eventC)
select {
case event := <-eventC:
callback(event.Payload)
}
return nil
})
}
|
go
|
func (process *TeleportProcess) onExit(serviceName string, callback func(interface{})) {
process.RegisterFunc(serviceName, func() error {
eventC := make(chan Event)
process.WaitForEvent(context.TODO(), TeleportExitEvent, eventC)
select {
case event := <-eventC:
callback(event.Payload)
}
return nil
})
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"onExit",
"(",
"serviceName",
"string",
",",
"callback",
"func",
"(",
"interface",
"{",
"}",
")",
")",
"{",
"process",
".",
"RegisterFunc",
"(",
"serviceName",
",",
"func",
"(",
")",
"error",
"{",
"eventC",
":=",
"make",
"(",
"chan",
"Event",
")",
"\n",
"process",
".",
"WaitForEvent",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"TeleportExitEvent",
",",
"eventC",
")",
"\n",
"select",
"{",
"case",
"event",
":=",
"<-",
"eventC",
":",
"callback",
"(",
"event",
".",
"Payload",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}"
] |
// onExit allows individual services to register a callback function which will be
// called when Teleport Process is asked to exit. Usually services terminate themselves
// when the callback is called
|
[
"onExit",
"allows",
"individual",
"services",
"to",
"register",
"a",
"callback",
"function",
"which",
"will",
"be",
"called",
"when",
"Teleport",
"Process",
"is",
"asked",
"to",
"exit",
".",
"Usually",
"services",
"terminate",
"themselves",
"when",
"the",
"callback",
"is",
"called"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1160-L1170
|
train
|
gravitational/teleport
|
lib/service/service.go
|
newAccessCache
|
func (process *TeleportProcess) newAccessCache(cfg accessCacheConfig) (*cache.Cache, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
var cacheBackend backend.Backend
if cfg.inMemory {
mem, err := memory.New(memory.Config{
Context: process.ExitContext(),
EventsOff: !cfg.events,
Mirror: true,
})
if err != nil {
return nil, trace.Wrap(err)
}
cacheBackend = mem
} else {
path := filepath.Join(append([]string{process.Config.DataDir, "cache"}, cfg.cacheName...)...)
if err := os.MkdirAll(path, teleport.SharedDirMode); err != nil {
return nil, trace.ConvertSystemError(err)
}
liteBackend, err := lite.NewWithConfig(process.ExitContext(),
lite.Config{
Path: path,
EventsOff: !cfg.events,
Memory: false,
Mirror: true,
PollStreamPeriod: 100 * time.Millisecond,
})
if err != nil {
return nil, trace.Wrap(err)
}
cacheBackend = liteBackend
}
reporter, err := backend.NewReporter(backend.ReporterConfig{
Component: teleport.ComponentCache,
Backend: cacheBackend,
TrackTopRequests: process.Config.Debug,
})
if err != nil {
return nil, trace.Wrap(err)
}
return cache.New(cfg.setup(cache.Config{
Context: process.ExitContext(),
Backend: reporter,
Events: cfg.services,
ClusterConfig: cfg.services,
Provisioner: cfg.services,
Trust: cfg.services,
Users: cfg.services,
Access: cfg.services,
Presence: cfg.services,
Component: teleport.Component(append(cfg.cacheName, process.id, teleport.ComponentCache)...),
MetricComponent: teleport.Component(append(cfg.cacheName, teleport.ComponentCache)...),
}))
}
|
go
|
func (process *TeleportProcess) newAccessCache(cfg accessCacheConfig) (*cache.Cache, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
var cacheBackend backend.Backend
if cfg.inMemory {
mem, err := memory.New(memory.Config{
Context: process.ExitContext(),
EventsOff: !cfg.events,
Mirror: true,
})
if err != nil {
return nil, trace.Wrap(err)
}
cacheBackend = mem
} else {
path := filepath.Join(append([]string{process.Config.DataDir, "cache"}, cfg.cacheName...)...)
if err := os.MkdirAll(path, teleport.SharedDirMode); err != nil {
return nil, trace.ConvertSystemError(err)
}
liteBackend, err := lite.NewWithConfig(process.ExitContext(),
lite.Config{
Path: path,
EventsOff: !cfg.events,
Memory: false,
Mirror: true,
PollStreamPeriod: 100 * time.Millisecond,
})
if err != nil {
return nil, trace.Wrap(err)
}
cacheBackend = liteBackend
}
reporter, err := backend.NewReporter(backend.ReporterConfig{
Component: teleport.ComponentCache,
Backend: cacheBackend,
TrackTopRequests: process.Config.Debug,
})
if err != nil {
return nil, trace.Wrap(err)
}
return cache.New(cfg.setup(cache.Config{
Context: process.ExitContext(),
Backend: reporter,
Events: cfg.services,
ClusterConfig: cfg.services,
Provisioner: cfg.services,
Trust: cfg.services,
Users: cfg.services,
Access: cfg.services,
Presence: cfg.services,
Component: teleport.Component(append(cfg.cacheName, process.id, teleport.ComponentCache)...),
MetricComponent: teleport.Component(append(cfg.cacheName, teleport.ComponentCache)...),
}))
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newAccessCache",
"(",
"cfg",
"accessCacheConfig",
")",
"(",
"*",
"cache",
".",
"Cache",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"cacheBackend",
"backend",
".",
"Backend",
"\n",
"if",
"cfg",
".",
"inMemory",
"{",
"mem",
",",
"err",
":=",
"memory",
".",
"New",
"(",
"memory",
".",
"Config",
"{",
"Context",
":",
"process",
".",
"ExitContext",
"(",
")",
",",
"EventsOff",
":",
"!",
"cfg",
".",
"events",
",",
"Mirror",
":",
"true",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cacheBackend",
"=",
"mem",
"\n",
"}",
"else",
"{",
"path",
":=",
"filepath",
".",
"Join",
"(",
"append",
"(",
"[",
"]",
"string",
"{",
"process",
".",
"Config",
".",
"DataDir",
",",
"\"cache\"",
"}",
",",
"cfg",
".",
"cacheName",
"...",
")",
"...",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"path",
",",
"teleport",
".",
"SharedDirMode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"liteBackend",
",",
"err",
":=",
"lite",
".",
"NewWithConfig",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"lite",
".",
"Config",
"{",
"Path",
":",
"path",
",",
"EventsOff",
":",
"!",
"cfg",
".",
"events",
",",
"Memory",
":",
"false",
",",
"Mirror",
":",
"true",
",",
"PollStreamPeriod",
":",
"100",
"*",
"time",
".",
"Millisecond",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cacheBackend",
"=",
"liteBackend",
"\n",
"}",
"\n",
"reporter",
",",
"err",
":=",
"backend",
".",
"NewReporter",
"(",
"backend",
".",
"ReporterConfig",
"{",
"Component",
":",
"teleport",
".",
"ComponentCache",
",",
"Backend",
":",
"cacheBackend",
",",
"TrackTopRequests",
":",
"process",
".",
"Config",
".",
"Debug",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cache",
".",
"New",
"(",
"cfg",
".",
"setup",
"(",
"cache",
".",
"Config",
"{",
"Context",
":",
"process",
".",
"ExitContext",
"(",
")",
",",
"Backend",
":",
"reporter",
",",
"Events",
":",
"cfg",
".",
"services",
",",
"ClusterConfig",
":",
"cfg",
".",
"services",
",",
"Provisioner",
":",
"cfg",
".",
"services",
",",
"Trust",
":",
"cfg",
".",
"services",
",",
"Users",
":",
"cfg",
".",
"services",
",",
"Access",
":",
"cfg",
".",
"services",
",",
"Presence",
":",
"cfg",
".",
"services",
",",
"Component",
":",
"teleport",
".",
"Component",
"(",
"append",
"(",
"cfg",
".",
"cacheName",
",",
"process",
".",
"id",
",",
"teleport",
".",
"ComponentCache",
")",
"...",
")",
",",
"MetricComponent",
":",
"teleport",
".",
"Component",
"(",
"append",
"(",
"cfg",
".",
"cacheName",
",",
"teleport",
".",
"ComponentCache",
")",
"...",
")",
",",
"}",
")",
")",
"\n",
"}"
] |
// newAccessCache returns new local cache access point
|
[
"newAccessCache",
"returns",
"new",
"local",
"cache",
"access",
"point"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1209-L1264
|
train
|
gravitational/teleport
|
lib/service/service.go
|
setupCachePolicy
|
func (process *TeleportProcess) setupCachePolicy(in cache.SetupConfigFn) cache.SetupConfigFn {
return func(c cache.Config) cache.Config {
config := in(c)
config.PreferRecent = cache.PreferRecent{
Enabled: process.Config.CachePolicy.Enabled,
NeverExpires: process.Config.CachePolicy.NeverExpires,
MaxTTL: process.Config.CachePolicy.TTL,
}
return config
}
}
|
go
|
func (process *TeleportProcess) setupCachePolicy(in cache.SetupConfigFn) cache.SetupConfigFn {
return func(c cache.Config) cache.Config {
config := in(c)
config.PreferRecent = cache.PreferRecent{
Enabled: process.Config.CachePolicy.Enabled,
NeverExpires: process.Config.CachePolicy.NeverExpires,
MaxTTL: process.Config.CachePolicy.TTL,
}
return config
}
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"setupCachePolicy",
"(",
"in",
"cache",
".",
"SetupConfigFn",
")",
"cache",
".",
"SetupConfigFn",
"{",
"return",
"func",
"(",
"c",
"cache",
".",
"Config",
")",
"cache",
".",
"Config",
"{",
"config",
":=",
"in",
"(",
"c",
")",
"\n",
"config",
".",
"PreferRecent",
"=",
"cache",
".",
"PreferRecent",
"{",
"Enabled",
":",
"process",
".",
"Config",
".",
"CachePolicy",
".",
"Enabled",
",",
"NeverExpires",
":",
"process",
".",
"Config",
".",
"CachePolicy",
".",
"NeverExpires",
",",
"MaxTTL",
":",
"process",
".",
"Config",
".",
"CachePolicy",
".",
"TTL",
",",
"}",
"\n",
"return",
"config",
"\n",
"}",
"\n",
"}"
] |
// setupCachePolicy sets up cache policy based on teleport configuration,
// it is a wrapper function, that sets up configuration
|
[
"setupCachePolicy",
"sets",
"up",
"cache",
"policy",
"based",
"on",
"teleport",
"configuration",
"it",
"is",
"a",
"wrapper",
"function",
"that",
"sets",
"up",
"configuration"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1268-L1278
|
train
|
gravitational/teleport
|
lib/service/service.go
|
newLocalCacheForProxy
|
func (process *TeleportProcess) newLocalCacheForProxy(clt auth.ClientI, cacheName []string) (auth.AccessPoint, error) {
return process.newLocalCache(clt, cache.ForProxy, cacheName)
}
|
go
|
func (process *TeleportProcess) newLocalCacheForProxy(clt auth.ClientI, cacheName []string) (auth.AccessPoint, error) {
return process.newLocalCache(clt, cache.ForProxy, cacheName)
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newLocalCacheForProxy",
"(",
"clt",
"auth",
".",
"ClientI",
",",
"cacheName",
"[",
"]",
"string",
")",
"(",
"auth",
".",
"AccessPoint",
",",
"error",
")",
"{",
"return",
"process",
".",
"newLocalCache",
"(",
"clt",
",",
"cache",
".",
"ForProxy",
",",
"cacheName",
")",
"\n",
"}"
] |
// newAccessPointCache returns new instance of access point configured for proxy
|
[
"newAccessPointCache",
"returns",
"new",
"instance",
"of",
"access",
"point",
"configured",
"for",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1281-L1283
|
train
|
gravitational/teleport
|
lib/service/service.go
|
newLocalCache
|
func (process *TeleportProcess) newLocalCache(clt auth.ClientI, setupConfig cache.SetupConfigFn, cacheName []string) (auth.AccessPoint, error) {
// if caching is disabled, return access point
if !process.Config.CachePolicy.Enabled {
return clt, nil
}
cache, err := process.newAccessCache(accessCacheConfig{
services: clt,
setup: process.setupCachePolicy(setupConfig),
cacheName: cacheName,
})
if err != nil {
return nil, trace.Wrap(err)
}
return auth.NewWrapper(clt, cache), nil
}
|
go
|
func (process *TeleportProcess) newLocalCache(clt auth.ClientI, setupConfig cache.SetupConfigFn, cacheName []string) (auth.AccessPoint, error) {
// if caching is disabled, return access point
if !process.Config.CachePolicy.Enabled {
return clt, nil
}
cache, err := process.newAccessCache(accessCacheConfig{
services: clt,
setup: process.setupCachePolicy(setupConfig),
cacheName: cacheName,
})
if err != nil {
return nil, trace.Wrap(err)
}
return auth.NewWrapper(clt, cache), nil
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newLocalCache",
"(",
"clt",
"auth",
".",
"ClientI",
",",
"setupConfig",
"cache",
".",
"SetupConfigFn",
",",
"cacheName",
"[",
"]",
"string",
")",
"(",
"auth",
".",
"AccessPoint",
",",
"error",
")",
"{",
"if",
"!",
"process",
".",
"Config",
".",
"CachePolicy",
".",
"Enabled",
"{",
"return",
"clt",
",",
"nil",
"\n",
"}",
"\n",
"cache",
",",
"err",
":=",
"process",
".",
"newAccessCache",
"(",
"accessCacheConfig",
"{",
"services",
":",
"clt",
",",
"setup",
":",
"process",
".",
"setupCachePolicy",
"(",
"setupConfig",
")",
",",
"cacheName",
":",
"cacheName",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"auth",
".",
"NewWrapper",
"(",
"clt",
",",
"cache",
")",
",",
"nil",
"\n",
"}"
] |
// newAccessPointCache returns new instance of access point
|
[
"newAccessPointCache",
"returns",
"new",
"instance",
"of",
"access",
"point"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1286-L1300
|
train
|
gravitational/teleport
|
lib/service/service.go
|
registerWithAuthServer
|
func (process *TeleportProcess) registerWithAuthServer(role teleport.Role, eventName string) {
serviceName := strings.ToLower(role.String())
process.RegisterCriticalFunc(fmt.Sprintf("register.%v", serviceName), func() error {
connector, err := process.reconnectToAuthService(role)
if err != nil {
return trace.Wrap(err)
}
process.onExit(fmt.Sprintf("auth.client.%v", serviceName), func(interface{}) {
process.Debugf("Closed client for %v.", role)
err := connector.Client.Close()
if err != nil {
process.Debugf("Failed to close client: %v", err)
}
})
process.BroadcastEvent(Event{Name: eventName, Payload: connector})
return nil
})
}
|
go
|
func (process *TeleportProcess) registerWithAuthServer(role teleport.Role, eventName string) {
serviceName := strings.ToLower(role.String())
process.RegisterCriticalFunc(fmt.Sprintf("register.%v", serviceName), func() error {
connector, err := process.reconnectToAuthService(role)
if err != nil {
return trace.Wrap(err)
}
process.onExit(fmt.Sprintf("auth.client.%v", serviceName), func(interface{}) {
process.Debugf("Closed client for %v.", role)
err := connector.Client.Close()
if err != nil {
process.Debugf("Failed to close client: %v", err)
}
})
process.BroadcastEvent(Event{Name: eventName, Payload: connector})
return nil
})
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"registerWithAuthServer",
"(",
"role",
"teleport",
".",
"Role",
",",
"eventName",
"string",
")",
"{",
"serviceName",
":=",
"strings",
".",
"ToLower",
"(",
"role",
".",
"String",
"(",
")",
")",
"\n",
"process",
".",
"RegisterCriticalFunc",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"register.%v\"",
",",
"serviceName",
")",
",",
"func",
"(",
")",
"error",
"{",
"connector",
",",
"err",
":=",
"process",
".",
"reconnectToAuthService",
"(",
"role",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"onExit",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"auth.client.%v\"",
",",
"serviceName",
")",
",",
"func",
"(",
"interface",
"{",
"}",
")",
"{",
"process",
".",
"Debugf",
"(",
"\"Closed client for %v.\"",
",",
"role",
")",
"\n",
"err",
":=",
"connector",
".",
"Client",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"process",
".",
"Debugf",
"(",
"\"Failed to close client: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
")",
"\n",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"eventName",
",",
"Payload",
":",
"connector",
"}",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}"
] |
// registerWithAuthServer uses one time provisioning token obtained earlier
// from the server to get a pair of SSH keys signed by Auth server host
// certificate authority
|
[
"registerWithAuthServer",
"uses",
"one",
"time",
"provisioning",
"token",
"obtained",
"earlier",
"from",
"the",
"server",
"to",
"get",
"a",
"pair",
"of",
"SSH",
"keys",
"signed",
"by",
"Auth",
"server",
"host",
"certificate",
"authority"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1521-L1538
|
train
|
gravitational/teleport
|
lib/service/service.go
|
getAdditionalPrincipals
|
func (process *TeleportProcess) getAdditionalPrincipals(role teleport.Role) ([]string, []string, error) {
var principals []string
var dnsNames []string
if process.Config.Hostname != "" {
principals = append(principals, process.Config.Hostname)
}
var addrs []utils.NetAddr
switch role {
case teleport.RoleProxy:
addrs = append(process.Config.Proxy.PublicAddrs, utils.NetAddr{Addr: reversetunnel.RemoteKubeProxy})
addrs = append(addrs, process.Config.Proxy.SSHPublicAddrs...)
addrs = append(addrs, process.Config.Proxy.TunnelPublicAddrs...)
addrs = append(addrs, process.Config.Proxy.Kube.PublicAddrs...)
// Automatically add wildcards for every proxy public address for k8s SNI routing
if process.Config.Proxy.Kube.Enabled {
for _, publicAddr := range utils.JoinAddrSlices(process.Config.Proxy.PublicAddrs, process.Config.Proxy.Kube.PublicAddrs) {
host, err := utils.Host(publicAddr.Addr)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if ip := net.ParseIP(host); ip == nil {
dnsNames = append(dnsNames, "*."+host)
}
}
}
case teleport.RoleAuth, teleport.RoleAdmin:
addrs = process.Config.Auth.PublicAddrs
case teleport.RoleNode:
addrs = process.Config.SSH.PublicAddrs
// If advertise IP is set, add it to the list of principals. Otherwise
// add in the default (0.0.0.0) which will be replaced by the Auth Server
// when a host certificate is issued.
if process.Config.AdvertiseIP != "" {
advertiseIP, err := utils.ParseAddr(process.Config.AdvertiseIP)
if err != nil {
return nil, nil, trace.Wrap(err)
}
addrs = append(addrs, *advertiseIP)
} else {
addrs = append(addrs, process.Config.SSH.Addr)
}
}
for _, addr := range addrs {
host, err := utils.Host(addr.Addr)
if err != nil {
return nil, nil, trace.Wrap(err)
}
principals = append(principals, host)
}
return principals, dnsNames, nil
}
|
go
|
func (process *TeleportProcess) getAdditionalPrincipals(role teleport.Role) ([]string, []string, error) {
var principals []string
var dnsNames []string
if process.Config.Hostname != "" {
principals = append(principals, process.Config.Hostname)
}
var addrs []utils.NetAddr
switch role {
case teleport.RoleProxy:
addrs = append(process.Config.Proxy.PublicAddrs, utils.NetAddr{Addr: reversetunnel.RemoteKubeProxy})
addrs = append(addrs, process.Config.Proxy.SSHPublicAddrs...)
addrs = append(addrs, process.Config.Proxy.TunnelPublicAddrs...)
addrs = append(addrs, process.Config.Proxy.Kube.PublicAddrs...)
// Automatically add wildcards for every proxy public address for k8s SNI routing
if process.Config.Proxy.Kube.Enabled {
for _, publicAddr := range utils.JoinAddrSlices(process.Config.Proxy.PublicAddrs, process.Config.Proxy.Kube.PublicAddrs) {
host, err := utils.Host(publicAddr.Addr)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if ip := net.ParseIP(host); ip == nil {
dnsNames = append(dnsNames, "*."+host)
}
}
}
case teleport.RoleAuth, teleport.RoleAdmin:
addrs = process.Config.Auth.PublicAddrs
case teleport.RoleNode:
addrs = process.Config.SSH.PublicAddrs
// If advertise IP is set, add it to the list of principals. Otherwise
// add in the default (0.0.0.0) which will be replaced by the Auth Server
// when a host certificate is issued.
if process.Config.AdvertiseIP != "" {
advertiseIP, err := utils.ParseAddr(process.Config.AdvertiseIP)
if err != nil {
return nil, nil, trace.Wrap(err)
}
addrs = append(addrs, *advertiseIP)
} else {
addrs = append(addrs, process.Config.SSH.Addr)
}
}
for _, addr := range addrs {
host, err := utils.Host(addr.Addr)
if err != nil {
return nil, nil, trace.Wrap(err)
}
principals = append(principals, host)
}
return principals, dnsNames, nil
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"getAdditionalPrincipals",
"(",
"role",
"teleport",
".",
"Role",
")",
"(",
"[",
"]",
"string",
",",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"principals",
"[",
"]",
"string",
"\n",
"var",
"dnsNames",
"[",
"]",
"string",
"\n",
"if",
"process",
".",
"Config",
".",
"Hostname",
"!=",
"\"\"",
"{",
"principals",
"=",
"append",
"(",
"principals",
",",
"process",
".",
"Config",
".",
"Hostname",
")",
"\n",
"}",
"\n",
"var",
"addrs",
"[",
"]",
"utils",
".",
"NetAddr",
"\n",
"switch",
"role",
"{",
"case",
"teleport",
".",
"RoleProxy",
":",
"addrs",
"=",
"append",
"(",
"process",
".",
"Config",
".",
"Proxy",
".",
"PublicAddrs",
",",
"utils",
".",
"NetAddr",
"{",
"Addr",
":",
"reversetunnel",
".",
"RemoteKubeProxy",
"}",
")",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"process",
".",
"Config",
".",
"Proxy",
".",
"SSHPublicAddrs",
"...",
")",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"process",
".",
"Config",
".",
"Proxy",
".",
"TunnelPublicAddrs",
"...",
")",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"process",
".",
"Config",
".",
"Proxy",
".",
"Kube",
".",
"PublicAddrs",
"...",
")",
"\n",
"if",
"process",
".",
"Config",
".",
"Proxy",
".",
"Kube",
".",
"Enabled",
"{",
"for",
"_",
",",
"publicAddr",
":=",
"range",
"utils",
".",
"JoinAddrSlices",
"(",
"process",
".",
"Config",
".",
"Proxy",
".",
"PublicAddrs",
",",
"process",
".",
"Config",
".",
"Proxy",
".",
"Kube",
".",
"PublicAddrs",
")",
"{",
"host",
",",
"err",
":=",
"utils",
".",
"Host",
"(",
"publicAddr",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"host",
")",
";",
"ip",
"==",
"nil",
"{",
"dnsNames",
"=",
"append",
"(",
"dnsNames",
",",
"\"*.\"",
"+",
"host",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"teleport",
".",
"RoleAuth",
",",
"teleport",
".",
"RoleAdmin",
":",
"addrs",
"=",
"process",
".",
"Config",
".",
"Auth",
".",
"PublicAddrs",
"\n",
"case",
"teleport",
".",
"RoleNode",
":",
"addrs",
"=",
"process",
".",
"Config",
".",
"SSH",
".",
"PublicAddrs",
"\n",
"if",
"process",
".",
"Config",
".",
"AdvertiseIP",
"!=",
"\"\"",
"{",
"advertiseIP",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"process",
".",
"Config",
".",
"AdvertiseIP",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"*",
"advertiseIP",
")",
"\n",
"}",
"else",
"{",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"process",
".",
"Config",
".",
"SSH",
".",
"Addr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"host",
",",
"err",
":=",
"utils",
".",
"Host",
"(",
"addr",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"principals",
"=",
"append",
"(",
"principals",
",",
"host",
")",
"\n",
"}",
"\n",
"return",
"principals",
",",
"dnsNames",
",",
"nil",
"\n",
"}"
] |
// getAdditionalPrincipals returns a list of additional principals to add
// to role's service certificates.
|
[
"getAdditionalPrincipals",
"returns",
"a",
"list",
"of",
"additional",
"principals",
"to",
"add",
"to",
"role",
"s",
"service",
"certificates",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L1698-L1748
|
train
|
gravitational/teleport
|
lib/service/service.go
|
initAuthStorage
|
func (process *TeleportProcess) initAuthStorage() (bk backend.Backend, err error) {
bc := &process.Config.Auth.StorageConfig
process.Debugf("Using %v backend.", bc.Type)
switch bc.Type {
case lite.GetName():
bk, err = lite.New(context.TODO(), bc.Params)
// legacy bolt backend, import all data into SQLite and return
// SQLite data
case boltbk.GetName():
litebk, err := lite.New(context.TODO(), bc.Params)
if err != nil {
return nil, trace.Wrap(err)
}
err = legacy.Import(context.TODO(), litebk, func() (legacy.Exporter, error) {
return boltbk.New(legacy.Params(bc.Params))
})
if err != nil {
return nil, trace.Wrap(err)
}
bk = litebk
// legacy filesystem backend, import all data into SQLite and return
// SQLite data
case dir.GetName():
litebk, err := lite.New(context.TODO(), bc.Params)
if err != nil {
return nil, trace.Wrap(err)
}
err = legacy.Import(context.TODO(), litebk, func() (legacy.Exporter, error) {
return dir.New(legacy.Params(bc.Params))
})
if err != nil {
return nil, trace.Wrap(err)
}
bk = litebk
// DynamoDB backend:
case dynamo.GetName():
bk, err = dynamo.New(context.TODO(), bc.Params)
// etcd backend:
case etcdbk.GetName():
bk, err = etcdbk.New(context.TODO(), bc.Params)
default:
err = trace.BadParameter("unsupported secrets storage type: %q", bc.Type)
}
if err != nil {
return nil, trace.Wrap(err)
}
reporter, err := backend.NewReporter(backend.ReporterConfig{
Component: teleport.ComponentBackend,
Backend: backend.NewSanitizer(bk),
TrackTopRequests: process.Config.Debug,
})
if err != nil {
return nil, trace.Wrap(err)
}
process.setReporter(reporter)
return reporter, nil
}
|
go
|
func (process *TeleportProcess) initAuthStorage() (bk backend.Backend, err error) {
bc := &process.Config.Auth.StorageConfig
process.Debugf("Using %v backend.", bc.Type)
switch bc.Type {
case lite.GetName():
bk, err = lite.New(context.TODO(), bc.Params)
// legacy bolt backend, import all data into SQLite and return
// SQLite data
case boltbk.GetName():
litebk, err := lite.New(context.TODO(), bc.Params)
if err != nil {
return nil, trace.Wrap(err)
}
err = legacy.Import(context.TODO(), litebk, func() (legacy.Exporter, error) {
return boltbk.New(legacy.Params(bc.Params))
})
if err != nil {
return nil, trace.Wrap(err)
}
bk = litebk
// legacy filesystem backend, import all data into SQLite and return
// SQLite data
case dir.GetName():
litebk, err := lite.New(context.TODO(), bc.Params)
if err != nil {
return nil, trace.Wrap(err)
}
err = legacy.Import(context.TODO(), litebk, func() (legacy.Exporter, error) {
return dir.New(legacy.Params(bc.Params))
})
if err != nil {
return nil, trace.Wrap(err)
}
bk = litebk
// DynamoDB backend:
case dynamo.GetName():
bk, err = dynamo.New(context.TODO(), bc.Params)
// etcd backend:
case etcdbk.GetName():
bk, err = etcdbk.New(context.TODO(), bc.Params)
default:
err = trace.BadParameter("unsupported secrets storage type: %q", bc.Type)
}
if err != nil {
return nil, trace.Wrap(err)
}
reporter, err := backend.NewReporter(backend.ReporterConfig{
Component: teleport.ComponentBackend,
Backend: backend.NewSanitizer(bk),
TrackTopRequests: process.Config.Debug,
})
if err != nil {
return nil, trace.Wrap(err)
}
process.setReporter(reporter)
return reporter, nil
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"initAuthStorage",
"(",
")",
"(",
"bk",
"backend",
".",
"Backend",
",",
"err",
"error",
")",
"{",
"bc",
":=",
"&",
"process",
".",
"Config",
".",
"Auth",
".",
"StorageConfig",
"\n",
"process",
".",
"Debugf",
"(",
"\"Using %v backend.\"",
",",
"bc",
".",
"Type",
")",
"\n",
"switch",
"bc",
".",
"Type",
"{",
"case",
"lite",
".",
"GetName",
"(",
")",
":",
"bk",
",",
"err",
"=",
"lite",
".",
"New",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"bc",
".",
"Params",
")",
"\n",
"case",
"boltbk",
".",
"GetName",
"(",
")",
":",
"litebk",
",",
"err",
":=",
"lite",
".",
"New",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"bc",
".",
"Params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"legacy",
".",
"Import",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"litebk",
",",
"func",
"(",
")",
"(",
"legacy",
".",
"Exporter",
",",
"error",
")",
"{",
"return",
"boltbk",
".",
"New",
"(",
"legacy",
".",
"Params",
"(",
"bc",
".",
"Params",
")",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"bk",
"=",
"litebk",
"\n",
"case",
"dir",
".",
"GetName",
"(",
")",
":",
"litebk",
",",
"err",
":=",
"lite",
".",
"New",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"bc",
".",
"Params",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"legacy",
".",
"Import",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"litebk",
",",
"func",
"(",
")",
"(",
"legacy",
".",
"Exporter",
",",
"error",
")",
"{",
"return",
"dir",
".",
"New",
"(",
"legacy",
".",
"Params",
"(",
"bc",
".",
"Params",
")",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"bk",
"=",
"litebk",
"\n",
"case",
"dynamo",
".",
"GetName",
"(",
")",
":",
"bk",
",",
"err",
"=",
"dynamo",
".",
"New",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"bc",
".",
"Params",
")",
"\n",
"case",
"etcdbk",
".",
"GetName",
"(",
")",
":",
"bk",
",",
"err",
"=",
"etcdbk",
".",
"New",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"bc",
".",
"Params",
")",
"\n",
"default",
":",
"err",
"=",
"trace",
".",
"BadParameter",
"(",
"\"unsupported secrets storage type: %q\"",
",",
"bc",
".",
"Type",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"reporter",
",",
"err",
":=",
"backend",
".",
"NewReporter",
"(",
"backend",
".",
"ReporterConfig",
"{",
"Component",
":",
"teleport",
".",
"ComponentBackend",
",",
"Backend",
":",
"backend",
".",
"NewSanitizer",
"(",
"bk",
")",
",",
"TrackTopRequests",
":",
"process",
".",
"Config",
".",
"Debug",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"setReporter",
"(",
"reporter",
")",
"\n",
"return",
"reporter",
",",
"nil",
"\n",
"}"
] |
// initAuthStorage initializes the storage backend for the auth service.
|
[
"initAuthStorage",
"initializes",
"the",
"storage",
"backend",
"for",
"the",
"auth",
"service",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L2225-L2281
|
train
|
gravitational/teleport
|
lib/service/service.go
|
WaitWithContext
|
func (process *TeleportProcess) WaitWithContext(ctx context.Context) {
local, cancel := context.WithCancel(ctx)
go func() {
defer cancel()
process.Supervisor.Wait()
}()
select {
case <-local.Done():
return
}
}
|
go
|
func (process *TeleportProcess) WaitWithContext(ctx context.Context) {
local, cancel := context.WithCancel(ctx)
go func() {
defer cancel()
process.Supervisor.Wait()
}()
select {
case <-local.Done():
return
}
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"WaitWithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"local",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"cancel",
"(",
")",
"\n",
"process",
".",
"Supervisor",
".",
"Wait",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"local",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}"
] |
// WaitWithContext waits until all internal services stop.
|
[
"WaitWithContext",
"waits",
"until",
"all",
"internal",
"services",
"stop",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L2296-L2306
|
train
|
gravitational/teleport
|
lib/service/service.go
|
StartShutdown
|
func (process *TeleportProcess) StartShutdown(ctx context.Context) context.Context {
process.BroadcastEvent(Event{Name: TeleportExitEvent, Payload: ctx})
localCtx, cancel := context.WithCancel(ctx)
go func() {
defer cancel()
process.Supervisor.Wait()
process.Debugf("All supervisor functions are completed.")
localAuth := process.getLocalAuth()
if localAuth != nil {
if err := process.localAuth.Close(); err != nil {
process.Warningf("Failed closing auth server: %v.", err)
}
}
}()
go process.printShutdownStatus(localCtx)
return localCtx
}
|
go
|
func (process *TeleportProcess) StartShutdown(ctx context.Context) context.Context {
process.BroadcastEvent(Event{Name: TeleportExitEvent, Payload: ctx})
localCtx, cancel := context.WithCancel(ctx)
go func() {
defer cancel()
process.Supervisor.Wait()
process.Debugf("All supervisor functions are completed.")
localAuth := process.getLocalAuth()
if localAuth != nil {
if err := process.localAuth.Close(); err != nil {
process.Warningf("Failed closing auth server: %v.", err)
}
}
}()
go process.printShutdownStatus(localCtx)
return localCtx
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"StartShutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"context",
".",
"Context",
"{",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportExitEvent",
",",
"Payload",
":",
"ctx",
"}",
")",
"\n",
"localCtx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"cancel",
"(",
")",
"\n",
"process",
".",
"Supervisor",
".",
"Wait",
"(",
")",
"\n",
"process",
".",
"Debugf",
"(",
"\"All supervisor functions are completed.\"",
")",
"\n",
"localAuth",
":=",
"process",
".",
"getLocalAuth",
"(",
")",
"\n",
"if",
"localAuth",
"!=",
"nil",
"{",
"if",
"err",
":=",
"process",
".",
"localAuth",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"process",
".",
"Warningf",
"(",
"\"Failed closing auth server: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"go",
"process",
".",
"printShutdownStatus",
"(",
"localCtx",
")",
"\n",
"return",
"localCtx",
"\n",
"}"
] |
// StartShutdown launches non-blocking graceful shutdown process that signals
// completion, returns context that will be closed once the shutdown is done
|
[
"StartShutdown",
"launches",
"non",
"-",
"blocking",
"graceful",
"shutdown",
"process",
"that",
"signals",
"completion",
"returns",
"context",
"that",
"will",
"be",
"closed",
"once",
"the",
"shutdown",
"is",
"done"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L2310-L2326
|
train
|
gravitational/teleport
|
lib/service/service.go
|
Shutdown
|
func (process *TeleportProcess) Shutdown(ctx context.Context) {
localCtx := process.StartShutdown(ctx)
// wait until parent context closes
select {
case <-localCtx.Done():
process.Debugf("Process completed.")
}
}
|
go
|
func (process *TeleportProcess) Shutdown(ctx context.Context) {
localCtx := process.StartShutdown(ctx)
// wait until parent context closes
select {
case <-localCtx.Done():
process.Debugf("Process completed.")
}
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"{",
"localCtx",
":=",
"process",
".",
"StartShutdown",
"(",
"ctx",
")",
"\n",
"select",
"{",
"case",
"<-",
"localCtx",
".",
"Done",
"(",
")",
":",
"process",
".",
"Debugf",
"(",
"\"Process completed.\"",
")",
"\n",
"}",
"\n",
"}"
] |
// Shutdown launches graceful shutdown process and waits
// for it to complete
|
[
"Shutdown",
"launches",
"graceful",
"shutdown",
"process",
"and",
"waits",
"for",
"it",
"to",
"complete"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L2330-L2337
|
train
|
gravitational/teleport
|
lib/service/service.go
|
Close
|
func (process *TeleportProcess) Close() error {
process.BroadcastEvent(Event{Name: TeleportExitEvent})
process.Config.Keygen.Close()
var errors []error
localAuth := process.getLocalAuth()
if localAuth != nil {
errors = append(errors, process.localAuth.Close())
}
if process.storage != nil {
errors = append(errors, process.storage.Close())
}
return trace.NewAggregate(errors...)
}
|
go
|
func (process *TeleportProcess) Close() error {
process.BroadcastEvent(Event{Name: TeleportExitEvent})
process.Config.Keygen.Close()
var errors []error
localAuth := process.getLocalAuth()
if localAuth != nil {
errors = append(errors, process.localAuth.Close())
}
if process.storage != nil {
errors = append(errors, process.storage.Close())
}
return trace.NewAggregate(errors...)
}
|
[
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"Close",
"(",
")",
"error",
"{",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportExitEvent",
"}",
")",
"\n",
"process",
".",
"Config",
".",
"Keygen",
".",
"Close",
"(",
")",
"\n",
"var",
"errors",
"[",
"]",
"error",
"\n",
"localAuth",
":=",
"process",
".",
"getLocalAuth",
"(",
")",
"\n",
"if",
"localAuth",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"process",
".",
"localAuth",
".",
"Close",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"process",
".",
"storage",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"process",
".",
"storage",
".",
"Close",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] |
// Close broadcasts close signals and exits immediately
|
[
"Close",
"broadcasts",
"close",
"signals",
"and",
"exits",
"immediately"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L2340-L2356
|
train
|
gravitational/teleport
|
lib/service/service.go
|
initSelfSignedHTTPSCert
|
func initSelfSignedHTTPSCert(cfg *Config) (err error) {
log.Warningf("No TLS Keys provided, using self signed certificate.")
keyPath := filepath.Join(cfg.DataDir, defaults.SelfSignedKeyPath)
certPath := filepath.Join(cfg.DataDir, defaults.SelfSignedCertPath)
cfg.Proxy.TLSKey = keyPath
cfg.Proxy.TLSCert = certPath
// return the existing pair if they have already been generated:
_, err = tls.LoadX509KeyPair(certPath, keyPath)
if err == nil {
return nil
}
if !os.IsNotExist(err) {
return trace.Wrap(err, "unrecognized error reading certs")
}
log.Warningf("Generating self signed key and cert to %v %v.", keyPath, certPath)
creds, err := utils.GenerateSelfSignedCert([]string{cfg.Hostname, "localhost"})
if err != nil {
return trace.Wrap(err)
}
if err := ioutil.WriteFile(keyPath, creds.PrivateKey, 0600); err != nil {
return trace.Wrap(err, "error writing key PEM")
}
if err := ioutil.WriteFile(certPath, creds.Cert, 0600); err != nil {
return trace.Wrap(err, "error writing key PEM")
}
return nil
}
|
go
|
func initSelfSignedHTTPSCert(cfg *Config) (err error) {
log.Warningf("No TLS Keys provided, using self signed certificate.")
keyPath := filepath.Join(cfg.DataDir, defaults.SelfSignedKeyPath)
certPath := filepath.Join(cfg.DataDir, defaults.SelfSignedCertPath)
cfg.Proxy.TLSKey = keyPath
cfg.Proxy.TLSCert = certPath
// return the existing pair if they have already been generated:
_, err = tls.LoadX509KeyPair(certPath, keyPath)
if err == nil {
return nil
}
if !os.IsNotExist(err) {
return trace.Wrap(err, "unrecognized error reading certs")
}
log.Warningf("Generating self signed key and cert to %v %v.", keyPath, certPath)
creds, err := utils.GenerateSelfSignedCert([]string{cfg.Hostname, "localhost"})
if err != nil {
return trace.Wrap(err)
}
if err := ioutil.WriteFile(keyPath, creds.PrivateKey, 0600); err != nil {
return trace.Wrap(err, "error writing key PEM")
}
if err := ioutil.WriteFile(certPath, creds.Cert, 0600); err != nil {
return trace.Wrap(err, "error writing key PEM")
}
return nil
}
|
[
"func",
"initSelfSignedHTTPSCert",
"(",
"cfg",
"*",
"Config",
")",
"(",
"err",
"error",
")",
"{",
"log",
".",
"Warningf",
"(",
"\"No TLS Keys provided, using self signed certificate.\"",
")",
"\n",
"keyPath",
":=",
"filepath",
".",
"Join",
"(",
"cfg",
".",
"DataDir",
",",
"defaults",
".",
"SelfSignedKeyPath",
")",
"\n",
"certPath",
":=",
"filepath",
".",
"Join",
"(",
"cfg",
".",
"DataDir",
",",
"defaults",
".",
"SelfSignedCertPath",
")",
"\n",
"cfg",
".",
"Proxy",
".",
"TLSKey",
"=",
"keyPath",
"\n",
"cfg",
".",
"Proxy",
".",
"TLSCert",
"=",
"certPath",
"\n",
"_",
",",
"err",
"=",
"tls",
".",
"LoadX509KeyPair",
"(",
"certPath",
",",
"keyPath",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"unrecognized error reading certs\"",
")",
"\n",
"}",
"\n",
"log",
".",
"Warningf",
"(",
"\"Generating self signed key and cert to %v %v.\"",
",",
"keyPath",
",",
"certPath",
")",
"\n",
"creds",
",",
"err",
":=",
"utils",
".",
"GenerateSelfSignedCert",
"(",
"[",
"]",
"string",
"{",
"cfg",
".",
"Hostname",
",",
"\"localhost\"",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"keyPath",
",",
"creds",
".",
"PrivateKey",
",",
"0600",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"error writing key PEM\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"certPath",
",",
"creds",
".",
"Cert",
",",
"0600",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"error writing key PEM\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// initSelfSignedHTTPSCert generates and self-signs a TLS key+cert pair for https connection
// to the proxy server.
|
[
"initSelfSignedHTTPSCert",
"generates",
"and",
"self",
"-",
"signs",
"a",
"TLS",
"key",
"+",
"cert",
"pair",
"for",
"https",
"connection",
"to",
"the",
"proxy",
"server",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/service.go#L2401-L2432
|
train
|
gravitational/teleport
|
lib/kube/utils/utils.go
|
GetKubeClient
|
func GetKubeClient(configPath string) (client *kubernetes.Clientset, config *rest.Config, err error) {
// if path to kubeconfig was provided, init config from it
if configPath != "" {
config, err = clientcmd.BuildConfigFromFlags("", configPath)
if err != nil {
return nil, nil, trace.Wrap(err)
}
} else {
// otherwise attempt to init as if connecting from cluster
config, err = rest.InClusterConfig()
if err != nil {
return nil, nil, trace.Wrap(err)
}
}
client, err = kubernetes.NewForConfig(config)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return client, config, nil
}
|
go
|
func GetKubeClient(configPath string) (client *kubernetes.Clientset, config *rest.Config, err error) {
// if path to kubeconfig was provided, init config from it
if configPath != "" {
config, err = clientcmd.BuildConfigFromFlags("", configPath)
if err != nil {
return nil, nil, trace.Wrap(err)
}
} else {
// otherwise attempt to init as if connecting from cluster
config, err = rest.InClusterConfig()
if err != nil {
return nil, nil, trace.Wrap(err)
}
}
client, err = kubernetes.NewForConfig(config)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return client, config, nil
}
|
[
"func",
"GetKubeClient",
"(",
"configPath",
"string",
")",
"(",
"client",
"*",
"kubernetes",
".",
"Clientset",
",",
"config",
"*",
"rest",
".",
"Config",
",",
"err",
"error",
")",
"{",
"if",
"configPath",
"!=",
"\"\"",
"{",
"config",
",",
"err",
"=",
"clientcmd",
".",
"BuildConfigFromFlags",
"(",
"\"\"",
",",
"configPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"config",
",",
"err",
"=",
"rest",
".",
"InClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"client",
",",
"err",
"=",
"kubernetes",
".",
"NewForConfig",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"client",
",",
"config",
",",
"nil",
"\n",
"}"
] |
// GetKubeClient returns instance of client to the kubernetes cluster
// using in-cluster configuration if available and falling back to
// configuration file under configPath otherwise
|
[
"GetKubeClient",
"returns",
"instance",
"of",
"client",
"to",
"the",
"kubernetes",
"cluster",
"using",
"in",
"-",
"cluster",
"configuration",
"if",
"available",
"and",
"falling",
"back",
"to",
"configuration",
"file",
"under",
"configPath",
"otherwise"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/utils/utils.go#L16-L36
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.