repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/utils/copy.go | CopyByteSlice | func CopyByteSlice(in []byte) []byte {
if in == nil {
return nil
}
out := make([]byte, len(in))
copy(out, in)
return out
} | go | func CopyByteSlice(in []byte) []byte {
if in == nil {
return nil
}
out := make([]byte, len(in))
copy(out, in)
return out
} | [
"func",
"CopyByteSlice",
"(",
"in",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"in",
")",
")",
"\n",
"copy",
"(",
"out",
",",
"in",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // CopyByteSlice returns a copy of the byte slice. | [
"CopyByteSlice",
"returns",
"a",
"copy",
"of",
"the",
"byte",
"slice",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L20-L27 | train |
gravitational/teleport | lib/utils/copy.go | CopyByteSlices | func CopyByteSlices(in [][]byte) [][]byte {
if in == nil {
return nil
}
out := make([][]byte, len(in))
for i := range in {
out[i] = CopyByteSlice(in[i])
}
return out
} | go | func CopyByteSlices(in [][]byte) [][]byte {
if in == nil {
return nil
}
out := make([][]byte, len(in))
for i := range in {
out[i] = CopyByteSlice(in[i])
}
return out
} | [
"func",
"CopyByteSlices",
"(",
"in",
"[",
"]",
"[",
"]",
"byte",
")",
"[",
"]",
"[",
"]",
"byte",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"in",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"in",
"{",
"out",
"[",
"i",
"]",
"=",
"CopyByteSlice",
"(",
"in",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // CopyByteSlices returns a copy of the byte slices. | [
"CopyByteSlices",
"returns",
"a",
"copy",
"of",
"the",
"byte",
"slices",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L30-L39 | train |
gravitational/teleport | lib/utils/copy.go | JoinStringSlices | func JoinStringSlices(a []string, b []string) []string {
if len(a)+len(b) == 0 {
return nil
}
out := make([]string, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | go | func JoinStringSlices(a []string, b []string) []string {
if len(a)+len(b) == 0 {
return nil
}
out := make([]string, 0, len(a)+len(b))
out = append(out, a...)
out = append(out, b...)
return out
} | [
"func",
"JoinStringSlices",
"(",
"a",
"[",
"]",
"string",
",",
"b",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"a",
")",
"+",
"len",
"(",
"b",
")",
")",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"a",
"...",
")",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"b",
"...",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // JoinStringSlices joins two string slices and returns a resulting slice | [
"JoinStringSlices",
"joins",
"two",
"string",
"slices",
"and",
"returns",
"a",
"resulting",
"slice"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L42-L50 | train |
gravitational/teleport | lib/utils/copy.go | CopyStrings | func CopyStrings(in []string) []string {
if in == nil {
return nil
}
out := make([]string, len(in))
copy(out, in)
return out
} | go | func CopyStrings(in []string) []string {
if in == nil {
return nil
}
out := make([]string, len(in))
copy(out, in)
return out
} | [
"func",
"CopyStrings",
"(",
"in",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"in",
")",
")",
"\n",
"copy",
"(",
"out",
",",
"in",
")",
"\n\n",
"return",
"out",
"\n",
"}"
] | // CopyStrings makes a deep copy of the passed in string slice and returns
// the copy. | [
"CopyStrings",
"makes",
"a",
"deep",
"copy",
"of",
"the",
"passed",
"in",
"string",
"slice",
"and",
"returns",
"the",
"copy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L54-L63 | train |
gravitational/teleport | lib/utils/copy.go | ReplaceInSlice | func ReplaceInSlice(s []string, old string, new string) []string {
out := make([]string, 0, len(s))
for _, x := range s {
if x == old {
out = append(out, new)
} else {
out = append(out, x)
}
}
return out
} | go | func ReplaceInSlice(s []string, old string, new string) []string {
out := make([]string, 0, len(s))
for _, x := range s {
if x == old {
out = append(out, new)
} else {
out = append(out, x)
}
}
return out
} | [
"func",
"ReplaceInSlice",
"(",
"s",
"[",
"]",
"string",
",",
"old",
"string",
",",
"new",
"string",
")",
"[",
"]",
"string",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"s",
")",
")",
"\n\n",
"for",
"_",
",",
"x",
":=",
"range",
"s",
"{",
"if",
"x",
"==",
"old",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"new",
")",
"\n",
"}",
"else",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"x",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"out",
"\n",
"}"
] | // ReplaceInSlice replaces element old with new and returns a new slice. | [
"ReplaceInSlice",
"replaces",
"element",
"old",
"with",
"new",
"and",
"returns",
"a",
"new",
"slice",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/copy.go#L112-L124 | train |
gravitational/teleport | lib/service/connect.go | reconnectToAuthService | func (process *TeleportProcess) reconnectToAuthService(role teleport.Role) (*Connector, error) {
retryTime := defaults.HighResPollingPeriod
for {
connector, err := process.connectToAuthService(role)
if err == nil {
// if connected and client is present, make sure the connector's
// client works, by using call that should succeed at all times
if connector.Client != nil {
_, err = connector.Client.GetNamespace(defaults.Namespace)
if err == nil {
return connector, nil
}
process.Debugf("Connected client %v failed to execute test call: %v. Node or proxy credentials are out of sync.", role, err)
if err := connector.Client.Close(); err != nil {
process.Debugf("Failed to close the client: %v.", err)
}
}
}
process.Infof("%v failed attempt connecting to auth server: %v.", role, err)
// Wait in between attempts, but return if teleport is shutting down
select {
case <-time.After(retryTime):
case <-process.ExitContext().Done():
process.Infof("%v stopping connection attempts, teleport is shutting down.", role)
return nil, ErrTeleportExited
}
}
} | go | func (process *TeleportProcess) reconnectToAuthService(role teleport.Role) (*Connector, error) {
retryTime := defaults.HighResPollingPeriod
for {
connector, err := process.connectToAuthService(role)
if err == nil {
// if connected and client is present, make sure the connector's
// client works, by using call that should succeed at all times
if connector.Client != nil {
_, err = connector.Client.GetNamespace(defaults.Namespace)
if err == nil {
return connector, nil
}
process.Debugf("Connected client %v failed to execute test call: %v. Node or proxy credentials are out of sync.", role, err)
if err := connector.Client.Close(); err != nil {
process.Debugf("Failed to close the client: %v.", err)
}
}
}
process.Infof("%v failed attempt connecting to auth server: %v.", role, err)
// Wait in between attempts, but return if teleport is shutting down
select {
case <-time.After(retryTime):
case <-process.ExitContext().Done():
process.Infof("%v stopping connection attempts, teleport is shutting down.", role)
return nil, ErrTeleportExited
}
}
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"reconnectToAuthService",
"(",
"role",
"teleport",
".",
"Role",
")",
"(",
"*",
"Connector",
",",
"error",
")",
"{",
"retryTime",
":=",
"defaults",
".",
"HighResPollingPeriod",
"\n",
"for",
"{",
"connector",
",",
"err",
":=",
"process",
".",
"connectToAuthService",
"(",
"role",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"// if connected and client is present, make sure the connector's",
"// client works, by using call that should succeed at all times",
"if",
"connector",
".",
"Client",
"!=",
"nil",
"{",
"_",
",",
"err",
"=",
"connector",
".",
"Client",
".",
"GetNamespace",
"(",
"defaults",
".",
"Namespace",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"connector",
",",
"nil",
"\n",
"}",
"\n",
"process",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"role",
",",
"err",
")",
"\n",
"if",
"err",
":=",
"connector",
".",
"Client",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"process",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"process",
".",
"Infof",
"(",
"\"",
"\"",
",",
"role",
",",
"err",
")",
"\n",
"// Wait in between attempts, but return if teleport is shutting down",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"retryTime",
")",
":",
"case",
"<-",
"process",
".",
"ExitContext",
"(",
")",
".",
"Done",
"(",
")",
":",
"process",
".",
"Infof",
"(",
"\"",
"\"",
",",
"role",
")",
"\n",
"return",
"nil",
",",
"ErrTeleportExited",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // reconnectToAuthService continuously attempts to reconnect to the auth
// service until succeeds or process gets shut down | [
"reconnectToAuthService",
"continuously",
"attempts",
"to",
"reconnect",
"to",
"the",
"auth",
"service",
"until",
"succeeds",
"or",
"process",
"gets",
"shut",
"down"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L41-L68 | train |
gravitational/teleport | lib/service/connect.go | connectToAuthService | func (process *TeleportProcess) connectToAuthService(role teleport.Role) (*Connector, error) {
connector, err := process.connect(role)
if err != nil {
return nil, trace.Wrap(err)
}
process.Debugf("Connected client: %v", connector.ClientIdentity)
process.Debugf("Connected server: %v", connector.ServerIdentity)
process.addConnector(connector)
return connector, nil
} | go | func (process *TeleportProcess) connectToAuthService(role teleport.Role) (*Connector, error) {
connector, err := process.connect(role)
if err != nil {
return nil, trace.Wrap(err)
}
process.Debugf("Connected client: %v", connector.ClientIdentity)
process.Debugf("Connected server: %v", connector.ServerIdentity)
process.addConnector(connector)
return connector, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"connectToAuthService",
"(",
"role",
"teleport",
".",
"Role",
")",
"(",
"*",
"Connector",
",",
"error",
")",
"{",
"connector",
",",
"err",
":=",
"process",
".",
"connect",
"(",
"role",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"connector",
".",
"ClientIdentity",
")",
"\n",
"process",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"connector",
".",
"ServerIdentity",
")",
"\n",
"process",
".",
"addConnector",
"(",
"connector",
")",
"\n\n",
"return",
"connector",
",",
"nil",
"\n",
"}"
] | // connectToAuthService attempts to login into the auth servers specified in the
// configuration and receive credentials. | [
"connectToAuthService",
"attempts",
"to",
"login",
"into",
"the",
"auth",
"servers",
"specified",
"in",
"the",
"configuration",
"and",
"receive",
"credentials",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L72-L82 | train |
gravitational/teleport | lib/service/connect.go | newWatcher | func (process *TeleportProcess) newWatcher(conn *Connector, watch services.Watch) (services.Watcher, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.NewWatcher(process.ExitContext(), watch)
}
return conn.Client.NewWatcher(process.ExitContext(), watch)
} | go | func (process *TeleportProcess) newWatcher(conn *Connector, watch services.Watch) (services.Watcher, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.NewWatcher(process.ExitContext(), watch)
}
return conn.Client.NewWatcher(process.ExitContext(), watch)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newWatcher",
"(",
"conn",
"*",
"Connector",
",",
"watch",
"services",
".",
"Watch",
")",
"(",
"services",
".",
"Watcher",
",",
"error",
")",
"{",
"if",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAdmin",
"||",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAuth",
"{",
"return",
"process",
".",
"localAuth",
".",
"NewWatcher",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"watch",
")",
"\n",
"}",
"\n",
"return",
"conn",
".",
"Client",
".",
"NewWatcher",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"watch",
")",
"\n",
"}"
] | // newWatcher returns a new watcher,
// either using local auth server connection or remote client | [
"newWatcher",
"returns",
"a",
"new",
"watcher",
"either",
"using",
"local",
"auth",
"server",
"connection",
"or",
"remote",
"client"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L279-L284 | train |
gravitational/teleport | lib/service/connect.go | getCertAuthority | func (process *TeleportProcess) getCertAuthority(conn *Connector, id services.CertAuthID, loadPrivateKeys bool) (services.CertAuthority, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.GetCertAuthority(id, loadPrivateKeys)
}
return conn.Client.GetCertAuthority(id, loadPrivateKeys)
} | go | func (process *TeleportProcess) getCertAuthority(conn *Connector, id services.CertAuthID, loadPrivateKeys bool) (services.CertAuthority, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return process.localAuth.GetCertAuthority(id, loadPrivateKeys)
}
return conn.Client.GetCertAuthority(id, loadPrivateKeys)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"getCertAuthority",
"(",
"conn",
"*",
"Connector",
",",
"id",
"services",
".",
"CertAuthID",
",",
"loadPrivateKeys",
"bool",
")",
"(",
"services",
".",
"CertAuthority",
",",
"error",
")",
"{",
"if",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAdmin",
"||",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAuth",
"{",
"return",
"process",
".",
"localAuth",
".",
"GetCertAuthority",
"(",
"id",
",",
"loadPrivateKeys",
")",
"\n",
"}",
"\n",
"return",
"conn",
".",
"Client",
".",
"GetCertAuthority",
"(",
"id",
",",
"loadPrivateKeys",
")",
"\n",
"}"
] | // getCertAuthority returns cert authority by ID.
// In case if auth servers, the role is 'TeleportAdmin' and instead of using
// TLS client this method uses the local auth server. | [
"getCertAuthority",
"returns",
"cert",
"authority",
"by",
"ID",
".",
"In",
"case",
"if",
"auth",
"servers",
"the",
"role",
"is",
"TeleportAdmin",
"and",
"instead",
"of",
"using",
"TLS",
"client",
"this",
"method",
"uses",
"the",
"local",
"auth",
"server",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L289-L294 | train |
gravitational/teleport | lib/service/connect.go | reRegister | func (process *TeleportProcess) reRegister(conn *Connector, additionalPrincipals []string, dnsNames []string, rotation services.Rotation) (*auth.Identity, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return auth.GenerateIdentity(process.localAuth, conn.ClientIdentity.ID, additionalPrincipals, dnsNames)
}
const reason = "re-register"
keyPair, err := process.generateKeyPair(conn.ClientIdentity.ID.Role, reason)
if err != nil {
return nil, trace.Wrap(err)
}
identity, err := auth.ReRegister(auth.ReRegisterParams{
Client: conn.Client,
ID: conn.ClientIdentity.ID,
AdditionalPrincipals: additionalPrincipals,
PrivateKey: keyPair.PrivateKey,
PublicTLSKey: keyPair.PublicTLSKey,
PublicSSHKey: keyPair.PublicSSHKey,
DNSNames: dnsNames,
Rotation: rotation,
})
if err != nil {
return nil, trace.Wrap(err)
}
process.deleteKeyPair(conn.ClientIdentity.ID.Role, reason)
return identity, nil
} | go | func (process *TeleportProcess) reRegister(conn *Connector, additionalPrincipals []string, dnsNames []string, rotation services.Rotation) (*auth.Identity, error) {
if conn.ClientIdentity.ID.Role == teleport.RoleAdmin || conn.ClientIdentity.ID.Role == teleport.RoleAuth {
return auth.GenerateIdentity(process.localAuth, conn.ClientIdentity.ID, additionalPrincipals, dnsNames)
}
const reason = "re-register"
keyPair, err := process.generateKeyPair(conn.ClientIdentity.ID.Role, reason)
if err != nil {
return nil, trace.Wrap(err)
}
identity, err := auth.ReRegister(auth.ReRegisterParams{
Client: conn.Client,
ID: conn.ClientIdentity.ID,
AdditionalPrincipals: additionalPrincipals,
PrivateKey: keyPair.PrivateKey,
PublicTLSKey: keyPair.PublicTLSKey,
PublicSSHKey: keyPair.PublicSSHKey,
DNSNames: dnsNames,
Rotation: rotation,
})
if err != nil {
return nil, trace.Wrap(err)
}
process.deleteKeyPair(conn.ClientIdentity.ID.Role, reason)
return identity, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"reRegister",
"(",
"conn",
"*",
"Connector",
",",
"additionalPrincipals",
"[",
"]",
"string",
",",
"dnsNames",
"[",
"]",
"string",
",",
"rotation",
"services",
".",
"Rotation",
")",
"(",
"*",
"auth",
".",
"Identity",
",",
"error",
")",
"{",
"if",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAdmin",
"||",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
"==",
"teleport",
".",
"RoleAuth",
"{",
"return",
"auth",
".",
"GenerateIdentity",
"(",
"process",
".",
"localAuth",
",",
"conn",
".",
"ClientIdentity",
".",
"ID",
",",
"additionalPrincipals",
",",
"dnsNames",
")",
"\n",
"}",
"\n",
"const",
"reason",
"=",
"\"",
"\"",
"\n",
"keyPair",
",",
"err",
":=",
"process",
".",
"generateKeyPair",
"(",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
",",
"reason",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"identity",
",",
"err",
":=",
"auth",
".",
"ReRegister",
"(",
"auth",
".",
"ReRegisterParams",
"{",
"Client",
":",
"conn",
".",
"Client",
",",
"ID",
":",
"conn",
".",
"ClientIdentity",
".",
"ID",
",",
"AdditionalPrincipals",
":",
"additionalPrincipals",
",",
"PrivateKey",
":",
"keyPair",
".",
"PrivateKey",
",",
"PublicTLSKey",
":",
"keyPair",
".",
"PublicTLSKey",
",",
"PublicSSHKey",
":",
"keyPair",
".",
"PublicSSHKey",
",",
"DNSNames",
":",
"dnsNames",
",",
"Rotation",
":",
"rotation",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"deleteKeyPair",
"(",
"conn",
".",
"ClientIdentity",
".",
"ID",
".",
"Role",
",",
"reason",
")",
"\n",
"return",
"identity",
",",
"nil",
"\n",
"}"
] | // reRegister receives new identity credentials for proxy, node and auth.
// In case if auth servers, the role is 'TeleportAdmin' and instead of using
// TLS client this method uses the local auth server. | [
"reRegister",
"receives",
"new",
"identity",
"credentials",
"for",
"proxy",
"node",
"and",
"auth",
".",
"In",
"case",
"if",
"auth",
"servers",
"the",
"role",
"is",
"TeleportAdmin",
"and",
"instead",
"of",
"using",
"TLS",
"client",
"this",
"method",
"uses",
"the",
"local",
"auth",
"server",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L299-L323 | train |
gravitational/teleport | lib/service/connect.go | periodicSyncRotationState | func (process *TeleportProcess) periodicSyncRotationState() error {
// start rotation only after teleport process has started
eventC := make(chan Event, 1)
process.WaitForEvent(process.ExitContext(), TeleportReadyEvent, eventC)
select {
case <-eventC:
process.Infof("The new service has started successfully. Starting syncing rotation status with period %v.", process.Config.PollingPeriod)
case <-process.ExitContext().Done():
return nil
}
retryTicker := time.NewTicker(defaults.HighResPollingPeriod)
defer retryTicker.Stop()
for {
err := process.syncRotationStateCycle()
if err == nil {
return nil
}
process.Warningf("Sync rotation state cycle failed: %v, going to retry after %v.", err, defaults.HighResPollingPeriod)
select {
case <-retryTicker.C:
case <-process.ExitContext().Done():
return nil
}
}
} | go | func (process *TeleportProcess) periodicSyncRotationState() error {
// start rotation only after teleport process has started
eventC := make(chan Event, 1)
process.WaitForEvent(process.ExitContext(), TeleportReadyEvent, eventC)
select {
case <-eventC:
process.Infof("The new service has started successfully. Starting syncing rotation status with period %v.", process.Config.PollingPeriod)
case <-process.ExitContext().Done():
return nil
}
retryTicker := time.NewTicker(defaults.HighResPollingPeriod)
defer retryTicker.Stop()
for {
err := process.syncRotationStateCycle()
if err == nil {
return nil
}
process.Warningf("Sync rotation state cycle failed: %v, going to retry after %v.", err, defaults.HighResPollingPeriod)
select {
case <-retryTicker.C:
case <-process.ExitContext().Done():
return nil
}
}
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"periodicSyncRotationState",
"(",
")",
"error",
"{",
"// start rotation only after teleport process has started",
"eventC",
":=",
"make",
"(",
"chan",
"Event",
",",
"1",
")",
"\n",
"process",
".",
"WaitForEvent",
"(",
"process",
".",
"ExitContext",
"(",
")",
",",
"TeleportReadyEvent",
",",
"eventC",
")",
"\n",
"select",
"{",
"case",
"<-",
"eventC",
":",
"process",
".",
"Infof",
"(",
"\"",
"\"",
",",
"process",
".",
"Config",
".",
"PollingPeriod",
")",
"\n",
"case",
"<-",
"process",
".",
"ExitContext",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"}",
"\n\n",
"retryTicker",
":=",
"time",
".",
"NewTicker",
"(",
"defaults",
".",
"HighResPollingPeriod",
")",
"\n",
"defer",
"retryTicker",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"err",
":=",
"process",
".",
"syncRotationStateCycle",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"process",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
",",
"defaults",
".",
"HighResPollingPeriod",
")",
"\n",
"select",
"{",
"case",
"<-",
"retryTicker",
".",
"C",
":",
"case",
"<-",
"process",
".",
"ExitContext",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // periodicSyncRotationState checks rotation state periodically and
// takes action if necessary | [
"periodicSyncRotationState",
"checks",
"rotation",
"state",
"periodically",
"and",
"takes",
"action",
"if",
"necessary"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L441-L466 | train |
gravitational/teleport | lib/service/connect.go | syncRotationStateAndBroadcast | func (process *TeleportProcess) syncRotationStateAndBroadcast(conn *Connector) (*rotationStatus, error) {
status, err := process.syncRotationState(conn)
if err != nil {
process.BroadcastEvent(Event{Name: TeleportDegradedEvent, Payload: nil})
if trace.IsConnectionProblem(err) {
process.Warningf("Connection problem: sync rotation state: %v.", err)
} else {
process.Warningf("Failed to sync rotation state: %v.", err)
}
return nil, trace.Wrap(err)
}
process.BroadcastEvent(Event{Name: TeleportOKEvent, Payload: nil})
if status.phaseChanged || status.needsReload {
process.Debugf("Sync rotation state detected cert authority reload phase update.")
}
if status.phaseChanged {
process.BroadcastEvent(Event{Name: TeleportPhaseChangeEvent})
}
if status.needsReload {
process.Debugf("Triggering reload process.")
process.BroadcastEvent(Event{Name: TeleportReloadEvent})
}
return status, nil
} | go | func (process *TeleportProcess) syncRotationStateAndBroadcast(conn *Connector) (*rotationStatus, error) {
status, err := process.syncRotationState(conn)
if err != nil {
process.BroadcastEvent(Event{Name: TeleportDegradedEvent, Payload: nil})
if trace.IsConnectionProblem(err) {
process.Warningf("Connection problem: sync rotation state: %v.", err)
} else {
process.Warningf("Failed to sync rotation state: %v.", err)
}
return nil, trace.Wrap(err)
}
process.BroadcastEvent(Event{Name: TeleportOKEvent, Payload: nil})
if status.phaseChanged || status.needsReload {
process.Debugf("Sync rotation state detected cert authority reload phase update.")
}
if status.phaseChanged {
process.BroadcastEvent(Event{Name: TeleportPhaseChangeEvent})
}
if status.needsReload {
process.Debugf("Triggering reload process.")
process.BroadcastEvent(Event{Name: TeleportReloadEvent})
}
return status, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"syncRotationStateAndBroadcast",
"(",
"conn",
"*",
"Connector",
")",
"(",
"*",
"rotationStatus",
",",
"error",
")",
"{",
"status",
",",
"err",
":=",
"process",
".",
"syncRotationState",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportDegradedEvent",
",",
"Payload",
":",
"nil",
"}",
")",
"\n",
"if",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
"{",
"process",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"process",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportOKEvent",
",",
"Payload",
":",
"nil",
"}",
")",
"\n\n",
"if",
"status",
".",
"phaseChanged",
"||",
"status",
".",
"needsReload",
"{",
"process",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"status",
".",
"phaseChanged",
"{",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportPhaseChangeEvent",
"}",
")",
"\n",
"}",
"\n",
"if",
"status",
".",
"needsReload",
"{",
"process",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"process",
".",
"BroadcastEvent",
"(",
"Event",
"{",
"Name",
":",
"TeleportReloadEvent",
"}",
")",
"\n",
"}",
"\n",
"return",
"status",
",",
"nil",
"\n",
"}"
] | // syncRotationStateAndBroadcast syncs rotation state and broadcasts events
// when phase has been changed or reload happened | [
"syncRotationStateAndBroadcast",
"syncs",
"rotation",
"state",
"and",
"broadcasts",
"events",
"when",
"phase",
"has",
"been",
"changed",
"or",
"reload",
"happened"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L546-L570 | train |
gravitational/teleport | lib/service/connect.go | syncRotationState | func (process *TeleportProcess) syncRotationState(conn *Connector) (*rotationStatus, error) {
connectors := process.getConnectors()
ca, err := process.getCertAuthority(conn, services.CertAuthID{
DomainName: conn.ClientIdentity.ClusterName,
Type: services.HostCA,
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
var status rotationStatus
status.ca = ca
for _, conn := range connectors {
serviceStatus, err := process.syncServiceRotationState(ca, conn)
if err != nil {
return nil, trace.Wrap(err)
}
if serviceStatus.needsReload {
status.needsReload = true
}
if serviceStatus.phaseChanged {
status.phaseChanged = true
}
}
return &status, nil
} | go | func (process *TeleportProcess) syncRotationState(conn *Connector) (*rotationStatus, error) {
connectors := process.getConnectors()
ca, err := process.getCertAuthority(conn, services.CertAuthID{
DomainName: conn.ClientIdentity.ClusterName,
Type: services.HostCA,
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
var status rotationStatus
status.ca = ca
for _, conn := range connectors {
serviceStatus, err := process.syncServiceRotationState(ca, conn)
if err != nil {
return nil, trace.Wrap(err)
}
if serviceStatus.needsReload {
status.needsReload = true
}
if serviceStatus.phaseChanged {
status.phaseChanged = true
}
}
return &status, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"syncRotationState",
"(",
"conn",
"*",
"Connector",
")",
"(",
"*",
"rotationStatus",
",",
"error",
")",
"{",
"connectors",
":=",
"process",
".",
"getConnectors",
"(",
")",
"\n",
"ca",
",",
"err",
":=",
"process",
".",
"getCertAuthority",
"(",
"conn",
",",
"services",
".",
"CertAuthID",
"{",
"DomainName",
":",
"conn",
".",
"ClientIdentity",
".",
"ClusterName",
",",
"Type",
":",
"services",
".",
"HostCA",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"status",
"rotationStatus",
"\n",
"status",
".",
"ca",
"=",
"ca",
"\n",
"for",
"_",
",",
"conn",
":=",
"range",
"connectors",
"{",
"serviceStatus",
",",
"err",
":=",
"process",
".",
"syncServiceRotationState",
"(",
"ca",
",",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"serviceStatus",
".",
"needsReload",
"{",
"status",
".",
"needsReload",
"=",
"true",
"\n",
"}",
"\n",
"if",
"serviceStatus",
".",
"phaseChanged",
"{",
"status",
".",
"phaseChanged",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"status",
",",
"nil",
"\n",
"}"
] | // syncRotationState compares cluster rotation state with the state of
// internal services and performs the rotation if necessary. | [
"syncRotationState",
"compares",
"cluster",
"rotation",
"state",
"with",
"the",
"state",
"of",
"internal",
"services",
"and",
"performs",
"the",
"rotation",
"if",
"necessary",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L574-L598 | train |
gravitational/teleport | lib/service/connect.go | newClient | func (process *TeleportProcess) newClient(authServers []utils.NetAddr, identity *auth.Identity) (*auth.Client, bool, error) {
directClient, err := process.newClientDirect(authServers, identity)
if err != nil {
return nil, false, trace.Wrap(err)
}
// Try and connect to the Auth Server. If the request fails, try and
// connect through a tunnel.
log.Debugf("Attempting to connect to Auth Server directly.")
_, err = directClient.GetLocalClusterName()
if err != nil {
// Only attempt to connect through the proxy for nodes.
if identity.ID.Role != teleport.RoleNode {
return nil, false, trace.Wrap(err)
}
log.Debugf("Attempting to connect to Auth Server through tunnel.")
tunnelClient, er := process.newClientThroughTunnel(authServers, identity)
if er != nil {
return nil, false, trace.NewAggregate(err, er)
}
log.Debugf("Connected to Auth Server through tunnel.")
return tunnelClient, true, nil
}
log.Debugf("Connected to Auth Server with direct connection.")
return directClient, false, nil
} | go | func (process *TeleportProcess) newClient(authServers []utils.NetAddr, identity *auth.Identity) (*auth.Client, bool, error) {
directClient, err := process.newClientDirect(authServers, identity)
if err != nil {
return nil, false, trace.Wrap(err)
}
// Try and connect to the Auth Server. If the request fails, try and
// connect through a tunnel.
log.Debugf("Attempting to connect to Auth Server directly.")
_, err = directClient.GetLocalClusterName()
if err != nil {
// Only attempt to connect through the proxy for nodes.
if identity.ID.Role != teleport.RoleNode {
return nil, false, trace.Wrap(err)
}
log.Debugf("Attempting to connect to Auth Server through tunnel.")
tunnelClient, er := process.newClientThroughTunnel(authServers, identity)
if er != nil {
return nil, false, trace.NewAggregate(err, er)
}
log.Debugf("Connected to Auth Server through tunnel.")
return tunnelClient, true, nil
}
log.Debugf("Connected to Auth Server with direct connection.")
return directClient, false, nil
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"newClient",
"(",
"authServers",
"[",
"]",
"utils",
".",
"NetAddr",
",",
"identity",
"*",
"auth",
".",
"Identity",
")",
"(",
"*",
"auth",
".",
"Client",
",",
"bool",
",",
"error",
")",
"{",
"directClient",
",",
"err",
":=",
"process",
".",
"newClientDirect",
"(",
"authServers",
",",
"identity",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Try and connect to the Auth Server. If the request fails, try and",
"// connect through a tunnel.",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
"=",
"directClient",
".",
"GetLocalClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Only attempt to connect through the proxy for nodes.",
"if",
"identity",
".",
"ID",
".",
"Role",
"!=",
"teleport",
".",
"RoleNode",
"{",
"return",
"nil",
",",
"false",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"tunnelClient",
",",
"er",
":=",
"process",
".",
"newClientThroughTunnel",
"(",
"authServers",
",",
"identity",
")",
"\n",
"if",
"er",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"trace",
".",
"NewAggregate",
"(",
"err",
",",
"er",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"tunnelClient",
",",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"directClient",
",",
"false",
",",
"nil",
"\n",
"}"
] | // newClient attempts to connect directly to the Auth Server. If it fails, it
// falls back to trying to connect to the Auth Server through the proxy. | [
"newClient",
"attempts",
"to",
"connect",
"directly",
"to",
"the",
"Auth",
"Server",
".",
"If",
"it",
"fails",
"it",
"falls",
"back",
"to",
"trying",
"to",
"connect",
"to",
"the",
"Auth",
"Server",
"through",
"the",
"proxy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L778-L806 | train |
gravitational/teleport | lib/service/connect.go | findReverseTunnel | func (process *TeleportProcess) findReverseTunnel(addrs []utils.NetAddr) (string, error) {
var errs []error
for _, addr := range addrs {
// In insecure mode, any certificate is accepted. In secure mode the hosts
// CAs are used to validate the certificate on the proxy.
clt, err := client.NewCredentialsClient(
addr.String(),
lib.IsInsecureDevMode(),
nil)
if err != nil {
return "", trace.Wrap(err)
}
resp, err := clt.Find(process.ExitContext())
if err == nil {
// If a tunnel public address is set, return it otherwise return the
// tunnel listen address.
if resp.Proxy.SSH.TunnelPublicAddr != "" {
return resp.Proxy.SSH.TunnelPublicAddr, nil
}
return resp.Proxy.SSH.TunnelListenAddr, nil
}
errs = append(errs, err)
}
return "", trace.NewAggregate(errs...)
} | go | func (process *TeleportProcess) findReverseTunnel(addrs []utils.NetAddr) (string, error) {
var errs []error
for _, addr := range addrs {
// In insecure mode, any certificate is accepted. In secure mode the hosts
// CAs are used to validate the certificate on the proxy.
clt, err := client.NewCredentialsClient(
addr.String(),
lib.IsInsecureDevMode(),
nil)
if err != nil {
return "", trace.Wrap(err)
}
resp, err := clt.Find(process.ExitContext())
if err == nil {
// If a tunnel public address is set, return it otherwise return the
// tunnel listen address.
if resp.Proxy.SSH.TunnelPublicAddr != "" {
return resp.Proxy.SSH.TunnelPublicAddr, nil
}
return resp.Proxy.SSH.TunnelListenAddr, nil
}
errs = append(errs, err)
}
return "", trace.NewAggregate(errs...)
} | [
"func",
"(",
"process",
"*",
"TeleportProcess",
")",
"findReverseTunnel",
"(",
"addrs",
"[",
"]",
"utils",
".",
"NetAddr",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"errs",
"[",
"]",
"error",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"// In insecure mode, any certificate is accepted. In secure mode the hosts",
"// CAs are used to validate the certificate on the proxy.",
"clt",
",",
"err",
":=",
"client",
".",
"NewCredentialsClient",
"(",
"addr",
".",
"String",
"(",
")",
",",
"lib",
".",
"IsInsecureDevMode",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"clt",
".",
"Find",
"(",
"process",
".",
"ExitContext",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"// If a tunnel public address is set, return it otherwise return the",
"// tunnel listen address.",
"if",
"resp",
".",
"Proxy",
".",
"SSH",
".",
"TunnelPublicAddr",
"!=",
"\"",
"\"",
"{",
"return",
"resp",
".",
"Proxy",
".",
"SSH",
".",
"TunnelPublicAddr",
",",
"nil",
"\n",
"}",
"\n",
"return",
"resp",
".",
"Proxy",
".",
"SSH",
".",
"TunnelListenAddr",
",",
"nil",
"\n",
"}",
"\n",
"errs",
"=",
"append",
"(",
"errs",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"trace",
".",
"NewAggregate",
"(",
"errs",
"...",
")",
"\n",
"}"
] | // findReverseTunnel uses the web proxy to discover where the SSH reverse tunnel
// server is running. | [
"findReverseTunnel",
"uses",
"the",
"web",
"proxy",
"to",
"discover",
"where",
"the",
"SSH",
"reverse",
"tunnel",
"server",
"is",
"running",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/service/connect.go#L810-L835 | train |
gravitational/teleport | lib/utils/spki.go | CalculateSPKI | func CalculateSPKI(cert *x509.Certificate) string {
sum := sha256.Sum256(cert.RawSubjectPublicKeyInfo)
return "sha256:" + hex.EncodeToString(sum[:])
} | go | func CalculateSPKI(cert *x509.Certificate) string {
sum := sha256.Sum256(cert.RawSubjectPublicKeyInfo)
return "sha256:" + hex.EncodeToString(sum[:])
} | [
"func",
"CalculateSPKI",
"(",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"string",
"{",
"sum",
":=",
"sha256",
".",
"Sum256",
"(",
"cert",
".",
"RawSubjectPublicKeyInfo",
")",
"\n",
"return",
"\"",
"\"",
"+",
"hex",
".",
"EncodeToString",
"(",
"sum",
"[",
":",
"]",
")",
"\n",
"}"
] | // CalculateSPKI the hash value of the SPKI header in a certificate. | [
"CalculateSPKI",
"the",
"hash",
"value",
"of",
"the",
"SPKI",
"header",
"in",
"a",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/spki.go#L30-L33 | train |
gravitational/teleport | lib/utils/spki.go | CheckSPKI | func CheckSPKI(pin string, cert *x509.Certificate) error {
// Check that the format of the pin is valid.
parts := strings.Split(pin, ":")
if len(parts) != 2 {
return trace.BadParameter("invalid format for certificate pin, expected algorithm:pin")
}
if parts[0] != "sha256" {
return trace.BadParameter("sha256 only supported hashing algorithm for certificate pin")
}
// Check that that pin itself matches that value calculated from the passed
// in certificate.
if subtle.ConstantTimeCompare([]byte(CalculateSPKI(cert)), []byte(pin)) != 1 {
return trace.BadParameter(errorMessage)
}
return nil
} | go | func CheckSPKI(pin string, cert *x509.Certificate) error {
// Check that the format of the pin is valid.
parts := strings.Split(pin, ":")
if len(parts) != 2 {
return trace.BadParameter("invalid format for certificate pin, expected algorithm:pin")
}
if parts[0] != "sha256" {
return trace.BadParameter("sha256 only supported hashing algorithm for certificate pin")
}
// Check that that pin itself matches that value calculated from the passed
// in certificate.
if subtle.ConstantTimeCompare([]byte(CalculateSPKI(cert)), []byte(pin)) != 1 {
return trace.BadParameter(errorMessage)
}
return nil
} | [
"func",
"CheckSPKI",
"(",
"pin",
"string",
",",
"cert",
"*",
"x509",
".",
"Certificate",
")",
"error",
"{",
"// Check that the format of the pin is valid.",
"parts",
":=",
"strings",
".",
"Split",
"(",
"pin",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"parts",
"[",
"0",
"]",
"!=",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check that that pin itself matches that value calculated from the passed",
"// in certificate.",
"if",
"subtle",
".",
"ConstantTimeCompare",
"(",
"[",
"]",
"byte",
"(",
"CalculateSPKI",
"(",
"cert",
")",
")",
",",
"[",
"]",
"byte",
"(",
"pin",
")",
")",
"!=",
"1",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"errorMessage",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckSPKI the passed in pin against the calculated value from a certificate. | [
"CheckSPKI",
"the",
"passed",
"in",
"pin",
"against",
"the",
"calculated",
"value",
"from",
"a",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/spki.go#L36-L53 | train |
gravitational/teleport | lib/httplib/httplib.go | MakeHandler | func MakeHandler(fn HandlerFunc) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r, p)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | go | func MakeHandler(fn HandlerFunc) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r, p)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | [
"func",
"MakeHandler",
"(",
"fn",
"HandlerFunc",
")",
"httprouter",
".",
"Handle",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"{",
"// ensure that neither proxies nor browsers cache http traffic",
"SetNoCacheHeaders",
"(",
"w",
".",
"Header",
"(",
")",
")",
"\n\n",
"out",
",",
"err",
":=",
"fn",
"(",
"w",
",",
"r",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"trace",
".",
"WriteError",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"out",
"!=",
"nil",
"{",
"roundtrip",
".",
"ReplyJSON",
"(",
"w",
",",
"http",
".",
"StatusOK",
",",
"out",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // MakeHandler returns a new httprouter.Handle func from a handler func | [
"MakeHandler",
"returns",
"a",
"new",
"httprouter",
".",
"Handle",
"func",
"from",
"a",
"handler",
"func"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L45-L59 | train |
gravitational/teleport | lib/httplib/httplib.go | MakeStdHandler | func MakeStdHandler(fn StdHandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | go | func MakeStdHandler(fn StdHandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// ensure that neither proxies nor browsers cache http traffic
SetNoCacheHeaders(w.Header())
out, err := fn(w, r)
if err != nil {
trace.WriteError(w, err)
return
}
if out != nil {
roundtrip.ReplyJSON(w, http.StatusOK, out)
}
}
} | [
"func",
"MakeStdHandler",
"(",
"fn",
"StdHandlerFunc",
")",
"http",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"// ensure that neither proxies nor browsers cache http traffic",
"SetNoCacheHeaders",
"(",
"w",
".",
"Header",
"(",
")",
")",
"\n\n",
"out",
",",
"err",
":=",
"fn",
"(",
"w",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"trace",
".",
"WriteError",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"out",
"!=",
"nil",
"{",
"roundtrip",
".",
"ReplyJSON",
"(",
"w",
",",
"http",
".",
"StatusOK",
",",
"out",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // MakeStdHandler returns a new http.Handle func from http.HandlerFunc | [
"MakeStdHandler",
"returns",
"a",
"new",
"http",
".",
"Handle",
"func",
"from",
"http",
".",
"HandlerFunc"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L62-L76 | train |
gravitational/teleport | lib/httplib/httplib.go | WithCSRFProtection | func WithCSRFProtection(fn HandlerFunc) httprouter.Handle {
hanlderFn := MakeHandler(fn)
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
err := csrf.VerifyHTTPHeader(r)
if err != nil {
log.Warningf("unable to validate CSRF token %v", err)
trace.WriteError(w, trace.AccessDenied("access denied"))
return
}
hanlderFn(w, r, p)
}
} | go | func WithCSRFProtection(fn HandlerFunc) httprouter.Handle {
hanlderFn := MakeHandler(fn)
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
err := csrf.VerifyHTTPHeader(r)
if err != nil {
log.Warningf("unable to validate CSRF token %v", err)
trace.WriteError(w, trace.AccessDenied("access denied"))
return
}
hanlderFn(w, r, p)
}
} | [
"func",
"WithCSRFProtection",
"(",
"fn",
"HandlerFunc",
")",
"httprouter",
".",
"Handle",
"{",
"hanlderFn",
":=",
"MakeHandler",
"(",
"fn",
")",
"\n",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"{",
"err",
":=",
"csrf",
".",
"VerifyHTTPHeader",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"trace",
".",
"WriteError",
"(",
"w",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"hanlderFn",
"(",
"w",
",",
"r",
",",
"p",
")",
"\n",
"}",
"\n",
"}"
] | // WithCSRFProtection ensures that request to unauthenticated API is checked against CSRF attacks | [
"WithCSRFProtection",
"ensures",
"that",
"request",
"to",
"unauthenticated",
"API",
"is",
"checked",
"against",
"CSRF",
"attacks"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L79-L90 | train |
gravitational/teleport | lib/httplib/httplib.go | ConvertResponse | func ConvertResponse(re *roundtrip.Response, err error) (*roundtrip.Response, error) {
if err != nil {
if uerr, ok := err.(*url.Error); ok && uerr != nil && uerr.Err != nil {
return nil, trace.ConnectionProblem(uerr.Err, uerr.Error())
}
return nil, trace.ConvertSystemError(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | go | func ConvertResponse(re *roundtrip.Response, err error) (*roundtrip.Response, error) {
if err != nil {
if uerr, ok := err.(*url.Error); ok && uerr != nil && uerr.Err != nil {
return nil, trace.ConnectionProblem(uerr.Err, uerr.Error())
}
return nil, trace.ConvertSystemError(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | [
"func",
"ConvertResponse",
"(",
"re",
"*",
"roundtrip",
".",
"Response",
",",
"err",
"error",
")",
"(",
"*",
"roundtrip",
".",
"Response",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"if",
"uerr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"url",
".",
"Error",
")",
";",
"ok",
"&&",
"uerr",
"!=",
"nil",
"&&",
"uerr",
".",
"Err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"uerr",
".",
"Err",
",",
"uerr",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"trace",
".",
"ReadError",
"(",
"re",
".",
"Code",
"(",
")",
",",
"re",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // ConvertResponse converts http error to internal error type
// based on HTTP response code and HTTP body contents | [
"ConvertResponse",
"converts",
"http",
"error",
"to",
"internal",
"error",
"type",
"based",
"on",
"HTTP",
"response",
"code",
"and",
"HTTP",
"body",
"contents"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L107-L115 | train |
gravitational/teleport | lib/httplib/httplib.go | ParseBool | func ParseBool(q url.Values, name string) (bool, bool, error) {
stringVal := q.Get(name)
if stringVal == "" {
return false, false, nil
}
val, err := strconv.ParseBool(stringVal)
if err != nil {
return false, false, trace.BadParameter(
"'%v': expected 'true' or 'false', got %v", name, stringVal)
}
return val, true, nil
} | go | func ParseBool(q url.Values, name string) (bool, bool, error) {
stringVal := q.Get(name)
if stringVal == "" {
return false, false, nil
}
val, err := strconv.ParseBool(stringVal)
if err != nil {
return false, false, trace.BadParameter(
"'%v': expected 'true' or 'false', got %v", name, stringVal)
}
return val, true, nil
} | [
"func",
"ParseBool",
"(",
"q",
"url",
".",
"Values",
",",
"name",
"string",
")",
"(",
"bool",
",",
"bool",
",",
"error",
")",
"{",
"stringVal",
":=",
"q",
".",
"Get",
"(",
"name",
")",
"\n",
"if",
"stringVal",
"==",
"\"",
"\"",
"{",
"return",
"false",
",",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"val",
",",
"err",
":=",
"strconv",
".",
"ParseBool",
"(",
"stringVal",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"false",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"name",
",",
"stringVal",
")",
"\n",
"}",
"\n",
"return",
"val",
",",
"true",
",",
"nil",
"\n",
"}"
] | // ParseBool will parse boolean variable from url query
// returns value, ok, error | [
"ParseBool",
"will",
"parse",
"boolean",
"variable",
"from",
"url",
"query",
"returns",
"value",
"ok",
"error"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L119-L131 | train |
gravitational/teleport | lib/httplib/httplib.go | Rewrite | func Rewrite(in, out string) RewritePair {
return RewritePair{
Expr: regexp.MustCompile(in),
Replacement: out,
}
} | go | func Rewrite(in, out string) RewritePair {
return RewritePair{
Expr: regexp.MustCompile(in),
Replacement: out,
}
} | [
"func",
"Rewrite",
"(",
"in",
",",
"out",
"string",
")",
"RewritePair",
"{",
"return",
"RewritePair",
"{",
"Expr",
":",
"regexp",
".",
"MustCompile",
"(",
"in",
")",
",",
"Replacement",
":",
"out",
",",
"}",
"\n",
"}"
] | // Rewrite creates a rewrite pair, panics if in epxression
// is not a valid regular expressoin | [
"Rewrite",
"creates",
"a",
"rewrite",
"pair",
"panics",
"if",
"in",
"epxression",
"is",
"not",
"a",
"valid",
"regular",
"expressoin"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L143-L148 | train |
gravitational/teleport | lib/httplib/httplib.go | RewritePaths | func RewritePaths(next http.Handler, rewrites ...RewritePair) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
for _, rewrite := range rewrites {
req.URL.Path = rewrite.Expr.ReplaceAllString(req.URL.Path, rewrite.Replacement)
}
next.ServeHTTP(w, req)
})
} | go | func RewritePaths(next http.Handler, rewrites ...RewritePair) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
for _, rewrite := range rewrites {
req.URL.Path = rewrite.Expr.ReplaceAllString(req.URL.Path, rewrite.Replacement)
}
next.ServeHTTP(w, req)
})
} | [
"func",
"RewritePaths",
"(",
"next",
"http",
".",
"Handler",
",",
"rewrites",
"...",
"RewritePair",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"for",
"_",
",",
"rewrite",
":=",
"range",
"rewrites",
"{",
"req",
".",
"URL",
".",
"Path",
"=",
"rewrite",
".",
"Expr",
".",
"ReplaceAllString",
"(",
"req",
".",
"URL",
".",
"Path",
",",
"rewrite",
".",
"Replacement",
")",
"\n",
"}",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"req",
")",
"\n",
"}",
")",
"\n",
"}"
] | // RewritePaths creates a middleware that rewrites paths in incoming request | [
"RewritePaths",
"creates",
"a",
"middleware",
"that",
"rewrites",
"paths",
"in",
"incoming",
"request"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L151-L158 | train |
gravitational/teleport | lib/httplib/httplib.go | SafeRedirect | func SafeRedirect(w http.ResponseWriter, r *http.Request, redirectURL string) error {
parsedURL, err := url.Parse(redirectURL)
if err != nil {
return trace.Wrap(err)
}
http.Redirect(w, r, parsedURL.RequestURI(), http.StatusFound)
return nil
} | go | func SafeRedirect(w http.ResponseWriter, r *http.Request, redirectURL string) error {
parsedURL, err := url.Parse(redirectURL)
if err != nil {
return trace.Wrap(err)
}
http.Redirect(w, r, parsedURL.RequestURI(), http.StatusFound)
return nil
} | [
"func",
"SafeRedirect",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"redirectURL",
"string",
")",
"error",
"{",
"parsedURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"redirectURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"parsedURL",
".",
"RequestURI",
"(",
")",
",",
"http",
".",
"StatusFound",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // SafeRedirect performs a relative redirect to the URI part of the provided redirect URL | [
"SafeRedirect",
"performs",
"a",
"relative",
"redirect",
"to",
"the",
"URI",
"part",
"of",
"the",
"provided",
"redirect",
"URL"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/httplib.go#L161-L168 | train |
gravitational/teleport | lib/srv/ctx.go | CreateOrJoinSession | func (c *ServerContext) CreateOrJoinSession(reg *SessionRegistry) error {
// As SSH conversation progresses, at some point a session will be created and
// its ID will be added to the environment
ssid, found := c.GetEnv(sshutils.SessionEnvVar)
if !found {
return nil
}
// make sure whatever session is requested is a valid session
_, err := rsession.ParseID(ssid)
if err != nil {
return trace.BadParameter("invalid session id")
}
findSession := func() (*session, bool) {
reg.Lock()
defer reg.Unlock()
return reg.findSession(rsession.ID(ssid))
}
// update ctx with a session ID
c.session, _ = findSession()
if c.session == nil {
log.Debugf("Will create new session for SSH connection %v.", c.Conn.RemoteAddr())
} else {
log.Debugf("Will join session %v for SSH connection %v.", c.session, c.Conn.RemoteAddr())
}
return nil
} | go | func (c *ServerContext) CreateOrJoinSession(reg *SessionRegistry) error {
// As SSH conversation progresses, at some point a session will be created and
// its ID will be added to the environment
ssid, found := c.GetEnv(sshutils.SessionEnvVar)
if !found {
return nil
}
// make sure whatever session is requested is a valid session
_, err := rsession.ParseID(ssid)
if err != nil {
return trace.BadParameter("invalid session id")
}
findSession := func() (*session, bool) {
reg.Lock()
defer reg.Unlock()
return reg.findSession(rsession.ID(ssid))
}
// update ctx with a session ID
c.session, _ = findSession()
if c.session == nil {
log.Debugf("Will create new session for SSH connection %v.", c.Conn.RemoteAddr())
} else {
log.Debugf("Will join session %v for SSH connection %v.", c.session, c.Conn.RemoteAddr())
}
return nil
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"CreateOrJoinSession",
"(",
"reg",
"*",
"SessionRegistry",
")",
"error",
"{",
"// As SSH conversation progresses, at some point a session will be created and",
"// its ID will be added to the environment",
"ssid",
",",
"found",
":=",
"c",
".",
"GetEnv",
"(",
"sshutils",
".",
"SessionEnvVar",
")",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"// make sure whatever session is requested is a valid session",
"_",
",",
"err",
":=",
"rsession",
".",
"ParseID",
"(",
"ssid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"findSession",
":=",
"func",
"(",
")",
"(",
"*",
"session",
",",
"bool",
")",
"{",
"reg",
".",
"Lock",
"(",
")",
"\n",
"defer",
"reg",
".",
"Unlock",
"(",
")",
"\n",
"return",
"reg",
".",
"findSession",
"(",
"rsession",
".",
"ID",
"(",
"ssid",
")",
")",
"\n",
"}",
"\n\n",
"// update ctx with a session ID",
"c",
".",
"session",
",",
"_",
"=",
"findSession",
"(",
")",
"\n",
"if",
"c",
".",
"session",
"==",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"c",
".",
"Conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"c",
".",
"session",
",",
"c",
".",
"Conn",
".",
"RemoteAddr",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CreateOrJoinSession will look in the SessionRegistry for the session ID. If
// no session is found, a new one is created. If one is found, it is returned. | [
"CreateOrJoinSession",
"will",
"look",
"in",
"the",
"SessionRegistry",
"for",
"the",
"session",
"ID",
".",
"If",
"no",
"session",
"is",
"found",
"a",
"new",
"one",
"is",
"created",
".",
"If",
"one",
"is",
"found",
"it",
"is",
"returned",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L332-L360 | train |
gravitational/teleport | lib/srv/ctx.go | UpdateClientActivity | func (c *ServerContext) UpdateClientActivity() {
c.Lock()
defer c.Unlock()
c.clientLastActive = c.srv.GetClock().Now().UTC()
} | go | func (c *ServerContext) UpdateClientActivity() {
c.Lock()
defer c.Unlock()
c.clientLastActive = c.srv.GetClock().Now().UTC()
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"UpdateClientActivity",
"(",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"clientLastActive",
"=",
"c",
".",
"srv",
".",
"GetClock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] | // UpdateClientActivity sets last recorded client activity associated with this context
// either channel or session | [
"UpdateClientActivity",
"sets",
"last",
"recorded",
"client",
"activity",
"associated",
"with",
"this",
"context",
"either",
"channel",
"or",
"session"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L371-L375 | train |
gravitational/teleport | lib/srv/ctx.go | GetAgent | func (c *ServerContext) GetAgent() agent.Agent {
c.RLock()
defer c.RUnlock()
return c.agent
} | go | func (c *ServerContext) GetAgent() agent.Agent {
c.RLock()
defer c.RUnlock()
return c.agent
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetAgent",
"(",
")",
"agent",
".",
"Agent",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"agent",
"\n",
"}"
] | // GetAgent returns a agent.Agent which represents the capabilities of an SSH agent. | [
"GetAgent",
"returns",
"a",
"agent",
".",
"Agent",
"which",
"represents",
"the",
"capabilities",
"of",
"an",
"SSH",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L386-L390 | train |
gravitational/teleport | lib/srv/ctx.go | GetAgentChannel | func (c *ServerContext) GetAgentChannel() ssh.Channel {
c.RLock()
defer c.RUnlock()
return c.agentChannel
} | go | func (c *ServerContext) GetAgentChannel() ssh.Channel {
c.RLock()
defer c.RUnlock()
return c.agentChannel
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetAgentChannel",
"(",
")",
"ssh",
".",
"Channel",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"c",
".",
"agentChannel",
"\n",
"}"
] | // GetAgentChannel returns the channel over which communication with the agent occurs. | [
"GetAgentChannel",
"returns",
"the",
"channel",
"over",
"which",
"communication",
"with",
"the",
"agent",
"occurs",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L393-L397 | train |
gravitational/teleport | lib/srv/ctx.go | SetAgent | func (c *ServerContext) SetAgent(a agent.Agent, channel ssh.Channel) {
c.Lock()
defer c.Unlock()
if c.agentChannel != nil {
c.Infof("closing previous agent channel")
c.agentChannel.Close()
}
c.agentChannel = channel
c.agent = a
} | go | func (c *ServerContext) SetAgent(a agent.Agent, channel ssh.Channel) {
c.Lock()
defer c.Unlock()
if c.agentChannel != nil {
c.Infof("closing previous agent channel")
c.agentChannel.Close()
}
c.agentChannel = channel
c.agent = a
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SetAgent",
"(",
"a",
"agent",
".",
"Agent",
",",
"channel",
"ssh",
".",
"Channel",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"if",
"c",
".",
"agentChannel",
"!=",
"nil",
"{",
"c",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"c",
".",
"agentChannel",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"c",
".",
"agentChannel",
"=",
"channel",
"\n",
"c",
".",
"agent",
"=",
"a",
"\n",
"}"
] | // SetAgent sets the agent and channel over which communication with the agent occurs. | [
"SetAgent",
"sets",
"the",
"agent",
"and",
"channel",
"over",
"which",
"communication",
"with",
"the",
"agent",
"occurs",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L400-L409 | train |
gravitational/teleport | lib/srv/ctx.go | GetTerm | func (c *ServerContext) GetTerm() Terminal {
c.RLock()
defer c.RUnlock()
return c.term
} | go | func (c *ServerContext) GetTerm() Terminal {
c.RLock()
defer c.RUnlock()
return c.term
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetTerm",
"(",
")",
"Terminal",
"{",
"c",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"c",
".",
"term",
"\n",
"}"
] | // GetTerm returns a Terminal. | [
"GetTerm",
"returns",
"a",
"Terminal",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L412-L417 | train |
gravitational/teleport | lib/srv/ctx.go | SetTerm | func (c *ServerContext) SetTerm(t Terminal) {
c.Lock()
defer c.Unlock()
c.term = t
} | go | func (c *ServerContext) SetTerm(t Terminal) {
c.Lock()
defer c.Unlock()
c.term = t
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SetTerm",
"(",
"t",
"Terminal",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"term",
"=",
"t",
"\n",
"}"
] | // SetTerm set a Terminal. | [
"SetTerm",
"set",
"a",
"Terminal",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L420-L425 | train |
gravitational/teleport | lib/srv/ctx.go | SetEnv | func (c *ServerContext) SetEnv(key, val string) {
c.env[key] = val
} | go | func (c *ServerContext) SetEnv(key, val string) {
c.env[key] = val
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SetEnv",
"(",
"key",
",",
"val",
"string",
")",
"{",
"c",
".",
"env",
"[",
"key",
"]",
"=",
"val",
"\n",
"}"
] | // SetEnv sets a environment variable within this context. | [
"SetEnv",
"sets",
"a",
"environment",
"variable",
"within",
"this",
"context",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L428-L430 | train |
gravitational/teleport | lib/srv/ctx.go | GetEnv | func (c *ServerContext) GetEnv(key string) (string, bool) {
val, ok := c.env[key]
return val, ok
} | go | func (c *ServerContext) GetEnv(key string) (string, bool) {
val, ok := c.env[key]
return val, ok
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"GetEnv",
"(",
"key",
"string",
")",
"(",
"string",
",",
"bool",
")",
"{",
"val",
",",
"ok",
":=",
"c",
".",
"env",
"[",
"key",
"]",
"\n",
"return",
"val",
",",
"ok",
"\n",
"}"
] | // GetEnv returns a environment variable within this context. | [
"GetEnv",
"returns",
"a",
"environment",
"variable",
"within",
"this",
"context",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L433-L436 | train |
gravitational/teleport | lib/srv/ctx.go | SendExecResult | func (c *ServerContext) SendExecResult(r ExecResult) {
select {
case c.ExecResultCh <- r:
default:
log.Infof("blocked on sending exec result %v", r)
}
} | go | func (c *ServerContext) SendExecResult(r ExecResult) {
select {
case c.ExecResultCh <- r:
default:
log.Infof("blocked on sending exec result %v", r)
}
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SendExecResult",
"(",
"r",
"ExecResult",
")",
"{",
"select",
"{",
"case",
"c",
".",
"ExecResultCh",
"<-",
"r",
":",
"default",
":",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n",
"}"
] | // SendExecResult sends the result of execution of the "exec" command over the
// ExecResultCh. | [
"SendExecResult",
"sends",
"the",
"result",
"of",
"execution",
"of",
"the",
"exec",
"command",
"over",
"the",
"ExecResultCh",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L520-L526 | train |
gravitational/teleport | lib/srv/ctx.go | SendSubsystemResult | func (c *ServerContext) SendSubsystemResult(r SubsystemResult) {
select {
case c.SubsystemResultCh <- r:
default:
c.Infof("blocked on sending subsystem result")
}
} | go | func (c *ServerContext) SendSubsystemResult(r SubsystemResult) {
select {
case c.SubsystemResultCh <- r:
default:
c.Infof("blocked on sending subsystem result")
}
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"SendSubsystemResult",
"(",
"r",
"SubsystemResult",
")",
"{",
"select",
"{",
"case",
"c",
".",
"SubsystemResultCh",
"<-",
"r",
":",
"default",
":",
"c",
".",
"Infof",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // SendSubsystemResult sends the result of running the subsystem over the
// SubsystemResultCh. | [
"SendSubsystemResult",
"sends",
"the",
"result",
"of",
"running",
"the",
"subsystem",
"over",
"the",
"SubsystemResultCh",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L530-L536 | train |
gravitational/teleport | lib/srv/ctx.go | ProxyPublicAddress | func (c *ServerContext) ProxyPublicAddress() string {
proxyHost := "<proxyhost>:3080"
if c.srv == nil {
return proxyHost
}
proxies, err := c.srv.GetAccessPoint().GetProxies()
if err != nil {
c.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHost = fmt.Sprintf("%v:%v", proxies[0].GetHostname(), defaults.HTTPListenPort)
c.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
return proxyHost
} | go | func (c *ServerContext) ProxyPublicAddress() string {
proxyHost := "<proxyhost>:3080"
if c.srv == nil {
return proxyHost
}
proxies, err := c.srv.GetAccessPoint().GetProxies()
if err != nil {
c.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHost = fmt.Sprintf("%v:%v", proxies[0].GetHostname(), defaults.HTTPListenPort)
c.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
return proxyHost
} | [
"func",
"(",
"c",
"*",
"ServerContext",
")",
"ProxyPublicAddress",
"(",
")",
"string",
"{",
"proxyHost",
":=",
"\"",
"\"",
"\n\n",
"if",
"c",
".",
"srv",
"==",
"nil",
"{",
"return",
"proxyHost",
"\n",
"}",
"\n\n",
"proxies",
",",
"err",
":=",
"c",
".",
"srv",
".",
"GetAccessPoint",
"(",
")",
".",
"GetProxies",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"proxies",
")",
">",
"0",
"{",
"proxyHost",
"=",
"proxies",
"[",
"0",
"]",
".",
"GetPublicAddr",
"(",
")",
"\n",
"if",
"proxyHost",
"==",
"\"",
"\"",
"{",
"proxyHost",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"proxies",
"[",
"0",
"]",
".",
"GetHostname",
"(",
")",
",",
"defaults",
".",
"HTTPListenPort",
")",
"\n",
"c",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"proxyHost",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"proxyHost",
"\n",
"}"
] | // ProxyPublicAddress tries to get the public address from the first
// available proxy. if public_address is not set, fall back to the hostname
// of the first proxy we get back. | [
"ProxyPublicAddress",
"tries",
"to",
"get",
"the",
"public",
"address",
"from",
"the",
"first",
"available",
"proxy",
".",
"if",
"public_address",
"is",
"not",
"set",
"fall",
"back",
"to",
"the",
"hostname",
"of",
"the",
"first",
"proxy",
"we",
"get",
"back",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L541-L562 | train |
gravitational/teleport | lib/srv/ctx.go | NewTrackingReader | func NewTrackingReader(ctx *ServerContext, r io.Reader) *TrackingReader {
return &TrackingReader{ctx: ctx, r: r}
} | go | func NewTrackingReader(ctx *ServerContext, r io.Reader) *TrackingReader {
return &TrackingReader{ctx: ctx, r: r}
} | [
"func",
"NewTrackingReader",
"(",
"ctx",
"*",
"ServerContext",
",",
"r",
"io",
".",
"Reader",
")",
"*",
"TrackingReader",
"{",
"return",
"&",
"TrackingReader",
"{",
"ctx",
":",
"ctx",
",",
"r",
":",
"r",
"}",
"\n",
"}"
] | // NewTrackingReader returns a new instance of
// activity tracking reader. | [
"NewTrackingReader",
"returns",
"a",
"new",
"instance",
"of",
"activity",
"tracking",
"reader",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L595-L597 | train |
gravitational/teleport | lib/srv/ctx.go | Read | func (a *TrackingReader) Read(b []byte) (int, error) {
a.ctx.UpdateClientActivity()
return a.r.Read(b)
} | go | func (a *TrackingReader) Read(b []byte) (int, error) {
a.ctx.UpdateClientActivity()
return a.r.Read(b)
} | [
"func",
"(",
"a",
"*",
"TrackingReader",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"a",
".",
"ctx",
".",
"UpdateClientActivity",
"(",
")",
"\n",
"return",
"a",
".",
"r",
".",
"Read",
"(",
"b",
")",
"\n",
"}"
] | // Read passes the read through to internal
// reader, and updates activity of the server context | [
"Read",
"passes",
"the",
"read",
"through",
"to",
"internal",
"reader",
"and",
"updates",
"activity",
"of",
"the",
"server",
"context"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/ctx.go#L609-L612 | train |
gravitational/teleport | lib/pam/config.go | CheckDefaults | func (c *Config) CheckDefaults() error {
if c.ServiceName == "" {
return trace.BadParameter("required parameter ServiceName missing")
}
if c.Username == "" {
return trace.BadParameter("required parameter Username missing")
}
if c.Stdin == nil {
return trace.BadParameter("required parameter Stdin missing")
}
if c.Stdout == nil {
return trace.BadParameter("required parameter Stdout missing")
}
if c.Stderr == nil {
return trace.BadParameter("required parameter Stderr missing")
}
return nil
} | go | func (c *Config) CheckDefaults() error {
if c.ServiceName == "" {
return trace.BadParameter("required parameter ServiceName missing")
}
if c.Username == "" {
return trace.BadParameter("required parameter Username missing")
}
if c.Stdin == nil {
return trace.BadParameter("required parameter Stdin missing")
}
if c.Stdout == nil {
return trace.BadParameter("required parameter Stdout missing")
}
if c.Stderr == nil {
return trace.BadParameter("required parameter Stderr missing")
}
return nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"CheckDefaults",
"(",
")",
"error",
"{",
"if",
"c",
".",
"ServiceName",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Username",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Stdin",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Stdout",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Stderr",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckDefaults makes sure the Config structure has minimum required values. | [
"CheckDefaults",
"makes",
"sure",
"the",
"Config",
"structure",
"has",
"minimum",
"required",
"values",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/config.go#L53-L71 | train |
gravitational/teleport | lib/auth/permissions.go | NewAdminContext | func NewAdminContext() (*AuthContext, error) {
authContext, err := contextForBuiltinRole("", nil, teleport.RoleAdmin, fmt.Sprintf("%v", teleport.RoleAdmin))
if err != nil {
return nil, trace.Wrap(err)
}
return authContext, nil
} | go | func NewAdminContext() (*AuthContext, error) {
authContext, err := contextForBuiltinRole("", nil, teleport.RoleAdmin, fmt.Sprintf("%v", teleport.RoleAdmin))
if err != nil {
return nil, trace.Wrap(err)
}
return authContext, nil
} | [
"func",
"NewAdminContext",
"(",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"contextForBuiltinRole",
"(",
"\"",
"\"",
",",
"nil",
",",
"teleport",
".",
"RoleAdmin",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"teleport",
".",
"RoleAdmin",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"authContext",
",",
"nil",
"\n",
"}"
] | // NewAdminContext returns new admin auth context | [
"NewAdminContext",
"returns",
"new",
"admin",
"auth",
"context"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L31-L37 | train |
gravitational/teleport | lib/auth/permissions.go | NewRoleAuthorizer | func NewRoleAuthorizer(clusterName string, clusterConfig services.ClusterConfig, r teleport.Role) (Authorizer, error) {
authContext, err := contextForBuiltinRole(clusterName, clusterConfig, r, fmt.Sprintf("%v", r))
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | go | func NewRoleAuthorizer(clusterName string, clusterConfig services.ClusterConfig, r teleport.Role) (Authorizer, error) {
authContext, err := contextForBuiltinRole(clusterName, clusterConfig, r, fmt.Sprintf("%v", r))
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | [
"func",
"NewRoleAuthorizer",
"(",
"clusterName",
"string",
",",
"clusterConfig",
"services",
".",
"ClusterConfig",
",",
"r",
"teleport",
".",
"Role",
")",
"(",
"Authorizer",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"contextForBuiltinRole",
"(",
"clusterName",
",",
"clusterConfig",
",",
"r",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"contextAuthorizer",
"{",
"authContext",
":",
"*",
"authContext",
"}",
",",
"nil",
"\n",
"}"
] | // NewRoleAuthorizer authorizes everyone as predefined role, used in tests | [
"NewRoleAuthorizer",
"authorizes",
"everyone",
"as",
"predefined",
"role",
"used",
"in",
"tests"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L40-L46 | train |
gravitational/teleport | lib/auth/permissions.go | NewUserAuthorizer | func NewUserAuthorizer(username string, identity services.UserGetter, access services.Access) (Authorizer, error) {
authContext, err := contextForLocalUser(username, identity, access)
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | go | func NewUserAuthorizer(username string, identity services.UserGetter, access services.Access) (Authorizer, error) {
authContext, err := contextForLocalUser(username, identity, access)
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | [
"func",
"NewUserAuthorizer",
"(",
"username",
"string",
",",
"identity",
"services",
".",
"UserGetter",
",",
"access",
"services",
".",
"Access",
")",
"(",
"Authorizer",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"contextForLocalUser",
"(",
"username",
",",
"identity",
",",
"access",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"contextAuthorizer",
"{",
"authContext",
":",
"*",
"authContext",
"}",
",",
"nil",
"\n",
"}"
] | // NewUserAuthorizer authorizes everyone as predefined local user | [
"NewUserAuthorizer",
"authorizes",
"everyone",
"as",
"predefined",
"local",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L60-L66 | train |
gravitational/teleport | lib/auth/permissions.go | NewAuthorizer | func NewAuthorizer(access services.Access, identity services.UserGetter, trust services.Trust) (Authorizer, error) {
if access == nil {
return nil, trace.BadParameter("missing parameter access")
}
if identity == nil {
return nil, trace.BadParameter("missing parameter identity")
}
if trust == nil {
return nil, trace.BadParameter("missing parameter trust")
}
return &authorizer{access: access, identity: identity, trust: trust}, nil
} | go | func NewAuthorizer(access services.Access, identity services.UserGetter, trust services.Trust) (Authorizer, error) {
if access == nil {
return nil, trace.BadParameter("missing parameter access")
}
if identity == nil {
return nil, trace.BadParameter("missing parameter identity")
}
if trust == nil {
return nil, trace.BadParameter("missing parameter trust")
}
return &authorizer{access: access, identity: identity, trust: trust}, nil
} | [
"func",
"NewAuthorizer",
"(",
"access",
"services",
".",
"Access",
",",
"identity",
"services",
".",
"UserGetter",
",",
"trust",
"services",
".",
"Trust",
")",
"(",
"Authorizer",
",",
"error",
")",
"{",
"if",
"access",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"identity",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"trust",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"authorizer",
"{",
"access",
":",
"access",
",",
"identity",
":",
"identity",
",",
"trust",
":",
"trust",
"}",
",",
"nil",
"\n",
"}"
] | // NewAuthorizer returns new authorizer using backends | [
"NewAuthorizer",
"returns",
"new",
"authorizer",
"using",
"backends"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L69-L80 | train |
gravitational/teleport | lib/auth/permissions.go | authorizeLocalUser | func (a *authorizer) authorizeLocalUser(u LocalUser) (*AuthContext, error) {
return contextForLocalUser(u.Username, a.identity, a.access)
} | go | func (a *authorizer) authorizeLocalUser(u LocalUser) (*AuthContext, error) {
return contextForLocalUser(u.Username, a.identity, a.access)
} | [
"func",
"(",
"a",
"*",
"authorizer",
")",
"authorizeLocalUser",
"(",
"u",
"LocalUser",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"return",
"contextForLocalUser",
"(",
"u",
".",
"Username",
",",
"a",
".",
"identity",
",",
"a",
".",
"access",
")",
"\n",
"}"
] | // authorizeLocalUser returns authz context based on the username | [
"authorizeLocalUser",
"returns",
"authz",
"context",
"based",
"on",
"the",
"username"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L124-L126 | train |
gravitational/teleport | lib/auth/permissions.go | authorizeRemoteUser | func (a *authorizer) authorizeRemoteUser(u RemoteUser) (*AuthContext, error) {
ca, err := a.trust.GetCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: u.ClusterName}, false)
if err != nil {
return nil, trace.Wrap(err)
}
roleNames, err := ca.CombinedMapping().Map(u.RemoteRoles)
if err != nil {
return nil, trace.AccessDenied("failed to map roles for remote user %q from cluster %q", u.Username, u.ClusterName)
}
if len(roleNames) == 0 {
return nil, trace.AccessDenied("no roles mapped for remote user %q from cluster %q", u.Username, u.ClusterName)
}
// Set "logins" trait and "kubernetes_groups" for the remote user. This allows Teleport to work by
// passing exact logins and kubernetes groups to the remote cluster. Note that claims (OIDC/SAML)
// are not passed, but rather the exact logins, this is done to prevent
// leaking too much of identity to the remote cluster, and instead of focus
// on main cluster's interpretation of this identity
traits := map[string][]string{
teleport.TraitLogins: u.Principals,
teleport.TraitKubeGroups: u.KubernetesGroups,
}
log.Debugf("Mapped roles %v of remote user %q to local roles %v and traits %v.", u.RemoteRoles, u.Username, roleNames, traits)
checker, err := services.FetchRoles(roleNames, a.access, traits)
if err != nil {
return nil, trace.Wrap(err)
}
// The user is prefixed with "remote-" and suffixed with cluster name with
// the hope that it does not match a real local user.
user, err := services.NewUser(fmt.Sprintf("remote-%v-%v", u.Username, u.ClusterName))
if err != nil {
return nil, trace.Wrap(err)
}
user.SetTraits(traits)
// Set the list of roles this user has in the remote cluster.
user.SetRoles(roleNames)
return &AuthContext{
User: user,
Checker: checker,
}, nil
} | go | func (a *authorizer) authorizeRemoteUser(u RemoteUser) (*AuthContext, error) {
ca, err := a.trust.GetCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: u.ClusterName}, false)
if err != nil {
return nil, trace.Wrap(err)
}
roleNames, err := ca.CombinedMapping().Map(u.RemoteRoles)
if err != nil {
return nil, trace.AccessDenied("failed to map roles for remote user %q from cluster %q", u.Username, u.ClusterName)
}
if len(roleNames) == 0 {
return nil, trace.AccessDenied("no roles mapped for remote user %q from cluster %q", u.Username, u.ClusterName)
}
// Set "logins" trait and "kubernetes_groups" for the remote user. This allows Teleport to work by
// passing exact logins and kubernetes groups to the remote cluster. Note that claims (OIDC/SAML)
// are not passed, but rather the exact logins, this is done to prevent
// leaking too much of identity to the remote cluster, and instead of focus
// on main cluster's interpretation of this identity
traits := map[string][]string{
teleport.TraitLogins: u.Principals,
teleport.TraitKubeGroups: u.KubernetesGroups,
}
log.Debugf("Mapped roles %v of remote user %q to local roles %v and traits %v.", u.RemoteRoles, u.Username, roleNames, traits)
checker, err := services.FetchRoles(roleNames, a.access, traits)
if err != nil {
return nil, trace.Wrap(err)
}
// The user is prefixed with "remote-" and suffixed with cluster name with
// the hope that it does not match a real local user.
user, err := services.NewUser(fmt.Sprintf("remote-%v-%v", u.Username, u.ClusterName))
if err != nil {
return nil, trace.Wrap(err)
}
user.SetTraits(traits)
// Set the list of roles this user has in the remote cluster.
user.SetRoles(roleNames)
return &AuthContext{
User: user,
Checker: checker,
}, nil
} | [
"func",
"(",
"a",
"*",
"authorizer",
")",
"authorizeRemoteUser",
"(",
"u",
"RemoteUser",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"ca",
",",
"err",
":=",
"a",
".",
"trust",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"UserCA",
",",
"DomainName",
":",
"u",
".",
"ClusterName",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roleNames",
",",
"err",
":=",
"ca",
".",
"CombinedMapping",
"(",
")",
".",
"Map",
"(",
"u",
".",
"RemoteRoles",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
",",
"u",
".",
"Username",
",",
"u",
".",
"ClusterName",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"roleNames",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
",",
"u",
".",
"Username",
",",
"u",
".",
"ClusterName",
")",
"\n",
"}",
"\n",
"// Set \"logins\" trait and \"kubernetes_groups\" for the remote user. This allows Teleport to work by",
"// passing exact logins and kubernetes groups to the remote cluster. Note that claims (OIDC/SAML)",
"// are not passed, but rather the exact logins, this is done to prevent",
"// leaking too much of identity to the remote cluster, and instead of focus",
"// on main cluster's interpretation of this identity",
"traits",
":=",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"teleport",
".",
"TraitLogins",
":",
"u",
".",
"Principals",
",",
"teleport",
".",
"TraitKubeGroups",
":",
"u",
".",
"KubernetesGroups",
",",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"u",
".",
"RemoteRoles",
",",
"u",
".",
"Username",
",",
"roleNames",
",",
"traits",
")",
"\n",
"checker",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"roleNames",
",",
"a",
".",
"access",
",",
"traits",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"// The user is prefixed with \"remote-\" and suffixed with cluster name with",
"// the hope that it does not match a real local user.",
"user",
",",
"err",
":=",
"services",
".",
"NewUser",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"u",
".",
"Username",
",",
"u",
".",
"ClusterName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
".",
"SetTraits",
"(",
"traits",
")",
"\n\n",
"// Set the list of roles this user has in the remote cluster.",
"user",
".",
"SetRoles",
"(",
"roleNames",
")",
"\n\n",
"return",
"&",
"AuthContext",
"{",
"User",
":",
"user",
",",
"Checker",
":",
"checker",
",",
"}",
",",
"nil",
"\n",
"}"
] | // authorizeRemoteUser returns checker based on cert authority roles | [
"authorizeRemoteUser",
"returns",
"checker",
"based",
"on",
"cert",
"authority",
"roles"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L129-L170 | train |
gravitational/teleport | lib/auth/permissions.go | authorizeBuiltinRole | func (a *authorizer) authorizeBuiltinRole(r BuiltinRole) (*AuthContext, error) {
config, err := r.GetClusterConfig()
if err != nil {
return nil, trace.Wrap(err)
}
return contextForBuiltinRole(r.ClusterName, config, r.Role, r.Username)
} | go | func (a *authorizer) authorizeBuiltinRole(r BuiltinRole) (*AuthContext, error) {
config, err := r.GetClusterConfig()
if err != nil {
return nil, trace.Wrap(err)
}
return contextForBuiltinRole(r.ClusterName, config, r.Role, r.Username)
} | [
"func",
"(",
"a",
"*",
"authorizer",
")",
"authorizeBuiltinRole",
"(",
"r",
"BuiltinRole",
")",
"(",
"*",
"AuthContext",
",",
"error",
")",
"{",
"config",
",",
"err",
":=",
"r",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"contextForBuiltinRole",
"(",
"r",
".",
"ClusterName",
",",
"config",
",",
"r",
".",
"Role",
",",
"r",
".",
"Username",
")",
"\n",
"}"
] | // authorizeBuiltinRole authorizes builtin role | [
"authorizeBuiltinRole",
"authorizes",
"builtin",
"role"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/permissions.go#L173-L179 | train |
gravitational/teleport | tool/tctl/common/user_command.go | Initialize | func (u *UserCommand) Initialize(app *kingpin.Application, config *service.Config) {
u.config = config
users := app.Command("users", "Manage user accounts")
u.userAdd = users.Command("add", "Generate a user invitation token")
u.userAdd.Arg("account", "Teleport user account name").Required().StringVar(&u.login)
u.userAdd.Arg("local-logins", "Local UNIX users this account can log in as [login]").
Default("").StringVar(&u.allowedLogins)
u.userAdd.Flag("k8s-groups", "Kubernetes groups to assign to a user.").
Default("").StringVar(&u.kubeGroups)
u.userAdd.Flag("ttl", fmt.Sprintf("Set expiration time for token, default is %v hour, maximum is %v hours",
int(defaults.SignupTokenTTL/time.Hour), int(defaults.MaxSignupTokenTTL/time.Hour))).
Default(fmt.Sprintf("%v", defaults.SignupTokenTTL)).DurationVar(&u.ttl)
u.userAdd.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userAdd.Alias(AddUserHelp)
u.userUpdate = users.Command("update", "Update properties for existing user").Hidden()
u.userUpdate.Arg("login", "Teleport user login").Required().StringVar(&u.login)
u.userUpdate.Flag("set-roles", "Roles to assign to this user").
Default("").StringVar(&u.roles)
u.userList = users.Command("ls", "List all user accounts")
u.userList.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userDelete = users.Command("rm", "Deletes user accounts").Alias("del")
u.userDelete.Arg("logins", "Comma-separated list of user logins to delete").
Required().StringVar(&u.login)
} | go | func (u *UserCommand) Initialize(app *kingpin.Application, config *service.Config) {
u.config = config
users := app.Command("users", "Manage user accounts")
u.userAdd = users.Command("add", "Generate a user invitation token")
u.userAdd.Arg("account", "Teleport user account name").Required().StringVar(&u.login)
u.userAdd.Arg("local-logins", "Local UNIX users this account can log in as [login]").
Default("").StringVar(&u.allowedLogins)
u.userAdd.Flag("k8s-groups", "Kubernetes groups to assign to a user.").
Default("").StringVar(&u.kubeGroups)
u.userAdd.Flag("ttl", fmt.Sprintf("Set expiration time for token, default is %v hour, maximum is %v hours",
int(defaults.SignupTokenTTL/time.Hour), int(defaults.MaxSignupTokenTTL/time.Hour))).
Default(fmt.Sprintf("%v", defaults.SignupTokenTTL)).DurationVar(&u.ttl)
u.userAdd.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userAdd.Alias(AddUserHelp)
u.userUpdate = users.Command("update", "Update properties for existing user").Hidden()
u.userUpdate.Arg("login", "Teleport user login").Required().StringVar(&u.login)
u.userUpdate.Flag("set-roles", "Roles to assign to this user").
Default("").StringVar(&u.roles)
u.userList = users.Command("ls", "List all user accounts")
u.userList.Flag("format", "Output format, 'text' or 'json'").Hidden().Default(teleport.Text).StringVar(&u.format)
u.userDelete = users.Command("rm", "Deletes user accounts").Alias("del")
u.userDelete.Arg("logins", "Comma-separated list of user logins to delete").
Required().StringVar(&u.login)
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"Initialize",
"(",
"app",
"*",
"kingpin",
".",
"Application",
",",
"config",
"*",
"service",
".",
"Config",
")",
"{",
"u",
".",
"config",
"=",
"config",
"\n",
"users",
":=",
"app",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"u",
".",
"userAdd",
"=",
"users",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"u",
".",
"userAdd",
".",
"Arg",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"login",
")",
"\n",
"u",
".",
"userAdd",
".",
"Arg",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Default",
"(",
"\"",
"\"",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"allowedLogins",
")",
"\n",
"u",
".",
"userAdd",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Default",
"(",
"\"",
"\"",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"kubeGroups",
")",
"\n",
"u",
".",
"userAdd",
".",
"Flag",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"int",
"(",
"defaults",
".",
"SignupTokenTTL",
"/",
"time",
".",
"Hour",
")",
",",
"int",
"(",
"defaults",
".",
"MaxSignupTokenTTL",
"/",
"time",
".",
"Hour",
")",
")",
")",
".",
"Default",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"defaults",
".",
"SignupTokenTTL",
")",
")",
".",
"DurationVar",
"(",
"&",
"u",
".",
"ttl",
")",
"\n",
"u",
".",
"userAdd",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"Default",
"(",
"teleport",
".",
"Text",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"format",
")",
"\n",
"u",
".",
"userAdd",
".",
"Alias",
"(",
"AddUserHelp",
")",
"\n\n",
"u",
".",
"userUpdate",
"=",
"users",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
"\n",
"u",
".",
"userUpdate",
".",
"Arg",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"login",
")",
"\n",
"u",
".",
"userUpdate",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Default",
"(",
"\"",
"\"",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"roles",
")",
"\n\n",
"u",
".",
"userList",
"=",
"users",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"u",
".",
"userList",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"Default",
"(",
"teleport",
".",
"Text",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"format",
")",
"\n\n",
"u",
".",
"userDelete",
"=",
"users",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Alias",
"(",
"\"",
"\"",
")",
"\n",
"u",
".",
"userDelete",
".",
"Arg",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Required",
"(",
")",
".",
"StringVar",
"(",
"&",
"u",
".",
"login",
")",
"\n",
"}"
] | // Initialize allows UserCommand to plug itself into the CLI parser | [
"Initialize",
"allows",
"UserCommand",
"to",
"plug",
"itself",
"into",
"the",
"CLI",
"parser"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L57-L84 | train |
gravitational/teleport | tool/tctl/common/user_command.go | Add | func (u *UserCommand) Add(client auth.ClientI) error {
// if no local logins were specified, default to 'login'
if u.allowedLogins == "" {
u.allowedLogins = u.login
}
var kubeGroups []string
if u.kubeGroups != "" {
kubeGroups = strings.Split(u.kubeGroups, ",")
}
user := services.UserV1{
Name: u.login,
AllowedLogins: strings.Split(u.allowedLogins, ","),
KubeGroups: kubeGroups,
}
token, err := client.CreateSignupToken(user, u.ttl)
if err != nil {
return err
}
// try to auto-suggest the activation link
return u.PrintSignupURL(client, token, u.ttl, u.format)
} | go | func (u *UserCommand) Add(client auth.ClientI) error {
// if no local logins were specified, default to 'login'
if u.allowedLogins == "" {
u.allowedLogins = u.login
}
var kubeGroups []string
if u.kubeGroups != "" {
kubeGroups = strings.Split(u.kubeGroups, ",")
}
user := services.UserV1{
Name: u.login,
AllowedLogins: strings.Split(u.allowedLogins, ","),
KubeGroups: kubeGroups,
}
token, err := client.CreateSignupToken(user, u.ttl)
if err != nil {
return err
}
// try to auto-suggest the activation link
return u.PrintSignupURL(client, token, u.ttl, u.format)
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"Add",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"// if no local logins were specified, default to 'login'",
"if",
"u",
".",
"allowedLogins",
"==",
"\"",
"\"",
"{",
"u",
".",
"allowedLogins",
"=",
"u",
".",
"login",
"\n",
"}",
"\n",
"var",
"kubeGroups",
"[",
"]",
"string",
"\n",
"if",
"u",
".",
"kubeGroups",
"!=",
"\"",
"\"",
"{",
"kubeGroups",
"=",
"strings",
".",
"Split",
"(",
"u",
".",
"kubeGroups",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"user",
":=",
"services",
".",
"UserV1",
"{",
"Name",
":",
"u",
".",
"login",
",",
"AllowedLogins",
":",
"strings",
".",
"Split",
"(",
"u",
".",
"allowedLogins",
",",
"\"",
"\"",
")",
",",
"KubeGroups",
":",
"kubeGroups",
",",
"}",
"\n",
"token",
",",
"err",
":=",
"client",
".",
"CreateSignupToken",
"(",
"user",
",",
"u",
".",
"ttl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// try to auto-suggest the activation link",
"return",
"u",
".",
"PrintSignupURL",
"(",
"client",
",",
"token",
",",
"u",
".",
"ttl",
",",
"u",
".",
"format",
")",
"\n",
"}"
] | // Add creates a new sign-up token and prints a token URL to stdout.
// A user is not created until he visits the sign-up URL and completes the process | [
"Add",
"creates",
"a",
"new",
"sign",
"-",
"up",
"token",
"and",
"prints",
"a",
"token",
"URL",
"to",
"stdout",
".",
"A",
"user",
"is",
"not",
"created",
"until",
"he",
"visits",
"the",
"sign",
"-",
"up",
"URL",
"and",
"completes",
"the",
"process"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L105-L126 | train |
gravitational/teleport | tool/tctl/common/user_command.go | PrintSignupURL | func (u *UserCommand) PrintSignupURL(client auth.ClientI, token string, ttl time.Duration, format string) error {
signupURL, proxyHost := web.CreateSignupLink(client, token)
if format == teleport.Text {
fmt.Printf("Signup token has been created and is valid for %v hours. Share this URL with the user:\n%v\n\n",
int(ttl/time.Hour), signupURL)
fmt.Printf("NOTE: Make sure %v points at a Teleport proxy which users can access.\n", proxyHost)
} else {
out, err := json.MarshalIndent(services.NewInviteToken(token, signupURL, time.Now().Add(ttl).UTC()), "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal signup infos")
}
fmt.Printf(string(out))
}
return nil
} | go | func (u *UserCommand) PrintSignupURL(client auth.ClientI, token string, ttl time.Duration, format string) error {
signupURL, proxyHost := web.CreateSignupLink(client, token)
if format == teleport.Text {
fmt.Printf("Signup token has been created and is valid for %v hours. Share this URL with the user:\n%v\n\n",
int(ttl/time.Hour), signupURL)
fmt.Printf("NOTE: Make sure %v points at a Teleport proxy which users can access.\n", proxyHost)
} else {
out, err := json.MarshalIndent(services.NewInviteToken(token, signupURL, time.Now().Add(ttl).UTC()), "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal signup infos")
}
fmt.Printf(string(out))
}
return nil
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"PrintSignupURL",
"(",
"client",
"auth",
".",
"ClientI",
",",
"token",
"string",
",",
"ttl",
"time",
".",
"Duration",
",",
"format",
"string",
")",
"error",
"{",
"signupURL",
",",
"proxyHost",
":=",
"web",
".",
"CreateSignupLink",
"(",
"client",
",",
"token",
")",
"\n\n",
"if",
"format",
"==",
"teleport",
".",
"Text",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
",",
"int",
"(",
"ttl",
"/",
"time",
".",
"Hour",
")",
",",
"signupURL",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"proxyHost",
")",
"\n",
"}",
"else",
"{",
"out",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"services",
".",
"NewInviteToken",
"(",
"token",
",",
"signupURL",
",",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"ttl",
")",
".",
"UTC",
"(",
")",
")",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"string",
"(",
"out",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // PrintSignupURL prints signup URL | [
"PrintSignupURL",
"prints",
"signup",
"URL"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L129-L144 | train |
gravitational/teleport | tool/tctl/common/user_command.go | Update | func (u *UserCommand) Update(client auth.ClientI) error {
user, err := client.GetUser(u.login)
if err != nil {
return trace.Wrap(err)
}
roles := strings.Split(u.roles, ",")
for _, role := range roles {
if _, err := client.GetRole(role); err != nil {
return trace.Wrap(err)
}
}
user.SetRoles(roles)
if err := client.UpsertUser(user); err != nil {
return trace.Wrap(err)
}
fmt.Printf("%v has been updated with roles %v\n", user.GetName(), strings.Join(user.GetRoles(), ","))
return nil
} | go | func (u *UserCommand) Update(client auth.ClientI) error {
user, err := client.GetUser(u.login)
if err != nil {
return trace.Wrap(err)
}
roles := strings.Split(u.roles, ",")
for _, role := range roles {
if _, err := client.GetRole(role); err != nil {
return trace.Wrap(err)
}
}
user.SetRoles(roles)
if err := client.UpsertUser(user); err != nil {
return trace.Wrap(err)
}
fmt.Printf("%v has been updated with roles %v\n", user.GetName(), strings.Join(user.GetRoles(), ","))
return nil
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"Update",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"user",
",",
"err",
":=",
"client",
".",
"GetUser",
"(",
"u",
".",
"login",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roles",
":=",
"strings",
".",
"Split",
"(",
"u",
".",
"roles",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"role",
":=",
"range",
"roles",
"{",
"if",
"_",
",",
"err",
":=",
"client",
".",
"GetRole",
"(",
"role",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"user",
".",
"SetRoles",
"(",
"roles",
")",
"\n",
"if",
"err",
":=",
"client",
".",
"UpsertUser",
"(",
"user",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"user",
".",
"GetName",
"(",
")",
",",
"strings",
".",
"Join",
"(",
"user",
".",
"GetRoles",
"(",
")",
",",
"\"",
"\"",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Update updates existing user | [
"Update",
"updates",
"existing",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L147-L164 | train |
gravitational/teleport | tool/tctl/common/user_command.go | List | func (u *UserCommand) List(client auth.ClientI) error {
users, err := client.GetUsers()
if err != nil {
return trace.Wrap(err)
}
if u.format == teleport.Text {
if len(users) == 0 {
fmt.Println("No users found")
return nil
}
t := asciitable.MakeTable([]string{"User", "Allowed logins"})
for _, u := range users {
logins, _ := u.GetTraits()[teleport.TraitLogins]
t.AddRow([]string{u.GetName(), strings.Join(logins, ",")})
}
fmt.Println(t.AsBuffer().String())
} else {
out, err := json.MarshalIndent(users, "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal users")
}
fmt.Printf(string(out))
}
return nil
} | go | func (u *UserCommand) List(client auth.ClientI) error {
users, err := client.GetUsers()
if err != nil {
return trace.Wrap(err)
}
if u.format == teleport.Text {
if len(users) == 0 {
fmt.Println("No users found")
return nil
}
t := asciitable.MakeTable([]string{"User", "Allowed logins"})
for _, u := range users {
logins, _ := u.GetTraits()[teleport.TraitLogins]
t.AddRow([]string{u.GetName(), strings.Join(logins, ",")})
}
fmt.Println(t.AsBuffer().String())
} else {
out, err := json.MarshalIndent(users, "", " ")
if err != nil {
return trace.Wrap(err, "failed to marshal users")
}
fmt.Printf(string(out))
}
return nil
} | [
"func",
"(",
"u",
"*",
"UserCommand",
")",
"List",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"users",
",",
"err",
":=",
"client",
".",
"GetUsers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"format",
"==",
"teleport",
".",
"Text",
"{",
"if",
"len",
"(",
"users",
")",
"==",
"0",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"t",
":=",
"asciitable",
".",
"MakeTable",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
")",
"\n",
"for",
"_",
",",
"u",
":=",
"range",
"users",
"{",
"logins",
",",
"_",
":=",
"u",
".",
"GetTraits",
"(",
")",
"[",
"teleport",
".",
"TraitLogins",
"]",
"\n",
"t",
".",
"AddRow",
"(",
"[",
"]",
"string",
"{",
"u",
".",
"GetName",
"(",
")",
",",
"strings",
".",
"Join",
"(",
"logins",
",",
"\"",
"\"",
")",
"}",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"t",
".",
"AsBuffer",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"out",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"users",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"string",
"(",
"out",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // List prints all existing user accounts | [
"List",
"prints",
"all",
"existing",
"user",
"accounts"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/user_command.go#L167-L191 | train |
gravitational/teleport | lib/teleagent/agent.go | ListenUnixSocket | func (a *AgentServer) ListenUnixSocket(path string, uid, gid int, mode os.FileMode) error {
l, err := net.Listen("unix", path)
if err != nil {
return trace.Wrap(err)
}
if err := os.Chown(path, uid, gid); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
if err := os.Chmod(path, mode); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
a.listener = l
a.path = path
return nil
} | go | func (a *AgentServer) ListenUnixSocket(path string, uid, gid int, mode os.FileMode) error {
l, err := net.Listen("unix", path)
if err != nil {
return trace.Wrap(err)
}
if err := os.Chown(path, uid, gid); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
if err := os.Chmod(path, mode); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
a.listener = l
a.path = path
return nil
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"ListenUnixSocket",
"(",
"path",
"string",
",",
"uid",
",",
"gid",
"int",
",",
"mode",
"os",
".",
"FileMode",
")",
"error",
"{",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"Chown",
"(",
"path",
",",
"uid",
",",
"gid",
")",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"Close",
"(",
")",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"Chmod",
"(",
"path",
",",
"mode",
")",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"Close",
"(",
")",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"listener",
"=",
"l",
"\n",
"a",
".",
"path",
"=",
"path",
"\n",
"return",
"nil",
"\n",
"}"
] | // ListenUnixSocket starts listening and serving agent assuming that | [
"ListenUnixSocket",
"starts",
"listening",
"and",
"serving",
"agent",
"assuming",
"that"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L30-L46 | train |
gravitational/teleport | lib/teleagent/agent.go | Serve | func (a *AgentServer) Serve() error {
if a.listener == nil {
return trace.BadParameter("Serve needs a Listen call first")
}
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := a.listener.Accept()
if err != nil {
neterr, ok := err.(net.Error)
if !ok {
return trace.Wrap(err, "unknown error")
}
if !neterr.Temporary() {
if !strings.Contains(neterr.Error(), "use of closed network connection") {
log.Errorf("got permanent error: %v", err)
}
return err
}
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
log.Errorf("got temp error: %v, will sleep %v", err, tempDelay)
time.Sleep(tempDelay)
continue
}
tempDelay = 0
go func() {
if err := agent.ServeAgent(a.Agent, conn); err != nil {
if err != io.EOF {
log.Errorf(err.Error())
}
}
}()
}
} | go | func (a *AgentServer) Serve() error {
if a.listener == nil {
return trace.BadParameter("Serve needs a Listen call first")
}
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := a.listener.Accept()
if err != nil {
neterr, ok := err.(net.Error)
if !ok {
return trace.Wrap(err, "unknown error")
}
if !neterr.Temporary() {
if !strings.Contains(neterr.Error(), "use of closed network connection") {
log.Errorf("got permanent error: %v", err)
}
return err
}
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
log.Errorf("got temp error: %v, will sleep %v", err, tempDelay)
time.Sleep(tempDelay)
continue
}
tempDelay = 0
go func() {
if err := agent.ServeAgent(a.Agent, conn); err != nil {
if err != io.EOF {
log.Errorf(err.Error())
}
}
}()
}
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"Serve",
"(",
")",
"error",
"{",
"if",
"a",
".",
"listener",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"tempDelay",
"time",
".",
"Duration",
"// how long to sleep on accept failure",
"\n",
"for",
"{",
"conn",
",",
"err",
":=",
"a",
".",
"listener",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"neterr",
",",
"ok",
":=",
"err",
".",
"(",
"net",
".",
"Error",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"neterr",
".",
"Temporary",
"(",
")",
"{",
"if",
"!",
"strings",
".",
"Contains",
"(",
"neterr",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"tempDelay",
"==",
"0",
"{",
"tempDelay",
"=",
"5",
"*",
"time",
".",
"Millisecond",
"\n",
"}",
"else",
"{",
"tempDelay",
"*=",
"2",
"\n",
"}",
"\n",
"if",
"max",
":=",
"1",
"*",
"time",
".",
"Second",
";",
"tempDelay",
">",
"max",
"{",
"tempDelay",
"=",
"max",
"\n",
"}",
"\n",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
",",
"tempDelay",
")",
"\n",
"time",
".",
"Sleep",
"(",
"tempDelay",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"tempDelay",
"=",
"0",
"\n",
"go",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"agent",
".",
"ServeAgent",
"(",
"a",
".",
"Agent",
",",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"io",
".",
"EOF",
"{",
"log",
".",
"Errorf",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Serve starts serving on the listener, assumes that Listen was called before | [
"Serve",
"starts",
"serving",
"on",
"the",
"listener",
"assumes",
"that",
"Listen",
"was",
"called",
"before"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L49-L88 | train |
gravitational/teleport | lib/teleagent/agent.go | ListenAndServe | func (a *AgentServer) ListenAndServe(addr utils.NetAddr) error {
l, err := net.Listen(addr.AddrNetwork, addr.Addr)
if err != nil {
return trace.Wrap(err)
}
a.listener = l
return a.Serve()
} | go | func (a *AgentServer) ListenAndServe(addr utils.NetAddr) error {
l, err := net.Listen(addr.AddrNetwork, addr.Addr)
if err != nil {
return trace.Wrap(err)
}
a.listener = l
return a.Serve()
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"ListenAndServe",
"(",
"addr",
"utils",
".",
"NetAddr",
")",
"error",
"{",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"addr",
".",
"AddrNetwork",
",",
"addr",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"listener",
"=",
"l",
"\n",
"return",
"a",
".",
"Serve",
"(",
")",
"\n",
"}"
] | // ListenAndServe is similar http.ListenAndServe | [
"ListenAndServe",
"is",
"similar",
"http",
".",
"ListenAndServe"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L91-L98 | train |
gravitational/teleport | lib/teleagent/agent.go | Close | func (a *AgentServer) Close() error {
var errors []error
if a.listener != nil {
log.Debugf("AgentServer(%v) is closing", a.listener.Addr())
if err := a.listener.Close(); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
if a.path != "" {
if err := os.Remove(a.path); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
return trace.NewAggregate(errors...)
} | go | func (a *AgentServer) Close() error {
var errors []error
if a.listener != nil {
log.Debugf("AgentServer(%v) is closing", a.listener.Addr())
if err := a.listener.Close(); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
if a.path != "" {
if err := os.Remove(a.path); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
return trace.NewAggregate(errors...)
} | [
"func",
"(",
"a",
"*",
"AgentServer",
")",
"Close",
"(",
")",
"error",
"{",
"var",
"errors",
"[",
"]",
"error",
"\n",
"if",
"a",
".",
"listener",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"a",
".",
"listener",
".",
"Addr",
"(",
")",
")",
"\n",
"if",
"err",
":=",
"a",
".",
"listener",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"a",
".",
"path",
"!=",
"\"",
"\"",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"a",
".",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] | // Close closes listener and stops serving agent | [
"Close",
"closes",
"listener",
"and",
"stops",
"serving",
"agent"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/teleagent/agent.go#L101-L115 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | VerifyHTTPHeader | func VerifyHTTPHeader(r *http.Request) error {
token := r.Header.Get(HeaderName)
if len(token) == 0 {
return trace.BadParameter("cannot retrieve CSRF token from HTTP header %q", HeaderName)
}
err := VerifyToken(token, r)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func VerifyHTTPHeader(r *http.Request) error {
token := r.Header.Get(HeaderName)
if len(token) == 0 {
return trace.BadParameter("cannot retrieve CSRF token from HTTP header %q", HeaderName)
}
err := VerifyToken(token, r)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"VerifyHTTPHeader",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"token",
":=",
"r",
".",
"Header",
".",
"Get",
"(",
"HeaderName",
")",
"\n",
"if",
"len",
"(",
"token",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"HeaderName",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"VerifyToken",
"(",
"token",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // VerifyHTTPHeader checks if HTTP header value matches the cookie. | [
"VerifyHTTPHeader",
"checks",
"if",
"HTTP",
"header",
"value",
"matches",
"the",
"cookie",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L56-L68 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | VerifyToken | func VerifyToken(token string, r *http.Request) error {
realToken, err := ExtractTokenFromCookie(r)
if err != nil {
return trace.Wrap(err, "unable to extract CSRF token from cookie")
}
decodedTokenA, err := decode(token)
if err != nil {
return trace.Wrap(err, "unable to decode CSRF token")
}
decodedTokenB, err := decode(realToken)
if err != nil {
return trace.Wrap(err, "unable to decode cookie CSRF token")
}
if !compareTokens(decodedTokenA, decodedTokenB) {
return trace.BadParameter("CSRF tokens do not match")
}
return nil
} | go | func VerifyToken(token string, r *http.Request) error {
realToken, err := ExtractTokenFromCookie(r)
if err != nil {
return trace.Wrap(err, "unable to extract CSRF token from cookie")
}
decodedTokenA, err := decode(token)
if err != nil {
return trace.Wrap(err, "unable to decode CSRF token")
}
decodedTokenB, err := decode(realToken)
if err != nil {
return trace.Wrap(err, "unable to decode cookie CSRF token")
}
if !compareTokens(decodedTokenA, decodedTokenB) {
return trace.BadParameter("CSRF tokens do not match")
}
return nil
} | [
"func",
"VerifyToken",
"(",
"token",
"string",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"realToken",
",",
"err",
":=",
"ExtractTokenFromCookie",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"decodedTokenA",
",",
"err",
":=",
"decode",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"decodedTokenB",
",",
"err",
":=",
"decode",
"(",
"realToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"compareTokens",
"(",
"decodedTokenA",
",",
"decodedTokenB",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // VerifyToken validates given token based on HTTP request cookie | [
"VerifyToken",
"validates",
"given",
"token",
"based",
"on",
"HTTP",
"request",
"cookie"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L71-L92 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | ExtractTokenFromCookie | func ExtractTokenFromCookie(r *http.Request) (string, error) {
cookie, err := r.Cookie(CookieName)
if err != nil {
return "", trace.Wrap(err)
}
return cookie.Value, nil
} | go | func ExtractTokenFromCookie(r *http.Request) (string, error) {
cookie, err := r.Cookie(CookieName)
if err != nil {
return "", trace.Wrap(err)
}
return cookie.Value, nil
} | [
"func",
"ExtractTokenFromCookie",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"error",
")",
"{",
"cookie",
",",
"err",
":=",
"r",
".",
"Cookie",
"(",
"CookieName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"cookie",
".",
"Value",
",",
"nil",
"\n",
"}"
] | // ExtractTokenFromCookie retrieves a CSRF token from the session cookie. | [
"ExtractTokenFromCookie",
"retrieves",
"a",
"CSRF",
"token",
"from",
"the",
"session",
"cookie",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L95-L102 | train |
gravitational/teleport | lib/httplib/csrf/csrf.go | save | func save(encodedToken string, w http.ResponseWriter) string {
cookie := &http.Cookie{
Name: CookieName,
Value: encodedToken,
MaxAge: defaultMaxAge,
HttpOnly: true,
Secure: true,
Path: "/",
}
// write the authenticated cookie to the response.
http.SetCookie(w, cookie)
w.Header().Add("Vary", "Cookie")
return encodedToken
} | go | func save(encodedToken string, w http.ResponseWriter) string {
cookie := &http.Cookie{
Name: CookieName,
Value: encodedToken,
MaxAge: defaultMaxAge,
HttpOnly: true,
Secure: true,
Path: "/",
}
// write the authenticated cookie to the response.
http.SetCookie(w, cookie)
w.Header().Add("Vary", "Cookie")
return encodedToken
} | [
"func",
"save",
"(",
"encodedToken",
"string",
",",
"w",
"http",
".",
"ResponseWriter",
")",
"string",
"{",
"cookie",
":=",
"&",
"http",
".",
"Cookie",
"{",
"Name",
":",
"CookieName",
",",
"Value",
":",
"encodedToken",
",",
"MaxAge",
":",
"defaultMaxAge",
",",
"HttpOnly",
":",
"true",
",",
"Secure",
":",
"true",
",",
"Path",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"// write the authenticated cookie to the response.",
"http",
".",
"SetCookie",
"(",
"w",
",",
"cookie",
")",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"encodedToken",
"\n",
"}"
] | // save stores encoded CSRF token in the session cookie. | [
"save",
"stores",
"encoded",
"CSRF",
"token",
"in",
"the",
"session",
"cookie",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/httplib/csrf/csrf.go#L124-L138 | train |
gravitational/teleport | lib/auth/oidc.go | ValidateOIDCAuthCallback | func (a *AuthServer) ValidateOIDCAuthCallback(q url.Values) (*OIDCAuthResponse, error) {
re, err := a.validateOIDCAuthCallback(q)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptSuccess: false,
// log the original internal error in audit log
events.AuthAttemptErr: trace.Unwrap(err).Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodOIDC,
})
}
return re, err
} | go | func (a *AuthServer) ValidateOIDCAuthCallback(q url.Values) (*OIDCAuthResponse, error) {
re, err := a.validateOIDCAuthCallback(q)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptSuccess: false,
// log the original internal error in audit log
events.AuthAttemptErr: trace.Unwrap(err).Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodOIDC,
})
}
return re, err
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"ValidateOIDCAuthCallback",
"(",
"q",
"url",
".",
"Values",
")",
"(",
"*",
"OIDCAuthResponse",
",",
"error",
")",
"{",
"re",
",",
"err",
":=",
"a",
".",
"validateOIDCAuthCallback",
"(",
"q",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodOIDC",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"false",
",",
"// log the original internal error in audit log",
"events",
".",
"AuthAttemptErr",
":",
"trace",
".",
"Unwrap",
"(",
"err",
")",
".",
"Error",
"(",
")",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLogin",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"re",
".",
"Username",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"true",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodOIDC",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"err",
"\n",
"}"
] | // ValidateOIDCAuthCallback is called by the proxy to check OIDC query parameters
// returned by OIDC Provider, if everything checks out, auth server
// will respond with OIDCAuthResponse, otherwise it will return error | [
"ValidateOIDCAuthCallback",
"is",
"called",
"by",
"the",
"proxy",
"to",
"check",
"OIDC",
"query",
"parameters",
"returned",
"by",
"OIDC",
"Provider",
"if",
"everything",
"checks",
"out",
"auth",
"server",
"will",
"respond",
"with",
"OIDCAuthResponse",
"otherwise",
"it",
"will",
"return",
"error"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L128-L145 | train |
gravitational/teleport | lib/auth/oidc.go | buildOIDCRoles | func (a *AuthServer) buildOIDCRoles(connector services.OIDCConnector, claims jose.Claims) ([]string, error) {
roles := connector.MapClaims(claims)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map claims to role for connector: %v", connector.GetName())
}
return roles, nil
} | go | func (a *AuthServer) buildOIDCRoles(connector services.OIDCConnector, claims jose.Claims) ([]string, error) {
roles := connector.MapClaims(claims)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map claims to role for connector: %v", connector.GetName())
}
return roles, nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"buildOIDCRoles",
"(",
"connector",
"services",
".",
"OIDCConnector",
",",
"claims",
"jose",
".",
"Claims",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"roles",
":=",
"connector",
".",
"MapClaims",
"(",
"claims",
")",
"\n",
"if",
"len",
"(",
"roles",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
",",
"connector",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"roles",
",",
"nil",
"\n",
"}"
] | // buildOIDCRoles takes a connector and claims and returns a slice of roles. | [
"buildOIDCRoles",
"takes",
"a",
"connector",
"and",
"claims",
"and",
"returns",
"a",
"slice",
"of",
"roles",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L301-L308 | train |
gravitational/teleport | lib/auth/oidc.go | claimsToTraitMap | func claimsToTraitMap(claims jose.Claims) map[string][]string {
traits := make(map[string][]string)
for claimName := range claims {
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
traits[claimName] = []string{claimValue}
}
claimValues, ok, _ := claims.StringsClaim(claimName)
if ok {
traits[claimName] = claimValues
}
}
return traits
} | go | func claimsToTraitMap(claims jose.Claims) map[string][]string {
traits := make(map[string][]string)
for claimName := range claims {
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
traits[claimName] = []string{claimValue}
}
claimValues, ok, _ := claims.StringsClaim(claimName)
if ok {
traits[claimName] = claimValues
}
}
return traits
} | [
"func",
"claimsToTraitMap",
"(",
"claims",
"jose",
".",
"Claims",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"traits",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n\n",
"for",
"claimName",
":=",
"range",
"claims",
"{",
"claimValue",
",",
"ok",
",",
"_",
":=",
"claims",
".",
"StringClaim",
"(",
"claimName",
")",
"\n",
"if",
"ok",
"{",
"traits",
"[",
"claimName",
"]",
"=",
"[",
"]",
"string",
"{",
"claimValue",
"}",
"\n",
"}",
"\n",
"claimValues",
",",
"ok",
",",
"_",
":=",
"claims",
".",
"StringsClaim",
"(",
"claimName",
")",
"\n",
"if",
"ok",
"{",
"traits",
"[",
"claimName",
"]",
"=",
"claimValues",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"traits",
"\n",
"}"
] | // claimsToTraitMap extracts all string claims and creates a map of traits
// that can be used to populate role variables. | [
"claimsToTraitMap",
"extracts",
"all",
"string",
"claims",
"and",
"creates",
"a",
"map",
"of",
"traits",
"that",
"can",
"be",
"used",
"to",
"populate",
"role",
"variables",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L312-L327 | train |
gravitational/teleport | lib/auth/oidc.go | claimsFromIDToken | func claimsFromIDToken(oidcClient *oidc.Client, idToken string) (jose.Claims, error) {
jwt, err := jose.ParseJWT(idToken)
if err != nil {
return nil, trace.Wrap(err)
}
err = oidcClient.VerifyJWT(jwt)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("Extracting OIDC claims from ID token.")
claims, err := jwt.Claims()
if err != nil {
return nil, trace.Wrap(err)
}
return claims, nil
} | go | func claimsFromIDToken(oidcClient *oidc.Client, idToken string) (jose.Claims, error) {
jwt, err := jose.ParseJWT(idToken)
if err != nil {
return nil, trace.Wrap(err)
}
err = oidcClient.VerifyJWT(jwt)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("Extracting OIDC claims from ID token.")
claims, err := jwt.Claims()
if err != nil {
return nil, trace.Wrap(err)
}
return claims, nil
} | [
"func",
"claimsFromIDToken",
"(",
"oidcClient",
"*",
"oidc",
".",
"Client",
",",
"idToken",
"string",
")",
"(",
"jose",
".",
"Claims",
",",
"error",
")",
"{",
"jwt",
",",
"err",
":=",
"jose",
".",
"ParseJWT",
"(",
"idToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"oidcClient",
".",
"VerifyJWT",
"(",
"jwt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"claims",
",",
"err",
":=",
"jwt",
".",
"Claims",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"claims",
",",
"nil",
"\n",
"}"
] | // claimsFromIDToken extracts claims from the ID token. | [
"claimsFromIDToken",
"extracts",
"claims",
"from",
"the",
"ID",
"token",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L422-L441 | train |
gravitational/teleport | lib/auth/oidc.go | fetchGroups | func (g *gsuiteClient) fetchGroups() (jose.Claims, error) {
count := 0
var groups []string
var nextPageToken string
collect:
for {
if count > MaxPages {
warningMessage := "Truncating list of teams used to populate claims: " +
"hit maximum number pages that can be fetched from GSuite."
// Print warning to Teleport logs as well as the Audit Log.
log.Warnf(warningMessage)
g.auditLog.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptMessage: warningMessage,
})
break collect
}
response, err := g.fetchGroupsPage(nextPageToken)
if err != nil {
return nil, trace.Wrap(err)
}
groups = append(groups, response.groups()...)
if response.NextPageToken == "" {
break collect
}
count++
nextPageToken = response.NextPageToken
}
return jose.Claims{"groups": groups}, nil
} | go | func (g *gsuiteClient) fetchGroups() (jose.Claims, error) {
count := 0
var groups []string
var nextPageToken string
collect:
for {
if count > MaxPages {
warningMessage := "Truncating list of teams used to populate claims: " +
"hit maximum number pages that can be fetched from GSuite."
// Print warning to Teleport logs as well as the Audit Log.
log.Warnf(warningMessage)
g.auditLog.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptMessage: warningMessage,
})
break collect
}
response, err := g.fetchGroupsPage(nextPageToken)
if err != nil {
return nil, trace.Wrap(err)
}
groups = append(groups, response.groups()...)
if response.NextPageToken == "" {
break collect
}
count++
nextPageToken = response.NextPageToken
}
return jose.Claims{"groups": groups}, nil
} | [
"func",
"(",
"g",
"*",
"gsuiteClient",
")",
"fetchGroups",
"(",
")",
"(",
"jose",
".",
"Claims",
",",
"error",
")",
"{",
"count",
":=",
"0",
"\n",
"var",
"groups",
"[",
"]",
"string",
"\n",
"var",
"nextPageToken",
"string",
"\n",
"collect",
":",
"for",
"{",
"if",
"count",
">",
"MaxPages",
"{",
"warningMessage",
":=",
"\"",
"\"",
"+",
"\"",
"\"",
"\n\n",
"// Print warning to Teleport logs as well as the Audit Log.",
"log",
".",
"Warnf",
"(",
"warningMessage",
")",
"\n",
"g",
".",
"auditLog",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodOIDC",
",",
"events",
".",
"AuthAttemptMessage",
":",
"warningMessage",
",",
"}",
")",
"\n",
"break",
"collect",
"\n",
"}",
"\n",
"response",
",",
"err",
":=",
"g",
".",
"fetchGroupsPage",
"(",
"nextPageToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"groups",
"=",
"append",
"(",
"groups",
",",
"response",
".",
"groups",
"(",
")",
"...",
")",
"\n",
"if",
"response",
".",
"NextPageToken",
"==",
"\"",
"\"",
"{",
"break",
"collect",
"\n",
"}",
"\n",
"count",
"++",
"\n",
"nextPageToken",
"=",
"response",
".",
"NextPageToken",
"\n",
"}",
"\n",
"return",
"jose",
".",
"Claims",
"{",
"\"",
"\"",
":",
"groups",
"}",
",",
"nil",
"\n",
"}"
] | // fetchGroups fetches GSuite groups a user belongs to and returns
// "groups" claim with | [
"fetchGroups",
"fetches",
"GSuite",
"groups",
"a",
"user",
"belongs",
"to",
"and",
"returns",
"groups",
"claim",
"with"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L545-L575 | train |
gravitational/teleport | lib/auth/oidc.go | mergeClaims | func mergeClaims(a jose.Claims, b jose.Claims) (jose.Claims, error) {
for k, v := range b {
_, ok := a[k]
if !ok {
a[k] = v
}
}
return a, nil
} | go | func mergeClaims(a jose.Claims, b jose.Claims) (jose.Claims, error) {
for k, v := range b {
_, ok := a[k]
if !ok {
a[k] = v
}
}
return a, nil
} | [
"func",
"mergeClaims",
"(",
"a",
"jose",
".",
"Claims",
",",
"b",
"jose",
".",
"Claims",
")",
"(",
"jose",
".",
"Claims",
",",
"error",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"b",
"{",
"_",
",",
"ok",
":=",
"a",
"[",
"k",
"]",
"\n",
"if",
"!",
"ok",
"{",
"a",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"a",
",",
"nil",
"\n",
"}"
] | // mergeClaims merges b into a. | [
"mergeClaims",
"merges",
"b",
"into",
"a",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L635-L644 | train |
gravitational/teleport | lib/auth/oidc.go | validateACRValues | func (a *AuthServer) validateACRValues(acrValue string, identityProvider string, claims jose.Claims) error {
switch identityProvider {
case teleport.NetIQ:
log.Debugf("Validating OIDC ACR values with '%v' rules.", identityProvider)
tokenAcr, ok := claims["acr"]
if !ok {
return trace.BadParameter("acr not found in claims")
}
tokenAcrMap, ok := tokenAcr.(map[string]interface{})
if !ok {
return trace.BadParameter("acr unexpected type: %T", tokenAcr)
}
tokenAcrValues, ok := tokenAcrMap["values"]
if !ok {
return trace.BadParameter("acr.values not found in claims")
}
tokenAcrValuesSlice, ok := tokenAcrValues.([]interface{})
if !ok {
return trace.BadParameter("acr.values unexpected type: %T", tokenAcr)
}
acrValueMatched := false
for _, v := range tokenAcrValuesSlice {
vv, ok := v.(string)
if !ok {
continue
}
if acrValue == vv {
acrValueMatched = true
break
}
}
if !acrValueMatched {
log.Debugf("No OIDC ACR match found for '%v' in '%v'.", acrValue, tokenAcrValues)
return trace.BadParameter("acr claim does not match")
}
default:
log.Debugf("Validating OIDC ACR values with default rules.")
claimValue, exists, err := claims.StringClaim("acr")
if !exists {
return trace.BadParameter("acr claim does not exist")
}
if err != nil {
return trace.Wrap(err)
}
if claimValue != acrValue {
log.Debugf("No OIDC ACR match found '%v' != '%v'.", acrValue, claimValue)
return trace.BadParameter("acr claim does not match")
}
}
return nil
} | go | func (a *AuthServer) validateACRValues(acrValue string, identityProvider string, claims jose.Claims) error {
switch identityProvider {
case teleport.NetIQ:
log.Debugf("Validating OIDC ACR values with '%v' rules.", identityProvider)
tokenAcr, ok := claims["acr"]
if !ok {
return trace.BadParameter("acr not found in claims")
}
tokenAcrMap, ok := tokenAcr.(map[string]interface{})
if !ok {
return trace.BadParameter("acr unexpected type: %T", tokenAcr)
}
tokenAcrValues, ok := tokenAcrMap["values"]
if !ok {
return trace.BadParameter("acr.values not found in claims")
}
tokenAcrValuesSlice, ok := tokenAcrValues.([]interface{})
if !ok {
return trace.BadParameter("acr.values unexpected type: %T", tokenAcr)
}
acrValueMatched := false
for _, v := range tokenAcrValuesSlice {
vv, ok := v.(string)
if !ok {
continue
}
if acrValue == vv {
acrValueMatched = true
break
}
}
if !acrValueMatched {
log.Debugf("No OIDC ACR match found for '%v' in '%v'.", acrValue, tokenAcrValues)
return trace.BadParameter("acr claim does not match")
}
default:
log.Debugf("Validating OIDC ACR values with default rules.")
claimValue, exists, err := claims.StringClaim("acr")
if !exists {
return trace.BadParameter("acr claim does not exist")
}
if err != nil {
return trace.Wrap(err)
}
if claimValue != acrValue {
log.Debugf("No OIDC ACR match found '%v' != '%v'.", acrValue, claimValue)
return trace.BadParameter("acr claim does not match")
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"validateACRValues",
"(",
"acrValue",
"string",
",",
"identityProvider",
"string",
",",
"claims",
"jose",
".",
"Claims",
")",
"error",
"{",
"switch",
"identityProvider",
"{",
"case",
"teleport",
".",
"NetIQ",
":",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"identityProvider",
")",
"\n\n",
"tokenAcr",
",",
"ok",
":=",
"claims",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tokenAcrMap",
",",
"ok",
":=",
"tokenAcr",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"tokenAcr",
")",
"\n",
"}",
"\n",
"tokenAcrValues",
",",
"ok",
":=",
"tokenAcrMap",
"[",
"\"",
"\"",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tokenAcrValuesSlice",
",",
"ok",
":=",
"tokenAcrValues",
".",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"tokenAcr",
")",
"\n",
"}",
"\n\n",
"acrValueMatched",
":=",
"false",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"tokenAcrValuesSlice",
"{",
"vv",
",",
"ok",
":=",
"v",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"acrValue",
"==",
"vv",
"{",
"acrValueMatched",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"acrValueMatched",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"acrValue",
",",
"tokenAcrValues",
")",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"default",
":",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
")",
"\n\n",
"claimValue",
",",
"exists",
",",
"err",
":=",
"claims",
".",
"StringClaim",
"(",
"\"",
"\"",
")",
"\n",
"if",
"!",
"exists",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"claimValue",
"!=",
"acrValue",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"acrValue",
",",
"claimValue",
")",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // validateACRValues validates that we get an appropriate response for acr values. By default
// we expect the same value we send, but this function also handles Identity Provider specific
// forms of validation. | [
"validateACRValues",
"validates",
"that",
"we",
"get",
"an",
"appropriate",
"response",
"for",
"acr",
"values",
".",
"By",
"default",
"we",
"expect",
"the",
"same",
"value",
"we",
"send",
"but",
"this",
"function",
"also",
"handles",
"Identity",
"Provider",
"specific",
"forms",
"of",
"validation",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/oidc.go#L733-L787 | train |
gravitational/teleport | lib/client/bench.go | Benchmark | func (tc *TeleportClient) Benchmark(ctx context.Context, bench Benchmark) (*BenchmarkResult, error) {
tc.Stdout = ioutil.Discard
tc.Stderr = ioutil.Discard
tc.Stdin = &bytes.Buffer{}
ctx, cancel := context.WithTimeout(ctx, bench.Duration)
defer cancel()
requestC := make(chan *benchMeasure)
responseC := make(chan *benchMeasure, bench.Threads)
// create goroutines for concurrency
for i := 0; i < bench.Threads; i++ {
thread := &benchmarkThread{
id: i,
ctx: ctx,
client: tc,
command: bench.Command,
interactive: bench.Interactive,
receiveC: requestC,
sendC: responseC,
}
go thread.run()
}
// producer goroutine
go func() {
interval := time.Duration(float64(1) / float64(bench.Rate) * float64(time.Second))
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
// notice how we start the timer regardless of whether any goroutine can process it
// this is to account for coordinated omission,
// http://psy-lob-saw.blogspot.com/2015/03/fixing-ycsb-coordinated-omission.html
measure := &benchMeasure{
Start: time.Now(),
}
select {
case requestC <- measure:
case <-ctx.Done():
return
}
case <-ctx.Done():
return
}
}
}()
var result BenchmarkResult
// from one millisecond to 60000 milliseconds (minute) with 3 digits precision
result.Histogram = hdrhistogram.New(1, 60000, 3)
var doneThreads int
var timeoutC <-chan time.Time
doneC := ctx.Done()
for {
select {
case <-timeoutC:
result.LastError = trace.BadParameter("several requests hang: timeout waiting for %v threads to finish", bench.Threads-doneThreads)
return &result, nil
case <-doneC:
// give it a couple of seconds to wrap up the goroutines,
// set up the timer that will fire up if the all goroutines were not finished
doneC = nil
waitTime := time.Duration(result.Histogram.Max()) * time.Millisecond
// going to wait latency + buffer to give requests in flight to wrap up
waitTime = time.Duration(1.2 * float64(waitTime))
timeoutC = time.After(waitTime)
case measure := <-responseC:
if measure.ThreadCompleted {
doneThreads += 1
if doneThreads == bench.Threads {
return &result, nil
}
} else {
if measure.Error != nil {
result.RequestsFailed += 1
result.LastError = measure.Error
}
result.RequestsOriginated += 1
result.Histogram.RecordValue(int64(measure.End.Sub(measure.Start) / time.Millisecond))
}
}
}
} | go | func (tc *TeleportClient) Benchmark(ctx context.Context, bench Benchmark) (*BenchmarkResult, error) {
tc.Stdout = ioutil.Discard
tc.Stderr = ioutil.Discard
tc.Stdin = &bytes.Buffer{}
ctx, cancel := context.WithTimeout(ctx, bench.Duration)
defer cancel()
requestC := make(chan *benchMeasure)
responseC := make(chan *benchMeasure, bench.Threads)
// create goroutines for concurrency
for i := 0; i < bench.Threads; i++ {
thread := &benchmarkThread{
id: i,
ctx: ctx,
client: tc,
command: bench.Command,
interactive: bench.Interactive,
receiveC: requestC,
sendC: responseC,
}
go thread.run()
}
// producer goroutine
go func() {
interval := time.Duration(float64(1) / float64(bench.Rate) * float64(time.Second))
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
// notice how we start the timer regardless of whether any goroutine can process it
// this is to account for coordinated omission,
// http://psy-lob-saw.blogspot.com/2015/03/fixing-ycsb-coordinated-omission.html
measure := &benchMeasure{
Start: time.Now(),
}
select {
case requestC <- measure:
case <-ctx.Done():
return
}
case <-ctx.Done():
return
}
}
}()
var result BenchmarkResult
// from one millisecond to 60000 milliseconds (minute) with 3 digits precision
result.Histogram = hdrhistogram.New(1, 60000, 3)
var doneThreads int
var timeoutC <-chan time.Time
doneC := ctx.Done()
for {
select {
case <-timeoutC:
result.LastError = trace.BadParameter("several requests hang: timeout waiting for %v threads to finish", bench.Threads-doneThreads)
return &result, nil
case <-doneC:
// give it a couple of seconds to wrap up the goroutines,
// set up the timer that will fire up if the all goroutines were not finished
doneC = nil
waitTime := time.Duration(result.Histogram.Max()) * time.Millisecond
// going to wait latency + buffer to give requests in flight to wrap up
waitTime = time.Duration(1.2 * float64(waitTime))
timeoutC = time.After(waitTime)
case measure := <-responseC:
if measure.ThreadCompleted {
doneThreads += 1
if doneThreads == bench.Threads {
return &result, nil
}
} else {
if measure.Error != nil {
result.RequestsFailed += 1
result.LastError = measure.Error
}
result.RequestsOriginated += 1
result.Histogram.RecordValue(int64(measure.End.Sub(measure.Start) / time.Millisecond))
}
}
}
} | [
"func",
"(",
"tc",
"*",
"TeleportClient",
")",
"Benchmark",
"(",
"ctx",
"context",
".",
"Context",
",",
"bench",
"Benchmark",
")",
"(",
"*",
"BenchmarkResult",
",",
"error",
")",
"{",
"tc",
".",
"Stdout",
"=",
"ioutil",
".",
"Discard",
"\n",
"tc",
".",
"Stderr",
"=",
"ioutil",
".",
"Discard",
"\n",
"tc",
".",
"Stdin",
"=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithTimeout",
"(",
"ctx",
",",
"bench",
".",
"Duration",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n\n",
"requestC",
":=",
"make",
"(",
"chan",
"*",
"benchMeasure",
")",
"\n",
"responseC",
":=",
"make",
"(",
"chan",
"*",
"benchMeasure",
",",
"bench",
".",
"Threads",
")",
"\n\n",
"// create goroutines for concurrency",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"bench",
".",
"Threads",
";",
"i",
"++",
"{",
"thread",
":=",
"&",
"benchmarkThread",
"{",
"id",
":",
"i",
",",
"ctx",
":",
"ctx",
",",
"client",
":",
"tc",
",",
"command",
":",
"bench",
".",
"Command",
",",
"interactive",
":",
"bench",
".",
"Interactive",
",",
"receiveC",
":",
"requestC",
",",
"sendC",
":",
"responseC",
",",
"}",
"\n",
"go",
"thread",
".",
"run",
"(",
")",
"\n",
"}",
"\n\n",
"// producer goroutine",
"go",
"func",
"(",
")",
"{",
"interval",
":=",
"time",
".",
"Duration",
"(",
"float64",
"(",
"1",
")",
"/",
"float64",
"(",
"bench",
".",
"Rate",
")",
"*",
"float64",
"(",
"time",
".",
"Second",
")",
")",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"interval",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"ticker",
".",
"C",
":",
"// notice how we start the timer regardless of whether any goroutine can process it",
"// this is to account for coordinated omission,",
"// http://psy-lob-saw.blogspot.com/2015/03/fixing-ycsb-coordinated-omission.html",
"measure",
":=",
"&",
"benchMeasure",
"{",
"Start",
":",
"time",
".",
"Now",
"(",
")",
",",
"}",
"\n",
"select",
"{",
"case",
"requestC",
"<-",
"measure",
":",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"var",
"result",
"BenchmarkResult",
"\n",
"// from one millisecond to 60000 milliseconds (minute) with 3 digits precision",
"result",
".",
"Histogram",
"=",
"hdrhistogram",
".",
"New",
"(",
"1",
",",
"60000",
",",
"3",
")",
"\n\n",
"var",
"doneThreads",
"int",
"\n",
"var",
"timeoutC",
"<-",
"chan",
"time",
".",
"Time",
"\n",
"doneC",
":=",
"ctx",
".",
"Done",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"timeoutC",
":",
"result",
".",
"LastError",
"=",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"bench",
".",
"Threads",
"-",
"doneThreads",
")",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"case",
"<-",
"doneC",
":",
"// give it a couple of seconds to wrap up the goroutines,",
"// set up the timer that will fire up if the all goroutines were not finished",
"doneC",
"=",
"nil",
"\n",
"waitTime",
":=",
"time",
".",
"Duration",
"(",
"result",
".",
"Histogram",
".",
"Max",
"(",
")",
")",
"*",
"time",
".",
"Millisecond",
"\n",
"// going to wait latency + buffer to give requests in flight to wrap up",
"waitTime",
"=",
"time",
".",
"Duration",
"(",
"1.2",
"*",
"float64",
"(",
"waitTime",
")",
")",
"\n",
"timeoutC",
"=",
"time",
".",
"After",
"(",
"waitTime",
")",
"\n",
"case",
"measure",
":=",
"<-",
"responseC",
":",
"if",
"measure",
".",
"ThreadCompleted",
"{",
"doneThreads",
"+=",
"1",
"\n",
"if",
"doneThreads",
"==",
"bench",
".",
"Threads",
"{",
"return",
"&",
"result",
",",
"nil",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"measure",
".",
"Error",
"!=",
"nil",
"{",
"result",
".",
"RequestsFailed",
"+=",
"1",
"\n",
"result",
".",
"LastError",
"=",
"measure",
".",
"Error",
"\n",
"}",
"\n",
"result",
".",
"RequestsOriginated",
"+=",
"1",
"\n",
"result",
".",
"Histogram",
".",
"RecordValue",
"(",
"int64",
"(",
"measure",
".",
"End",
".",
"Sub",
"(",
"measure",
".",
"Start",
")",
"/",
"time",
".",
"Millisecond",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"}"
] | // Benchmark connects to remote server and executes requests in parallel according
// to benchmark spec. It returns benchmark result when completed.
// This is a blocking function that can be cancelled via context argument. | [
"Benchmark",
"connects",
"to",
"remote",
"server",
"and",
"executes",
"requests",
"in",
"parallel",
"according",
"to",
"benchmark",
"spec",
".",
"It",
"returns",
"benchmark",
"result",
"when",
"completed",
".",
"This",
"is",
"a",
"blocking",
"function",
"that",
"can",
"be",
"cancelled",
"via",
"context",
"argument",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/bench.go#L60-L147 | train |
gravitational/teleport | lib/utils/conn.go | NewCloserConn | func NewCloserConn(conn net.Conn, closers ...io.Closer) *CloserConn {
return &CloserConn{
Conn: conn,
closers: closers,
}
} | go | func NewCloserConn(conn net.Conn, closers ...io.Closer) *CloserConn {
return &CloserConn{
Conn: conn,
closers: closers,
}
} | [
"func",
"NewCloserConn",
"(",
"conn",
"net",
".",
"Conn",
",",
"closers",
"...",
"io",
".",
"Closer",
")",
"*",
"CloserConn",
"{",
"return",
"&",
"CloserConn",
"{",
"Conn",
":",
"conn",
",",
"closers",
":",
"closers",
",",
"}",
"\n",
"}"
] | // NewCloserConn returns new connection wrapper that
// when closed will also close passed closers | [
"NewCloserConn",
"returns",
"new",
"connection",
"wrapper",
"that",
"when",
"closed",
"will",
"also",
"close",
"passed",
"closers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/conn.go#L33-L38 | train |
gravitational/teleport | lib/client/interfaces.go | ClientTLSConfig | func (k *Key) ClientTLSConfig() (*tls.Config, error) {
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
pool := x509.NewCertPool()
for _, ca := range k.TrustedCA {
for _, certPEM := range ca.TLSCertificates {
if !pool.AppendCertsFromPEM(certPEM) {
return nil, trace.BadParameter("failed to parse certificate received from the proxy")
}
}
}
tlsConfig.RootCAs = pool
tlsCert, err := tls.X509KeyPair(k.TLSCert, k.Priv)
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
return tlsConfig, nil
} | go | func (k *Key) ClientTLSConfig() (*tls.Config, error) {
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
pool := x509.NewCertPool()
for _, ca := range k.TrustedCA {
for _, certPEM := range ca.TLSCertificates {
if !pool.AppendCertsFromPEM(certPEM) {
return nil, trace.BadParameter("failed to parse certificate received from the proxy")
}
}
}
tlsConfig.RootCAs = pool
tlsCert, err := tls.X509KeyPair(k.TLSCert, k.Priv)
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
return tlsConfig, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"ClientTLSConfig",
"(",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"// Because Teleport clients can't be configured (yet), they take the default",
"// list of cipher suites from Go.",
"tlsConfig",
":=",
"utils",
".",
"TLSConfig",
"(",
"nil",
")",
"\n\n",
"pool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"for",
"_",
",",
"ca",
":=",
"range",
"k",
".",
"TrustedCA",
"{",
"for",
"_",
",",
"certPEM",
":=",
"range",
"ca",
".",
"TLSCertificates",
"{",
"if",
"!",
"pool",
".",
"AppendCertsFromPEM",
"(",
"certPEM",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"tlsConfig",
".",
"RootCAs",
"=",
"pool",
"\n",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"k",
".",
"TLSCert",
",",
"k",
".",
"Priv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"Certificates",
"=",
"append",
"(",
"tlsConfig",
".",
"Certificates",
",",
"tlsCert",
")",
"\n",
"return",
"tlsConfig",
",",
"nil",
"\n",
"}"
] | // TLSConfig returns client TLS configuration used
// to authenticate against API servers | [
"TLSConfig",
"returns",
"client",
"TLS",
"configuration",
"used",
"to",
"authenticate",
"against",
"API",
"servers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L62-L82 | train |
gravitational/teleport | lib/client/interfaces.go | CertUsername | func (k *Key) CertUsername() (string, error) {
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return "", trace.Wrap(err)
}
cert, ok := pubKey.(*ssh.Certificate)
if !ok {
return "", trace.BadParameter("expected SSH certificate, got public key")
}
return cert.KeyId, nil
} | go | func (k *Key) CertUsername() (string, error) {
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return "", trace.Wrap(err)
}
cert, ok := pubKey.(*ssh.Certificate)
if !ok {
return "", trace.BadParameter("expected SSH certificate, got public key")
}
return cert.KeyId, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CertUsername",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"pubKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"pubKey",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"cert",
".",
"KeyId",
",",
"nil",
"\n",
"}"
] | // CertUsername returns the name of the Teleport user encoded in the SSH certificate. | [
"CertUsername",
"returns",
"the",
"name",
"of",
"the",
"Teleport",
"user",
"encoded",
"in",
"the",
"SSH",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L85-L95 | train |
gravitational/teleport | lib/client/interfaces.go | CertPrincipals | func (k *Key) CertPrincipals() ([]string, error) {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("no certificate found")
}
return cert.ValidPrincipals, nil
} | go | func (k *Key) CertPrincipals() ([]string, error) {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("no certificate found")
}
return cert.ValidPrincipals, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CertPrincipals",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"publicKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"publicKey",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"cert",
".",
"ValidPrincipals",
",",
"nil",
"\n",
"}"
] | // CertPrincipals returns the principals listed on the SSH certificate. | [
"CertPrincipals",
"returns",
"the",
"principals",
"listed",
"on",
"the",
"SSH",
"certificate",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L98-L108 | train |
gravitational/teleport | lib/client/interfaces.go | EqualsTo | func (k *Key) EqualsTo(other *Key) bool {
if k == other {
return true
}
return bytes.Equal(k.Cert, other.Cert) &&
bytes.Equal(k.Priv, other.Priv) &&
bytes.Equal(k.Pub, other.Pub) &&
bytes.Equal(k.TLSCert, other.TLSCert)
} | go | func (k *Key) EqualsTo(other *Key) bool {
if k == other {
return true
}
return bytes.Equal(k.Cert, other.Cert) &&
bytes.Equal(k.Priv, other.Priv) &&
bytes.Equal(k.Pub, other.Pub) &&
bytes.Equal(k.TLSCert, other.TLSCert)
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"EqualsTo",
"(",
"other",
"*",
"Key",
")",
"bool",
"{",
"if",
"k",
"==",
"other",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"bytes",
".",
"Equal",
"(",
"k",
".",
"Cert",
",",
"other",
".",
"Cert",
")",
"&&",
"bytes",
".",
"Equal",
"(",
"k",
".",
"Priv",
",",
"other",
".",
"Priv",
")",
"&&",
"bytes",
".",
"Equal",
"(",
"k",
".",
"Pub",
",",
"other",
".",
"Pub",
")",
"&&",
"bytes",
".",
"Equal",
"(",
"k",
".",
"TLSCert",
",",
"other",
".",
"TLSCert",
")",
"\n",
"}"
] | // EqualsTo returns true if this key is the same as the other.
// Primarily used in tests | [
"EqualsTo",
"returns",
"true",
"if",
"this",
"key",
"is",
"the",
"same",
"as",
"the",
"other",
".",
"Primarily",
"used",
"in",
"tests"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L173-L181 | train |
gravitational/teleport | lib/client/interfaces.go | TLSCertValidBefore | func (k *Key) TLSCertValidBefore() (t time.Time, err error) {
cert, err := tlsca.ParseCertificatePEM(k.TLSCert)
if err != nil {
return t, trace.Wrap(err)
}
return cert.NotAfter, nil
} | go | func (k *Key) TLSCertValidBefore() (t time.Time, err error) {
cert, err := tlsca.ParseCertificatePEM(k.TLSCert)
if err != nil {
return t, trace.Wrap(err)
}
return cert.NotAfter, nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"TLSCertValidBefore",
"(",
")",
"(",
"t",
"time",
".",
"Time",
",",
"err",
"error",
")",
"{",
"cert",
",",
"err",
":=",
"tlsca",
".",
"ParseCertificatePEM",
"(",
"k",
".",
"TLSCert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"t",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cert",
".",
"NotAfter",
",",
"nil",
"\n",
"}"
] | // TLSCertValidBefore returns the time of the TLS cert expiration | [
"TLSCertValidBefore",
"returns",
"the",
"time",
"of",
"the",
"TLS",
"cert",
"expiration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L184-L190 | train |
gravitational/teleport | lib/client/interfaces.go | CertValidBefore | func (k *Key) CertValidBefore() (t time.Time, err error) {
pcert, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return t, trace.Wrap(err)
}
cert, ok := pcert.(*ssh.Certificate)
if !ok {
return t, trace.Errorf("not supported certificate type")
}
return time.Unix(int64(cert.ValidBefore), 0), nil
} | go | func (k *Key) CertValidBefore() (t time.Time, err error) {
pcert, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return t, trace.Wrap(err)
}
cert, ok := pcert.(*ssh.Certificate)
if !ok {
return t, trace.Errorf("not supported certificate type")
}
return time.Unix(int64(cert.ValidBefore), 0), nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CertValidBefore",
"(",
")",
"(",
"t",
"time",
".",
"Time",
",",
"err",
"error",
")",
"{",
"pcert",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"t",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"ok",
":=",
"pcert",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"t",
",",
"trace",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"cert",
".",
"ValidBefore",
")",
",",
"0",
")",
",",
"nil",
"\n",
"}"
] | // CertValidBefore returns the time of the cert expiration | [
"CertValidBefore",
"returns",
"the",
"time",
"of",
"the",
"cert",
"expiration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L193-L203 | train |
gravitational/teleport | lib/client/interfaces.go | AsAuthMethod | func (k *Key) AsAuthMethod() (ssh.AuthMethod, error) {
keys, err := k.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
signer, err := ssh.NewSignerFromKey(keys[0].PrivateKey)
if err != nil {
return nil, trace.Wrap(err)
}
if signer, err = ssh.NewCertSigner(keys[0].Certificate, signer); err != nil {
return nil, trace.Wrap(err)
}
return NewAuthMethodForCert(signer), nil
} | go | func (k *Key) AsAuthMethod() (ssh.AuthMethod, error) {
keys, err := k.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
signer, err := ssh.NewSignerFromKey(keys[0].PrivateKey)
if err != nil {
return nil, trace.Wrap(err)
}
if signer, err = ssh.NewCertSigner(keys[0].Certificate, signer); err != nil {
return nil, trace.Wrap(err)
}
return NewAuthMethodForCert(signer), nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"AsAuthMethod",
"(",
")",
"(",
"ssh",
".",
"AuthMethod",
",",
"error",
")",
"{",
"keys",
",",
"err",
":=",
"k",
".",
"AsAgentKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"signer",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"keys",
"[",
"0",
"]",
".",
"PrivateKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"signer",
",",
"err",
"=",
"ssh",
".",
"NewCertSigner",
"(",
"keys",
"[",
"0",
"]",
".",
"Certificate",
",",
"signer",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"NewAuthMethodForCert",
"(",
"signer",
")",
",",
"nil",
"\n",
"}"
] | // AsAuthMethod returns an "auth method" interface, a common abstraction
// used by Golang SSH library. This is how you actually use a Key to feed
// it into the SSH lib. | [
"AsAuthMethod",
"returns",
"an",
"auth",
"method",
"interface",
"a",
"common",
"abstraction",
"used",
"by",
"Golang",
"SSH",
"library",
".",
"This",
"is",
"how",
"you",
"actually",
"use",
"a",
"Key",
"to",
"feed",
"it",
"into",
"the",
"SSH",
"lib",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L208-L221 | train |
gravitational/teleport | lib/client/interfaces.go | CheckCert | func (k *Key) CheckCert() error {
key, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return trace.Wrap(err)
}
cert, ok := key.(*ssh.Certificate)
if !ok {
return trace.BadParameter("found key, not certificate")
}
if len(cert.ValidPrincipals) == 0 {
return trace.BadParameter("principals are required")
}
// A valid principal is always passed in because the principals are not being
// checked here, but rather the validity period, signature, and algorithms.
certChecker := utils.CertChecker{}
err = certChecker.CheckCert(cert.ValidPrincipals[0], cert)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (k *Key) CheckCert() error {
key, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return trace.Wrap(err)
}
cert, ok := key.(*ssh.Certificate)
if !ok {
return trace.BadParameter("found key, not certificate")
}
if len(cert.ValidPrincipals) == 0 {
return trace.BadParameter("principals are required")
}
// A valid principal is always passed in because the principals are not being
// checked here, but rather the validity period, signature, and algorithms.
certChecker := utils.CertChecker{}
err = certChecker.CheckCert(cert.ValidPrincipals[0], cert)
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"k",
"*",
"Key",
")",
"CheckCert",
"(",
")",
"error",
"{",
"key",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"k",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"cert",
",",
"ok",
":=",
"key",
".",
"(",
"*",
"ssh",
".",
"Certificate",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"cert",
".",
"ValidPrincipals",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// A valid principal is always passed in because the principals are not being",
"// checked here, but rather the validity period, signature, and algorithms.",
"certChecker",
":=",
"utils",
".",
"CertChecker",
"{",
"}",
"\n",
"err",
"=",
"certChecker",
".",
"CheckCert",
"(",
"cert",
".",
"ValidPrincipals",
"[",
"0",
"]",
",",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // CheckCert makes sure the SSH certificate is valid. | [
"CheckCert",
"makes",
"sure",
"the",
"SSH",
"certificate",
"is",
"valid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/interfaces.go#L224-L247 | train |
gravitational/teleport | lib/backend/dynamo/shards.go | collectActiveShards | func (b *DynamoDBBackend) collectActiveShards(ctx context.Context, streamArn *string) ([]*dynamodbstreams.Shard, error) {
var out []*dynamodbstreams.Shard
input := &dynamodbstreams.DescribeStreamInput{
StreamArn: streamArn,
}
for {
streamInfo, err := b.streams.DescribeStreamWithContext(ctx, input)
if err != nil {
return nil, convertError(err)
}
out = append(out, streamInfo.StreamDescription.Shards...)
if streamInfo.StreamDescription.LastEvaluatedShardId == nil {
return filterActiveShards(out), nil
}
input.ExclusiveStartShardId = streamInfo.StreamDescription.LastEvaluatedShardId
}
} | go | func (b *DynamoDBBackend) collectActiveShards(ctx context.Context, streamArn *string) ([]*dynamodbstreams.Shard, error) {
var out []*dynamodbstreams.Shard
input := &dynamodbstreams.DescribeStreamInput{
StreamArn: streamArn,
}
for {
streamInfo, err := b.streams.DescribeStreamWithContext(ctx, input)
if err != nil {
return nil, convertError(err)
}
out = append(out, streamInfo.StreamDescription.Shards...)
if streamInfo.StreamDescription.LastEvaluatedShardId == nil {
return filterActiveShards(out), nil
}
input.ExclusiveStartShardId = streamInfo.StreamDescription.LastEvaluatedShardId
}
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"collectActiveShards",
"(",
"ctx",
"context",
".",
"Context",
",",
"streamArn",
"*",
"string",
")",
"(",
"[",
"]",
"*",
"dynamodbstreams",
".",
"Shard",
",",
"error",
")",
"{",
"var",
"out",
"[",
"]",
"*",
"dynamodbstreams",
".",
"Shard",
"\n\n",
"input",
":=",
"&",
"dynamodbstreams",
".",
"DescribeStreamInput",
"{",
"StreamArn",
":",
"streamArn",
",",
"}",
"\n",
"for",
"{",
"streamInfo",
",",
"err",
":=",
"b",
".",
"streams",
".",
"DescribeStreamWithContext",
"(",
"ctx",
",",
"input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"convertError",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"streamInfo",
".",
"StreamDescription",
".",
"Shards",
"...",
")",
"\n",
"if",
"streamInfo",
".",
"StreamDescription",
".",
"LastEvaluatedShardId",
"==",
"nil",
"{",
"return",
"filterActiveShards",
"(",
"out",
")",
",",
"nil",
"\n",
"}",
"\n",
"input",
".",
"ExclusiveStartShardId",
"=",
"streamInfo",
".",
"StreamDescription",
".",
"LastEvaluatedShardId",
"\n",
"}",
"\n",
"}"
] | // collectActiveShards collects shards | [
"collectActiveShards",
"collects",
"shards"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/shards.go#L202-L219 | train |
gravitational/teleport | lib/backend/dynamo/dynamodbbk.go | GetRange | func (b *DynamoDBBackend) GetRange(ctx context.Context, startKey []byte, endKey []byte, limit int) (*backend.GetResult, error) {
if len(startKey) == 0 {
return nil, trace.BadParameter("missing parameter startKey")
}
if len(endKey) == 0 {
return nil, trace.BadParameter("missing parameter endKey")
}
result, err := b.getAllRecords(ctx, startKey, endKey, limit)
if err != nil {
return nil, trace.Wrap(err)
}
sort.Sort(records(result.records))
values := make([]backend.Item, len(result.records))
for i, r := range result.records {
values[i] = backend.Item{
Key: trimPrefix(r.FullPath),
Value: r.Value,
}
if r.Expires != nil {
values[i].Expires = time.Unix(*r.Expires, 0).UTC()
}
}
return &backend.GetResult{Items: values}, nil
} | go | func (b *DynamoDBBackend) GetRange(ctx context.Context, startKey []byte, endKey []byte, limit int) (*backend.GetResult, error) {
if len(startKey) == 0 {
return nil, trace.BadParameter("missing parameter startKey")
}
if len(endKey) == 0 {
return nil, trace.BadParameter("missing parameter endKey")
}
result, err := b.getAllRecords(ctx, startKey, endKey, limit)
if err != nil {
return nil, trace.Wrap(err)
}
sort.Sort(records(result.records))
values := make([]backend.Item, len(result.records))
for i, r := range result.records {
values[i] = backend.Item{
Key: trimPrefix(r.FullPath),
Value: r.Value,
}
if r.Expires != nil {
values[i].Expires = time.Unix(*r.Expires, 0).UTC()
}
}
return &backend.GetResult{Items: values}, nil
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"GetRange",
"(",
"ctx",
"context",
".",
"Context",
",",
"startKey",
"[",
"]",
"byte",
",",
"endKey",
"[",
"]",
"byte",
",",
"limit",
"int",
")",
"(",
"*",
"backend",
".",
"GetResult",
",",
"error",
")",
"{",
"if",
"len",
"(",
"startKey",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"endKey",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"result",
",",
"err",
":=",
"b",
".",
"getAllRecords",
"(",
"ctx",
",",
"startKey",
",",
"endKey",
",",
"limit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"records",
"(",
"result",
".",
"records",
")",
")",
"\n",
"values",
":=",
"make",
"(",
"[",
"]",
"backend",
".",
"Item",
",",
"len",
"(",
"result",
".",
"records",
")",
")",
"\n",
"for",
"i",
",",
"r",
":=",
"range",
"result",
".",
"records",
"{",
"values",
"[",
"i",
"]",
"=",
"backend",
".",
"Item",
"{",
"Key",
":",
"trimPrefix",
"(",
"r",
".",
"FullPath",
")",
",",
"Value",
":",
"r",
".",
"Value",
",",
"}",
"\n",
"if",
"r",
".",
"Expires",
"!=",
"nil",
"{",
"values",
"[",
"i",
"]",
".",
"Expires",
"=",
"time",
".",
"Unix",
"(",
"*",
"r",
".",
"Expires",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"backend",
".",
"GetResult",
"{",
"Items",
":",
"values",
"}",
",",
"nil",
"\n",
"}"
] | // GetRange returns range of elements | [
"GetRange",
"returns",
"range",
"of",
"elements"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/dynamodbbk.go#L302-L325 | train |
gravitational/teleport | lib/backend/dynamo/dynamodbbk.go | CompareAndSwap | func (b *DynamoDBBackend) CompareAndSwap(ctx context.Context, expected backend.Item, replaceWith backend.Item) (*backend.Lease, error) {
if len(expected.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if len(replaceWith.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if bytes.Compare(expected.Key, replaceWith.Key) != 0 {
return nil, trace.BadParameter("expected and replaceWith keys should match")
}
r := record{
HashKey: hashKey,
FullPath: prependPrefix(replaceWith.Key),
Value: replaceWith.Value,
Timestamp: time.Now().UTC().Unix(),
ID: time.Now().UTC().UnixNano(),
}
if !replaceWith.Expires.IsZero() {
r.Expires = aws.Int64(replaceWith.Expires.UTC().Unix())
}
av, err := dynamodbattribute.MarshalMap(r)
if err != nil {
return nil, trace.Wrap(err)
}
input := dynamodb.PutItemInput{
Item: av,
TableName: aws.String(b.Tablename),
}
input.SetConditionExpression("#v = :prev")
input.SetExpressionAttributeNames(map[string]*string{
"#v": aws.String("Value"),
})
input.SetExpressionAttributeValues(map[string]*dynamodb.AttributeValue{
":prev": &dynamodb.AttributeValue{
B: expected.Value,
},
})
_, err = b.svc.PutItemWithContext(ctx, &input)
err = convertError(err)
if err != nil {
// in this case let's use more specific compare failed error
if trace.IsAlreadyExists(err) {
return nil, trace.CompareFailed(err.Error())
}
return nil, trace.Wrap(err)
}
return b.newLease(replaceWith), nil
} | go | func (b *DynamoDBBackend) CompareAndSwap(ctx context.Context, expected backend.Item, replaceWith backend.Item) (*backend.Lease, error) {
if len(expected.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if len(replaceWith.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if bytes.Compare(expected.Key, replaceWith.Key) != 0 {
return nil, trace.BadParameter("expected and replaceWith keys should match")
}
r := record{
HashKey: hashKey,
FullPath: prependPrefix(replaceWith.Key),
Value: replaceWith.Value,
Timestamp: time.Now().UTC().Unix(),
ID: time.Now().UTC().UnixNano(),
}
if !replaceWith.Expires.IsZero() {
r.Expires = aws.Int64(replaceWith.Expires.UTC().Unix())
}
av, err := dynamodbattribute.MarshalMap(r)
if err != nil {
return nil, trace.Wrap(err)
}
input := dynamodb.PutItemInput{
Item: av,
TableName: aws.String(b.Tablename),
}
input.SetConditionExpression("#v = :prev")
input.SetExpressionAttributeNames(map[string]*string{
"#v": aws.String("Value"),
})
input.SetExpressionAttributeValues(map[string]*dynamodb.AttributeValue{
":prev": &dynamodb.AttributeValue{
B: expected.Value,
},
})
_, err = b.svc.PutItemWithContext(ctx, &input)
err = convertError(err)
if err != nil {
// in this case let's use more specific compare failed error
if trace.IsAlreadyExists(err) {
return nil, trace.CompareFailed(err.Error())
}
return nil, trace.Wrap(err)
}
return b.newLease(replaceWith), nil
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"CompareAndSwap",
"(",
"ctx",
"context",
".",
"Context",
",",
"expected",
"backend",
".",
"Item",
",",
"replaceWith",
"backend",
".",
"Item",
")",
"(",
"*",
"backend",
".",
"Lease",
",",
"error",
")",
"{",
"if",
"len",
"(",
"expected",
".",
"Key",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"replaceWith",
".",
"Key",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"bytes",
".",
"Compare",
"(",
"expected",
".",
"Key",
",",
"replaceWith",
".",
"Key",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
":=",
"record",
"{",
"HashKey",
":",
"hashKey",
",",
"FullPath",
":",
"prependPrefix",
"(",
"replaceWith",
".",
"Key",
")",
",",
"Value",
":",
"replaceWith",
".",
"Value",
",",
"Timestamp",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Unix",
"(",
")",
",",
"ID",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"UnixNano",
"(",
")",
",",
"}",
"\n",
"if",
"!",
"replaceWith",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"r",
".",
"Expires",
"=",
"aws",
".",
"Int64",
"(",
"replaceWith",
".",
"Expires",
".",
"UTC",
"(",
")",
".",
"Unix",
"(",
")",
")",
"\n",
"}",
"\n",
"av",
",",
"err",
":=",
"dynamodbattribute",
".",
"MarshalMap",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"input",
":=",
"dynamodb",
".",
"PutItemInput",
"{",
"Item",
":",
"av",
",",
"TableName",
":",
"aws",
".",
"String",
"(",
"b",
".",
"Tablename",
")",
",",
"}",
"\n",
"input",
".",
"SetConditionExpression",
"(",
"\"",
"\"",
")",
"\n",
"input",
".",
"SetExpressionAttributeNames",
"(",
"map",
"[",
"string",
"]",
"*",
"string",
"{",
"\"",
"\"",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"}",
")",
"\n",
"input",
".",
"SetExpressionAttributeValues",
"(",
"map",
"[",
"string",
"]",
"*",
"dynamodb",
".",
"AttributeValue",
"{",
"\"",
"\"",
":",
"&",
"dynamodb",
".",
"AttributeValue",
"{",
"B",
":",
"expected",
".",
"Value",
",",
"}",
",",
"}",
")",
"\n",
"_",
",",
"err",
"=",
"b",
".",
"svc",
".",
"PutItemWithContext",
"(",
"ctx",
",",
"&",
"input",
")",
"\n",
"err",
"=",
"convertError",
"(",
"err",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// in this case let's use more specific compare failed error",
"if",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"CompareFailed",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"b",
".",
"newLease",
"(",
"replaceWith",
")",
",",
"nil",
"\n",
"}"
] | // CompareAndSwap compares and swap values in atomic operation
// CompareAndSwap compares item with existing item
// and replaces is with replaceWith item | [
"CompareAndSwap",
"compares",
"and",
"swap",
"values",
"in",
"atomic",
"operation",
"CompareAndSwap",
"compares",
"item",
"with",
"existing",
"item",
"and",
"replaces",
"is",
"with",
"replaceWith",
"item"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/dynamodbbk.go#L413-L460 | train |
gravitational/teleport | lib/backend/dynamo/dynamodbbk.go | Close | func (b *DynamoDBBackend) Close() error {
b.setClosed()
b.cancel()
return b.buf.Close()
} | go | func (b *DynamoDBBackend) Close() error {
b.setClosed()
b.cancel()
return b.buf.Close()
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"Close",
"(",
")",
"error",
"{",
"b",
".",
"setClosed",
"(",
")",
"\n",
"b",
".",
"cancel",
"(",
")",
"\n",
"return",
"b",
".",
"buf",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Close closes the DynamoDB driver
// and releases associated resources | [
"Close",
"closes",
"the",
"DynamoDB",
"driver",
"and",
"releases",
"associated",
"resources"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/dynamodbbk.go#L530-L534 | train |
gravitational/teleport | lib/backend/dynamo/dynamodbbk.go | deleteTable | func (b *DynamoDBBackend) deleteTable(ctx context.Context, tableName string, wait bool) error {
tn := aws.String(tableName)
_, err := b.svc.DeleteTable(&dynamodb.DeleteTableInput{TableName: tn})
if err != nil {
return trace.Wrap(err)
}
if wait {
return trace.Wrap(
b.svc.WaitUntilTableNotExists(&dynamodb.DescribeTableInput{TableName: tn}))
}
return nil
} | go | func (b *DynamoDBBackend) deleteTable(ctx context.Context, tableName string, wait bool) error {
tn := aws.String(tableName)
_, err := b.svc.DeleteTable(&dynamodb.DeleteTableInput{TableName: tn})
if err != nil {
return trace.Wrap(err)
}
if wait {
return trace.Wrap(
b.svc.WaitUntilTableNotExists(&dynamodb.DescribeTableInput{TableName: tn}))
}
return nil
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"deleteTable",
"(",
"ctx",
"context",
".",
"Context",
",",
"tableName",
"string",
",",
"wait",
"bool",
")",
"error",
"{",
"tn",
":=",
"aws",
".",
"String",
"(",
"tableName",
")",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"svc",
".",
"DeleteTable",
"(",
"&",
"dynamodb",
".",
"DeleteTableInput",
"{",
"TableName",
":",
"tn",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"wait",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"b",
".",
"svc",
".",
"WaitUntilTableNotExists",
"(",
"&",
"dynamodb",
".",
"DescribeTableInput",
"{",
"TableName",
":",
"tn",
"}",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // deleteTable deletes DynamoDB table with a given name | [
"deleteTable",
"deletes",
"DynamoDB",
"table",
"with",
"a",
"given",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/dynamodbbk.go#L637-L648 | train |
gravitational/teleport | lib/backend/dynamo/dynamodbbk.go | getRecords | func (b *DynamoDBBackend) getRecords(ctx context.Context, startKey, endKey string, limit int, lastEvaluatedKey map[string]*dynamodb.AttributeValue) (*getResult, error) {
query := "HashKey = :hashKey AND FullPath BETWEEN :fullPath AND :rangeEnd"
attrV := map[string]interface{}{
":fullPath": startKey,
":hashKey": hashKey,
":timestamp": b.clock.Now().UTC().Unix(),
":rangeEnd": endKey,
}
// filter out expired items, otherwise they might show up in the query
// http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html
filter := fmt.Sprintf("attribute_not_exists(Expires) OR Expires >= :timestamp")
av, err := dynamodbattribute.MarshalMap(attrV)
if err != nil {
return nil, convertError(err)
}
input := dynamodb.QueryInput{
KeyConditionExpression: aws.String(query),
TableName: &b.Tablename,
ExpressionAttributeValues: av,
FilterExpression: aws.String(filter),
ConsistentRead: aws.Bool(true),
ExclusiveStartKey: lastEvaluatedKey,
}
if limit > 0 {
input.Limit = aws.Int64(int64(limit))
}
out, err := b.svc.Query(&input)
if err != nil {
return nil, trace.Wrap(err)
}
var result getResult
for _, item := range out.Items {
var r record
dynamodbattribute.UnmarshalMap(item, &r)
result.records = append(result.records, r)
}
sort.Sort(records(result.records))
result.records = removeDuplicates(result.records)
result.lastEvaluatedKey = out.LastEvaluatedKey
return &result, nil
} | go | func (b *DynamoDBBackend) getRecords(ctx context.Context, startKey, endKey string, limit int, lastEvaluatedKey map[string]*dynamodb.AttributeValue) (*getResult, error) {
query := "HashKey = :hashKey AND FullPath BETWEEN :fullPath AND :rangeEnd"
attrV := map[string]interface{}{
":fullPath": startKey,
":hashKey": hashKey,
":timestamp": b.clock.Now().UTC().Unix(),
":rangeEnd": endKey,
}
// filter out expired items, otherwise they might show up in the query
// http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html
filter := fmt.Sprintf("attribute_not_exists(Expires) OR Expires >= :timestamp")
av, err := dynamodbattribute.MarshalMap(attrV)
if err != nil {
return nil, convertError(err)
}
input := dynamodb.QueryInput{
KeyConditionExpression: aws.String(query),
TableName: &b.Tablename,
ExpressionAttributeValues: av,
FilterExpression: aws.String(filter),
ConsistentRead: aws.Bool(true),
ExclusiveStartKey: lastEvaluatedKey,
}
if limit > 0 {
input.Limit = aws.Int64(int64(limit))
}
out, err := b.svc.Query(&input)
if err != nil {
return nil, trace.Wrap(err)
}
var result getResult
for _, item := range out.Items {
var r record
dynamodbattribute.UnmarshalMap(item, &r)
result.records = append(result.records, r)
}
sort.Sort(records(result.records))
result.records = removeDuplicates(result.records)
result.lastEvaluatedKey = out.LastEvaluatedKey
return &result, nil
} | [
"func",
"(",
"b",
"*",
"DynamoDBBackend",
")",
"getRecords",
"(",
"ctx",
"context",
".",
"Context",
",",
"startKey",
",",
"endKey",
"string",
",",
"limit",
"int",
",",
"lastEvaluatedKey",
"map",
"[",
"string",
"]",
"*",
"dynamodb",
".",
"AttributeValue",
")",
"(",
"*",
"getResult",
",",
"error",
")",
"{",
"query",
":=",
"\"",
"\"",
"\n",
"attrV",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"startKey",
",",
"\"",
"\"",
":",
"hashKey",
",",
"\"",
"\"",
":",
"b",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Unix",
"(",
")",
",",
"\"",
"\"",
":",
"endKey",
",",
"}",
"\n\n",
"// filter out expired items, otherwise they might show up in the query",
"// http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html",
"filter",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
")",
"\n",
"av",
",",
"err",
":=",
"dynamodbattribute",
".",
"MarshalMap",
"(",
"attrV",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"convertError",
"(",
"err",
")",
"\n",
"}",
"\n",
"input",
":=",
"dynamodb",
".",
"QueryInput",
"{",
"KeyConditionExpression",
":",
"aws",
".",
"String",
"(",
"query",
")",
",",
"TableName",
":",
"&",
"b",
".",
"Tablename",
",",
"ExpressionAttributeValues",
":",
"av",
",",
"FilterExpression",
":",
"aws",
".",
"String",
"(",
"filter",
")",
",",
"ConsistentRead",
":",
"aws",
".",
"Bool",
"(",
"true",
")",
",",
"ExclusiveStartKey",
":",
"lastEvaluatedKey",
",",
"}",
"\n",
"if",
"limit",
">",
"0",
"{",
"input",
".",
"Limit",
"=",
"aws",
".",
"Int64",
"(",
"int64",
"(",
"limit",
")",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"b",
".",
"svc",
".",
"Query",
"(",
"&",
"input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"result",
"getResult",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"out",
".",
"Items",
"{",
"var",
"r",
"record",
"\n",
"dynamodbattribute",
".",
"UnmarshalMap",
"(",
"item",
",",
"&",
"r",
")",
"\n",
"result",
".",
"records",
"=",
"append",
"(",
"result",
".",
"records",
",",
"r",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"records",
"(",
"result",
".",
"records",
")",
")",
"\n",
"result",
".",
"records",
"=",
"removeDuplicates",
"(",
"result",
".",
"records",
")",
"\n",
"result",
".",
"lastEvaluatedKey",
"=",
"out",
".",
"LastEvaluatedKey",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"}"
] | // getRecords retrieves all keys by path | [
"getRecords",
"retrieves",
"all",
"keys",
"by",
"path"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/dynamo/dynamodbbk.go#L659-L700 | train |
gravitational/teleport | lib/backend/buffer.go | NewCircularBuffer | func NewCircularBuffer(ctx context.Context, size int) (*CircularBuffer, error) {
if size <= 0 {
return nil, trace.BadParameter("circular buffer size should be > 0")
}
ctx, cancel := context.WithCancel(ctx)
buf := &CircularBuffer{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentBuffer,
}),
ctx: ctx,
cancel: cancel,
events: make([]Event, size),
start: -1,
end: -1,
size: 0,
watchers: newWatcherTree(),
}
return buf, nil
} | go | func NewCircularBuffer(ctx context.Context, size int) (*CircularBuffer, error) {
if size <= 0 {
return nil, trace.BadParameter("circular buffer size should be > 0")
}
ctx, cancel := context.WithCancel(ctx)
buf := &CircularBuffer{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentBuffer,
}),
ctx: ctx,
cancel: cancel,
events: make([]Event, size),
start: -1,
end: -1,
size: 0,
watchers: newWatcherTree(),
}
return buf, nil
} | [
"func",
"NewCircularBuffer",
"(",
"ctx",
"context",
".",
"Context",
",",
"size",
"int",
")",
"(",
"*",
"CircularBuffer",
",",
"error",
")",
"{",
"if",
"size",
"<=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"buf",
":=",
"&",
"CircularBuffer",
"{",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentBuffer",
",",
"}",
")",
",",
"ctx",
":",
"ctx",
",",
"cancel",
":",
"cancel",
",",
"events",
":",
"make",
"(",
"[",
"]",
"Event",
",",
"size",
")",
",",
"start",
":",
"-",
"1",
",",
"end",
":",
"-",
"1",
",",
"size",
":",
"0",
",",
"watchers",
":",
"newWatcherTree",
"(",
")",
",",
"}",
"\n",
"return",
"buf",
",",
"nil",
"\n",
"}"
] | // NewCircularBuffer returns a new instance of circular buffer | [
"NewCircularBuffer",
"returns",
"a",
"new",
"instance",
"of",
"circular",
"buffer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L48-L66 | train |
gravitational/teleport | lib/backend/buffer.go | Reset | func (c *CircularBuffer) Reset() {
c.Lock()
defer c.Unlock()
// could close mulitple times
c.watchers.walk(func(w *BufferWatcher) {
w.Close()
})
c.watchers = newWatcherTree()
c.start = -1
c.end = -1
c.size = 0
for i := 0; i < len(c.events); i++ {
c.events[i] = Event{}
}
} | go | func (c *CircularBuffer) Reset() {
c.Lock()
defer c.Unlock()
// could close mulitple times
c.watchers.walk(func(w *BufferWatcher) {
w.Close()
})
c.watchers = newWatcherTree()
c.start = -1
c.end = -1
c.size = 0
for i := 0; i < len(c.events); i++ {
c.events[i] = Event{}
}
} | [
"func",
"(",
"c",
"*",
"CircularBuffer",
")",
"Reset",
"(",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"// could close mulitple times",
"c",
".",
"watchers",
".",
"walk",
"(",
"func",
"(",
"w",
"*",
"BufferWatcher",
")",
"{",
"w",
".",
"Close",
"(",
")",
"\n",
"}",
")",
"\n",
"c",
".",
"watchers",
"=",
"newWatcherTree",
"(",
")",
"\n",
"c",
".",
"start",
"=",
"-",
"1",
"\n",
"c",
".",
"end",
"=",
"-",
"1",
"\n",
"c",
".",
"size",
"=",
"0",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"c",
".",
"events",
")",
";",
"i",
"++",
"{",
"c",
".",
"events",
"[",
"i",
"]",
"=",
"Event",
"{",
"}",
"\n",
"}",
"\n",
"}"
] | // Reset resets all events from the queue
// and closes all active watchers | [
"Reset",
"resets",
"all",
"events",
"from",
"the",
"queue",
"and",
"closes",
"all",
"active",
"watchers"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L70-L84 | train |
gravitational/teleport | lib/backend/buffer.go | Events | func (c *CircularBuffer) Events() []Event {
c.Lock()
defer c.Unlock()
return c.eventsCopy()
} | go | func (c *CircularBuffer) Events() []Event {
c.Lock()
defer c.Unlock()
return c.eventsCopy()
} | [
"func",
"(",
"c",
"*",
"CircularBuffer",
")",
"Events",
"(",
")",
"[",
"]",
"Event",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"return",
"c",
".",
"eventsCopy",
"(",
")",
"\n",
"}"
] | // Events returns a copy of records as arranged from start to end | [
"Events",
"returns",
"a",
"copy",
"of",
"records",
"as",
"arranged",
"from",
"start",
"to",
"end"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L99-L103 | train |
gravitational/teleport | lib/backend/buffer.go | eventsCopy | func (c *CircularBuffer) eventsCopy() []Event {
if c.size == 0 {
return nil
}
var out []Event
for i := 0; i < c.size; i++ {
index := (c.start + i) % len(c.events)
if out == nil {
out = make([]Event, 0, c.size)
}
out = append(out, c.events[index])
}
return out
} | go | func (c *CircularBuffer) eventsCopy() []Event {
if c.size == 0 {
return nil
}
var out []Event
for i := 0; i < c.size; i++ {
index := (c.start + i) % len(c.events)
if out == nil {
out = make([]Event, 0, c.size)
}
out = append(out, c.events[index])
}
return out
} | [
"func",
"(",
"c",
"*",
"CircularBuffer",
")",
"eventsCopy",
"(",
")",
"[",
"]",
"Event",
"{",
"if",
"c",
".",
"size",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"out",
"[",
"]",
"Event",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"c",
".",
"size",
";",
"i",
"++",
"{",
"index",
":=",
"(",
"c",
".",
"start",
"+",
"i",
")",
"%",
"len",
"(",
"c",
".",
"events",
")",
"\n",
"if",
"out",
"==",
"nil",
"{",
"out",
"=",
"make",
"(",
"[",
"]",
"Event",
",",
"0",
",",
"c",
".",
"size",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"c",
".",
"events",
"[",
"index",
"]",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // eventsCopy returns a copy of events as arranged from start to end | [
"eventsCopy",
"returns",
"a",
"copy",
"of",
"events",
"as",
"arranged",
"from",
"start",
"to",
"end"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L106-L119 | train |
gravitational/teleport | lib/backend/buffer.go | PushBatch | func (c *CircularBuffer) PushBatch(events []Event) {
c.Lock()
defer c.Unlock()
for i := range events {
c.push(events[i])
}
} | go | func (c *CircularBuffer) PushBatch(events []Event) {
c.Lock()
defer c.Unlock()
for i := range events {
c.push(events[i])
}
} | [
"func",
"(",
"c",
"*",
"CircularBuffer",
")",
"PushBatch",
"(",
"events",
"[",
"]",
"Event",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"for",
"i",
":=",
"range",
"events",
"{",
"c",
".",
"push",
"(",
"events",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // PushBatch pushes elements to the queue as a batch | [
"PushBatch",
"pushes",
"elements",
"to",
"the",
"queue",
"as",
"a",
"batch"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L122-L129 | train |
gravitational/teleport | lib/backend/buffer.go | Push | func (c *CircularBuffer) Push(r Event) {
c.Lock()
defer c.Unlock()
c.push(r)
} | go | func (c *CircularBuffer) Push(r Event) {
c.Lock()
defer c.Unlock()
c.push(r)
} | [
"func",
"(",
"c",
"*",
"CircularBuffer",
")",
"Push",
"(",
"r",
"Event",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"c",
".",
"push",
"(",
"r",
")",
"\n",
"}"
] | // Push pushes elements to the queue | [
"Push",
"pushes",
"elements",
"to",
"the",
"queue"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L132-L136 | train |
gravitational/teleport | lib/backend/buffer.go | NewWatcher | func (c *CircularBuffer) NewWatcher(ctx context.Context, watch Watch) (Watcher, error) {
c.Lock()
defer c.Unlock()
select {
case <-c.ctx.Done():
return nil, trace.BadParameter("buffer is closed")
default:
}
if watch.QueueSize == 0 {
watch.QueueSize = len(c.events)
}
if len(watch.Prefixes) == 0 {
// if watcher has no prefixes, assume it will match anything
// starting from the separator (what includes all keys in backend invariant, see Keys function)
watch.Prefixes = append(watch.Prefixes, []byte{Separator})
} else {
// if watcher's prefixes are redundant, keep only shorter prefixes
// to avoid double fan out
watch.Prefixes = removeRedundantPrefixes(watch.Prefixes)
}
closeCtx, cancel := context.WithCancel(ctx)
w := &BufferWatcher{
Watch: watch,
eventsC: make(chan Event, watch.QueueSize),
ctx: closeCtx,
cancel: cancel,
capacity: watch.QueueSize,
}
c.Debugf("Add %v.", w)
select {
case w.eventsC <- Event{Type: OpInit}:
case <-c.ctx.Done():
return nil, trace.BadParameter("buffer is closed")
default:
c.Warningf("Closing %v, buffer overflow.", w)
w.Close()
return nil, trace.BadParameter("buffer overflow")
}
c.watchers.add(w)
return w, nil
} | go | func (c *CircularBuffer) NewWatcher(ctx context.Context, watch Watch) (Watcher, error) {
c.Lock()
defer c.Unlock()
select {
case <-c.ctx.Done():
return nil, trace.BadParameter("buffer is closed")
default:
}
if watch.QueueSize == 0 {
watch.QueueSize = len(c.events)
}
if len(watch.Prefixes) == 0 {
// if watcher has no prefixes, assume it will match anything
// starting from the separator (what includes all keys in backend invariant, see Keys function)
watch.Prefixes = append(watch.Prefixes, []byte{Separator})
} else {
// if watcher's prefixes are redundant, keep only shorter prefixes
// to avoid double fan out
watch.Prefixes = removeRedundantPrefixes(watch.Prefixes)
}
closeCtx, cancel := context.WithCancel(ctx)
w := &BufferWatcher{
Watch: watch,
eventsC: make(chan Event, watch.QueueSize),
ctx: closeCtx,
cancel: cancel,
capacity: watch.QueueSize,
}
c.Debugf("Add %v.", w)
select {
case w.eventsC <- Event{Type: OpInit}:
case <-c.ctx.Done():
return nil, trace.BadParameter("buffer is closed")
default:
c.Warningf("Closing %v, buffer overflow.", w)
w.Close()
return nil, trace.BadParameter("buffer overflow")
}
c.watchers.add(w)
return w, nil
} | [
"func",
"(",
"c",
"*",
"CircularBuffer",
")",
"NewWatcher",
"(",
"ctx",
"context",
".",
"Context",
",",
"watch",
"Watch",
")",
"(",
"Watcher",
",",
"error",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n\n",
"select",
"{",
"case",
"<-",
"c",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"}",
"\n\n",
"if",
"watch",
".",
"QueueSize",
"==",
"0",
"{",
"watch",
".",
"QueueSize",
"=",
"len",
"(",
"c",
".",
"events",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"watch",
".",
"Prefixes",
")",
"==",
"0",
"{",
"// if watcher has no prefixes, assume it will match anything",
"// starting from the separator (what includes all keys in backend invariant, see Keys function)",
"watch",
".",
"Prefixes",
"=",
"append",
"(",
"watch",
".",
"Prefixes",
",",
"[",
"]",
"byte",
"{",
"Separator",
"}",
")",
"\n",
"}",
"else",
"{",
"// if watcher's prefixes are redundant, keep only shorter prefixes",
"// to avoid double fan out",
"watch",
".",
"Prefixes",
"=",
"removeRedundantPrefixes",
"(",
"watch",
".",
"Prefixes",
")",
"\n",
"}",
"\n\n",
"closeCtx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"w",
":=",
"&",
"BufferWatcher",
"{",
"Watch",
":",
"watch",
",",
"eventsC",
":",
"make",
"(",
"chan",
"Event",
",",
"watch",
".",
"QueueSize",
")",
",",
"ctx",
":",
"closeCtx",
",",
"cancel",
":",
"cancel",
",",
"capacity",
":",
"watch",
".",
"QueueSize",
",",
"}",
"\n",
"c",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"w",
")",
"\n",
"select",
"{",
"case",
"w",
".",
"eventsC",
"<-",
"Event",
"{",
"Type",
":",
"OpInit",
"}",
":",
"case",
"<-",
"c",
".",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"c",
".",
"Warningf",
"(",
"\"",
"\"",
",",
"w",
")",
"\n",
"w",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"c",
".",
"watchers",
".",
"add",
"(",
"w",
")",
"\n",
"return",
"w",
",",
"nil",
"\n",
"}"
] | // NewWatcher adds a new watcher to the events buffer | [
"NewWatcher",
"adds",
"a",
"new",
"watcher",
"to",
"the",
"events",
"buffer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L203-L247 | train |
gravitational/teleport | lib/backend/buffer.go | String | func (w *BufferWatcher) String() string {
return fmt.Sprintf("Watcher(name=%v, prefixes=%v, capacity=%v, size=%v)", w.Name, string(bytes.Join(w.Prefixes, []byte(", "))), w.capacity, len(w.eventsC))
} | go | func (w *BufferWatcher) String() string {
return fmt.Sprintf("Watcher(name=%v, prefixes=%v, capacity=%v, size=%v)", w.Name, string(bytes.Join(w.Prefixes, []byte(", "))), w.capacity, len(w.eventsC))
} | [
"func",
"(",
"w",
"*",
"BufferWatcher",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"w",
".",
"Name",
",",
"string",
"(",
"bytes",
".",
"Join",
"(",
"w",
".",
"Prefixes",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
")",
")",
",",
"w",
".",
"capacity",
",",
"len",
"(",
"w",
".",
"eventsC",
")",
")",
"\n",
"}"
] | // String returns user-friendly representation
// of the buffer watcher | [
"String",
"returns",
"user",
"-",
"friendly",
"representation",
"of",
"the",
"buffer",
"watcher"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L268-L270 | train |
gravitational/teleport | lib/backend/buffer.go | add | func (t *watcherTree) add(w *BufferWatcher) {
for _, p := range w.Prefixes {
prefix := string(p)
val, ok := t.Tree.Get(prefix)
var watchers []*BufferWatcher
if ok {
watchers = val.([]*BufferWatcher)
}
watchers = append(watchers, w)
t.Tree.Insert(prefix, watchers)
}
} | go | func (t *watcherTree) add(w *BufferWatcher) {
for _, p := range w.Prefixes {
prefix := string(p)
val, ok := t.Tree.Get(prefix)
var watchers []*BufferWatcher
if ok {
watchers = val.([]*BufferWatcher)
}
watchers = append(watchers, w)
t.Tree.Insert(prefix, watchers)
}
} | [
"func",
"(",
"t",
"*",
"watcherTree",
")",
"add",
"(",
"w",
"*",
"BufferWatcher",
")",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"w",
".",
"Prefixes",
"{",
"prefix",
":=",
"string",
"(",
"p",
")",
"\n",
"val",
",",
"ok",
":=",
"t",
".",
"Tree",
".",
"Get",
"(",
"prefix",
")",
"\n",
"var",
"watchers",
"[",
"]",
"*",
"BufferWatcher",
"\n",
"if",
"ok",
"{",
"watchers",
"=",
"val",
".",
"(",
"[",
"]",
"*",
"BufferWatcher",
")",
"\n",
"}",
"\n",
"watchers",
"=",
"append",
"(",
"watchers",
",",
"w",
")",
"\n",
"t",
".",
"Tree",
".",
"Insert",
"(",
"prefix",
",",
"watchers",
")",
"\n",
"}",
"\n",
"}"
] | // add adds buffer watcher to the tree | [
"add",
"adds",
"buffer",
"watcher",
"to",
"the",
"tree"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L300-L311 | train |
gravitational/teleport | lib/backend/buffer.go | rm | func (t *watcherTree) rm(w *BufferWatcher) bool {
if w == nil {
return false
}
var found bool
for _, p := range w.Prefixes {
prefix := string(p)
val, ok := t.Tree.Get(prefix)
if !ok {
continue
}
buffers := val.([]*BufferWatcher)
prevLen := len(buffers)
for i := range buffers {
if buffers[i] == w {
buffers = append(buffers[:i], buffers[i+1:]...)
found = true
break
}
}
if len(buffers) == 0 {
t.Tree.Delete(prefix)
} else if len(buffers) != prevLen {
t.Tree.Insert(prefix, buffers)
}
}
return found
} | go | func (t *watcherTree) rm(w *BufferWatcher) bool {
if w == nil {
return false
}
var found bool
for _, p := range w.Prefixes {
prefix := string(p)
val, ok := t.Tree.Get(prefix)
if !ok {
continue
}
buffers := val.([]*BufferWatcher)
prevLen := len(buffers)
for i := range buffers {
if buffers[i] == w {
buffers = append(buffers[:i], buffers[i+1:]...)
found = true
break
}
}
if len(buffers) == 0 {
t.Tree.Delete(prefix)
} else if len(buffers) != prevLen {
t.Tree.Insert(prefix, buffers)
}
}
return found
} | [
"func",
"(",
"t",
"*",
"watcherTree",
")",
"rm",
"(",
"w",
"*",
"BufferWatcher",
")",
"bool",
"{",
"if",
"w",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"var",
"found",
"bool",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"w",
".",
"Prefixes",
"{",
"prefix",
":=",
"string",
"(",
"p",
")",
"\n",
"val",
",",
"ok",
":=",
"t",
".",
"Tree",
".",
"Get",
"(",
"prefix",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"buffers",
":=",
"val",
".",
"(",
"[",
"]",
"*",
"BufferWatcher",
")",
"\n",
"prevLen",
":=",
"len",
"(",
"buffers",
")",
"\n",
"for",
"i",
":=",
"range",
"buffers",
"{",
"if",
"buffers",
"[",
"i",
"]",
"==",
"w",
"{",
"buffers",
"=",
"append",
"(",
"buffers",
"[",
":",
"i",
"]",
",",
"buffers",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"buffers",
")",
"==",
"0",
"{",
"t",
".",
"Tree",
".",
"Delete",
"(",
"prefix",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"buffers",
")",
"!=",
"prevLen",
"{",
"t",
".",
"Tree",
".",
"Insert",
"(",
"prefix",
",",
"buffers",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"found",
"\n",
"}"
] | // rm removes the buffer watcher from the prefix tree | [
"rm",
"removes",
"the",
"buffer",
"watcher",
"from",
"the",
"prefix",
"tree"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L314-L341 | train |
gravitational/teleport | lib/backend/buffer.go | walkPath | func (t *watcherTree) walkPath(key string, fn walkFn) {
t.Tree.WalkPath(key, func(prefix string, val interface{}) bool {
watchers := val.([]*BufferWatcher)
for _, w := range watchers {
fn(w)
}
return false
})
} | go | func (t *watcherTree) walkPath(key string, fn walkFn) {
t.Tree.WalkPath(key, func(prefix string, val interface{}) bool {
watchers := val.([]*BufferWatcher)
for _, w := range watchers {
fn(w)
}
return false
})
} | [
"func",
"(",
"t",
"*",
"watcherTree",
")",
"walkPath",
"(",
"key",
"string",
",",
"fn",
"walkFn",
")",
"{",
"t",
".",
"Tree",
".",
"WalkPath",
"(",
"key",
",",
"func",
"(",
"prefix",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"bool",
"{",
"watchers",
":=",
"val",
".",
"(",
"[",
"]",
"*",
"BufferWatcher",
")",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"watchers",
"{",
"fn",
"(",
"w",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
")",
"\n",
"}"
] | // walkPath walks the tree above the longest matching prefix
// and calls fn callback for every buffer watcher | [
"walkPath",
"walks",
"the",
"tree",
"above",
"the",
"longest",
"matching",
"prefix",
"and",
"calls",
"fn",
"callback",
"for",
"every",
"buffer",
"watcher"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L348-L356 | train |
gravitational/teleport | lib/backend/buffer.go | walk | func (t *watcherTree) walk(fn walkFn) {
t.Tree.Walk(func(prefix string, val interface{}) bool {
watchers := val.([]*BufferWatcher)
for _, w := range watchers {
fn(w)
}
return false
})
} | go | func (t *watcherTree) walk(fn walkFn) {
t.Tree.Walk(func(prefix string, val interface{}) bool {
watchers := val.([]*BufferWatcher)
for _, w := range watchers {
fn(w)
}
return false
})
} | [
"func",
"(",
"t",
"*",
"watcherTree",
")",
"walk",
"(",
"fn",
"walkFn",
")",
"{",
"t",
".",
"Tree",
".",
"Walk",
"(",
"func",
"(",
"prefix",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"bool",
"{",
"watchers",
":=",
"val",
".",
"(",
"[",
"]",
"*",
"BufferWatcher",
")",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"watchers",
"{",
"fn",
"(",
"w",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
")",
"\n",
"}"
] | // walk calls fn for every matching leaf of the tree | [
"walk",
"calls",
"fn",
"for",
"every",
"matching",
"leaf",
"of",
"the",
"tree"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/buffer.go#L359-L367 | train |
gravitational/teleport | lib/kube/client/kubeclient.go | UpdateKubeconfig | func UpdateKubeconfig(tc *client.TeleportClient) error {
config, err := LoadKubeConfig()
if err != nil {
return trace.Wrap(err)
}
clusterName, proxyPort := tc.KubeProxyHostPort()
var clusterAddr string
if tc.SiteName != "" {
// In case of a remote cluster, use SNI subdomain to "point" to a remote cluster name
clusterAddr = fmt.Sprintf("https://%v.%v:%v",
kubeutils.EncodeClusterName(tc.SiteName), clusterName, proxyPort)
clusterName = tc.SiteName
} else {
clusterAddr = fmt.Sprintf("https://%v:%v", clusterName, proxyPort)
}
creds, err := tc.LocalAgent().GetKey()
if err != nil {
return trace.Wrap(err)
}
certAuthorities, err := tc.LocalAgent().GetCertsPEM()
if err != nil {
return trace.Wrap(err)
}
config.AuthInfos[clusterName] = &clientcmdapi.AuthInfo{
ClientCertificateData: creds.TLSCert,
ClientKeyData: creds.Priv,
}
config.Clusters[clusterName] = &clientcmdapi.Cluster{
Server: clusterAddr,
CertificateAuthorityData: certAuthorities,
}
lastContext := config.Contexts[clusterName]
newContext := &clientcmdapi.Context{
Cluster: clusterName,
AuthInfo: clusterName,
}
if lastContext != nil {
newContext.Namespace = lastContext.Namespace
newContext.Extensions = lastContext.Extensions
}
config.Contexts[clusterName] = newContext
config.CurrentContext = clusterName
return SaveKubeConfig(*config)
} | go | func UpdateKubeconfig(tc *client.TeleportClient) error {
config, err := LoadKubeConfig()
if err != nil {
return trace.Wrap(err)
}
clusterName, proxyPort := tc.KubeProxyHostPort()
var clusterAddr string
if tc.SiteName != "" {
// In case of a remote cluster, use SNI subdomain to "point" to a remote cluster name
clusterAddr = fmt.Sprintf("https://%v.%v:%v",
kubeutils.EncodeClusterName(tc.SiteName), clusterName, proxyPort)
clusterName = tc.SiteName
} else {
clusterAddr = fmt.Sprintf("https://%v:%v", clusterName, proxyPort)
}
creds, err := tc.LocalAgent().GetKey()
if err != nil {
return trace.Wrap(err)
}
certAuthorities, err := tc.LocalAgent().GetCertsPEM()
if err != nil {
return trace.Wrap(err)
}
config.AuthInfos[clusterName] = &clientcmdapi.AuthInfo{
ClientCertificateData: creds.TLSCert,
ClientKeyData: creds.Priv,
}
config.Clusters[clusterName] = &clientcmdapi.Cluster{
Server: clusterAddr,
CertificateAuthorityData: certAuthorities,
}
lastContext := config.Contexts[clusterName]
newContext := &clientcmdapi.Context{
Cluster: clusterName,
AuthInfo: clusterName,
}
if lastContext != nil {
newContext.Namespace = lastContext.Namespace
newContext.Extensions = lastContext.Extensions
}
config.Contexts[clusterName] = newContext
config.CurrentContext = clusterName
return SaveKubeConfig(*config)
} | [
"func",
"UpdateKubeconfig",
"(",
"tc",
"*",
"client",
".",
"TeleportClient",
")",
"error",
"{",
"config",
",",
"err",
":=",
"LoadKubeConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"clusterName",
",",
"proxyPort",
":=",
"tc",
".",
"KubeProxyHostPort",
"(",
")",
"\n",
"var",
"clusterAddr",
"string",
"\n",
"if",
"tc",
".",
"SiteName",
"!=",
"\"",
"\"",
"{",
"// In case of a remote cluster, use SNI subdomain to \"point\" to a remote cluster name",
"clusterAddr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"kubeutils",
".",
"EncodeClusterName",
"(",
"tc",
".",
"SiteName",
")",
",",
"clusterName",
",",
"proxyPort",
")",
"\n",
"clusterName",
"=",
"tc",
".",
"SiteName",
"\n",
"}",
"else",
"{",
"clusterAddr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"clusterName",
",",
"proxyPort",
")",
"\n",
"}",
"\n\n",
"creds",
",",
"err",
":=",
"tc",
".",
"LocalAgent",
"(",
")",
".",
"GetKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certAuthorities",
",",
"err",
":=",
"tc",
".",
"LocalAgent",
"(",
")",
".",
"GetCertsPEM",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"config",
".",
"AuthInfos",
"[",
"clusterName",
"]",
"=",
"&",
"clientcmdapi",
".",
"AuthInfo",
"{",
"ClientCertificateData",
":",
"creds",
".",
"TLSCert",
",",
"ClientKeyData",
":",
"creds",
".",
"Priv",
",",
"}",
"\n",
"config",
".",
"Clusters",
"[",
"clusterName",
"]",
"=",
"&",
"clientcmdapi",
".",
"Cluster",
"{",
"Server",
":",
"clusterAddr",
",",
"CertificateAuthorityData",
":",
"certAuthorities",
",",
"}",
"\n\n",
"lastContext",
":=",
"config",
".",
"Contexts",
"[",
"clusterName",
"]",
"\n",
"newContext",
":=",
"&",
"clientcmdapi",
".",
"Context",
"{",
"Cluster",
":",
"clusterName",
",",
"AuthInfo",
":",
"clusterName",
",",
"}",
"\n",
"if",
"lastContext",
"!=",
"nil",
"{",
"newContext",
".",
"Namespace",
"=",
"lastContext",
".",
"Namespace",
"\n",
"newContext",
".",
"Extensions",
"=",
"lastContext",
".",
"Extensions",
"\n",
"}",
"\n",
"config",
".",
"Contexts",
"[",
"clusterName",
"]",
"=",
"newContext",
"\n",
"config",
".",
"CurrentContext",
"=",
"clusterName",
"\n",
"return",
"SaveKubeConfig",
"(",
"*",
"config",
")",
"\n",
"}"
] | // UpdateKubeconfig adds Teleport configuration to kubeconfig. | [
"UpdateKubeconfig",
"adds",
"Teleport",
"configuration",
"to",
"kubeconfig",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/client/kubeclient.go#L26-L73 | train |
gravitational/teleport | lib/kube/client/kubeclient.go | RemoveKubeconifg | func RemoveKubeconifg(tc *client.TeleportClient, clusterName string) error {
// Load existing kubeconfig from disk.
config, err := LoadKubeConfig()
if err != nil {
return trace.Wrap(err)
}
// Remove Teleport related AuthInfos, Clusters, and Contexts from kubeconfig.
delete(config.AuthInfos, clusterName)
delete(config.Clusters, clusterName)
delete(config.Contexts, clusterName)
// Take an element from the list of contexts and make it the current context.
if len(config.Contexts) > 0 {
var currentContext *clientcmdapi.Context
for _, cc := range config.Contexts {
currentContext = cc
break
}
config.CurrentContext = currentContext.Cluster
}
// Update kubeconfig on disk.
return SaveKubeConfig(*config)
} | go | func RemoveKubeconifg(tc *client.TeleportClient, clusterName string) error {
// Load existing kubeconfig from disk.
config, err := LoadKubeConfig()
if err != nil {
return trace.Wrap(err)
}
// Remove Teleport related AuthInfos, Clusters, and Contexts from kubeconfig.
delete(config.AuthInfos, clusterName)
delete(config.Clusters, clusterName)
delete(config.Contexts, clusterName)
// Take an element from the list of contexts and make it the current context.
if len(config.Contexts) > 0 {
var currentContext *clientcmdapi.Context
for _, cc := range config.Contexts {
currentContext = cc
break
}
config.CurrentContext = currentContext.Cluster
}
// Update kubeconfig on disk.
return SaveKubeConfig(*config)
} | [
"func",
"RemoveKubeconifg",
"(",
"tc",
"*",
"client",
".",
"TeleportClient",
",",
"clusterName",
"string",
")",
"error",
"{",
"// Load existing kubeconfig from disk.",
"config",
",",
"err",
":=",
"LoadKubeConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Remove Teleport related AuthInfos, Clusters, and Contexts from kubeconfig.",
"delete",
"(",
"config",
".",
"AuthInfos",
",",
"clusterName",
")",
"\n",
"delete",
"(",
"config",
".",
"Clusters",
",",
"clusterName",
")",
"\n",
"delete",
"(",
"config",
".",
"Contexts",
",",
"clusterName",
")",
"\n\n",
"// Take an element from the list of contexts and make it the current context.",
"if",
"len",
"(",
"config",
".",
"Contexts",
")",
">",
"0",
"{",
"var",
"currentContext",
"*",
"clientcmdapi",
".",
"Context",
"\n",
"for",
"_",
",",
"cc",
":=",
"range",
"config",
".",
"Contexts",
"{",
"currentContext",
"=",
"cc",
"\n",
"break",
"\n",
"}",
"\n",
"config",
".",
"CurrentContext",
"=",
"currentContext",
".",
"Cluster",
"\n",
"}",
"\n\n",
"// Update kubeconfig on disk.",
"return",
"SaveKubeConfig",
"(",
"*",
"config",
")",
"\n",
"}"
] | // RemoveKubeconifg removes Teleport configuration from kubeconfig. | [
"RemoveKubeconifg",
"removes",
"Teleport",
"configuration",
"from",
"kubeconfig",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/client/kubeclient.go#L76-L100 | train |
gravitational/teleport | lib/kube/client/kubeclient.go | LoadKubeConfig | func LoadKubeConfig() (*clientcmdapi.Config, error) {
filename, err := utils.EnsureLocalPath(
kubeconfigFromEnv(),
teleport.KubeConfigDir,
teleport.KubeConfigFile)
if err != nil {
return nil, trace.Wrap(err)
}
config, err := clientcmd.LoadFromFile(filename)
if err != nil && !os.IsNotExist(err) {
return nil, trace.ConvertSystemError(err)
}
if config == nil {
config = clientcmdapi.NewConfig()
}
return config, nil
} | go | func LoadKubeConfig() (*clientcmdapi.Config, error) {
filename, err := utils.EnsureLocalPath(
kubeconfigFromEnv(),
teleport.KubeConfigDir,
teleport.KubeConfigFile)
if err != nil {
return nil, trace.Wrap(err)
}
config, err := clientcmd.LoadFromFile(filename)
if err != nil && !os.IsNotExist(err) {
return nil, trace.ConvertSystemError(err)
}
if config == nil {
config = clientcmdapi.NewConfig()
}
return config, nil
} | [
"func",
"LoadKubeConfig",
"(",
")",
"(",
"*",
"clientcmdapi",
".",
"Config",
",",
"error",
")",
"{",
"filename",
",",
"err",
":=",
"utils",
".",
"EnsureLocalPath",
"(",
"kubeconfigFromEnv",
"(",
")",
",",
"teleport",
".",
"KubeConfigDir",
",",
"teleport",
".",
"KubeConfigFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"config",
",",
"err",
":=",
"clientcmd",
".",
"LoadFromFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"config",
"==",
"nil",
"{",
"config",
"=",
"clientcmdapi",
".",
"NewConfig",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] | // LoadKubeconfig tries to read a kubeconfig file and if it can't, returns an error.
// One exception, missing files result in empty configs, not an error. | [
"LoadKubeconfig",
"tries",
"to",
"read",
"a",
"kubeconfig",
"file",
"and",
"if",
"it",
"can",
"t",
"returns",
"an",
"error",
".",
"One",
"exception",
"missing",
"files",
"result",
"in",
"empty",
"configs",
"not",
"an",
"error",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/client/kubeclient.go#L104-L121 | train |
gravitational/teleport | lib/kube/client/kubeclient.go | SaveKubeConfig | func SaveKubeConfig(config clientcmdapi.Config) error {
filename, err := utils.EnsureLocalPath(
kubeconfigFromEnv(),
teleport.KubeConfigDir,
teleport.KubeConfigFile)
if err != nil {
return trace.Wrap(err)
}
err = clientcmd.WriteToFile(config, filename)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | func SaveKubeConfig(config clientcmdapi.Config) error {
filename, err := utils.EnsureLocalPath(
kubeconfigFromEnv(),
teleport.KubeConfigDir,
teleport.KubeConfigFile)
if err != nil {
return trace.Wrap(err)
}
err = clientcmd.WriteToFile(config, filename)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"SaveKubeConfig",
"(",
"config",
"clientcmdapi",
".",
"Config",
")",
"error",
"{",
"filename",
",",
"err",
":=",
"utils",
".",
"EnsureLocalPath",
"(",
"kubeconfigFromEnv",
"(",
")",
",",
"teleport",
".",
"KubeConfigDir",
",",
"teleport",
".",
"KubeConfigFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"clientcmd",
".",
"WriteToFile",
"(",
"config",
",",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SaveKubeConfig saves updated config to location specified by environment variable or
// default location | [
"SaveKubeConfig",
"saves",
"updated",
"config",
"to",
"location",
"specified",
"by",
"environment",
"variable",
"or",
"default",
"location"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/client/kubeclient.go#L125-L139 | train |
gravitational/teleport | lib/kube/client/kubeclient.go | kubeconfigFromEnv | func kubeconfigFromEnv() string {
kubeconfig := os.Getenv(teleport.EnvKubeConfig)
// The KUBECONFIG environment variable is a list. On Windows it's
// semicolon-delimited. On Linux and macOS it's colon-delimited.
var parts []string
switch runtime.GOOS {
case teleport.WindowsOS:
parts = strings.Split(kubeconfig, ";")
default:
parts = strings.Split(kubeconfig, ":")
}
// Default behavior of kubectl is to return the first file from list.
var configpath string
if len(parts) > 0 {
configpath = parts[0]
}
log.Debugf("Found kubeconfig in environment at '%v'.", configpath)
return configpath
} | go | func kubeconfigFromEnv() string {
kubeconfig := os.Getenv(teleport.EnvKubeConfig)
// The KUBECONFIG environment variable is a list. On Windows it's
// semicolon-delimited. On Linux and macOS it's colon-delimited.
var parts []string
switch runtime.GOOS {
case teleport.WindowsOS:
parts = strings.Split(kubeconfig, ";")
default:
parts = strings.Split(kubeconfig, ":")
}
// Default behavior of kubectl is to return the first file from list.
var configpath string
if len(parts) > 0 {
configpath = parts[0]
}
log.Debugf("Found kubeconfig in environment at '%v'.", configpath)
return configpath
} | [
"func",
"kubeconfigFromEnv",
"(",
")",
"string",
"{",
"kubeconfig",
":=",
"os",
".",
"Getenv",
"(",
"teleport",
".",
"EnvKubeConfig",
")",
"\n\n",
"// The KUBECONFIG environment variable is a list. On Windows it's",
"// semicolon-delimited. On Linux and macOS it's colon-delimited.",
"var",
"parts",
"[",
"]",
"string",
"\n",
"switch",
"runtime",
".",
"GOOS",
"{",
"case",
"teleport",
".",
"WindowsOS",
":",
"parts",
"=",
"strings",
".",
"Split",
"(",
"kubeconfig",
",",
"\"",
"\"",
")",
"\n",
"default",
":",
"parts",
"=",
"strings",
".",
"Split",
"(",
"kubeconfig",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Default behavior of kubectl is to return the first file from list.",
"var",
"configpath",
"string",
"\n",
"if",
"len",
"(",
"parts",
")",
">",
"0",
"{",
"configpath",
"=",
"parts",
"[",
"0",
"]",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"configpath",
")",
"\n\n",
"return",
"configpath",
"\n",
"}"
] | // kubeconfigFromEnv extracts location of kubeconfig from the environment. | [
"kubeconfigFromEnv",
"extracts",
"location",
"of",
"kubeconfig",
"from",
"the",
"environment",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/client/kubeclient.go#L142-L163 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.