repo
stringlengths 5
67
| path
stringlengths 4
218
| func_name
stringlengths 0
151
| original_string
stringlengths 52
373k
| language
stringclasses 6
values | code
stringlengths 52
373k
| code_tokens
listlengths 10
512
| docstring
stringlengths 3
47.2k
| docstring_tokens
listlengths 3
234
| sha
stringlengths 40
40
| url
stringlengths 85
339
| partition
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport
|
lib/services/local/presence.go
|
GetReverseTunnels
|
func (s *PresenceService) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
startKey := backend.Key(reverseTunnelsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(result.Items))
for i, item := range result.Items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(
item.Value, services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
// sorting helps with tests and makes it all deterministic
sort.Sort(services.SortedReverseTunnels(tunnels))
return tunnels, nil
}
|
go
|
func (s *PresenceService) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
startKey := backend.Key(reverseTunnelsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(result.Items))
for i, item := range result.Items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(
item.Value, services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
// sorting helps with tests and makes it all deterministic
sort.Sort(services.SortedReverseTunnels(tunnels))
return tunnels, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetReverseTunnels",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"ReverseTunnel",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tunnels",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"ReverseTunnel",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"tunnel",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"UnmarshalReverseTunnel",
"(",
"item",
".",
"Value",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tunnels",
"[",
"i",
"]",
"=",
"tunnel",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedReverseTunnels",
"(",
"tunnels",
")",
")",
"\n",
"return",
"tunnels",
",",
"nil",
"\n",
"}"
] |
// GetReverseTunnels returns a list of registered servers
|
[
"GetReverseTunnels",
"returns",
"a",
"list",
"of",
"registered",
"servers"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L385-L403
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteReverseTunnel
|
func (s *PresenceService) DeleteReverseTunnel(clusterName string) error {
err := s.Delete(context.TODO(), backend.Key(reverseTunnelsPrefix, clusterName))
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) DeleteReverseTunnel(clusterName string) error {
err := s.Delete(context.TODO(), backend.Key(reverseTunnelsPrefix, clusterName))
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteReverseTunnel",
"(",
"clusterName",
"string",
")",
"error",
"{",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
",",
"clusterName",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// DeleteReverseTunnel deletes reverse tunnel by it's cluster name
|
[
"DeleteReverseTunnel",
"deletes",
"reverse",
"tunnel",
"by",
"it",
"s",
"cluster",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L406-L409
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertTrustedCluster
|
func (s *PresenceService) UpsertTrustedCluster(trustedCluster services.TrustedCluster) (services.TrustedCluster, error) {
if err := trustedCluster.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
value, err := services.GetTrustedClusterMarshaler().Marshal(trustedCluster)
if err != nil {
return nil, trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(trustedClustersPrefix, trustedCluster.GetName()),
Value: value,
Expires: trustedCluster.Expiry(),
ID: trustedCluster.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
return trustedCluster, nil
}
|
go
|
func (s *PresenceService) UpsertTrustedCluster(trustedCluster services.TrustedCluster) (services.TrustedCluster, error) {
if err := trustedCluster.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
value, err := services.GetTrustedClusterMarshaler().Marshal(trustedCluster)
if err != nil {
return nil, trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(trustedClustersPrefix, trustedCluster.GetName()),
Value: value,
Expires: trustedCluster.Expiry(),
ID: trustedCluster.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
return trustedCluster, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertTrustedCluster",
"(",
"trustedCluster",
"services",
".",
"TrustedCluster",
")",
"(",
"services",
".",
"TrustedCluster",
",",
"error",
")",
"{",
"if",
"err",
":=",
"trustedCluster",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Marshal",
"(",
"trustedCluster",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
",",
"trustedCluster",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"trustedCluster",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"trustedCluster",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"trustedCluster",
",",
"nil",
"\n",
"}"
] |
// UpsertTrustedCluster creates or updates a TrustedCluster in the backend.
|
[
"UpsertTrustedCluster",
"creates",
"or",
"updates",
"a",
"TrustedCluster",
"in",
"the",
"backend",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L412-L430
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetTrustedCluster
|
func (s *PresenceService) GetTrustedCluster(name string) (services.TrustedCluster, error) {
if name == "" {
return nil, trace.BadParameter("missing trusted cluster name")
}
item, err := s.Get(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetTrustedClusterMarshaler().Unmarshal(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
}
|
go
|
func (s *PresenceService) GetTrustedCluster(name string) (services.TrustedCluster, error) {
if name == "" {
return nil, trace.BadParameter("missing trusted cluster name")
}
item, err := s.Get(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetTrustedClusterMarshaler().Unmarshal(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTrustedCluster",
"(",
"name",
"string",
")",
"(",
"services",
".",
"TrustedCluster",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing trusted cluster name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"}"
] |
// GetTrustedCluster returns a single TrustedCluster by name.
|
[
"GetTrustedCluster",
"returns",
"a",
"single",
"TrustedCluster",
"by",
"name",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L433-L442
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetTrustedClusters
|
func (s *PresenceService) GetTrustedClusters() ([]services.TrustedCluster, error) {
startKey := backend.Key(trustedClustersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.TrustedCluster, len(result.Items))
for i, item := range result.Items {
tc, err := services.GetTrustedClusterMarshaler().Unmarshal(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out[i] = tc
}
sort.Sort(services.SortedTrustedCluster(out))
return out, nil
}
|
go
|
func (s *PresenceService) GetTrustedClusters() ([]services.TrustedCluster, error) {
startKey := backend.Key(trustedClustersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.TrustedCluster, len(result.Items))
for i, item := range result.Items {
tc, err := services.GetTrustedClusterMarshaler().Unmarshal(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out[i] = tc
}
sort.Sort(services.SortedTrustedCluster(out))
return out, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTrustedClusters",
"(",
")",
"(",
"[",
"]",
"services",
".",
"TrustedCluster",
",",
"error",
")",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"TrustedCluster",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"tc",
",",
"err",
":=",
"services",
".",
"GetTrustedClusterMarshaler",
"(",
")",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"[",
"i",
"]",
"=",
"tc",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"services",
".",
"SortedTrustedCluster",
"(",
"out",
")",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// GetTrustedClusters returns all TrustedClusters in the backend.
|
[
"GetTrustedClusters",
"returns",
"all",
"TrustedClusters",
"in",
"the",
"backend",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L445-L463
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteTrustedCluster
|
func (s *PresenceService) DeleteTrustedCluster(name string) error {
if name == "" {
return trace.BadParameter("missing trusted cluster name")
}
err := s.Delete(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("trusted cluster %q is not found", name)
}
}
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) DeleteTrustedCluster(name string) error {
if name == "" {
return trace.BadParameter("missing trusted cluster name")
}
err := s.Delete(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("trusted cluster %q is not found", name)
}
}
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteTrustedCluster",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing trusted cluster name\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"trustedClustersPrefix",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"trusted cluster %q is not found\"",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// DeleteTrustedCluster removes a TrustedCluster from the backend by name.
|
[
"DeleteTrustedCluster",
"removes",
"a",
"TrustedCluster",
"from",
"the",
"backend",
"by",
"name",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L466-L477
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertTunnelConnection
|
func (s *PresenceService) UpsertTunnelConnection(conn services.TunnelConnection) error {
if err := conn.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(tunnelConnectionsPrefix, conn.GetClusterName(), conn.GetName()),
Value: value,
Expires: conn.Expiry(),
ID: conn.GetResourceID(),
})
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *PresenceService) UpsertTunnelConnection(conn services.TunnelConnection) error {
if err := conn.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(tunnelConnectionsPrefix, conn.GetClusterName(), conn.GetName()),
Value: value,
Expires: conn.Expiry(),
ID: conn.GetResourceID(),
})
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertTunnelConnection",
"(",
"conn",
"services",
".",
"TunnelConnection",
")",
"error",
"{",
"if",
"err",
":=",
"conn",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"MarshalTunnelConnection",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"conn",
".",
"GetClusterName",
"(",
")",
",",
"conn",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"conn",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"conn",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UpsertTunnelConnection updates or creates tunnel connection
|
[
"UpsertTunnelConnection",
"updates",
"or",
"creates",
"tunnel",
"connection"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L480-L498
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetTunnelConnection
|
func (s *PresenceService) GetTunnelConnection(clusterName, connectionName string, opts ...services.MarshalOption) (services.TunnelConnection, error) {
item, err := s.Get(context.TODO(), backend.Key(tunnelConnectionsPrefix, clusterName, connectionName))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("trusted cluster connection %q is not found", connectionName)
}
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
}
|
go
|
func (s *PresenceService) GetTunnelConnection(clusterName, connectionName string, opts ...services.MarshalOption) (services.TunnelConnection, error) {
item, err := s.Get(context.TODO(), backend.Key(tunnelConnectionsPrefix, clusterName, connectionName))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("trusted cluster connection %q is not found", connectionName)
}
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTunnelConnection",
"(",
"clusterName",
",",
"connectionName",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"TunnelConnection",
",",
"error",
")",
"{",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"clusterName",
",",
"connectionName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"trusted cluster connection %q is not found\"",
",",
"connectionName",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalTunnelConnection",
"(",
"item",
".",
"Value",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] |
// GetTunnelConnection returns connection by cluster name and connection name
|
[
"GetTunnelConnection",
"returns",
"connection",
"by",
"cluster",
"name",
"and",
"connection",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L501-L515
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetTunnelConnections
|
func (s *PresenceService) GetTunnelConnections(clusterName string, opts ...services.MarshalOption) ([]services.TunnelConnection, error) {
if clusterName == "" {
return nil, trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
conns := make([]services.TunnelConnection, len(result.Items))
for i, item := range result.Items {
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
conns[i] = conn
}
return conns, nil
}
|
go
|
func (s *PresenceService) GetTunnelConnections(clusterName string, opts ...services.MarshalOption) ([]services.TunnelConnection, error) {
if clusterName == "" {
return nil, trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
conns := make([]services.TunnelConnection, len(result.Items))
for i, item := range result.Items {
conn, err := services.UnmarshalTunnelConnection(item.Value,
services.AddOptions(opts, services.WithResourceID(item.ID), services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
conns[i] = conn
}
return conns, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetTunnelConnections",
"(",
"clusterName",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"TunnelConnection",
",",
"error",
")",
"{",
"if",
"clusterName",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing cluster name\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"clusterName",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conns",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"TunnelConnection",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalTunnelConnection",
"(",
"item",
".",
"Value",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conns",
"[",
"i",
"]",
"=",
"conn",
"\n",
"}",
"\n",
"return",
"conns",
",",
"nil",
"\n",
"}"
] |
// GetTunnelConnections returns connections for a trusted cluster
|
[
"GetTunnelConnections",
"returns",
"connections",
"for",
"a",
"trusted",
"cluster"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L518-L538
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteTunnelConnections
|
func (s *PresenceService) DeleteTunnelConnections(clusterName string) error {
if clusterName == "" {
return trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) DeleteTunnelConnections(clusterName string) error {
if clusterName == "" {
return trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteTunnelConnections",
"(",
"clusterName",
"string",
")",
"error",
"{",
"if",
"clusterName",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing cluster name\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
",",
"clusterName",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// DeleteTunnelConnections deletes all tunnel connections for cluster
|
[
"DeleteTunnelConnections",
"deletes",
"all",
"tunnel",
"connections",
"for",
"cluster"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L575-L582
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteAllTunnelConnections
|
func (s *PresenceService) DeleteAllTunnelConnections() error {
startKey := backend.Key(tunnelConnectionsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) DeleteAllTunnelConnections() error {
startKey := backend.Key(tunnelConnectionsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllTunnelConnections",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"tunnelConnectionsPrefix",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// DeleteAllTunnelConnections deletes all tunnel connections
|
[
"DeleteAllTunnelConnections",
"deletes",
"all",
"tunnel",
"connections"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L585-L589
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
CreateRemoteCluster
|
func (s *PresenceService) CreateRemoteCluster(rc services.RemoteCluster) error {
value, err := json.Marshal(rc)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(remoteClustersPrefix, rc.GetName()),
Value: value,
Expires: rc.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *PresenceService) CreateRemoteCluster(rc services.RemoteCluster) error {
value, err := json.Marshal(rc)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(remoteClustersPrefix, rc.GetName()),
Value: value,
Expires: rc.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"CreateRemoteCluster",
"(",
"rc",
"services",
".",
"RemoteCluster",
")",
"error",
"{",
"value",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"rc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"remoteClustersPrefix",
",",
"rc",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"rc",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CreateRemoteCluster creates remote cluster
|
[
"CreateRemoteCluster",
"creates",
"remote",
"cluster"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L592-L607
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteAllRemoteClusters
|
func (s *PresenceService) DeleteAllRemoteClusters() error {
startKey := backend.Key(remoteClustersPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) DeleteAllRemoteClusters() error {
startKey := backend.Key(remoteClustersPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllRemoteClusters",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"remoteClustersPrefix",
")",
"\n",
"err",
":=",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// DeleteAllRemoteClusters deletes all remote clusters
|
[
"DeleteAllRemoteClusters",
"deletes",
"all",
"remote",
"clusters"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L654-L658
|
train
|
gravitational/teleport
|
lib/client/player.go
|
timestampFrame
|
func timestampFrame(message string) {
const (
saveCursor = "7"
restoreCursor = "8"
)
sz, err := term.GetWinsize(0)
if err != nil {
return
}
esc := func(s string) {
os.Stdout.Write([]byte("\x1b" + s))
}
esc(saveCursor)
defer esc(restoreCursor)
// move cursor to -10:0
esc(fmt.Sprintf("[%d;%df", 0, int(sz.Width)-len(message)))
os.Stdout.WriteString(message)
}
|
go
|
func timestampFrame(message string) {
const (
saveCursor = "7"
restoreCursor = "8"
)
sz, err := term.GetWinsize(0)
if err != nil {
return
}
esc := func(s string) {
os.Stdout.Write([]byte("\x1b" + s))
}
esc(saveCursor)
defer esc(restoreCursor)
// move cursor to -10:0
esc(fmt.Sprintf("[%d;%df", 0, int(sz.Width)-len(message)))
os.Stdout.WriteString(message)
}
|
[
"func",
"timestampFrame",
"(",
"message",
"string",
")",
"{",
"const",
"(",
"saveCursor",
"=",
"\"7\"",
"\n",
"restoreCursor",
"=",
"\"8\"",
"\n",
")",
"\n",
"sz",
",",
"err",
":=",
"term",
".",
"GetWinsize",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"esc",
":=",
"func",
"(",
"s",
"string",
")",
"{",
"os",
".",
"Stdout",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"\\x1b\"",
"+",
"\\x1b",
")",
")",
"\n",
"}",
"\n",
"s",
"\n",
"esc",
"(",
"saveCursor",
")",
"\n",
"defer",
"esc",
"(",
"restoreCursor",
")",
"\n",
"esc",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"[%d;%df\"",
",",
"0",
",",
"int",
"(",
"sz",
".",
"Width",
")",
"-",
"len",
"(",
"message",
")",
")",
")",
"\n",
"}"
] |
// timestampFrame prints 'event timestamp' in the top right corner of the
// terminal after playing every 'print' event
|
[
"timestampFrame",
"prints",
"event",
"timestamp",
"in",
"the",
"top",
"right",
"corner",
"of",
"the",
"terminal",
"after",
"playing",
"every",
"print",
"event"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/player.go#L119-L137
|
train
|
gravitational/teleport
|
lib/utils/jsontools.go
|
FastUnmarshal
|
func FastUnmarshal(data []byte, v interface{}) error {
iter := jsoniter.ConfigFastest.BorrowIterator(data)
defer jsoniter.ConfigFastest.ReturnIterator(iter)
iter.ReadVal(v)
if iter.Error != nil {
return trace.Wrap(iter.Error)
}
return nil
}
|
go
|
func FastUnmarshal(data []byte, v interface{}) error {
iter := jsoniter.ConfigFastest.BorrowIterator(data)
defer jsoniter.ConfigFastest.ReturnIterator(iter)
iter.ReadVal(v)
if iter.Error != nil {
return trace.Wrap(iter.Error)
}
return nil
}
|
[
"func",
"FastUnmarshal",
"(",
"data",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"iter",
":=",
"jsoniter",
".",
"ConfigFastest",
".",
"BorrowIterator",
"(",
"data",
")",
"\n",
"defer",
"jsoniter",
".",
"ConfigFastest",
".",
"ReturnIterator",
"(",
"iter",
")",
"\n",
"iter",
".",
"ReadVal",
"(",
"v",
")",
"\n",
"if",
"iter",
".",
"Error",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"iter",
".",
"Error",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// FastUnmarshal uses the json-iterator library for fast JSON unmarshalling.
// Note, this function marshals floats with 6 digits precision.
|
[
"FastUnmarshal",
"uses",
"the",
"json",
"-",
"iterator",
"library",
"for",
"fast",
"JSON",
"unmarshalling",
".",
"Note",
"this",
"function",
"marshals",
"floats",
"with",
"6",
"digits",
"precision",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L61-L71
|
train
|
gravitational/teleport
|
lib/utils/jsontools.go
|
FastMarshal
|
func FastMarshal(v interface{}) ([]byte, error) {
data, err := jsoniter.ConfigFastest.Marshal(v)
if err != nil {
return nil, trace.Wrap(err)
}
return data, nil
}
|
go
|
func FastMarshal(v interface{}) ([]byte, error) {
data, err := jsoniter.ConfigFastest.Marshal(v)
if err != nil {
return nil, trace.Wrap(err)
}
return data, nil
}
|
[
"func",
"FastMarshal",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"jsoniter",
".",
"ConfigFastest",
".",
"Marshal",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"data",
",",
"nil",
"\n",
"}"
] |
// FastMarshal uses the json-iterator library for fast JSON marshalling.
// Note, this function marshals floats with 6 digits precision.
|
[
"FastMarshal",
"uses",
"the",
"json",
"-",
"iterator",
"library",
"for",
"fast",
"JSON",
"marshalling",
".",
"Note",
"this",
"function",
"marshals",
"floats",
"with",
"6",
"digits",
"precision",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L75-L82
|
train
|
gravitational/teleport
|
lib/utils/jsontools.go
|
isDoc
|
func isDoc(val reflect.Value) bool {
iterations := 0
for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
// preventing cycles
iterations++
if iterations > 10 {
return false
}
}
return val.Kind() == reflect.Struct || val.Kind() == reflect.Map
}
|
go
|
func isDoc(val reflect.Value) bool {
iterations := 0
for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
// preventing cycles
iterations++
if iterations > 10 {
return false
}
}
return val.Kind() == reflect.Struct || val.Kind() == reflect.Map
}
|
[
"func",
"isDoc",
"(",
"val",
"reflect",
".",
"Value",
")",
"bool",
"{",
"iterations",
":=",
"0",
"\n",
"for",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Interface",
"||",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"val",
"=",
"val",
".",
"Elem",
"(",
")",
"\n",
"iterations",
"++",
"\n",
"if",
"iterations",
">",
"10",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"||",
"val",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Map",
"\n",
"}"
] |
// isDoc detects whether value constitues a document
|
[
"isDoc",
"detects",
"whether",
"value",
"constitues",
"a",
"document"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L122-L133
|
train
|
gravitational/teleport
|
lib/utils/jsontools.go
|
writeYAML
|
func writeYAML(w io.Writer, values interface{}) error {
data, err := yaml.Marshal(values)
if err != nil {
return trace.Wrap(err)
}
_, err = w.Write(data)
return trace.Wrap(err)
}
|
go
|
func writeYAML(w io.Writer, values interface{}) error {
data, err := yaml.Marshal(values)
if err != nil {
return trace.Wrap(err)
}
_, err = w.Write(data)
return trace.Wrap(err)
}
|
[
"func",
"writeYAML",
"(",
"w",
"io",
".",
"Writer",
",",
"values",
"interface",
"{",
"}",
")",
"error",
"{",
"data",
",",
"err",
":=",
"yaml",
".",
"Marshal",
"(",
"values",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"data",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// writeYAML writes marshaled YAML to writer
|
[
"writeYAML",
"writes",
"marshaled",
"YAML",
"to",
"writer"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L136-L143
|
train
|
gravitational/teleport
|
lib/utils/jsontools.go
|
ReadYAML
|
func ReadYAML(reader io.Reader) (interface{}, error) {
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
var values []interface{}
for {
var val interface{}
err := decoder.Decode(&val)
if err != nil {
if err == io.EOF {
if len(values) == 0 {
return nil, trace.BadParameter("no resources found, empty input?")
}
if len(values) == 1 {
return values[0], nil
}
return values, nil
}
return nil, trace.Wrap(err)
}
values = append(values, val)
}
}
|
go
|
func ReadYAML(reader io.Reader) (interface{}, error) {
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
var values []interface{}
for {
var val interface{}
err := decoder.Decode(&val)
if err != nil {
if err == io.EOF {
if len(values) == 0 {
return nil, trace.BadParameter("no resources found, empty input?")
}
if len(values) == 1 {
return values[0], nil
}
return values, nil
}
return nil, trace.Wrap(err)
}
values = append(values, val)
}
}
|
[
"func",
"ReadYAML",
"(",
"reader",
"io",
".",
"Reader",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"decoder",
":=",
"kyaml",
".",
"NewYAMLOrJSONDecoder",
"(",
"reader",
",",
"32",
"*",
"1024",
")",
"\n",
"var",
"values",
"[",
"]",
"interface",
"{",
"}",
"\n",
"for",
"{",
"var",
"val",
"interface",
"{",
"}",
"\n",
"err",
":=",
"decoder",
".",
"Decode",
"(",
"&",
"val",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"if",
"len",
"(",
"values",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"no resources found, empty input?\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"values",
")",
"==",
"1",
"{",
"return",
"values",
"[",
"0",
"]",
",",
"nil",
"\n",
"}",
"\n",
"return",
"values",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"values",
"=",
"append",
"(",
"values",
",",
"val",
")",
"\n",
"}",
"\n",
"}"
] |
// ReadYAML can unmarshal a stream of documents, used in tests.
|
[
"ReadYAML",
"can",
"unmarshal",
"a",
"stream",
"of",
"documents",
"used",
"in",
"tests",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/jsontools.go#L146-L166
|
train
|
gravitational/teleport
|
lib/client/redirect.go
|
NewRedirector
|
func NewRedirector(login SSHLogin) (*Redirector, error) {
//clt, proxyURL, err := initClient(login.ProxyAddr, login.Insecure, login.Pool)
//if err != nil {
// return nil, trace.Wrap(err)
//}
clt, err := NewCredentialsClient(login.ProxyAddr, login.Insecure, login.Pool)
if err != nil {
return nil, trace.Wrap(err)
}
// Create secret key that will be sent with the request and then used the
// decrypt the response from the server.
key, err := secret.NewKey()
if err != nil {
return nil, trace.Wrap(err)
}
context, cancel := context.WithCancel(login.Context)
rd := &Redirector{
context: context,
cancel: cancel,
proxyClient: clt.clt,
proxyURL: clt.url,
SSHLogin: login,
mux: http.NewServeMux(),
key: key,
shortPath: "/" + uuid.New(),
responseC: make(chan *auth.SSHLoginResponse, 1),
errorC: make(chan error, 1),
}
// callback is a callback URL communicated to the Teleport proxy,
// after SAML/OIDC login, the teleport will redirect user's browser
// to this laptop-local URL
rd.mux.Handle("/callback", rd.wrapCallback(rd.callback))
// short path is a link-shortener style URL
// that will redirect to the Teleport-Proxy supplied address
rd.mux.HandleFunc(rd.shortPath, func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, rd.redirectURL.Value(), http.StatusFound)
})
return rd, nil
}
|
go
|
func NewRedirector(login SSHLogin) (*Redirector, error) {
//clt, proxyURL, err := initClient(login.ProxyAddr, login.Insecure, login.Pool)
//if err != nil {
// return nil, trace.Wrap(err)
//}
clt, err := NewCredentialsClient(login.ProxyAddr, login.Insecure, login.Pool)
if err != nil {
return nil, trace.Wrap(err)
}
// Create secret key that will be sent with the request and then used the
// decrypt the response from the server.
key, err := secret.NewKey()
if err != nil {
return nil, trace.Wrap(err)
}
context, cancel := context.WithCancel(login.Context)
rd := &Redirector{
context: context,
cancel: cancel,
proxyClient: clt.clt,
proxyURL: clt.url,
SSHLogin: login,
mux: http.NewServeMux(),
key: key,
shortPath: "/" + uuid.New(),
responseC: make(chan *auth.SSHLoginResponse, 1),
errorC: make(chan error, 1),
}
// callback is a callback URL communicated to the Teleport proxy,
// after SAML/OIDC login, the teleport will redirect user's browser
// to this laptop-local URL
rd.mux.Handle("/callback", rd.wrapCallback(rd.callback))
// short path is a link-shortener style URL
// that will redirect to the Teleport-Proxy supplied address
rd.mux.HandleFunc(rd.shortPath, func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, rd.redirectURL.Value(), http.StatusFound)
})
return rd, nil
}
|
[
"func",
"NewRedirector",
"(",
"login",
"SSHLogin",
")",
"(",
"*",
"Redirector",
",",
"error",
")",
"{",
"clt",
",",
"err",
":=",
"NewCredentialsClient",
"(",
"login",
".",
"ProxyAddr",
",",
"login",
".",
"Insecure",
",",
"login",
".",
"Pool",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"key",
",",
"err",
":=",
"secret",
".",
"NewKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"context",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"login",
".",
"Context",
")",
"\n",
"rd",
":=",
"&",
"Redirector",
"{",
"context",
":",
"context",
",",
"cancel",
":",
"cancel",
",",
"proxyClient",
":",
"clt",
".",
"clt",
",",
"proxyURL",
":",
"clt",
".",
"url",
",",
"SSHLogin",
":",
"login",
",",
"mux",
":",
"http",
".",
"NewServeMux",
"(",
")",
",",
"key",
":",
"key",
",",
"shortPath",
":",
"\"/\"",
"+",
"uuid",
".",
"New",
"(",
")",
",",
"responseC",
":",
"make",
"(",
"chan",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"1",
")",
",",
"errorC",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n",
"rd",
".",
"mux",
".",
"Handle",
"(",
"\"/callback\"",
",",
"rd",
".",
"wrapCallback",
"(",
"rd",
".",
"callback",
")",
")",
"\n",
"rd",
".",
"mux",
".",
"HandleFunc",
"(",
"rd",
".",
"shortPath",
",",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"rd",
".",
"redirectURL",
".",
"Value",
"(",
")",
",",
"http",
".",
"StatusFound",
")",
"\n",
"}",
")",
"\n",
"return",
"rd",
",",
"nil",
"\n",
"}"
] |
// NewRedirector returns new local web server redirector
|
[
"NewRedirector",
"returns",
"new",
"local",
"web",
"server",
"redirector"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L69-L111
|
train
|
gravitational/teleport
|
lib/client/redirect.go
|
Start
|
func (rd *Redirector) Start() error {
if rd.BindAddr != "" {
log.Debugf("Binding to %v.", rd.BindAddr)
listener, err := net.Listen("tcp", rd.BindAddr)
if err != nil {
return trace.Wrap(err, "%v: could not bind to %v, make sure the address is host:port format for ipv4 and [ipv6]:port format for ipv6, and the address is not in use", err, rd.BindAddr)
}
rd.server = &httptest.Server{
Listener: listener,
Config: &http.Server{Handler: rd.mux},
}
rd.server.Start()
} else {
rd.server = httptest.NewServer(rd.mux)
}
log.Infof("Waiting for response at: %v.", rd.server.URL)
// communicate callback redirect URL to the Teleport Proxy
u, err := url.Parse(rd.server.URL + "/callback")
if err != nil {
return trace.Wrap(err)
}
query := u.Query()
query.Set("secret_key", rd.key.String())
u.RawQuery = query.Encode()
out, err := rd.proxyClient.PostJSON(rd.Context, rd.proxyClient.Endpoint("webapi", rd.Protocol, "login", "console"), SSOLoginConsoleReq{
RedirectURL: u.String(),
PublicKey: rd.PubKey,
CertTTL: rd.TTL,
ConnectorID: rd.ConnectorID,
Compatibility: rd.Compatibility,
})
if err != nil {
return trace.Wrap(err)
}
var re *SSOLoginConsoleResponse
err = json.Unmarshal(out.Bytes(), &re)
if err != nil {
return trace.Wrap(err)
}
// notice late binding of the redirect URL here, it is referenced
// in the callback handler, but is known only after the request
// is sent to the Teleport Proxy, that's why
// redirectURL is a SyncString
rd.redirectURL.Set(re.RedirectURL)
return nil
}
|
go
|
func (rd *Redirector) Start() error {
if rd.BindAddr != "" {
log.Debugf("Binding to %v.", rd.BindAddr)
listener, err := net.Listen("tcp", rd.BindAddr)
if err != nil {
return trace.Wrap(err, "%v: could not bind to %v, make sure the address is host:port format for ipv4 and [ipv6]:port format for ipv6, and the address is not in use", err, rd.BindAddr)
}
rd.server = &httptest.Server{
Listener: listener,
Config: &http.Server{Handler: rd.mux},
}
rd.server.Start()
} else {
rd.server = httptest.NewServer(rd.mux)
}
log.Infof("Waiting for response at: %v.", rd.server.URL)
// communicate callback redirect URL to the Teleport Proxy
u, err := url.Parse(rd.server.URL + "/callback")
if err != nil {
return trace.Wrap(err)
}
query := u.Query()
query.Set("secret_key", rd.key.String())
u.RawQuery = query.Encode()
out, err := rd.proxyClient.PostJSON(rd.Context, rd.proxyClient.Endpoint("webapi", rd.Protocol, "login", "console"), SSOLoginConsoleReq{
RedirectURL: u.String(),
PublicKey: rd.PubKey,
CertTTL: rd.TTL,
ConnectorID: rd.ConnectorID,
Compatibility: rd.Compatibility,
})
if err != nil {
return trace.Wrap(err)
}
var re *SSOLoginConsoleResponse
err = json.Unmarshal(out.Bytes(), &re)
if err != nil {
return trace.Wrap(err)
}
// notice late binding of the redirect URL here, it is referenced
// in the callback handler, but is known only after the request
// is sent to the Teleport Proxy, that's why
// redirectURL is a SyncString
rd.redirectURL.Set(re.RedirectURL)
return nil
}
|
[
"func",
"(",
"rd",
"*",
"Redirector",
")",
"Start",
"(",
")",
"error",
"{",
"if",
"rd",
".",
"BindAddr",
"!=",
"\"\"",
"{",
"log",
".",
"Debugf",
"(",
"\"Binding to %v.\"",
",",
"rd",
".",
"BindAddr",
")",
"\n",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"tcp\"",
",",
"rd",
".",
"BindAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"%v: could not bind to %v, make sure the address is host:port format for ipv4 and [ipv6]:port format for ipv6, and the address is not in use\"",
",",
"err",
",",
"rd",
".",
"BindAddr",
")",
"\n",
"}",
"\n",
"rd",
".",
"server",
"=",
"&",
"httptest",
".",
"Server",
"{",
"Listener",
":",
"listener",
",",
"Config",
":",
"&",
"http",
".",
"Server",
"{",
"Handler",
":",
"rd",
".",
"mux",
"}",
",",
"}",
"\n",
"rd",
".",
"server",
".",
"Start",
"(",
")",
"\n",
"}",
"else",
"{",
"rd",
".",
"server",
"=",
"httptest",
".",
"NewServer",
"(",
"rd",
".",
"mux",
")",
"\n",
"}",
"\n",
"log",
".",
"Infof",
"(",
"\"Waiting for response at: %v.\"",
",",
"rd",
".",
"server",
".",
"URL",
")",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"rd",
".",
"server",
".",
"URL",
"+",
"\"/callback\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"query",
":=",
"u",
".",
"Query",
"(",
")",
"\n",
"query",
".",
"Set",
"(",
"\"secret_key\"",
",",
"rd",
".",
"key",
".",
"String",
"(",
")",
")",
"\n",
"u",
".",
"RawQuery",
"=",
"query",
".",
"Encode",
"(",
")",
"\n",
"out",
",",
"err",
":=",
"rd",
".",
"proxyClient",
".",
"PostJSON",
"(",
"rd",
".",
"Context",
",",
"rd",
".",
"proxyClient",
".",
"Endpoint",
"(",
"\"webapi\"",
",",
"rd",
".",
"Protocol",
",",
"\"login\"",
",",
"\"console\"",
")",
",",
"SSOLoginConsoleReq",
"{",
"RedirectURL",
":",
"u",
".",
"String",
"(",
")",
",",
"PublicKey",
":",
"rd",
".",
"PubKey",
",",
"CertTTL",
":",
"rd",
".",
"TTL",
",",
"ConnectorID",
":",
"rd",
".",
"ConnectorID",
",",
"Compatibility",
":",
"rd",
".",
"Compatibility",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"re",
"*",
"SSOLoginConsoleResponse",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"re",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"rd",
".",
"redirectURL",
".",
"Set",
"(",
"re",
".",
"RedirectURL",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Start launches local http server on the machine,
// initiates SSO login request sequence with the Teleport Proxy
|
[
"Start",
"launches",
"local",
"http",
"server",
"on",
"the",
"machine",
"initiates",
"SSO",
"login",
"request",
"sequence",
"with",
"the",
"Teleport",
"Proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L115-L163
|
train
|
gravitational/teleport
|
lib/client/redirect.go
|
ClickableURL
|
func (rd *Redirector) ClickableURL() string {
if rd.server == nil {
return "<undefined - server is not started>"
}
return utils.ClickableURL(rd.server.URL + rd.shortPath)
}
|
go
|
func (rd *Redirector) ClickableURL() string {
if rd.server == nil {
return "<undefined - server is not started>"
}
return utils.ClickableURL(rd.server.URL + rd.shortPath)
}
|
[
"func",
"(",
"rd",
"*",
"Redirector",
")",
"ClickableURL",
"(",
")",
"string",
"{",
"if",
"rd",
".",
"server",
"==",
"nil",
"{",
"return",
"\"<undefined - server is not started>\"",
"\n",
"}",
"\n",
"return",
"utils",
".",
"ClickableURL",
"(",
"rd",
".",
"server",
".",
"URL",
"+",
"rd",
".",
"shortPath",
")",
"\n",
"}"
] |
// ClickableURL returns a short clickable redirect URL
|
[
"ClickableURL",
"returns",
"a",
"short",
"clickable",
"redirect",
"URL"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L172-L177
|
train
|
gravitational/teleport
|
lib/client/redirect.go
|
callback
|
func (rd *Redirector) callback(w http.ResponseWriter, r *http.Request) (*auth.SSHLoginResponse, error) {
if r.URL.Path != "/callback" {
return nil, trace.NotFound("path not found")
}
// Decrypt ciphertext to get login response.
plaintext, err := rd.key.Open([]byte(r.URL.Query().Get("response")))
if err != nil {
return nil, trace.BadParameter("failed to decrypt response: in %v, err: %v", r.URL.String(), err)
}
var re *auth.SSHLoginResponse
err = json.Unmarshal(plaintext, &re)
if err != nil {
return nil, trace.BadParameter("failed to decrypt response: in %v, err: %v", r.URL.String(), err)
}
return re, nil
}
|
go
|
func (rd *Redirector) callback(w http.ResponseWriter, r *http.Request) (*auth.SSHLoginResponse, error) {
if r.URL.Path != "/callback" {
return nil, trace.NotFound("path not found")
}
// Decrypt ciphertext to get login response.
plaintext, err := rd.key.Open([]byte(r.URL.Query().Get("response")))
if err != nil {
return nil, trace.BadParameter("failed to decrypt response: in %v, err: %v", r.URL.String(), err)
}
var re *auth.SSHLoginResponse
err = json.Unmarshal(plaintext, &re)
if err != nil {
return nil, trace.BadParameter("failed to decrypt response: in %v, err: %v", r.URL.String(), err)
}
return re, nil
}
|
[
"func",
"(",
"rd",
"*",
"Redirector",
")",
"callback",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"error",
")",
"{",
"if",
"r",
".",
"URL",
".",
"Path",
"!=",
"\"/callback\"",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"path not found\"",
")",
"\n",
"}",
"\n",
"plaintext",
",",
"err",
":=",
"rd",
".",
"key",
".",
"Open",
"(",
"[",
"]",
"byte",
"(",
"r",
".",
"URL",
".",
"Query",
"(",
")",
".",
"Get",
"(",
"\"response\"",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to decrypt response: in %v, err: %v\"",
",",
"r",
".",
"URL",
".",
"String",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"var",
"re",
"*",
"auth",
".",
"SSHLoginResponse",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"plaintext",
",",
"&",
"re",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to decrypt response: in %v, err: %v\"",
",",
"r",
".",
"URL",
".",
"String",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"nil",
"\n",
"}"
] |
// callback is used by Teleport proxy to send back credentials
// issued by Teleport proxy
|
[
"callback",
"is",
"used",
"by",
"Teleport",
"proxy",
"to",
"send",
"back",
"credentials",
"issued",
"by",
"Teleport",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L191-L209
|
train
|
gravitational/teleport
|
lib/client/redirect.go
|
Close
|
func (rd *Redirector) Close() error {
rd.cancel()
if rd.server != nil {
rd.server.Close()
}
return nil
}
|
go
|
func (rd *Redirector) Close() error {
rd.cancel()
if rd.server != nil {
rd.server.Close()
}
return nil
}
|
[
"func",
"(",
"rd",
"*",
"Redirector",
")",
"Close",
"(",
")",
"error",
"{",
"rd",
".",
"cancel",
"(",
")",
"\n",
"if",
"rd",
".",
"server",
"!=",
"nil",
"{",
"rd",
".",
"server",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close closes redirector and releases all resources
|
[
"Close",
"closes",
"redirector",
"and",
"releases",
"all",
"resources"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L212-L218
|
train
|
gravitational/teleport
|
lib/client/redirect.go
|
wrapCallback
|
func (rd *Redirector) wrapCallback(fn func(http.ResponseWriter, *http.Request) (*auth.SSHLoginResponse, error)) http.Handler {
clone := *rd.proxyURL
clone.Path = "/web/msg/error/login_failed"
errorURL := clone.String()
clone.Path = "/web/msg/info/login_success"
successURL := clone.String()
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
response, err := fn(w, r)
if err != nil {
if trace.IsNotFound(err) {
http.NotFound(w, r)
return
}
select {
case rd.errorC <- err:
case <-rd.context.Done():
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
select {
case rd.responseC <- response:
case <-rd.context.Done():
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
http.Redirect(w, r, successURL, http.StatusFound)
})
}
|
go
|
func (rd *Redirector) wrapCallback(fn func(http.ResponseWriter, *http.Request) (*auth.SSHLoginResponse, error)) http.Handler {
clone := *rd.proxyURL
clone.Path = "/web/msg/error/login_failed"
errorURL := clone.String()
clone.Path = "/web/msg/info/login_success"
successURL := clone.String()
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
response, err := fn(w, r)
if err != nil {
if trace.IsNotFound(err) {
http.NotFound(w, r)
return
}
select {
case rd.errorC <- err:
case <-rd.context.Done():
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
select {
case rd.responseC <- response:
case <-rd.context.Done():
http.Redirect(w, r, errorURL, http.StatusFound)
return
}
http.Redirect(w, r, successURL, http.StatusFound)
})
}
|
[
"func",
"(",
"rd",
"*",
"Redirector",
")",
"wrapCallback",
"(",
"fn",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"auth",
".",
"SSHLoginResponse",
",",
"error",
")",
")",
"http",
".",
"Handler",
"{",
"clone",
":=",
"*",
"rd",
".",
"proxyURL",
"\n",
"clone",
".",
"Path",
"=",
"\"/web/msg/error/login_failed\"",
"\n",
"errorURL",
":=",
"clone",
".",
"String",
"(",
")",
"\n",
"clone",
".",
"Path",
"=",
"\"/web/msg/info/login_success\"",
"\n",
"successURL",
":=",
"clone",
".",
"String",
"(",
")",
"\n",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"response",
",",
"err",
":=",
"fn",
"(",
"w",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"http",
".",
"NotFound",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"\n",
"select",
"{",
"case",
"rd",
".",
"errorC",
"<-",
"err",
":",
"case",
"<-",
"rd",
".",
"context",
".",
"Done",
"(",
")",
":",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"errorURL",
",",
"http",
".",
"StatusFound",
")",
"\n",
"return",
"\n",
"}",
"\n",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"errorURL",
",",
"http",
".",
"StatusFound",
")",
"\n",
"return",
"\n",
"}",
"\n",
"select",
"{",
"case",
"rd",
".",
"responseC",
"<-",
"response",
":",
"case",
"<-",
"rd",
".",
"context",
".",
"Done",
"(",
")",
":",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"errorURL",
",",
"http",
".",
"StatusFound",
")",
"\n",
"return",
"\n",
"}",
"\n",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"successURL",
",",
"http",
".",
"StatusFound",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// wrapCallback is a helper wrapper method that wraps callback HTTP handler
// and sends a result to the channel and redirect users to error page
|
[
"wrapCallback",
"is",
"a",
"helper",
"wrapper",
"method",
"that",
"wraps",
"callback",
"HTTP",
"handler",
"and",
"sends",
"a",
"result",
"to",
"the",
"channel",
"and",
"redirect",
"users",
"to",
"error",
"page"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/redirect.go#L222-L253
|
train
|
gravitational/teleport
|
lib/services/license.go
|
NewLicense
|
func NewLicense(name string, spec LicenseSpecV3) (License, error) {
return &LicenseV3{
Kind: KindLicense,
Version: V3,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
}
|
go
|
func NewLicense(name string, spec LicenseSpecV3) (License, error) {
return &LicenseV3{
Kind: KindLicense,
Version: V3,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
}
|
[
"func",
"NewLicense",
"(",
"name",
"string",
",",
"spec",
"LicenseSpecV3",
")",
"(",
"License",
",",
"error",
")",
"{",
"return",
"&",
"LicenseV3",
"{",
"Kind",
":",
"KindLicense",
",",
"Version",
":",
"V3",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewLicense is a convenience method to to create LicenseV3.
|
[
"NewLicense",
"is",
"a",
"convenience",
"method",
"to",
"to",
"create",
"LicenseV3",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/license.go#L73-L83
|
train
|
gravitational/teleport
|
lib/services/license.go
|
SetLabels
|
func (c *LicenseV3) SetLabels(labels map[string]string) {
c.Metadata.Labels = labels
}
|
go
|
func (c *LicenseV3) SetLabels(labels map[string]string) {
c.Metadata.Labels = labels
}
|
[
"func",
"(",
"c",
"*",
"LicenseV3",
")",
"SetLabels",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"c",
".",
"Metadata",
".",
"Labels",
"=",
"labels",
"\n",
"}"
] |
// SetLabels sets metadata labels
|
[
"SetLabels",
"sets",
"metadata",
"labels"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/license.go#L139-L141
|
train
|
gravitational/teleport
|
lib/services/license.go
|
String
|
func (c *LicenseV3) String() string {
var features []string
if !c.Expiry().IsZero() {
features = append(features, fmt.Sprintf("expires at %v", c.Expiry()))
}
if c.Spec.ReportsUsage.Value() {
features = append(features, "reports usage")
}
if c.Spec.SupportsKubernetes.Value() {
features = append(features, "supports kubernetes")
}
if c.Spec.AWSProductID != "" {
features = append(features, fmt.Sprintf("is limited to AWS product ID %q", c.Spec.AWSProductID))
}
if c.Spec.AWSAccountID != "" {
features = append(features, fmt.Sprintf("is limited to AWS account ID %q", c.Spec.AWSAccountID))
}
if len(features) == 0 {
return ""
}
return strings.Join(features, ",")
}
|
go
|
func (c *LicenseV3) String() string {
var features []string
if !c.Expiry().IsZero() {
features = append(features, fmt.Sprintf("expires at %v", c.Expiry()))
}
if c.Spec.ReportsUsage.Value() {
features = append(features, "reports usage")
}
if c.Spec.SupportsKubernetes.Value() {
features = append(features, "supports kubernetes")
}
if c.Spec.AWSProductID != "" {
features = append(features, fmt.Sprintf("is limited to AWS product ID %q", c.Spec.AWSProductID))
}
if c.Spec.AWSAccountID != "" {
features = append(features, fmt.Sprintf("is limited to AWS account ID %q", c.Spec.AWSAccountID))
}
if len(features) == 0 {
return ""
}
return strings.Join(features, ",")
}
|
[
"func",
"(",
"c",
"*",
"LicenseV3",
")",
"String",
"(",
")",
"string",
"{",
"var",
"features",
"[",
"]",
"string",
"\n",
"if",
"!",
"c",
".",
"Expiry",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"features",
"=",
"append",
"(",
"features",
",",
"fmt",
".",
"Sprintf",
"(",
"\"expires at %v\"",
",",
"c",
".",
"Expiry",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Spec",
".",
"ReportsUsage",
".",
"Value",
"(",
")",
"{",
"features",
"=",
"append",
"(",
"features",
",",
"\"reports usage\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Spec",
".",
"SupportsKubernetes",
".",
"Value",
"(",
")",
"{",
"features",
"=",
"append",
"(",
"features",
",",
"\"supports kubernetes\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Spec",
".",
"AWSProductID",
"!=",
"\"\"",
"{",
"features",
"=",
"append",
"(",
"features",
",",
"fmt",
".",
"Sprintf",
"(",
"\"is limited to AWS product ID %q\"",
",",
"c",
".",
"Spec",
".",
"AWSProductID",
")",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Spec",
".",
"AWSAccountID",
"!=",
"\"\"",
"{",
"features",
"=",
"append",
"(",
"features",
",",
"fmt",
".",
"Sprintf",
"(",
"\"is limited to AWS account ID %q\"",
",",
"c",
".",
"Spec",
".",
"AWSAccountID",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"features",
")",
"==",
"0",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"features",
",",
"\",\"",
")",
"\n",
"}"
] |
// String represents a human readable version of license enabled features
|
[
"String",
"represents",
"a",
"human",
"readable",
"version",
"of",
"license",
"enabled",
"features"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/license.go#L227-L248
|
train
|
gravitational/teleport
|
lib/services/license.go
|
UnmarshalLicense
|
func UnmarshalLicense(bytes []byte) (License, error) {
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
schema := fmt.Sprintf(V2SchemaTemplate, MetadataSchema, LicenseSpecV3Template, DefaultDefinitions)
var license LicenseV3
err := utils.UnmarshalWithSchema(schema, &license, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
if license.Version != V3 {
return nil, trace.BadParameter("unsupported version %v, expected version %v", license.Version, V3)
}
if err := license.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &license, nil
}
|
go
|
func UnmarshalLicense(bytes []byte) (License, error) {
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
schema := fmt.Sprintf(V2SchemaTemplate, MetadataSchema, LicenseSpecV3Template, DefaultDefinitions)
var license LicenseV3
err := utils.UnmarshalWithSchema(schema, &license, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
if license.Version != V3 {
return nil, trace.BadParameter("unsupported version %v, expected version %v", license.Version, V3)
}
if err := license.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &license, nil
}
|
[
"func",
"UnmarshalLicense",
"(",
"bytes",
"[",
"]",
"byte",
")",
"(",
"License",
",",
"error",
")",
"{",
"if",
"len",
"(",
"bytes",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing resource data\"",
")",
"\n",
"}",
"\n",
"schema",
":=",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"LicenseSpecV3Template",
",",
"DefaultDefinitions",
")",
"\n",
"var",
"license",
"LicenseV3",
"\n",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"schema",
",",
"&",
"license",
",",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"license",
".",
"Version",
"!=",
"V3",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unsupported version %v, expected version %v\"",
",",
"license",
".",
"Version",
",",
"V3",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"license",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"license",
",",
"nil",
"\n",
"}"
] |
// UnmarshalLicense unmarshals License from JSON or YAML
// and validates schema
|
[
"UnmarshalLicense",
"unmarshals",
"License",
"from",
"JSON",
"or",
"YAML",
"and",
"validates",
"schema"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/license.go#L292-L314
|
train
|
gravitational/teleport
|
lib/services/license.go
|
MarshalLicense
|
func MarshalLicense(license License, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := license.(type) {
case *LicenseV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", license)
}
}
|
go
|
func MarshalLicense(license License, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := license.(type) {
case *LicenseV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", license)
}
}
|
[
"func",
"MarshalLicense",
"(",
"license",
"License",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"resource",
":=",
"license",
".",
"(",
"type",
")",
"{",
"case",
"*",
"LicenseV3",
":",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"resource",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"resource",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"resource",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unrecognized resource version %T\"",
",",
"license",
")",
"\n",
"}",
"\n",
"}"
] |
// MarshalLicense marshals role to JSON or YAML.
|
[
"MarshalLicense",
"marshals",
"role",
"to",
"JSON",
"or",
"YAML",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/license.go#L317-L335
|
train
|
gravitational/teleport
|
lib/reversetunnel/agentpool.go
|
NewAgentPool
|
func NewAgentPool(cfg AgentPoolConfig) (*AgentPool, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
pool := &AgentPool{
agents: make(map[agentKey][]*Agent),
cfg: cfg,
ctx: ctx,
cancel: cancel,
discoveryC: make(chan *discoveryRequest),
}
pool.Entry = log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelAgent,
trace.ComponentFields: log.Fields{
"cluster": cfg.Cluster,
},
})
return pool, nil
}
|
go
|
func NewAgentPool(cfg AgentPoolConfig) (*AgentPool, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
pool := &AgentPool{
agents: make(map[agentKey][]*Agent),
cfg: cfg,
ctx: ctx,
cancel: cancel,
discoveryC: make(chan *discoveryRequest),
}
pool.Entry = log.WithFields(log.Fields{
trace.Component: teleport.ComponentReverseTunnelAgent,
trace.ComponentFields: log.Fields{
"cluster": cfg.Cluster,
},
})
return pool, nil
}
|
[
"func",
"NewAgentPool",
"(",
"cfg",
"AgentPoolConfig",
")",
"(",
"*",
"AgentPool",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"cfg",
".",
"Context",
")",
"\n",
"pool",
":=",
"&",
"AgentPool",
"{",
"agents",
":",
"make",
"(",
"map",
"[",
"agentKey",
"]",
"[",
"]",
"*",
"Agent",
")",
",",
"cfg",
":",
"cfg",
",",
"ctx",
":",
"ctx",
",",
"cancel",
":",
"cancel",
",",
"discoveryC",
":",
"make",
"(",
"chan",
"*",
"discoveryRequest",
")",
",",
"}",
"\n",
"pool",
".",
"Entry",
"=",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentReverseTunnelAgent",
",",
"trace",
".",
"ComponentFields",
":",
"log",
".",
"Fields",
"{",
"\"cluster\"",
":",
"cfg",
".",
"Cluster",
",",
"}",
",",
"}",
")",
"\n",
"return",
"pool",
",",
"nil",
"\n",
"}"
] |
// NewAgentPool returns new isntance of the agent pool
|
[
"NewAgentPool",
"returns",
"new",
"isntance",
"of",
"the",
"agent",
"pool"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/agentpool.go#L114-L133
|
train
|
gravitational/teleport
|
lib/reversetunnel/agentpool.go
|
reportStats
|
func (m *AgentPool) reportStats() {
var logReport bool
if m.cfg.Clock.Now().Sub(m.lastReport) > defaults.ReportingPeriod {
m.lastReport = m.cfg.Clock.Now()
logReport = true
}
for key, agents := range m.agents {
m.Debugf("Outbound tunnel for %v connected to %v proxies.", key.tunnelID, len(agents))
countPerState := map[string]int{
agentStateConnecting: 0,
agentStateDiscovering: 0,
agentStateConnected: 0,
agentStateDiscovered: 0,
agentStateDisconnected: 0,
}
for _, a := range agents {
countPerState[a.getState()]++
}
for state, count := range countPerState {
gauge, err := trustedClustersStats.GetMetricWithLabelValues(key.tunnelID, state)
if err != nil {
m.Warningf("Failed to get gauge: %v.", err)
continue
}
gauge.Set(float64(count))
}
if logReport {
m.WithFields(log.Fields{"target": key.tunnelID, "stats": countPerState}).Info("Outbound tunnel stats.")
}
}
}
|
go
|
func (m *AgentPool) reportStats() {
var logReport bool
if m.cfg.Clock.Now().Sub(m.lastReport) > defaults.ReportingPeriod {
m.lastReport = m.cfg.Clock.Now()
logReport = true
}
for key, agents := range m.agents {
m.Debugf("Outbound tunnel for %v connected to %v proxies.", key.tunnelID, len(agents))
countPerState := map[string]int{
agentStateConnecting: 0,
agentStateDiscovering: 0,
agentStateConnected: 0,
agentStateDiscovered: 0,
agentStateDisconnected: 0,
}
for _, a := range agents {
countPerState[a.getState()]++
}
for state, count := range countPerState {
gauge, err := trustedClustersStats.GetMetricWithLabelValues(key.tunnelID, state)
if err != nil {
m.Warningf("Failed to get gauge: %v.", err)
continue
}
gauge.Set(float64(count))
}
if logReport {
m.WithFields(log.Fields{"target": key.tunnelID, "stats": countPerState}).Info("Outbound tunnel stats.")
}
}
}
|
[
"func",
"(",
"m",
"*",
"AgentPool",
")",
"reportStats",
"(",
")",
"{",
"var",
"logReport",
"bool",
"\n",
"if",
"m",
".",
"cfg",
".",
"Clock",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"m",
".",
"lastReport",
")",
">",
"defaults",
".",
"ReportingPeriod",
"{",
"m",
".",
"lastReport",
"=",
"m",
".",
"cfg",
".",
"Clock",
".",
"Now",
"(",
")",
"\n",
"logReport",
"=",
"true",
"\n",
"}",
"\n",
"for",
"key",
",",
"agents",
":=",
"range",
"m",
".",
"agents",
"{",
"m",
".",
"Debugf",
"(",
"\"Outbound tunnel for %v connected to %v proxies.\"",
",",
"key",
".",
"tunnelID",
",",
"len",
"(",
"agents",
")",
")",
"\n",
"countPerState",
":=",
"map",
"[",
"string",
"]",
"int",
"{",
"agentStateConnecting",
":",
"0",
",",
"agentStateDiscovering",
":",
"0",
",",
"agentStateConnected",
":",
"0",
",",
"agentStateDiscovered",
":",
"0",
",",
"agentStateDisconnected",
":",
"0",
",",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"agents",
"{",
"countPerState",
"[",
"a",
".",
"getState",
"(",
")",
"]",
"++",
"\n",
"}",
"\n",
"for",
"state",
",",
"count",
":=",
"range",
"countPerState",
"{",
"gauge",
",",
"err",
":=",
"trustedClustersStats",
".",
"GetMetricWithLabelValues",
"(",
"key",
".",
"tunnelID",
",",
"state",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"m",
".",
"Warningf",
"(",
"\"Failed to get gauge: %v.\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"gauge",
".",
"Set",
"(",
"float64",
"(",
"count",
")",
")",
"\n",
"}",
"\n",
"if",
"logReport",
"{",
"m",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"target\"",
":",
"key",
".",
"tunnelID",
",",
"\"stats\"",
":",
"countPerState",
"}",
")",
".",
"Info",
"(",
"\"Outbound tunnel stats.\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// reportStats submits report about agents state once in a while at info
// level. Always logs more detailed information at debug level.
|
[
"reportStats",
"submits",
"report",
"about",
"agents",
"state",
"once",
"in",
"a",
"while",
"at",
"info",
"level",
".",
"Always",
"logs",
"more",
"detailed",
"information",
"at",
"debug",
"level",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/agentpool.go#L356-L388
|
train
|
gravitational/teleport
|
lib/reversetunnel/agentpool.go
|
removeDisconnected
|
func (m *AgentPool) removeDisconnected() {
for agentKey, agentSlice := range m.agents {
// Filter and close all disconnected agents.
validAgents := filterAndClose(agentSlice, func(agent *Agent) bool {
if agent.getState() == agentStateDisconnected {
return true
}
return false
})
// Update (or delete) agent key with filter applied.
if len(validAgents) > 0 {
m.agents[agentKey] = validAgents
} else {
delete(m.agents, agentKey)
}
}
}
|
go
|
func (m *AgentPool) removeDisconnected() {
for agentKey, agentSlice := range m.agents {
// Filter and close all disconnected agents.
validAgents := filterAndClose(agentSlice, func(agent *Agent) bool {
if agent.getState() == agentStateDisconnected {
return true
}
return false
})
// Update (or delete) agent key with filter applied.
if len(validAgents) > 0 {
m.agents[agentKey] = validAgents
} else {
delete(m.agents, agentKey)
}
}
}
|
[
"func",
"(",
"m",
"*",
"AgentPool",
")",
"removeDisconnected",
"(",
")",
"{",
"for",
"agentKey",
",",
"agentSlice",
":=",
"range",
"m",
".",
"agents",
"{",
"validAgents",
":=",
"filterAndClose",
"(",
"agentSlice",
",",
"func",
"(",
"agent",
"*",
"Agent",
")",
"bool",
"{",
"if",
"agent",
".",
"getState",
"(",
")",
"==",
"agentStateDisconnected",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
")",
"\n",
"if",
"len",
"(",
"validAgents",
")",
">",
"0",
"{",
"m",
".",
"agents",
"[",
"agentKey",
"]",
"=",
"validAgents",
"\n",
"}",
"else",
"{",
"delete",
"(",
"m",
".",
"agents",
",",
"agentKey",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// removeDisconnected removes disconnected agents from the list of agents.
// This function should be called under a lock.
|
[
"removeDisconnected",
"removes",
"disconnected",
"agents",
"from",
"the",
"list",
"of",
"agents",
".",
"This",
"function",
"should",
"be",
"called",
"under",
"a",
"lock",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/agentpool.go#L447-L464
|
train
|
gravitational/teleport
|
lib/utils/storage.go
|
SetAddresses
|
func (fs *FileAddrStorage) SetAddresses(addrs []NetAddr) error {
bytes, err := json.Marshal(addrs)
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(fs.filePath, bytes, 0666)
if err != nil {
log.Error(err)
return trace.ConvertSystemError(err)
}
return nil
}
|
go
|
func (fs *FileAddrStorage) SetAddresses(addrs []NetAddr) error {
bytes, err := json.Marshal(addrs)
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(fs.filePath, bytes, 0666)
if err != nil {
log.Error(err)
return trace.ConvertSystemError(err)
}
return nil
}
|
[
"func",
"(",
"fs",
"*",
"FileAddrStorage",
")",
"SetAddresses",
"(",
"addrs",
"[",
"]",
"NetAddr",
")",
"error",
"{",
"bytes",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"addrs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"fs",
".",
"filePath",
",",
"bytes",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetAddresses updates storage with new address list
|
[
"SetAddresses",
"updates",
"storage",
"with",
"new",
"address",
"list"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/storage.go#L43-L54
|
train
|
gravitational/teleport
|
lib/utils/storage.go
|
GetAddresses
|
func (fs *FileAddrStorage) GetAddresses() ([]NetAddr, error) {
bytes, err := ioutil.ReadFile(fs.filePath)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
var addrs []NetAddr
if len(bytes) > 0 {
err = json.Unmarshal(bytes, &addrs)
if err != nil {
return nil, trace.Wrap(err)
}
}
return addrs, nil
}
|
go
|
func (fs *FileAddrStorage) GetAddresses() ([]NetAddr, error) {
bytes, err := ioutil.ReadFile(fs.filePath)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
var addrs []NetAddr
if len(bytes) > 0 {
err = json.Unmarshal(bytes, &addrs)
if err != nil {
return nil, trace.Wrap(err)
}
}
return addrs, nil
}
|
[
"func",
"(",
"fs",
"*",
"FileAddrStorage",
")",
"GetAddresses",
"(",
")",
"(",
"[",
"]",
"NetAddr",
",",
"error",
")",
"{",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"fs",
".",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"addrs",
"[",
"]",
"NetAddr",
"\n",
"if",
"len",
"(",
"bytes",
")",
">",
"0",
"{",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"addrs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"addrs",
",",
"nil",
"\n",
"}"
] |
// GetAddresses returns saved address list
|
[
"GetAddresses",
"returns",
"saved",
"address",
"list"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/storage.go#L57-L70
|
train
|
gravitational/teleport
|
lib/utils/tlsdial.go
|
TLSDial
|
func TLSDial(ctx context.Context, dial DialWithContextFunc, network, addr string, tlsConfig *tls.Config) (*tls.Conn, error) {
if tlsConfig == nil {
tlsConfig = &tls.Config{}
}
plainConn, err := dial(ctx, network, addr)
if err != nil {
return nil, trace.Wrap(err)
}
colonPos := strings.LastIndex(addr, ":")
if colonPos == -1 {
colonPos = len(addr)
}
hostname := addr[:colonPos]
// If no ServerName is set, infer the ServerName
// from the hostname we're connecting to.
if tlsConfig.ServerName == "" {
// Make a copy to avoid polluting argument or default.
c := tlsConfig.Clone()
c.ServerName = hostname
tlsConfig = c
}
conn := tls.Client(plainConn, tlsConfig)
errC := make(chan error, 1)
go func() {
err := conn.Handshake()
errC <- err
}()
select {
case err := <-errC:
if err != nil {
plainConn.Close()
return nil, trace.Wrap(err)
}
case <-ctx.Done():
plainConn.Close()
return nil, trace.BadParameter("tls handshake has been cancelled due to timeout")
}
if tlsConfig.InsecureSkipVerify {
return conn, nil
}
if err := conn.VerifyHostname(tlsConfig.ServerName); err != nil {
plainConn.Close()
return nil, trace.Wrap(err)
}
return conn, nil
}
|
go
|
func TLSDial(ctx context.Context, dial DialWithContextFunc, network, addr string, tlsConfig *tls.Config) (*tls.Conn, error) {
if tlsConfig == nil {
tlsConfig = &tls.Config{}
}
plainConn, err := dial(ctx, network, addr)
if err != nil {
return nil, trace.Wrap(err)
}
colonPos := strings.LastIndex(addr, ":")
if colonPos == -1 {
colonPos = len(addr)
}
hostname := addr[:colonPos]
// If no ServerName is set, infer the ServerName
// from the hostname we're connecting to.
if tlsConfig.ServerName == "" {
// Make a copy to avoid polluting argument or default.
c := tlsConfig.Clone()
c.ServerName = hostname
tlsConfig = c
}
conn := tls.Client(plainConn, tlsConfig)
errC := make(chan error, 1)
go func() {
err := conn.Handshake()
errC <- err
}()
select {
case err := <-errC:
if err != nil {
plainConn.Close()
return nil, trace.Wrap(err)
}
case <-ctx.Done():
plainConn.Close()
return nil, trace.BadParameter("tls handshake has been cancelled due to timeout")
}
if tlsConfig.InsecureSkipVerify {
return conn, nil
}
if err := conn.VerifyHostname(tlsConfig.ServerName); err != nil {
plainConn.Close()
return nil, trace.Wrap(err)
}
return conn, nil
}
|
[
"func",
"TLSDial",
"(",
"ctx",
"context",
".",
"Context",
",",
"dial",
"DialWithContextFunc",
",",
"network",
",",
"addr",
"string",
",",
"tlsConfig",
"*",
"tls",
".",
"Config",
")",
"(",
"*",
"tls",
".",
"Conn",
",",
"error",
")",
"{",
"if",
"tlsConfig",
"==",
"nil",
"{",
"tlsConfig",
"=",
"&",
"tls",
".",
"Config",
"{",
"}",
"\n",
"}",
"\n",
"plainConn",
",",
"err",
":=",
"dial",
"(",
"ctx",
",",
"network",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"colonPos",
":=",
"strings",
".",
"LastIndex",
"(",
"addr",
",",
"\":\"",
")",
"\n",
"if",
"colonPos",
"==",
"-",
"1",
"{",
"colonPos",
"=",
"len",
"(",
"addr",
")",
"\n",
"}",
"\n",
"hostname",
":=",
"addr",
"[",
":",
"colonPos",
"]",
"\n",
"if",
"tlsConfig",
".",
"ServerName",
"==",
"\"\"",
"{",
"c",
":=",
"tlsConfig",
".",
"Clone",
"(",
")",
"\n",
"c",
".",
"ServerName",
"=",
"hostname",
"\n",
"tlsConfig",
"=",
"c",
"\n",
"}",
"\n",
"conn",
":=",
"tls",
".",
"Client",
"(",
"plainConn",
",",
"tlsConfig",
")",
"\n",
"errC",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"err",
":=",
"conn",
".",
"Handshake",
"(",
")",
"\n",
"errC",
"<-",
"err",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"errC",
":",
"if",
"err",
"!=",
"nil",
"{",
"plainConn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"plainConn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"tls handshake has been cancelled due to timeout\"",
")",
"\n",
"}",
"\n",
"if",
"tlsConfig",
".",
"InsecureSkipVerify",
"{",
"return",
"conn",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"conn",
".",
"VerifyHostname",
"(",
"tlsConfig",
".",
"ServerName",
")",
";",
"err",
"!=",
"nil",
"{",
"plainConn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] |
// TLSDial dials and establishes TLS connection using custom dialer
// is similar to tls.DialWithDialer
|
[
"TLSDial",
"dials",
"and",
"establishes",
"TLS",
"connection",
"using",
"custom",
"dialer",
"is",
"similar",
"to",
"tls",
".",
"DialWithDialer"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/tlsdial.go#L22-L75
|
train
|
gravitational/teleport
|
lib/web/ui/usercontext.go
|
NewUserContext
|
func NewUserContext(user services.User, userRoles services.RoleSet) (*userContext, error) {
ctx := &services.Context{User: user}
sessionAccess := newAccess(userRoles, ctx, services.KindSession)
roleAccess := newAccess(userRoles, ctx, services.KindRole)
authConnectors := newAccess(userRoles, ctx, services.KindAuthConnector)
trustedClusterAccess := newAccess(userRoles, ctx, services.KindTrustedCluster)
logins := getLogins(userRoles)
acl := userACL{
AuthConnectors: authConnectors,
TrustedClusters: trustedClusterAccess,
Sessions: sessionAccess,
Roles: roleAccess,
SSHLogins: logins,
}
// local user
authType := authLocal
// check for any SSO identities
isSSO := len(user.GetOIDCIdentities()) > 0 ||
len(user.GetGithubIdentities()) > 0 ||
len(user.GetSAMLIdentities()) > 0
if isSSO {
// SSO user
authType = authSSO
}
return &userContext{
Name: user.GetName(),
ACL: acl,
AuthType: authType,
Version: teleport.Version,
}, nil
}
|
go
|
func NewUserContext(user services.User, userRoles services.RoleSet) (*userContext, error) {
ctx := &services.Context{User: user}
sessionAccess := newAccess(userRoles, ctx, services.KindSession)
roleAccess := newAccess(userRoles, ctx, services.KindRole)
authConnectors := newAccess(userRoles, ctx, services.KindAuthConnector)
trustedClusterAccess := newAccess(userRoles, ctx, services.KindTrustedCluster)
logins := getLogins(userRoles)
acl := userACL{
AuthConnectors: authConnectors,
TrustedClusters: trustedClusterAccess,
Sessions: sessionAccess,
Roles: roleAccess,
SSHLogins: logins,
}
// local user
authType := authLocal
// check for any SSO identities
isSSO := len(user.GetOIDCIdentities()) > 0 ||
len(user.GetGithubIdentities()) > 0 ||
len(user.GetSAMLIdentities()) > 0
if isSSO {
// SSO user
authType = authSSO
}
return &userContext{
Name: user.GetName(),
ACL: acl,
AuthType: authType,
Version: teleport.Version,
}, nil
}
|
[
"func",
"NewUserContext",
"(",
"user",
"services",
".",
"User",
",",
"userRoles",
"services",
".",
"RoleSet",
")",
"(",
"*",
"userContext",
",",
"error",
")",
"{",
"ctx",
":=",
"&",
"services",
".",
"Context",
"{",
"User",
":",
"user",
"}",
"\n",
"sessionAccess",
":=",
"newAccess",
"(",
"userRoles",
",",
"ctx",
",",
"services",
".",
"KindSession",
")",
"\n",
"roleAccess",
":=",
"newAccess",
"(",
"userRoles",
",",
"ctx",
",",
"services",
".",
"KindRole",
")",
"\n",
"authConnectors",
":=",
"newAccess",
"(",
"userRoles",
",",
"ctx",
",",
"services",
".",
"KindAuthConnector",
")",
"\n",
"trustedClusterAccess",
":=",
"newAccess",
"(",
"userRoles",
",",
"ctx",
",",
"services",
".",
"KindTrustedCluster",
")",
"\n",
"logins",
":=",
"getLogins",
"(",
"userRoles",
")",
"\n",
"acl",
":=",
"userACL",
"{",
"AuthConnectors",
":",
"authConnectors",
",",
"TrustedClusters",
":",
"trustedClusterAccess",
",",
"Sessions",
":",
"sessionAccess",
",",
"Roles",
":",
"roleAccess",
",",
"SSHLogins",
":",
"logins",
",",
"}",
"\n",
"authType",
":=",
"authLocal",
"\n",
"isSSO",
":=",
"len",
"(",
"user",
".",
"GetOIDCIdentities",
"(",
")",
")",
">",
"0",
"||",
"len",
"(",
"user",
".",
"GetGithubIdentities",
"(",
")",
")",
">",
"0",
"||",
"len",
"(",
"user",
".",
"GetSAMLIdentities",
"(",
")",
")",
">",
"0",
"\n",
"if",
"isSSO",
"{",
"authType",
"=",
"authSSO",
"\n",
"}",
"\n",
"return",
"&",
"userContext",
"{",
"Name",
":",
"user",
".",
"GetName",
"(",
")",
",",
"ACL",
":",
"acl",
",",
"AuthType",
":",
"authType",
",",
"Version",
":",
"teleport",
".",
"Version",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewUserContext constructs user context from roles assigned to user
|
[
"NewUserContext",
"constructs",
"user",
"context",
"from",
"roles",
"assigned",
"to",
"user"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/ui/usercontext.go#L110-L145
|
train
|
gravitational/teleport
|
lib/auth/middleware.go
|
Serve
|
func (t *TLSServer) Serve(listener net.Listener) error {
return t.Server.Serve(tls.NewListener(listener, t.TLS))
}
|
go
|
func (t *TLSServer) Serve(listener net.Listener) error {
return t.Server.Serve(tls.NewListener(listener, t.TLS))
}
|
[
"func",
"(",
"t",
"*",
"TLSServer",
")",
"Serve",
"(",
"listener",
"net",
".",
"Listener",
")",
"error",
"{",
"return",
"t",
".",
"Server",
".",
"Serve",
"(",
"tls",
".",
"NewListener",
"(",
"listener",
",",
"t",
".",
"TLS",
")",
")",
"\n",
"}"
] |
// Serve takes TCP listener, upgrades to TLS using config and starts serving
|
[
"Serve",
"takes",
"TCP",
"listener",
"upgrades",
"to",
"TLS",
"using",
"config",
"and",
"starts",
"serving"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/middleware.go#L126-L128
|
train
|
gravitational/teleport
|
lib/auth/middleware.go
|
GetUser
|
func (a *AuthMiddleware) GetUser(r *http.Request) (interface{}, error) {
peers := r.TLS.PeerCertificates
if len(peers) > 1 {
// when turning intermediaries on, don't forget to verify
// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59
return nil, trace.AccessDenied("access denied: intermediaries are not supported")
}
localClusterName, err := a.AccessPoint.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
// with no client authentication in place, middleware
// assumes not-privileged Nop role.
// it theoretically possible to use bearer token auth even
// for connections without auth, but this is not active use-case
// therefore it is not allowed to reduce scope
if len(peers) == 0 {
return BuiltinRole{
GetClusterConfig: a.AccessPoint.GetClusterConfig,
Role: teleport.RoleNop,
Username: string(teleport.RoleNop),
ClusterName: localClusterName.GetClusterName(),
}, nil
}
clientCert := peers[0]
certClusterName, err := tlsca.ClusterName(clientCert.Issuer)
if err != nil {
log.Warnf("Failed to parse client certificate %v.", err)
return nil, trace.AccessDenied("access denied: invalid client certificate")
}
identity, err := tlsca.FromSubject(clientCert.Subject)
if err != nil {
return nil, trace.Wrap(err)
}
// If there is any restriction on the certificate usage
// reject the API server request. This is done so some classes
// of certificates issued for kubernetes usage by proxy, can not be used
// against auth server. Later on we can extend more
// advanced cert usage, but for now this is the safest option.
if len(identity.Usage) != 0 && !utils.StringSlicesEqual(a.AcceptedUsage, identity.Usage) {
log.Warningf("Restricted certificate of user %q with usage %v rejected while accessing the auth endpoint with acceptable usage %v.",
identity.Username, identity.Usage, a.AcceptedUsage)
return nil, trace.AccessDenied("access denied: invalid client certificate")
}
// this block assumes interactive user from remote cluster
// based on the remote certificate authority cluster name encoded in
// x509 organization name. This is a safe check because:
// 1. Trust and verification is established during TLS handshake
// by creating a cert pool constructed of trusted certificate authorities
// 2. Remote CAs are not allowed to have the same cluster name
// as the local certificate authority
if certClusterName != localClusterName.GetClusterName() {
// make sure that this user does not have system role
// the local auth server can not truste remote servers
// to issue certificates with system roles (e.g. Admin),
// to get unrestricted access to the local cluster
systemRole := findSystemRole(identity.Groups)
if systemRole != nil {
return RemoteBuiltinRole{
Role: *systemRole,
Username: identity.Username,
ClusterName: certClusterName,
}, nil
}
return RemoteUser{
ClusterName: certClusterName,
Username: identity.Username,
Principals: identity.Principals,
KubernetesGroups: identity.KubernetesGroups,
RemoteRoles: identity.Groups,
}, nil
}
// code below expects user or service from local cluster, to distinguish between
// interactive users and services (e.g. proxies), the code below
// checks for presence of system roles issued in certificate identity
systemRole := findSystemRole(identity.Groups)
// in case if the system role is present, assume this is a service
// agent, e.g. Proxy, connecting to the cluster
if systemRole != nil {
return BuiltinRole{
GetClusterConfig: a.AccessPoint.GetClusterConfig,
Role: *systemRole,
Username: identity.Username,
ClusterName: localClusterName.GetClusterName(),
}, nil
}
// otherwise assume that is a local role, no need to pass the roles
// as it will be fetched from the local database
return LocalUser{
Username: identity.Username,
}, nil
}
|
go
|
func (a *AuthMiddleware) GetUser(r *http.Request) (interface{}, error) {
peers := r.TLS.PeerCertificates
if len(peers) > 1 {
// when turning intermediaries on, don't forget to verify
// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59
return nil, trace.AccessDenied("access denied: intermediaries are not supported")
}
localClusterName, err := a.AccessPoint.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
// with no client authentication in place, middleware
// assumes not-privileged Nop role.
// it theoretically possible to use bearer token auth even
// for connections without auth, but this is not active use-case
// therefore it is not allowed to reduce scope
if len(peers) == 0 {
return BuiltinRole{
GetClusterConfig: a.AccessPoint.GetClusterConfig,
Role: teleport.RoleNop,
Username: string(teleport.RoleNop),
ClusterName: localClusterName.GetClusterName(),
}, nil
}
clientCert := peers[0]
certClusterName, err := tlsca.ClusterName(clientCert.Issuer)
if err != nil {
log.Warnf("Failed to parse client certificate %v.", err)
return nil, trace.AccessDenied("access denied: invalid client certificate")
}
identity, err := tlsca.FromSubject(clientCert.Subject)
if err != nil {
return nil, trace.Wrap(err)
}
// If there is any restriction on the certificate usage
// reject the API server request. This is done so some classes
// of certificates issued for kubernetes usage by proxy, can not be used
// against auth server. Later on we can extend more
// advanced cert usage, but for now this is the safest option.
if len(identity.Usage) != 0 && !utils.StringSlicesEqual(a.AcceptedUsage, identity.Usage) {
log.Warningf("Restricted certificate of user %q with usage %v rejected while accessing the auth endpoint with acceptable usage %v.",
identity.Username, identity.Usage, a.AcceptedUsage)
return nil, trace.AccessDenied("access denied: invalid client certificate")
}
// this block assumes interactive user from remote cluster
// based on the remote certificate authority cluster name encoded in
// x509 organization name. This is a safe check because:
// 1. Trust and verification is established during TLS handshake
// by creating a cert pool constructed of trusted certificate authorities
// 2. Remote CAs are not allowed to have the same cluster name
// as the local certificate authority
if certClusterName != localClusterName.GetClusterName() {
// make sure that this user does not have system role
// the local auth server can not truste remote servers
// to issue certificates with system roles (e.g. Admin),
// to get unrestricted access to the local cluster
systemRole := findSystemRole(identity.Groups)
if systemRole != nil {
return RemoteBuiltinRole{
Role: *systemRole,
Username: identity.Username,
ClusterName: certClusterName,
}, nil
}
return RemoteUser{
ClusterName: certClusterName,
Username: identity.Username,
Principals: identity.Principals,
KubernetesGroups: identity.KubernetesGroups,
RemoteRoles: identity.Groups,
}, nil
}
// code below expects user or service from local cluster, to distinguish between
// interactive users and services (e.g. proxies), the code below
// checks for presence of system roles issued in certificate identity
systemRole := findSystemRole(identity.Groups)
// in case if the system role is present, assume this is a service
// agent, e.g. Proxy, connecting to the cluster
if systemRole != nil {
return BuiltinRole{
GetClusterConfig: a.AccessPoint.GetClusterConfig,
Role: *systemRole,
Username: identity.Username,
ClusterName: localClusterName.GetClusterName(),
}, nil
}
// otherwise assume that is a local role, no need to pass the roles
// as it will be fetched from the local database
return LocalUser{
Username: identity.Username,
}, nil
}
|
[
"func",
"(",
"a",
"*",
"AuthMiddleware",
")",
"GetUser",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"peers",
":=",
"r",
".",
"TLS",
".",
"PeerCertificates",
"\n",
"if",
"len",
"(",
"peers",
")",
">",
"1",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"access denied: intermediaries are not supported\"",
")",
"\n",
"}",
"\n",
"localClusterName",
",",
"err",
":=",
"a",
".",
"AccessPoint",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"peers",
")",
"==",
"0",
"{",
"return",
"BuiltinRole",
"{",
"GetClusterConfig",
":",
"a",
".",
"AccessPoint",
".",
"GetClusterConfig",
",",
"Role",
":",
"teleport",
".",
"RoleNop",
",",
"Username",
":",
"string",
"(",
"teleport",
".",
"RoleNop",
")",
",",
"ClusterName",
":",
"localClusterName",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"clientCert",
":=",
"peers",
"[",
"0",
"]",
"\n",
"certClusterName",
",",
"err",
":=",
"tlsca",
".",
"ClusterName",
"(",
"clientCert",
".",
"Issuer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Failed to parse client certificate %v.\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"access denied: invalid client certificate\"",
")",
"\n",
"}",
"\n",
"identity",
",",
"err",
":=",
"tlsca",
".",
"FromSubject",
"(",
"clientCert",
".",
"Subject",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"identity",
".",
"Usage",
")",
"!=",
"0",
"&&",
"!",
"utils",
".",
"StringSlicesEqual",
"(",
"a",
".",
"AcceptedUsage",
",",
"identity",
".",
"Usage",
")",
"{",
"log",
".",
"Warningf",
"(",
"\"Restricted certificate of user %q with usage %v rejected while accessing the auth endpoint with acceptable usage %v.\"",
",",
"identity",
".",
"Username",
",",
"identity",
".",
"Usage",
",",
"a",
".",
"AcceptedUsage",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"access denied: invalid client certificate\"",
")",
"\n",
"}",
"\n",
"if",
"certClusterName",
"!=",
"localClusterName",
".",
"GetClusterName",
"(",
")",
"{",
"systemRole",
":=",
"findSystemRole",
"(",
"identity",
".",
"Groups",
")",
"\n",
"if",
"systemRole",
"!=",
"nil",
"{",
"return",
"RemoteBuiltinRole",
"{",
"Role",
":",
"*",
"systemRole",
",",
"Username",
":",
"identity",
".",
"Username",
",",
"ClusterName",
":",
"certClusterName",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"RemoteUser",
"{",
"ClusterName",
":",
"certClusterName",
",",
"Username",
":",
"identity",
".",
"Username",
",",
"Principals",
":",
"identity",
".",
"Principals",
",",
"KubernetesGroups",
":",
"identity",
".",
"KubernetesGroups",
",",
"RemoteRoles",
":",
"identity",
".",
"Groups",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"systemRole",
":=",
"findSystemRole",
"(",
"identity",
".",
"Groups",
")",
"\n",
"if",
"systemRole",
"!=",
"nil",
"{",
"return",
"BuiltinRole",
"{",
"GetClusterConfig",
":",
"a",
".",
"AccessPoint",
".",
"GetClusterConfig",
",",
"Role",
":",
"*",
"systemRole",
",",
"Username",
":",
"identity",
".",
"Username",
",",
"ClusterName",
":",
"localClusterName",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"LocalUser",
"{",
"Username",
":",
"identity",
".",
"Username",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// GetUser returns authenticated user based on request metadata set by HTTP server
|
[
"GetUser",
"returns",
"authenticated",
"user",
"based",
"on",
"request",
"metadata",
"set",
"by",
"HTTP",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/middleware.go#L189-L282
|
train
|
gravitational/teleport
|
lib/auth/middleware.go
|
ServeHTTP
|
func (a *AuthMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
baseContext := r.Context()
if baseContext == nil {
baseContext = context.TODO()
}
user, err := a.GetUser(r)
if err != nil {
trace.WriteError(w, err)
return
}
// determine authenticated user based on the request parameters
requestWithContext := r.WithContext(context.WithValue(baseContext, ContextUser, user))
a.Handler.ServeHTTP(w, requestWithContext)
}
|
go
|
func (a *AuthMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
baseContext := r.Context()
if baseContext == nil {
baseContext = context.TODO()
}
user, err := a.GetUser(r)
if err != nil {
trace.WriteError(w, err)
return
}
// determine authenticated user based on the request parameters
requestWithContext := r.WithContext(context.WithValue(baseContext, ContextUser, user))
a.Handler.ServeHTTP(w, requestWithContext)
}
|
[
"func",
"(",
"a",
"*",
"AuthMiddleware",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"baseContext",
":=",
"r",
".",
"Context",
"(",
")",
"\n",
"if",
"baseContext",
"==",
"nil",
"{",
"baseContext",
"=",
"context",
".",
"TODO",
"(",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"a",
".",
"GetUser",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"trace",
".",
"WriteError",
"(",
"w",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"requestWithContext",
":=",
"r",
".",
"WithContext",
"(",
"context",
".",
"WithValue",
"(",
"baseContext",
",",
"ContextUser",
",",
"user",
")",
")",
"\n",
"a",
".",
"Handler",
".",
"ServeHTTP",
"(",
"w",
",",
"requestWithContext",
")",
"\n",
"}"
] |
// ServeHTTP serves HTTP requests
|
[
"ServeHTTP",
"serves",
"HTTP",
"requests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/middleware.go#L296-L310
|
train
|
gravitational/teleport
|
lib/auth/middleware.go
|
ClientCertPool
|
func ClientCertPool(client AccessCache, clusterName string) (*x509.CertPool, error) {
pool := x509.NewCertPool()
var authorities []services.CertAuthority
if clusterName == "" {
hostCAs, err := client.GetCertAuthorities(services.HostCA, false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
userCAs, err := client.GetCertAuthorities(services.UserCA, false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
authorities = append(authorities, hostCAs...)
authorities = append(authorities, userCAs...)
} else {
hostCA, err := client.GetCertAuthority(
services.CertAuthID{Type: services.HostCA, DomainName: clusterName},
false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
userCA, err := client.GetCertAuthority(
services.CertAuthID{Type: services.UserCA, DomainName: clusterName},
false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
authorities = append(authorities, hostCA)
authorities = append(authorities, userCA)
}
for _, auth := range authorities {
for _, keyPair := range auth.GetTLSKeyPairs() {
cert, err := tlsca.ParseCertificatePEM(keyPair.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("ClientCertPool -> %v", CertInfo(cert))
pool.AddCert(cert)
}
}
return pool, nil
}
|
go
|
func ClientCertPool(client AccessCache, clusterName string) (*x509.CertPool, error) {
pool := x509.NewCertPool()
var authorities []services.CertAuthority
if clusterName == "" {
hostCAs, err := client.GetCertAuthorities(services.HostCA, false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
userCAs, err := client.GetCertAuthorities(services.UserCA, false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
authorities = append(authorities, hostCAs...)
authorities = append(authorities, userCAs...)
} else {
hostCA, err := client.GetCertAuthority(
services.CertAuthID{Type: services.HostCA, DomainName: clusterName},
false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
userCA, err := client.GetCertAuthority(
services.CertAuthID{Type: services.UserCA, DomainName: clusterName},
false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
authorities = append(authorities, hostCA)
authorities = append(authorities, userCA)
}
for _, auth := range authorities {
for _, keyPair := range auth.GetTLSKeyPairs() {
cert, err := tlsca.ParseCertificatePEM(keyPair.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("ClientCertPool -> %v", CertInfo(cert))
pool.AddCert(cert)
}
}
return pool, nil
}
|
[
"func",
"ClientCertPool",
"(",
"client",
"AccessCache",
",",
"clusterName",
"string",
")",
"(",
"*",
"x509",
".",
"CertPool",
",",
"error",
")",
"{",
"pool",
":=",
"x509",
".",
"NewCertPool",
"(",
")",
"\n",
"var",
"authorities",
"[",
"]",
"services",
".",
"CertAuthority",
"\n",
"if",
"clusterName",
"==",
"\"\"",
"{",
"hostCAs",
",",
"err",
":=",
"client",
".",
"GetCertAuthorities",
"(",
"services",
".",
"HostCA",
",",
"false",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"userCAs",
",",
"err",
":=",
"client",
".",
"GetCertAuthorities",
"(",
"services",
".",
"UserCA",
",",
"false",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authorities",
"=",
"append",
"(",
"authorities",
",",
"hostCAs",
"...",
")",
"\n",
"authorities",
"=",
"append",
"(",
"authorities",
",",
"userCAs",
"...",
")",
"\n",
"}",
"else",
"{",
"hostCA",
",",
"err",
":=",
"client",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"HostCA",
",",
"DomainName",
":",
"clusterName",
"}",
",",
"false",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"userCA",
",",
"err",
":=",
"client",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"UserCA",
",",
"DomainName",
":",
"clusterName",
"}",
",",
"false",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authorities",
"=",
"append",
"(",
"authorities",
",",
"hostCA",
")",
"\n",
"authorities",
"=",
"append",
"(",
"authorities",
",",
"userCA",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"auth",
":=",
"range",
"authorities",
"{",
"for",
"_",
",",
"keyPair",
":=",
"range",
"auth",
".",
"GetTLSKeyPairs",
"(",
")",
"{",
"cert",
",",
"err",
":=",
"tlsca",
".",
"ParseCertificatePEM",
"(",
"keyPair",
".",
"Cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"ClientCertPool -> %v\"",
",",
"CertInfo",
"(",
"cert",
")",
")",
"\n",
"pool",
".",
"AddCert",
"(",
"cert",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"pool",
",",
"nil",
"\n",
"}"
] |
// ClientCertPool returns trusted x509 cerificate authority pool
|
[
"ClientCertPool",
"returns",
"trusted",
"x509",
"cerificate",
"authority",
"pool"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/middleware.go#L313-L355
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
applySSHConfig
|
func applySSHConfig(fc *FileConfig, cfg *service.Config) error {
if fc.SSH.ListenAddress != "" {
addr, err := utils.ParseHostPortAddr(fc.SSH.ListenAddress, int(defaults.SSHServerListenPort))
if err != nil {
return trace.Wrap(err)
}
cfg.SSH.Addr = *addr
}
if fc.SSH.Labels != nil {
cfg.SSH.Labels = make(map[string]string)
for k, v := range fc.SSH.Labels {
cfg.SSH.Labels[k] = v
}
}
if fc.SSH.Commands != nil {
cfg.SSH.CmdLabels = make(services.CommandLabels)
for _, cmdLabel := range fc.SSH.Commands {
cfg.SSH.CmdLabels[cmdLabel.Name] = &services.CommandLabelV2{
Period: services.NewDuration(cmdLabel.Period),
Command: cmdLabel.Command,
Result: "",
}
}
}
if fc.SSH.Namespace != "" {
cfg.SSH.Namespace = fc.SSH.Namespace
}
if fc.SSH.PermitUserEnvironment {
cfg.SSH.PermitUserEnvironment = true
}
if fc.SSH.PAM != nil {
cfg.SSH.PAM = fc.SSH.PAM.Parse()
// If PAM is enabled, make sure that Teleport was built with PAM support
// and the PAM library was found at runtime.
if cfg.SSH.PAM.Enabled {
if !pam.BuildHasPAM() {
errorMessage := "Unable to start Teleport: PAM was enabled in file configuration but this \n" +
"Teleport binary was built without PAM support. To continue either download a \n" +
"Teleport binary build with PAM support from https://gravitational.com/teleport \n" +
"or disable PAM in file configuration."
return trace.BadParameter(errorMessage)
}
if !pam.SystemHasPAM() {
errorMessage := "Unable to start Teleport: PAM was enabled in file configuration but this \n" +
"system does not have the needed PAM library installed. To continue either \n" +
"install libpam or disable PAM in file configuration."
return trace.BadParameter(errorMessage)
}
}
}
if len(fc.SSH.PublicAddr) != 0 {
addrs, err := fc.SSH.PublicAddr.Addrs(defaults.SSHServerListenPort)
if err != nil {
return trace.Wrap(err)
}
cfg.SSH.PublicAddrs = addrs
}
return nil
}
|
go
|
func applySSHConfig(fc *FileConfig, cfg *service.Config) error {
if fc.SSH.ListenAddress != "" {
addr, err := utils.ParseHostPortAddr(fc.SSH.ListenAddress, int(defaults.SSHServerListenPort))
if err != nil {
return trace.Wrap(err)
}
cfg.SSH.Addr = *addr
}
if fc.SSH.Labels != nil {
cfg.SSH.Labels = make(map[string]string)
for k, v := range fc.SSH.Labels {
cfg.SSH.Labels[k] = v
}
}
if fc.SSH.Commands != nil {
cfg.SSH.CmdLabels = make(services.CommandLabels)
for _, cmdLabel := range fc.SSH.Commands {
cfg.SSH.CmdLabels[cmdLabel.Name] = &services.CommandLabelV2{
Period: services.NewDuration(cmdLabel.Period),
Command: cmdLabel.Command,
Result: "",
}
}
}
if fc.SSH.Namespace != "" {
cfg.SSH.Namespace = fc.SSH.Namespace
}
if fc.SSH.PermitUserEnvironment {
cfg.SSH.PermitUserEnvironment = true
}
if fc.SSH.PAM != nil {
cfg.SSH.PAM = fc.SSH.PAM.Parse()
// If PAM is enabled, make sure that Teleport was built with PAM support
// and the PAM library was found at runtime.
if cfg.SSH.PAM.Enabled {
if !pam.BuildHasPAM() {
errorMessage := "Unable to start Teleport: PAM was enabled in file configuration but this \n" +
"Teleport binary was built without PAM support. To continue either download a \n" +
"Teleport binary build with PAM support from https://gravitational.com/teleport \n" +
"or disable PAM in file configuration."
return trace.BadParameter(errorMessage)
}
if !pam.SystemHasPAM() {
errorMessage := "Unable to start Teleport: PAM was enabled in file configuration but this \n" +
"system does not have the needed PAM library installed. To continue either \n" +
"install libpam or disable PAM in file configuration."
return trace.BadParameter(errorMessage)
}
}
}
if len(fc.SSH.PublicAddr) != 0 {
addrs, err := fc.SSH.PublicAddr.Addrs(defaults.SSHServerListenPort)
if err != nil {
return trace.Wrap(err)
}
cfg.SSH.PublicAddrs = addrs
}
return nil
}
|
[
"func",
"applySSHConfig",
"(",
"fc",
"*",
"FileConfig",
",",
"cfg",
"*",
"service",
".",
"Config",
")",
"error",
"{",
"if",
"fc",
".",
"SSH",
".",
"ListenAddress",
"!=",
"\"\"",
"{",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseHostPortAddr",
"(",
"fc",
".",
"SSH",
".",
"ListenAddress",
",",
"int",
"(",
"defaults",
".",
"SSHServerListenPort",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cfg",
".",
"SSH",
".",
"Addr",
"=",
"*",
"addr",
"\n",
"}",
"\n",
"if",
"fc",
".",
"SSH",
".",
"Labels",
"!=",
"nil",
"{",
"cfg",
".",
"SSH",
".",
"Labels",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"fc",
".",
"SSH",
".",
"Labels",
"{",
"cfg",
".",
"SSH",
".",
"Labels",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"fc",
".",
"SSH",
".",
"Commands",
"!=",
"nil",
"{",
"cfg",
".",
"SSH",
".",
"CmdLabels",
"=",
"make",
"(",
"services",
".",
"CommandLabels",
")",
"\n",
"for",
"_",
",",
"cmdLabel",
":=",
"range",
"fc",
".",
"SSH",
".",
"Commands",
"{",
"cfg",
".",
"SSH",
".",
"CmdLabels",
"[",
"cmdLabel",
".",
"Name",
"]",
"=",
"&",
"services",
".",
"CommandLabelV2",
"{",
"Period",
":",
"services",
".",
"NewDuration",
"(",
"cmdLabel",
".",
"Period",
")",
",",
"Command",
":",
"cmdLabel",
".",
"Command",
",",
"Result",
":",
"\"\"",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"fc",
".",
"SSH",
".",
"Namespace",
"!=",
"\"\"",
"{",
"cfg",
".",
"SSH",
".",
"Namespace",
"=",
"fc",
".",
"SSH",
".",
"Namespace",
"\n",
"}",
"\n",
"if",
"fc",
".",
"SSH",
".",
"PermitUserEnvironment",
"{",
"cfg",
".",
"SSH",
".",
"PermitUserEnvironment",
"=",
"true",
"\n",
"}",
"\n",
"if",
"fc",
".",
"SSH",
".",
"PAM",
"!=",
"nil",
"{",
"cfg",
".",
"SSH",
".",
"PAM",
"=",
"fc",
".",
"SSH",
".",
"PAM",
".",
"Parse",
"(",
")",
"\n",
"if",
"cfg",
".",
"SSH",
".",
"PAM",
".",
"Enabled",
"{",
"if",
"!",
"pam",
".",
"BuildHasPAM",
"(",
")",
"{",
"errorMessage",
":=",
"\"Unable to start Teleport: PAM was enabled in file configuration but this \\n\"",
"+",
"\\n",
"+",
"\"Teleport binary was built without PAM support. To continue either download a \\n\"",
"+",
"\\n",
"\n",
"\"Teleport binary build with PAM support from https://gravitational.com/teleport \\n\"",
"\n",
"}",
"\n",
"\\n",
"\n",
"}",
"\n",
"}",
"\n",
"\"or disable PAM in file configuration.\"",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"errorMessage",
")",
"\n",
"}"
] |
// applySSHConfig applies file configuration for the "ssh_service" section.
|
[
"applySSHConfig",
"applies",
"file",
"configuration",
"for",
"the",
"ssh_service",
"section",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L560-L620
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
parseAuthorizedKeys
|
func parseAuthorizedKeys(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
pubkey, comment, _, _, err := ssh.ParseAuthorizedKey(bytes)
if err != nil {
return nil, nil, trace.Wrap(err)
}
comments, err := url.ParseQuery(comment)
if err != nil {
return nil, nil, trace.Wrap(err)
}
clusterName := comments.Get("clustername")
if clusterName == "" {
return nil, nil, trace.BadParameter("no clustername provided")
}
// create a new certificate authority
ca := services.NewCertAuthority(
services.UserCA,
clusterName,
nil,
[][]byte{ssh.MarshalAuthorizedKey(pubkey)},
nil)
// transform old allowed logins into roles
role := services.RoleForCertAuthority(ca)
role.SetLogins(services.Allow, allowedLogins)
ca.AddRole(role.GetName())
return ca, role, nil
}
|
go
|
func parseAuthorizedKeys(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
pubkey, comment, _, _, err := ssh.ParseAuthorizedKey(bytes)
if err != nil {
return nil, nil, trace.Wrap(err)
}
comments, err := url.ParseQuery(comment)
if err != nil {
return nil, nil, trace.Wrap(err)
}
clusterName := comments.Get("clustername")
if clusterName == "" {
return nil, nil, trace.BadParameter("no clustername provided")
}
// create a new certificate authority
ca := services.NewCertAuthority(
services.UserCA,
clusterName,
nil,
[][]byte{ssh.MarshalAuthorizedKey(pubkey)},
nil)
// transform old allowed logins into roles
role := services.RoleForCertAuthority(ca)
role.SetLogins(services.Allow, allowedLogins)
ca.AddRole(role.GetName())
return ca, role, nil
}
|
[
"func",
"parseAuthorizedKeys",
"(",
"bytes",
"[",
"]",
"byte",
",",
"allowedLogins",
"[",
"]",
"string",
")",
"(",
"services",
".",
"CertAuthority",
",",
"services",
".",
"Role",
",",
"error",
")",
"{",
"pubkey",
",",
"comment",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"comments",
",",
"err",
":=",
"url",
".",
"ParseQuery",
"(",
"comment",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"clusterName",
":=",
"comments",
".",
"Get",
"(",
"\"clustername\"",
")",
"\n",
"if",
"clusterName",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"no clustername provided\"",
")",
"\n",
"}",
"\n",
"ca",
":=",
"services",
".",
"NewCertAuthority",
"(",
"services",
".",
"UserCA",
",",
"clusterName",
",",
"nil",
",",
"[",
"]",
"[",
"]",
"byte",
"{",
"ssh",
".",
"MarshalAuthorizedKey",
"(",
"pubkey",
")",
"}",
",",
"nil",
")",
"\n",
"role",
":=",
"services",
".",
"RoleForCertAuthority",
"(",
"ca",
")",
"\n",
"role",
".",
"SetLogins",
"(",
"services",
".",
"Allow",
",",
"allowedLogins",
")",
"\n",
"ca",
".",
"AddRole",
"(",
"role",
".",
"GetName",
"(",
")",
")",
"\n",
"return",
"ca",
",",
"role",
",",
"nil",
"\n",
"}"
] |
// parseAuthorizedKeys parses keys in the authorized_keys format and
// returns a services.CertAuthority.
|
[
"parseAuthorizedKeys",
"parses",
"keys",
"in",
"the",
"authorized_keys",
"format",
"and",
"returns",
"a",
"services",
".",
"CertAuthority",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L624-L653
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
parseKnownHosts
|
func parseKnownHosts(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
marker, options, pubKey, comment, _, err := ssh.ParseKnownHosts(bytes)
if marker != "cert-authority" {
return nil, nil, trace.BadParameter("invalid file format. expected '@cert-authority` marker")
}
if err != nil {
return nil, nil, trace.BadParameter("invalid public key")
}
teleportOpts, err := url.ParseQuery(comment)
if err != nil {
return nil, nil, trace.BadParameter("invalid key comment: '%s'", comment)
}
authType := services.CertAuthType(teleportOpts.Get("type"))
if authType != services.HostCA && authType != services.UserCA {
return nil, nil, trace.BadParameter("unsupported CA type: '%s'", authType)
}
if len(options) == 0 {
return nil, nil, trace.BadParameter("key without cluster_name")
}
const prefix = "*."
domainName := strings.TrimPrefix(options[0], prefix)
v1 := &services.CertAuthorityV1{
AllowedLogins: utils.CopyStrings(allowedLogins),
DomainName: domainName,
Type: authType,
CheckingKeys: [][]byte{ssh.MarshalAuthorizedKey(pubKey)},
}
ca, role := services.ConvertV1CertAuthority(v1)
return ca, role, nil
}
|
go
|
func parseKnownHosts(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
marker, options, pubKey, comment, _, err := ssh.ParseKnownHosts(bytes)
if marker != "cert-authority" {
return nil, nil, trace.BadParameter("invalid file format. expected '@cert-authority` marker")
}
if err != nil {
return nil, nil, trace.BadParameter("invalid public key")
}
teleportOpts, err := url.ParseQuery(comment)
if err != nil {
return nil, nil, trace.BadParameter("invalid key comment: '%s'", comment)
}
authType := services.CertAuthType(teleportOpts.Get("type"))
if authType != services.HostCA && authType != services.UserCA {
return nil, nil, trace.BadParameter("unsupported CA type: '%s'", authType)
}
if len(options) == 0 {
return nil, nil, trace.BadParameter("key without cluster_name")
}
const prefix = "*."
domainName := strings.TrimPrefix(options[0], prefix)
v1 := &services.CertAuthorityV1{
AllowedLogins: utils.CopyStrings(allowedLogins),
DomainName: domainName,
Type: authType,
CheckingKeys: [][]byte{ssh.MarshalAuthorizedKey(pubKey)},
}
ca, role := services.ConvertV1CertAuthority(v1)
return ca, role, nil
}
|
[
"func",
"parseKnownHosts",
"(",
"bytes",
"[",
"]",
"byte",
",",
"allowedLogins",
"[",
"]",
"string",
")",
"(",
"services",
".",
"CertAuthority",
",",
"services",
".",
"Role",
",",
"error",
")",
"{",
"marker",
",",
"options",
",",
"pubKey",
",",
"comment",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseKnownHosts",
"(",
"bytes",
")",
"\n",
"if",
"marker",
"!=",
"\"cert-authority\"",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid file format. expected '@cert-authority` marker\"",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid public key\"",
")",
"\n",
"}",
"\n",
"teleportOpts",
",",
"err",
":=",
"url",
".",
"ParseQuery",
"(",
"comment",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid key comment: '%s'\"",
",",
"comment",
")",
"\n",
"}",
"\n",
"authType",
":=",
"services",
".",
"CertAuthType",
"(",
"teleportOpts",
".",
"Get",
"(",
"\"type\"",
")",
")",
"\n",
"if",
"authType",
"!=",
"services",
".",
"HostCA",
"&&",
"authType",
"!=",
"services",
".",
"UserCA",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unsupported CA type: '%s'\"",
",",
"authType",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"options",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"key without cluster_name\"",
")",
"\n",
"}",
"\n",
"const",
"prefix",
"=",
"\"*.\"",
"\n",
"domainName",
":=",
"strings",
".",
"TrimPrefix",
"(",
"options",
"[",
"0",
"]",
",",
"prefix",
")",
"\n",
"v1",
":=",
"&",
"services",
".",
"CertAuthorityV1",
"{",
"AllowedLogins",
":",
"utils",
".",
"CopyStrings",
"(",
"allowedLogins",
")",
",",
"DomainName",
":",
"domainName",
",",
"Type",
":",
"authType",
",",
"CheckingKeys",
":",
"[",
"]",
"[",
"]",
"byte",
"{",
"ssh",
".",
"MarshalAuthorizedKey",
"(",
"pubKey",
")",
"}",
",",
"}",
"\n",
"ca",
",",
"role",
":=",
"services",
".",
"ConvertV1CertAuthority",
"(",
"v1",
")",
"\n",
"return",
"ca",
",",
"role",
",",
"nil",
"\n",
"}"
] |
// parseKnownHosts parses keys in known_hosts format and returns a
// services.CertAuthority.
|
[
"parseKnownHosts",
"parses",
"keys",
"in",
"known_hosts",
"format",
"and",
"returns",
"a",
"services",
".",
"CertAuthority",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L657-L687
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
certificateAuthorityFormat
|
func certificateAuthorityFormat(bytes []byte) (string, error) {
_, _, _, _, err := ssh.ParseAuthorizedKey(bytes)
if err != nil {
_, _, _, _, _, err := ssh.ParseKnownHosts(bytes)
if err != nil {
return "", trace.BadParameter("unknown ca format")
}
return teleport.KnownHosts, nil
}
return teleport.AuthorizedKeys, nil
}
|
go
|
func certificateAuthorityFormat(bytes []byte) (string, error) {
_, _, _, _, err := ssh.ParseAuthorizedKey(bytes)
if err != nil {
_, _, _, _, _, err := ssh.ParseKnownHosts(bytes)
if err != nil {
return "", trace.BadParameter("unknown ca format")
}
return teleport.KnownHosts, nil
}
return teleport.AuthorizedKeys, nil
}
|
[
"func",
"certificateAuthorityFormat",
"(",
"bytes",
"[",
"]",
"byte",
")",
"(",
"string",
",",
"error",
")",
"{",
"_",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"_",
",",
"_",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseKnownHosts",
"(",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"unknown ca format\"",
")",
"\n",
"}",
"\n",
"return",
"teleport",
".",
"KnownHosts",
",",
"nil",
"\n",
"}",
"\n",
"return",
"teleport",
".",
"AuthorizedKeys",
",",
"nil",
"\n",
"}"
] |
// certificateAuthorityFormat parses bytes and determines if they are in
// known_hosts format or authorized_keys format.
|
[
"certificateAuthorityFormat",
"parses",
"bytes",
"and",
"determines",
"if",
"they",
"are",
"in",
"known_hosts",
"format",
"or",
"authorized_keys",
"format",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L691-L701
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
parseCAKey
|
func parseCAKey(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
caFormat, err := certificateAuthorityFormat(bytes)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if caFormat == teleport.AuthorizedKeys {
return parseAuthorizedKeys(bytes, allowedLogins)
}
return parseKnownHosts(bytes, allowedLogins)
}
|
go
|
func parseCAKey(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
caFormat, err := certificateAuthorityFormat(bytes)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if caFormat == teleport.AuthorizedKeys {
return parseAuthorizedKeys(bytes, allowedLogins)
}
return parseKnownHosts(bytes, allowedLogins)
}
|
[
"func",
"parseCAKey",
"(",
"bytes",
"[",
"]",
"byte",
",",
"allowedLogins",
"[",
"]",
"string",
")",
"(",
"services",
".",
"CertAuthority",
",",
"services",
".",
"Role",
",",
"error",
")",
"{",
"caFormat",
",",
"err",
":=",
"certificateAuthorityFormat",
"(",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"caFormat",
"==",
"teleport",
".",
"AuthorizedKeys",
"{",
"return",
"parseAuthorizedKeys",
"(",
"bytes",
",",
"allowedLogins",
")",
"\n",
"}",
"\n",
"return",
"parseKnownHosts",
"(",
"bytes",
",",
"allowedLogins",
")",
"\n",
"}"
] |
// parseCAKey parses bytes either in known_hosts or authorized_keys format
// and returns a services.CertAuthority.
|
[
"parseCAKey",
"parses",
"bytes",
"either",
"in",
"known_hosts",
"or",
"authorized_keys",
"format",
"and",
"returns",
"a",
"services",
".",
"CertAuthority",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L705-L715
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
readTrustedClusters
|
func readTrustedClusters(clusters []TrustedCluster, conf *service.Config) error {
if len(clusters) == 0 {
return nil
}
// go over all trusted clusters:
for i := range clusters {
tc := &clusters[i]
// parse "allow_logins"
var allowedLogins []string
for _, login := range strings.Split(tc.AllowedLogins, ",") {
login = strings.TrimSpace(login)
if login != "" {
allowedLogins = append(allowedLogins, login)
}
}
// open the key file for this cluster:
log.Debugf("reading trusted cluster key file %s", tc.KeyFile)
if tc.KeyFile == "" {
return trace.Errorf("key_file is missing for a trusted cluster")
}
f, err := os.Open(tc.KeyFile)
if err != nil {
return trace.Errorf("reading trusted cluster keys: %v", err)
}
defer f.Close()
// read the keyfile for this cluster and get trusted CA keys:
var authorities []services.CertAuthority
var roles []services.Role
scanner := bufio.NewScanner(f)
for line := 0; scanner.Scan(); {
ca, role, err := parseCAKey(scanner.Bytes(), allowedLogins)
if err != nil {
return trace.BadParameter("%s:L%d. %v", tc.KeyFile, line, err)
}
if ca.GetType() == services.UserCA && len(allowedLogins) == 0 && len(tc.TunnelAddr) > 0 {
return trace.BadParameter("trusted cluster '%s' needs allow_logins parameter",
ca.GetClusterName())
}
authorities = append(authorities, ca)
if role != nil {
roles = append(roles, role)
}
}
conf.Auth.Authorities = append(conf.Auth.Authorities, authorities...)
conf.Auth.Roles = append(conf.Auth.Roles, roles...)
clusterName := authorities[0].GetClusterName()
// parse "tunnel_addr"
var tunnelAddresses []string
for _, ta := range strings.Split(tc.TunnelAddr, ",") {
ta := strings.TrimSpace(ta)
if ta == "" {
continue
}
addr, err := utils.ParseHostPortAddr(ta, defaults.SSHProxyTunnelListenPort)
if err != nil {
return trace.Wrap(err,
"Invalid tunnel address '%s' for cluster '%s'. Expect host:port format",
ta, clusterName)
}
tunnelAddresses = append(tunnelAddresses, addr.FullAddress())
}
if len(tunnelAddresses) > 0 {
conf.ReverseTunnels = append(conf.ReverseTunnels, services.NewReverseTunnel(clusterName, tunnelAddresses))
}
}
return nil
}
|
go
|
func readTrustedClusters(clusters []TrustedCluster, conf *service.Config) error {
if len(clusters) == 0 {
return nil
}
// go over all trusted clusters:
for i := range clusters {
tc := &clusters[i]
// parse "allow_logins"
var allowedLogins []string
for _, login := range strings.Split(tc.AllowedLogins, ",") {
login = strings.TrimSpace(login)
if login != "" {
allowedLogins = append(allowedLogins, login)
}
}
// open the key file for this cluster:
log.Debugf("reading trusted cluster key file %s", tc.KeyFile)
if tc.KeyFile == "" {
return trace.Errorf("key_file is missing for a trusted cluster")
}
f, err := os.Open(tc.KeyFile)
if err != nil {
return trace.Errorf("reading trusted cluster keys: %v", err)
}
defer f.Close()
// read the keyfile for this cluster and get trusted CA keys:
var authorities []services.CertAuthority
var roles []services.Role
scanner := bufio.NewScanner(f)
for line := 0; scanner.Scan(); {
ca, role, err := parseCAKey(scanner.Bytes(), allowedLogins)
if err != nil {
return trace.BadParameter("%s:L%d. %v", tc.KeyFile, line, err)
}
if ca.GetType() == services.UserCA && len(allowedLogins) == 0 && len(tc.TunnelAddr) > 0 {
return trace.BadParameter("trusted cluster '%s' needs allow_logins parameter",
ca.GetClusterName())
}
authorities = append(authorities, ca)
if role != nil {
roles = append(roles, role)
}
}
conf.Auth.Authorities = append(conf.Auth.Authorities, authorities...)
conf.Auth.Roles = append(conf.Auth.Roles, roles...)
clusterName := authorities[0].GetClusterName()
// parse "tunnel_addr"
var tunnelAddresses []string
for _, ta := range strings.Split(tc.TunnelAddr, ",") {
ta := strings.TrimSpace(ta)
if ta == "" {
continue
}
addr, err := utils.ParseHostPortAddr(ta, defaults.SSHProxyTunnelListenPort)
if err != nil {
return trace.Wrap(err,
"Invalid tunnel address '%s' for cluster '%s'. Expect host:port format",
ta, clusterName)
}
tunnelAddresses = append(tunnelAddresses, addr.FullAddress())
}
if len(tunnelAddresses) > 0 {
conf.ReverseTunnels = append(conf.ReverseTunnels, services.NewReverseTunnel(clusterName, tunnelAddresses))
}
}
return nil
}
|
[
"func",
"readTrustedClusters",
"(",
"clusters",
"[",
"]",
"TrustedCluster",
",",
"conf",
"*",
"service",
".",
"Config",
")",
"error",
"{",
"if",
"len",
"(",
"clusters",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"clusters",
"{",
"tc",
":=",
"&",
"clusters",
"[",
"i",
"]",
"\n",
"var",
"allowedLogins",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"login",
":=",
"range",
"strings",
".",
"Split",
"(",
"tc",
".",
"AllowedLogins",
",",
"\",\"",
")",
"{",
"login",
"=",
"strings",
".",
"TrimSpace",
"(",
"login",
")",
"\n",
"if",
"login",
"!=",
"\"\"",
"{",
"allowedLogins",
"=",
"append",
"(",
"allowedLogins",
",",
"login",
")",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"reading trusted cluster key file %s\"",
",",
"tc",
".",
"KeyFile",
")",
"\n",
"if",
"tc",
".",
"KeyFile",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"Errorf",
"(",
"\"key_file is missing for a trusted cluster\"",
")",
"\n",
"}",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"tc",
".",
"KeyFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Errorf",
"(",
"\"reading trusted cluster keys: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"var",
"authorities",
"[",
"]",
"services",
".",
"CertAuthority",
"\n",
"var",
"roles",
"[",
"]",
"services",
".",
"Role",
"\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"f",
")",
"\n",
"for",
"line",
":=",
"0",
";",
"scanner",
".",
"Scan",
"(",
")",
";",
"{",
"ca",
",",
"role",
",",
"err",
":=",
"parseCAKey",
"(",
"scanner",
".",
"Bytes",
"(",
")",
",",
"allowedLogins",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"%s:L%d. %v\"",
",",
"tc",
".",
"KeyFile",
",",
"line",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"ca",
".",
"GetType",
"(",
")",
"==",
"services",
".",
"UserCA",
"&&",
"len",
"(",
"allowedLogins",
")",
"==",
"0",
"&&",
"len",
"(",
"tc",
".",
"TunnelAddr",
")",
">",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"trusted cluster '%s' needs allow_logins parameter\"",
",",
"ca",
".",
"GetClusterName",
"(",
")",
")",
"\n",
"}",
"\n",
"authorities",
"=",
"append",
"(",
"authorities",
",",
"ca",
")",
"\n",
"if",
"role",
"!=",
"nil",
"{",
"roles",
"=",
"append",
"(",
"roles",
",",
"role",
")",
"\n",
"}",
"\n",
"}",
"\n",
"conf",
".",
"Auth",
".",
"Authorities",
"=",
"append",
"(",
"conf",
".",
"Auth",
".",
"Authorities",
",",
"authorities",
"...",
")",
"\n",
"conf",
".",
"Auth",
".",
"Roles",
"=",
"append",
"(",
"conf",
".",
"Auth",
".",
"Roles",
",",
"roles",
"...",
")",
"\n",
"clusterName",
":=",
"authorities",
"[",
"0",
"]",
".",
"GetClusterName",
"(",
")",
"\n",
"var",
"tunnelAddresses",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"ta",
":=",
"range",
"strings",
".",
"Split",
"(",
"tc",
".",
"TunnelAddr",
",",
"\",\"",
")",
"{",
"ta",
":=",
"strings",
".",
"TrimSpace",
"(",
"ta",
")",
"\n",
"if",
"ta",
"==",
"\"\"",
"{",
"continue",
"\n",
"}",
"\n",
"addr",
",",
"err",
":=",
"utils",
".",
"ParseHostPortAddr",
"(",
"ta",
",",
"defaults",
".",
"SSHProxyTunnelListenPort",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"Invalid tunnel address '%s' for cluster '%s'. Expect host:port format\"",
",",
"ta",
",",
"clusterName",
")",
"\n",
"}",
"\n",
"tunnelAddresses",
"=",
"append",
"(",
"tunnelAddresses",
",",
"addr",
".",
"FullAddress",
"(",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"tunnelAddresses",
")",
">",
"0",
"{",
"conf",
".",
"ReverseTunnels",
"=",
"append",
"(",
"conf",
".",
"ReverseTunnels",
",",
"services",
".",
"NewReverseTunnel",
"(",
"clusterName",
",",
"tunnelAddresses",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// readTrustedClusters parses the content of "trusted_clusters" YAML structure
// and modifies Teleport 'conf' by adding "authorities" and "reverse tunnels"
// to it
|
[
"readTrustedClusters",
"parses",
"the",
"content",
"of",
"trusted_clusters",
"YAML",
"structure",
"and",
"modifies",
"Teleport",
"conf",
"by",
"adding",
"authorities",
"and",
"reverse",
"tunnels",
"to",
"it"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L720-L786
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
applyString
|
func applyString(src string, target *string) bool {
if src != "" {
*target = src
return true
}
return false
}
|
go
|
func applyString(src string, target *string) bool {
if src != "" {
*target = src
return true
}
return false
}
|
[
"func",
"applyString",
"(",
"src",
"string",
",",
"target",
"*",
"string",
")",
"bool",
"{",
"if",
"src",
"!=",
"\"\"",
"{",
"*",
"target",
"=",
"src",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// applyString takes 'src' and overwrites target with it, unless 'src' is empty
// returns 'True' if 'src' was not empty
|
[
"applyString",
"takes",
"src",
"and",
"overwrites",
"target",
"with",
"it",
"unless",
"src",
"is",
"empty",
"returns",
"True",
"if",
"src",
"was",
"not",
"empty"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L790-L796
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
applyListenIP
|
func applyListenIP(ip net.IP, cfg *service.Config) {
listeningAddresses := []*utils.NetAddr{
&cfg.Auth.SSHAddr,
&cfg.Auth.SSHAddr,
&cfg.Proxy.SSHAddr,
&cfg.Proxy.WebAddr,
&cfg.SSH.Addr,
&cfg.Proxy.ReverseTunnelListenAddr,
}
for _, addr := range listeningAddresses {
replaceHost(addr, ip.String())
}
}
|
go
|
func applyListenIP(ip net.IP, cfg *service.Config) {
listeningAddresses := []*utils.NetAddr{
&cfg.Auth.SSHAddr,
&cfg.Auth.SSHAddr,
&cfg.Proxy.SSHAddr,
&cfg.Proxy.WebAddr,
&cfg.SSH.Addr,
&cfg.Proxy.ReverseTunnelListenAddr,
}
for _, addr := range listeningAddresses {
replaceHost(addr, ip.String())
}
}
|
[
"func",
"applyListenIP",
"(",
"ip",
"net",
".",
"IP",
",",
"cfg",
"*",
"service",
".",
"Config",
")",
"{",
"listeningAddresses",
":=",
"[",
"]",
"*",
"utils",
".",
"NetAddr",
"{",
"&",
"cfg",
".",
"Auth",
".",
"SSHAddr",
",",
"&",
"cfg",
".",
"Auth",
".",
"SSHAddr",
",",
"&",
"cfg",
".",
"Proxy",
".",
"SSHAddr",
",",
"&",
"cfg",
".",
"Proxy",
".",
"WebAddr",
",",
"&",
"cfg",
".",
"SSH",
".",
"Addr",
",",
"&",
"cfg",
".",
"Proxy",
".",
"ReverseTunnelListenAddr",
",",
"}",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"listeningAddresses",
"{",
"replaceHost",
"(",
"addr",
",",
"ip",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// applyListenIP replaces all 'listen addr' settings for all services with
// a given IP
|
[
"applyListenIP",
"replaces",
"all",
"listen",
"addr",
"settings",
"for",
"all",
"services",
"with",
"a",
"given",
"IP"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L1001-L1013
|
train
|
gravitational/teleport
|
lib/config/configuration.go
|
replaceHost
|
func replaceHost(addr *utils.NetAddr, newHost string) {
_, port, err := net.SplitHostPort(addr.Addr)
if err != nil {
log.Errorf("failed parsing address: '%v'", addr.Addr)
}
addr.Addr = net.JoinHostPort(newHost, port)
}
|
go
|
func replaceHost(addr *utils.NetAddr, newHost string) {
_, port, err := net.SplitHostPort(addr.Addr)
if err != nil {
log.Errorf("failed parsing address: '%v'", addr.Addr)
}
addr.Addr = net.JoinHostPort(newHost, port)
}
|
[
"func",
"replaceHost",
"(",
"addr",
"*",
"utils",
".",
"NetAddr",
",",
"newHost",
"string",
")",
"{",
"_",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"addr",
".",
"Addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"failed parsing address: '%v'\"",
",",
"addr",
".",
"Addr",
")",
"\n",
"}",
"\n",
"addr",
".",
"Addr",
"=",
"net",
".",
"JoinHostPort",
"(",
"newHost",
",",
"port",
")",
"\n",
"}"
] |
// replaceHost takes utils.NetAddr and replaces the hostname in it, preserving
// the original port
|
[
"replaceHost",
"takes",
"utils",
".",
"NetAddr",
"and",
"replaces",
"the",
"hostname",
"in",
"it",
"preserving",
"the",
"original",
"port"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/config/configuration.go#L1017-L1023
|
train
|
gravitational/teleport
|
lib/services/legacy/metadata.go
|
MarshalJSON
|
func (d Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(fmt.Sprintf("%v", d.Duration))
}
|
go
|
func (d Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(fmt.Sprintf("%v", d.Duration))
}
|
[
"func",
"(",
"d",
"Duration",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"json",
".",
"Marshal",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"d",
".",
"Duration",
")",
")",
"\n",
"}"
] |
// MarshalJSON marshals Duration to string
|
[
"MarshalJSON",
"marshals",
"Duration",
"to",
"string"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/legacy/metadata.go#L54-L56
|
train
|
gravitational/teleport
|
lib/auth/new_web_user.go
|
initializeTOTP
|
func (s *AuthServer) initializeTOTP(accountName string) (key string, qr []byte, err error) {
// create totp key
otpKey, err := totp.Generate(totp.GenerateOpts{
Issuer: "Teleport",
AccountName: accountName,
})
if err != nil {
return "", nil, trace.Wrap(err)
}
// create QR code
var otpQRBuf bytes.Buffer
otpImage, err := otpKey.Image(456, 456)
if err != nil {
return "", nil, trace.Wrap(err)
}
png.Encode(&otpQRBuf, otpImage)
return otpKey.Secret(), otpQRBuf.Bytes(), nil
}
|
go
|
func (s *AuthServer) initializeTOTP(accountName string) (key string, qr []byte, err error) {
// create totp key
otpKey, err := totp.Generate(totp.GenerateOpts{
Issuer: "Teleport",
AccountName: accountName,
})
if err != nil {
return "", nil, trace.Wrap(err)
}
// create QR code
var otpQRBuf bytes.Buffer
otpImage, err := otpKey.Image(456, 456)
if err != nil {
return "", nil, trace.Wrap(err)
}
png.Encode(&otpQRBuf, otpImage)
return otpKey.Secret(), otpQRBuf.Bytes(), nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"initializeTOTP",
"(",
"accountName",
"string",
")",
"(",
"key",
"string",
",",
"qr",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"otpKey",
",",
"err",
":=",
"totp",
".",
"Generate",
"(",
"totp",
".",
"GenerateOpts",
"{",
"Issuer",
":",
"\"Teleport\"",
",",
"AccountName",
":",
"accountName",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"otpQRBuf",
"bytes",
".",
"Buffer",
"\n",
"otpImage",
",",
"err",
":=",
"otpKey",
".",
"Image",
"(",
"456",
",",
"456",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"png",
".",
"Encode",
"(",
"&",
"otpQRBuf",
",",
"otpImage",
")",
"\n",
"return",
"otpKey",
".",
"Secret",
"(",
")",
",",
"otpQRBuf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// initializeTOTP creates TOTP algorithm and returns the key and QR code.
|
[
"initializeTOTP",
"creates",
"TOTP",
"algorithm",
"and",
"returns",
"the",
"key",
"and",
"QR",
"code",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/new_web_user.go#L119-L138
|
train
|
gravitational/teleport
|
lib/auth/new_web_user.go
|
rotateAndFetchSignupToken
|
func (s *AuthServer) rotateAndFetchSignupToken(token string) (*services.SignupToken, error) {
var err error
// Fetch original signup token.
st, err := s.GetSignupToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
// Generate and set new OTP code for user in *services.SignupToken.
accountName := st.User.V2().GetName() + "@" + s.AuthServiceName
st.OTPKey, st.OTPQRCode, err = s.initializeTOTP(accountName)
if err != nil {
return nil, trace.Wrap(err)
}
// Upsert token into backend.
err = s.UpsertSignupToken(token, *st, st.Expires.Sub(s.clock.Now()))
if err != nil {
return nil, trace.Wrap(err)
}
return st, nil
}
|
go
|
func (s *AuthServer) rotateAndFetchSignupToken(token string) (*services.SignupToken, error) {
var err error
// Fetch original signup token.
st, err := s.GetSignupToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
// Generate and set new OTP code for user in *services.SignupToken.
accountName := st.User.V2().GetName() + "@" + s.AuthServiceName
st.OTPKey, st.OTPQRCode, err = s.initializeTOTP(accountName)
if err != nil {
return nil, trace.Wrap(err)
}
// Upsert token into backend.
err = s.UpsertSignupToken(token, *st, st.Expires.Sub(s.clock.Now()))
if err != nil {
return nil, trace.Wrap(err)
}
return st, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"rotateAndFetchSignupToken",
"(",
"token",
"string",
")",
"(",
"*",
"services",
".",
"SignupToken",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"st",
",",
"err",
":=",
"s",
".",
"GetSignupToken",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"accountName",
":=",
"st",
".",
"User",
".",
"V2",
"(",
")",
".",
"GetName",
"(",
")",
"+",
"\"@\"",
"+",
"s",
".",
"AuthServiceName",
"\n",
"st",
".",
"OTPKey",
",",
"st",
".",
"OTPQRCode",
",",
"err",
"=",
"s",
".",
"initializeTOTP",
"(",
"accountName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"UpsertSignupToken",
"(",
"token",
",",
"*",
"st",
",",
"st",
".",
"Expires",
".",
"Sub",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"st",
",",
"nil",
"\n",
"}"
] |
// rotateAndFetchSignupToken rotates the signup token everytime it's fetched.
// This ensures that an attacker that gains the signup link can not view it,
// extract the OTP key from the QR code, then allow the user to signup with
// the same OTP token.
|
[
"rotateAndFetchSignupToken",
"rotates",
"the",
"signup",
"token",
"everytime",
"it",
"s",
"fetched",
".",
"This",
"ensures",
"that",
"an",
"attacker",
"that",
"gains",
"the",
"signup",
"link",
"can",
"not",
"view",
"it",
"extract",
"the",
"OTP",
"key",
"from",
"the",
"QR",
"code",
"then",
"allow",
"the",
"user",
"to",
"signup",
"with",
"the",
"same",
"OTP",
"token",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/new_web_user.go#L144-L167
|
train
|
gravitational/teleport
|
lib/auth/new_web_user.go
|
CreateUserWithOTP
|
func (s *AuthServer) CreateUserWithOTP(token string, password string, otpToken string) (services.WebSession, error) {
tokenData, err := s.GetSignupToken(token)
if err != nil {
log.Debugf("failed to get signup token: %v", err)
return nil, trace.AccessDenied("expired or incorrect signup token")
}
err = s.UpsertTOTP(tokenData.User.Name, tokenData.OTPKey)
if err != nil {
return nil, trace.Wrap(err)
}
err = s.CheckOTP(tokenData.User.Name, otpToken)
if err != nil {
log.Debugf("failed to validate a token: %v", err)
return nil, trace.AccessDenied("failed to validate a token")
}
err = s.UpsertPassword(tokenData.User.Name, []byte(password))
if err != nil {
return nil, trace.Wrap(err)
}
// create services.User and services.WebSession
webSession, err := s.createUserAndSession(tokenData)
if err != nil {
return nil, trace.Wrap(err)
}
return webSession, nil
}
|
go
|
func (s *AuthServer) CreateUserWithOTP(token string, password string, otpToken string) (services.WebSession, error) {
tokenData, err := s.GetSignupToken(token)
if err != nil {
log.Debugf("failed to get signup token: %v", err)
return nil, trace.AccessDenied("expired or incorrect signup token")
}
err = s.UpsertTOTP(tokenData.User.Name, tokenData.OTPKey)
if err != nil {
return nil, trace.Wrap(err)
}
err = s.CheckOTP(tokenData.User.Name, otpToken)
if err != nil {
log.Debugf("failed to validate a token: %v", err)
return nil, trace.AccessDenied("failed to validate a token")
}
err = s.UpsertPassword(tokenData.User.Name, []byte(password))
if err != nil {
return nil, trace.Wrap(err)
}
// create services.User and services.WebSession
webSession, err := s.createUserAndSession(tokenData)
if err != nil {
return nil, trace.Wrap(err)
}
return webSession, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"CreateUserWithOTP",
"(",
"token",
"string",
",",
"password",
"string",
",",
"otpToken",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"tokenData",
",",
"err",
":=",
"s",
".",
"GetSignupToken",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"failed to get signup token: %v\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"expired or incorrect signup token\"",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"UpsertTOTP",
"(",
"tokenData",
".",
"User",
".",
"Name",
",",
"tokenData",
".",
"OTPKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"CheckOTP",
"(",
"tokenData",
".",
"User",
".",
"Name",
",",
"otpToken",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"failed to validate a token: %v\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"failed to validate a token\"",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"UpsertPassword",
"(",
"tokenData",
".",
"User",
".",
"Name",
",",
"[",
"]",
"byte",
"(",
"password",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"webSession",
",",
"err",
":=",
"s",
".",
"createUserAndSession",
"(",
"tokenData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"webSession",
",",
"nil",
"\n",
"}"
] |
// CreateUserWithOTP creates account with provided token and password.
// Account username and hotp generator are taken from token data.
// Deletes token after account creation.
|
[
"CreateUserWithOTP",
"creates",
"account",
"with",
"provided",
"token",
"and",
"password",
".",
"Account",
"username",
"and",
"hotp",
"generator",
"are",
"taken",
"from",
"token",
"data",
".",
"Deletes",
"token",
"after",
"account",
"creation",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/new_web_user.go#L232-L262
|
train
|
gravitational/teleport
|
lib/auth/new_web_user.go
|
CreateUserWithoutOTP
|
func (s *AuthServer) CreateUserWithoutOTP(token string, password string) (services.WebSession, error) {
authPreference, err := s.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
if authPreference.GetSecondFactor() != teleport.OFF {
return nil, trace.AccessDenied("missing second factor")
}
tokenData, err := s.GetSignupToken(token)
if err != nil {
log.Warningf("failed to get signup token: %v", err)
return nil, trace.AccessDenied("expired or incorrect signup token")
}
err = s.UpsertPassword(tokenData.User.Name, []byte(password))
if err != nil {
return nil, trace.Wrap(err)
}
// create services.User and services.WebSession
webSession, err := s.createUserAndSession(tokenData)
if err != nil {
return nil, trace.Wrap(err)
}
return webSession, nil
}
|
go
|
func (s *AuthServer) CreateUserWithoutOTP(token string, password string) (services.WebSession, error) {
authPreference, err := s.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
if authPreference.GetSecondFactor() != teleport.OFF {
return nil, trace.AccessDenied("missing second factor")
}
tokenData, err := s.GetSignupToken(token)
if err != nil {
log.Warningf("failed to get signup token: %v", err)
return nil, trace.AccessDenied("expired or incorrect signup token")
}
err = s.UpsertPassword(tokenData.User.Name, []byte(password))
if err != nil {
return nil, trace.Wrap(err)
}
// create services.User and services.WebSession
webSession, err := s.createUserAndSession(tokenData)
if err != nil {
return nil, trace.Wrap(err)
}
return webSession, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"CreateUserWithoutOTP",
"(",
"token",
"string",
",",
"password",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"authPreference",
",",
"err",
":=",
"s",
".",
"GetAuthPreference",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"authPreference",
".",
"GetSecondFactor",
"(",
")",
"!=",
"teleport",
".",
"OFF",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"missing second factor\"",
")",
"\n",
"}",
"\n",
"tokenData",
",",
"err",
":=",
"s",
".",
"GetSignupToken",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warningf",
"(",
"\"failed to get signup token: %v\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"expired or incorrect signup token\"",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"UpsertPassword",
"(",
"tokenData",
".",
"User",
".",
"Name",
",",
"[",
"]",
"byte",
"(",
"password",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"webSession",
",",
"err",
":=",
"s",
".",
"createUserAndSession",
"(",
"tokenData",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"webSession",
",",
"nil",
"\n",
"}"
] |
// CreateUserWithoutOTP creates an account with the provided password and deletes the token afterwards.
|
[
"CreateUserWithoutOTP",
"creates",
"an",
"account",
"with",
"the",
"provided",
"password",
"and",
"deletes",
"the",
"token",
"afterwards",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/new_web_user.go#L265-L291
|
train
|
gravitational/teleport
|
lib/services/statictokens.go
|
NewStaticTokens
|
func NewStaticTokens(spec StaticTokensSpecV2) (StaticTokens, error) {
st := StaticTokensV2{
Kind: KindStaticTokens,
Version: V2,
Metadata: Metadata{
Name: MetaNameStaticTokens,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := st.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &st, nil
}
|
go
|
func NewStaticTokens(spec StaticTokensSpecV2) (StaticTokens, error) {
st := StaticTokensV2{
Kind: KindStaticTokens,
Version: V2,
Metadata: Metadata{
Name: MetaNameStaticTokens,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := st.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &st, nil
}
|
[
"func",
"NewStaticTokens",
"(",
"spec",
"StaticTokensSpecV2",
")",
"(",
"StaticTokens",
",",
"error",
")",
"{",
"st",
":=",
"StaticTokensV2",
"{",
"Kind",
":",
"KindStaticTokens",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"MetaNameStaticTokens",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"if",
"err",
":=",
"st",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"st",
",",
"nil",
"\n",
"}"
] |
// NewStaticTokens is a convenience wrapper to create a StaticTokens resource.
|
[
"NewStaticTokens",
"is",
"a",
"convenience",
"wrapper",
"to",
"create",
"a",
"StaticTokens",
"resource",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/statictokens.go#L47-L62
|
train
|
gravitational/teleport
|
lib/services/statictokens.go
|
GetStaticTokensSchema
|
func GetStaticTokensSchema(extensionSchema string) string {
var staticTokensSchema string
if staticTokensSchema == "" {
staticTokensSchema = fmt.Sprintf(StaticTokensSpecSchemaTemplate, "")
} else {
staticTokensSchema = fmt.Sprintf(StaticTokensSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, staticTokensSchema, DefaultDefinitions)
}
|
go
|
func GetStaticTokensSchema(extensionSchema string) string {
var staticTokensSchema string
if staticTokensSchema == "" {
staticTokensSchema = fmt.Sprintf(StaticTokensSpecSchemaTemplate, "")
} else {
staticTokensSchema = fmt.Sprintf(StaticTokensSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, staticTokensSchema, DefaultDefinitions)
}
|
[
"func",
"GetStaticTokensSchema",
"(",
"extensionSchema",
"string",
")",
"string",
"{",
"var",
"staticTokensSchema",
"string",
"\n",
"if",
"staticTokensSchema",
"==",
"\"\"",
"{",
"staticTokensSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"StaticTokensSpecSchemaTemplate",
",",
"\"\"",
")",
"\n",
"}",
"else",
"{",
"staticTokensSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"StaticTokensSpecSchemaTemplate",
",",
"\",\"",
"+",
"extensionSchema",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"staticTokensSchema",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] |
// GetStaticTokensSchema returns the schema with optionally injected
// schema for extensions.
|
[
"GetStaticTokensSchema",
"returns",
"the",
"schema",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/statictokens.go#L197-L205
|
train
|
gravitational/teleport
|
lib/services/statictokens.go
|
Unmarshal
|
func (t *TeleportStaticTokensMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (StaticTokens, error) {
var staticTokens StaticTokensV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &staticTokens); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
err = utils.UnmarshalWithSchema(GetStaticTokensSchema(""), &staticTokens, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
}
err = staticTokens.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
staticTokens.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
staticTokens.SetExpiry(cfg.Expires)
}
return &staticTokens, nil
}
|
go
|
func (t *TeleportStaticTokensMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (StaticTokens, error) {
var staticTokens StaticTokensV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &staticTokens); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
err = utils.UnmarshalWithSchema(GetStaticTokensSchema(""), &staticTokens, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
}
err = staticTokens.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
staticTokens.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
staticTokens.SetExpiry(cfg.Expires)
}
return &staticTokens, nil
}
|
[
"func",
"(",
"t",
"*",
"TeleportStaticTokensMarshaler",
")",
"Unmarshal",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"StaticTokens",
",",
"error",
")",
"{",
"var",
"staticTokens",
"StaticTokensV2",
"\n",
"if",
"len",
"(",
"bytes",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing resource data\"",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"staticTokens",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
"=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetStaticTokensSchema",
"(",
"\"\"",
")",
",",
"&",
"staticTokens",
",",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"staticTokens",
".",
"CheckAndSetDefaults",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"staticTokens",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"staticTokens",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"staticTokens",
",",
"nil",
"\n",
"}"
] |
// Unmarshal unmarshals StaticTokens from JSON.
|
[
"Unmarshal",
"unmarshals",
"StaticTokens",
"from",
"JSON",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/statictokens.go#L234-L269
|
train
|
gravitational/teleport
|
lib/services/statictokens.go
|
Marshal
|
func (t *TeleportStaticTokensMarshaler) Marshal(c StaticTokens, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *StaticTokensV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
}
|
go
|
func (t *TeleportStaticTokensMarshaler) Marshal(c StaticTokens, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *StaticTokensV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
}
|
[
"func",
"(",
"t",
"*",
"TeleportStaticTokensMarshaler",
")",
"Marshal",
"(",
"c",
"StaticTokens",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"resource",
":=",
"c",
".",
"(",
"type",
")",
"{",
"case",
"*",
"StaticTokensV2",
":",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"resource",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"resource",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"resource",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unrecognized resource version %T\"",
",",
"c",
")",
"\n",
"}",
"\n",
"}"
] |
// Marshal marshals StaticTokens to JSON.
|
[
"Marshal",
"marshals",
"StaticTokens",
"to",
"JSON",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/statictokens.go#L272-L290
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
DeleteAllCertAuthorities
|
func (s *CA) DeleteAllCertAuthorities(caType services.CertAuthType) error {
startKey := backend.Key(authoritiesPrefix, string(caType))
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
}
|
go
|
func (s *CA) DeleteAllCertAuthorities(caType services.CertAuthType) error {
startKey := backend.Key(authoritiesPrefix, string(caType))
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"DeleteAllCertAuthorities",
"(",
"caType",
"services",
".",
"CertAuthType",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"string",
"(",
"caType",
")",
")",
"\n",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"}"
] |
// DeleteAllCertAuthorities deletes all certificate authorities of a certain type
|
[
"DeleteAllCertAuthorities",
"deletes",
"all",
"certificate",
"authorities",
"of",
"a",
"certain",
"type"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L26-L29
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
CreateCertAuthority
|
func (s *CA) CreateCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, string(ca.GetType()), ca.GetName()),
Value: value,
Expires: ca.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
if trace.IsAlreadyExists(err) {
return trace.AlreadyExists("cluster %q already exists", ca.GetName())
}
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *CA) CreateCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, string(ca.GetType()), ca.GetName()),
Value: value,
Expires: ca.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
if trace.IsAlreadyExists(err) {
return trace.AlreadyExists("cluster %q already exists", ca.GetName())
}
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"CreateCertAuthority",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"err",
":=",
"ca",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"MarshalCertAuthority",
"(",
"ca",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"string",
"(",
"ca",
".",
"GetType",
"(",
")",
")",
",",
"ca",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"ca",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsAlreadyExists",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"AlreadyExists",
"(",
"\"cluster %q already exists\"",
",",
"ca",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CreateCertAuthority updates or inserts a new certificate authority
|
[
"CreateCertAuthority",
"updates",
"or",
"inserts",
"a",
"new",
"certificate",
"authority"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L32-L54
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
UpsertCertAuthority
|
func (s *CA) UpsertCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, string(ca.GetType()), ca.GetName()),
Value: value,
Expires: ca.Expiry(),
ID: ca.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *CA) UpsertCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, string(ca.GetType()), ca.GetName()),
Value: value,
Expires: ca.Expiry(),
ID: ca.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"UpsertCertAuthority",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"err",
":=",
"ca",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"MarshalCertAuthority",
"(",
"ca",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"string",
"(",
"ca",
".",
"GetType",
"(",
")",
")",
",",
"ca",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"ca",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"ca",
".",
"GetResourceID",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UpsertCertAuthority updates or inserts a new certificate authority
|
[
"UpsertCertAuthority",
"updates",
"or",
"inserts",
"a",
"new",
"certificate",
"authority"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L57-L77
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
CompareAndSwapCertAuthority
|
func (s *CA) CompareAndSwapCertAuthority(new, existing services.CertAuthority) error {
if err := new.Check(); err != nil {
return trace.Wrap(err)
}
newValue, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(new)
if err != nil {
return trace.Wrap(err)
}
newItem := backend.Item{
Key: backend.Key(authoritiesPrefix, string(new.GetType()), new.GetName()),
Value: newValue,
Expires: new.Expiry(),
}
existingValue, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(existing)
if err != nil {
return trace.Wrap(err)
}
existingItem := backend.Item{
Key: backend.Key(authoritiesPrefix, string(existing.GetType()), existing.GetName()),
Value: existingValue,
Expires: existing.Expiry(),
}
_, err = s.CompareAndSwap(context.TODO(), existingItem, newItem)
if err != nil {
if trace.IsCompareFailed(err) {
return trace.CompareFailed("cluster %v settings have been updated, try again", new.GetName())
}
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *CA) CompareAndSwapCertAuthority(new, existing services.CertAuthority) error {
if err := new.Check(); err != nil {
return trace.Wrap(err)
}
newValue, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(new)
if err != nil {
return trace.Wrap(err)
}
newItem := backend.Item{
Key: backend.Key(authoritiesPrefix, string(new.GetType()), new.GetName()),
Value: newValue,
Expires: new.Expiry(),
}
existingValue, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(existing)
if err != nil {
return trace.Wrap(err)
}
existingItem := backend.Item{
Key: backend.Key(authoritiesPrefix, string(existing.GetType()), existing.GetName()),
Value: existingValue,
Expires: existing.Expiry(),
}
_, err = s.CompareAndSwap(context.TODO(), existingItem, newItem)
if err != nil {
if trace.IsCompareFailed(err) {
return trace.CompareFailed("cluster %v settings have been updated, try again", new.GetName())
}
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"CompareAndSwapCertAuthority",
"(",
"new",
",",
"existing",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"err",
":=",
"new",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"newValue",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"MarshalCertAuthority",
"(",
"new",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"newItem",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"string",
"(",
"new",
".",
"GetType",
"(",
")",
")",
",",
"new",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"newValue",
",",
"Expires",
":",
"new",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"existingValue",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"MarshalCertAuthority",
"(",
"existing",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"existingItem",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"string",
"(",
"existing",
".",
"GetType",
"(",
")",
")",
",",
"existing",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"existingValue",
",",
"Expires",
":",
"existing",
".",
"Expiry",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"CompareAndSwap",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"existingItem",
",",
"newItem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsCompareFailed",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"CompareFailed",
"(",
"\"cluster %v settings have been updated, try again\"",
",",
"new",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CompareAndSwapCertAuthority updates the cert authority value
// if the existing value matches existing parameter, returns nil if succeeds,
// trace.CompareFailed otherwise.
|
[
"CompareAndSwapCertAuthority",
"updates",
"the",
"cert",
"authority",
"value",
"if",
"the",
"existing",
"value",
"matches",
"existing",
"parameter",
"returns",
"nil",
"if",
"succeeds",
"trace",
".",
"CompareFailed",
"otherwise",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L82-L114
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
DeleteCertAuthority
|
func (s *CA) DeleteCertAuthority(id services.CertAuthID) error {
if err := id.Check(); err != nil {
return trace.Wrap(err)
}
// when removing a services.CertAuthority also remove any deactivated
// services.CertAuthority as well if they exist.
err := s.Delete(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
}
err = s.Delete(context.TODO(), backend.Key(authoritiesPrefix, string(id.Type), id.DomainName))
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *CA) DeleteCertAuthority(id services.CertAuthID) error {
if err := id.Check(); err != nil {
return trace.Wrap(err)
}
// when removing a services.CertAuthority also remove any deactivated
// services.CertAuthority as well if they exist.
err := s.Delete(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
}
err = s.Delete(context.TODO(), backend.Key(authoritiesPrefix, string(id.Type), id.DomainName))
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"DeleteCertAuthority",
"(",
"id",
"services",
".",
"CertAuthID",
")",
"error",
"{",
"if",
"err",
":=",
"id",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"deactivatedPrefix",
",",
"string",
"(",
"id",
".",
"Type",
")",
",",
"id",
".",
"DomainName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"string",
"(",
"id",
".",
"Type",
")",
",",
"id",
".",
"DomainName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DeleteCertAuthority deletes particular certificate authority
|
[
"DeleteCertAuthority",
"deletes",
"particular",
"certificate",
"authority"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L117-L134
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
ActivateCertAuthority
|
func (s *CA) ActivateCertAuthority(id services.CertAuthID) error {
item, err := s.Get(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
if trace.IsNotFound(err) {
return trace.BadParameter("can not activate cert authority %q which has not been deactivated", id.DomainName)
}
return trace.Wrap(err)
}
certAuthority, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertCertAuthority(certAuthority)
if err != nil {
return trace.Wrap(err)
}
err = s.Delete(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *CA) ActivateCertAuthority(id services.CertAuthID) error {
item, err := s.Get(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
if trace.IsNotFound(err) {
return trace.BadParameter("can not activate cert authority %q which has not been deactivated", id.DomainName)
}
return trace.Wrap(err)
}
certAuthority, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertCertAuthority(certAuthority)
if err != nil {
return trace.Wrap(err)
}
err = s.Delete(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"ActivateCertAuthority",
"(",
"id",
"services",
".",
"CertAuthID",
")",
"error",
"{",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"deactivatedPrefix",
",",
"string",
"(",
"id",
".",
"Type",
")",
",",
"id",
".",
"DomainName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"can not activate cert authority %q which has not been deactivated\"",
",",
"id",
".",
"DomainName",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certAuthority",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"UnmarshalCertAuthority",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"UpsertCertAuthority",
"(",
"certAuthority",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"deactivatedPrefix",
",",
"string",
"(",
"id",
".",
"Type",
")",
",",
"id",
".",
"DomainName",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ActivateCertAuthority moves a CertAuthority from the deactivated list to
// the normal list.
|
[
"ActivateCertAuthority",
"moves",
"a",
"CertAuthority",
"from",
"the",
"deactivated",
"list",
"to",
"the",
"normal",
"list",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L138-L164
|
train
|
gravitational/teleport
|
lib/services/local/trust.go
|
DeactivateCertAuthority
|
func (s *CA) DeactivateCertAuthority(id services.CertAuthID) error {
certAuthority, err := s.GetCertAuthority(id, true)
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("can not deactivate cert authority %q which does not exist", id.DomainName)
}
return trace.Wrap(err)
}
err = s.DeleteCertAuthority(id)
if err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(certAuthority)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName),
Value: value,
Expires: certAuthority.Expiry(),
ID: certAuthority.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *CA) DeactivateCertAuthority(id services.CertAuthID) error {
certAuthority, err := s.GetCertAuthority(id, true)
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("can not deactivate cert authority %q which does not exist", id.DomainName)
}
return trace.Wrap(err)
}
err = s.DeleteCertAuthority(id)
if err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(certAuthority)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName),
Value: value,
Expires: certAuthority.Expiry(),
ID: certAuthority.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"CA",
")",
"DeactivateCertAuthority",
"(",
"id",
"services",
".",
"CertAuthID",
")",
"error",
"{",
"certAuthority",
",",
"err",
":=",
"s",
".",
"GetCertAuthority",
"(",
"id",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"can not deactivate cert authority %q which does not exist\"",
",",
"id",
".",
"DomainName",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"DeleteCertAuthority",
"(",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"MarshalCertAuthority",
"(",
"certAuthority",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"authoritiesPrefix",
",",
"deactivatedPrefix",
",",
"string",
"(",
"id",
".",
"Type",
")",
",",
"id",
".",
"DomainName",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"certAuthority",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"certAuthority",
".",
"GetResourceID",
"(",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DeactivateCertAuthority moves a CertAuthority from the normal list to
// the deactivated list.
|
[
"DeactivateCertAuthority",
"moves",
"a",
"CertAuthority",
"from",
"the",
"normal",
"list",
"to",
"the",
"deactivated",
"list",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/trust.go#L168-L199
|
train
|
gravitational/teleport
|
lib/client/session.go
|
newSession
|
func newSession(client *NodeClient,
joinSession *session.Session,
env map[string]string,
stdin io.Reader,
stdout io.Writer,
stderr io.Writer) (*NodeSession, error) {
if stdin == nil {
stdin = os.Stdin
}
if stdout == nil {
stdout = os.Stdout
}
if stderr == nil {
stderr = os.Stderr
}
if env == nil {
env = make(map[string]string)
}
var err error
ns := &NodeSession{
env: env,
nodeClient: client,
stdin: stdin,
stdout: stdout,
stderr: stderr,
namespace: client.Namespace,
closer: utils.NewCloseBroadcaster(),
}
// if we're joining an existing session, we need to assume that session's
// existing/current terminal size:
if joinSession != nil {
ns.id = joinSession.ID
ns.namespace = joinSession.Namespace
tsize := joinSession.TerminalParams.Winsize()
if ns.isTerminalAttached() {
err = term.SetWinsize(0, tsize)
if err != nil {
log.Error(err)
}
os.Stdout.Write([]byte(fmt.Sprintf("\x1b[8;%d;%dt", tsize.Height, tsize.Width)))
}
// new session!
} else {
sid, ok := ns.env[sshutils.SessionEnvVar]
if !ok {
sid = string(session.NewID())
}
ns.id = session.ID(sid)
}
ns.env[sshutils.SessionEnvVar] = string(ns.id)
return ns, nil
}
|
go
|
func newSession(client *NodeClient,
joinSession *session.Session,
env map[string]string,
stdin io.Reader,
stdout io.Writer,
stderr io.Writer) (*NodeSession, error) {
if stdin == nil {
stdin = os.Stdin
}
if stdout == nil {
stdout = os.Stdout
}
if stderr == nil {
stderr = os.Stderr
}
if env == nil {
env = make(map[string]string)
}
var err error
ns := &NodeSession{
env: env,
nodeClient: client,
stdin: stdin,
stdout: stdout,
stderr: stderr,
namespace: client.Namespace,
closer: utils.NewCloseBroadcaster(),
}
// if we're joining an existing session, we need to assume that session's
// existing/current terminal size:
if joinSession != nil {
ns.id = joinSession.ID
ns.namespace = joinSession.Namespace
tsize := joinSession.TerminalParams.Winsize()
if ns.isTerminalAttached() {
err = term.SetWinsize(0, tsize)
if err != nil {
log.Error(err)
}
os.Stdout.Write([]byte(fmt.Sprintf("\x1b[8;%d;%dt", tsize.Height, tsize.Width)))
}
// new session!
} else {
sid, ok := ns.env[sshutils.SessionEnvVar]
if !ok {
sid = string(session.NewID())
}
ns.id = session.ID(sid)
}
ns.env[sshutils.SessionEnvVar] = string(ns.id)
return ns, nil
}
|
[
"func",
"newSession",
"(",
"client",
"*",
"NodeClient",
",",
"joinSession",
"*",
"session",
".",
"Session",
",",
"env",
"map",
"[",
"string",
"]",
"string",
",",
"stdin",
"io",
".",
"Reader",
",",
"stdout",
"io",
".",
"Writer",
",",
"stderr",
"io",
".",
"Writer",
")",
"(",
"*",
"NodeSession",
",",
"error",
")",
"{",
"if",
"stdin",
"==",
"nil",
"{",
"stdin",
"=",
"os",
".",
"Stdin",
"\n",
"}",
"\n",
"if",
"stdout",
"==",
"nil",
"{",
"stdout",
"=",
"os",
".",
"Stdout",
"\n",
"}",
"\n",
"if",
"stderr",
"==",
"nil",
"{",
"stderr",
"=",
"os",
".",
"Stderr",
"\n",
"}",
"\n",
"if",
"env",
"==",
"nil",
"{",
"env",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"}",
"\n",
"var",
"err",
"error",
"\n",
"ns",
":=",
"&",
"NodeSession",
"{",
"env",
":",
"env",
",",
"nodeClient",
":",
"client",
",",
"stdin",
":",
"stdin",
",",
"stdout",
":",
"stdout",
",",
"stderr",
":",
"stderr",
",",
"namespace",
":",
"client",
".",
"Namespace",
",",
"closer",
":",
"utils",
".",
"NewCloseBroadcaster",
"(",
")",
",",
"}",
"\n",
"if",
"joinSession",
"!=",
"nil",
"{",
"ns",
".",
"id",
"=",
"joinSession",
".",
"ID",
"\n",
"ns",
".",
"namespace",
"=",
"joinSession",
".",
"Namespace",
"\n",
"tsize",
":=",
"joinSession",
".",
"TerminalParams",
".",
"Winsize",
"(",
")",
"\n",
"if",
"ns",
".",
"isTerminalAttached",
"(",
")",
"{",
"err",
"=",
"term",
".",
"SetWinsize",
"(",
"0",
",",
"tsize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"\n",
"os",
".",
"Stdout",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"\\x1b[8;%d;%dt\"",
",",
"\\x1b",
",",
"tsize",
".",
"Height",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"tsize",
".",
"Width",
"\n",
"{",
"sid",
",",
"ok",
":=",
"ns",
".",
"env",
"[",
"sshutils",
".",
"SessionEnvVar",
"]",
"\n",
"if",
"!",
"ok",
"{",
"sid",
"=",
"string",
"(",
"session",
".",
"NewID",
"(",
")",
")",
"\n",
"}",
"\n",
"ns",
".",
"id",
"=",
"session",
".",
"ID",
"(",
"sid",
")",
"\n",
"}",
"\n",
"ns",
".",
"env",
"[",
"sshutils",
".",
"SessionEnvVar",
"]",
"=",
"string",
"(",
"ns",
".",
"id",
")",
"\n",
"}"
] |
// newSession creates a new Teleport session with the given remote node
// if 'joinSessin' is given, the session will join the existing session
// of another user
|
[
"newSession",
"creates",
"a",
"new",
"Teleport",
"session",
"with",
"the",
"given",
"remote",
"node",
"if",
"joinSessin",
"is",
"given",
"the",
"session",
"will",
"join",
"the",
"existing",
"session",
"of",
"another",
"user"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/session.go#L75-L128
|
train
|
gravitational/teleport
|
lib/client/session.go
|
interactiveSession
|
func (ns *NodeSession) interactiveSession(callback interactiveCallback) error {
// determine what kind of a terminal we need
termType := os.Getenv("TERM")
if termType == "" {
termType = teleport.SafeTerminalType
}
// create the server-side session:
sess, err := ns.createServerSession()
if err != nil {
return trace.Wrap(err)
}
// allocate terminal on the server:
remoteTerm, err := ns.allocateTerminal(termType, sess)
if err != nil {
return trace.Wrap(err)
}
defer remoteTerm.Close()
// call the passed callback and give them the established
// ssh session:
if err := callback(sess, remoteTerm); err != nil {
return trace.Wrap(err)
}
// Catch term signals, but only if we're attached to a real terminal
if ns.isTerminalAttached() {
ns.watchSignals(remoteTerm)
}
// start piping input into the remote shell and pipe the output from
// the remote shell into stdout:
ns.pipeInOut(remoteTerm)
// switch the terminal to raw mode (and switch back on exit!)
if ns.isTerminalAttached() {
ts, err := term.SetRawTerminal(0)
if err != nil {
log.Warn(err)
} else {
defer term.RestoreTerminal(0, ts)
}
}
// wait for the session to end
<-ns.closer.C
return nil
}
|
go
|
func (ns *NodeSession) interactiveSession(callback interactiveCallback) error {
// determine what kind of a terminal we need
termType := os.Getenv("TERM")
if termType == "" {
termType = teleport.SafeTerminalType
}
// create the server-side session:
sess, err := ns.createServerSession()
if err != nil {
return trace.Wrap(err)
}
// allocate terminal on the server:
remoteTerm, err := ns.allocateTerminal(termType, sess)
if err != nil {
return trace.Wrap(err)
}
defer remoteTerm.Close()
// call the passed callback and give them the established
// ssh session:
if err := callback(sess, remoteTerm); err != nil {
return trace.Wrap(err)
}
// Catch term signals, but only if we're attached to a real terminal
if ns.isTerminalAttached() {
ns.watchSignals(remoteTerm)
}
// start piping input into the remote shell and pipe the output from
// the remote shell into stdout:
ns.pipeInOut(remoteTerm)
// switch the terminal to raw mode (and switch back on exit!)
if ns.isTerminalAttached() {
ts, err := term.SetRawTerminal(0)
if err != nil {
log.Warn(err)
} else {
defer term.RestoreTerminal(0, ts)
}
}
// wait for the session to end
<-ns.closer.C
return nil
}
|
[
"func",
"(",
"ns",
"*",
"NodeSession",
")",
"interactiveSession",
"(",
"callback",
"interactiveCallback",
")",
"error",
"{",
"termType",
":=",
"os",
".",
"Getenv",
"(",
"\"TERM\"",
")",
"\n",
"if",
"termType",
"==",
"\"\"",
"{",
"termType",
"=",
"teleport",
".",
"SafeTerminalType",
"\n",
"}",
"\n",
"sess",
",",
"err",
":=",
"ns",
".",
"createServerSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"remoteTerm",
",",
"err",
":=",
"ns",
".",
"allocateTerminal",
"(",
"termType",
",",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"remoteTerm",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
":=",
"callback",
"(",
"sess",
",",
"remoteTerm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ns",
".",
"isTerminalAttached",
"(",
")",
"{",
"ns",
".",
"watchSignals",
"(",
"remoteTerm",
")",
"\n",
"}",
"\n",
"ns",
".",
"pipeInOut",
"(",
"remoteTerm",
")",
"\n",
"if",
"ns",
".",
"isTerminalAttached",
"(",
")",
"{",
"ts",
",",
"err",
":=",
"term",
".",
"SetRawTerminal",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warn",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"defer",
"term",
".",
"RestoreTerminal",
"(",
"0",
",",
"ts",
")",
"\n",
"}",
"\n",
"}",
"\n",
"<-",
"ns",
".",
"closer",
".",
"C",
"\n",
"return",
"nil",
"\n",
"}"
] |
// interactiveSession creates an interactive session on the remote node, executes
// the given callback on it, and waits for the session to end
|
[
"interactiveSession",
"creates",
"an",
"interactive",
"session",
"on",
"the",
"remote",
"node",
"executes",
"the",
"given",
"callback",
"on",
"it",
"and",
"waits",
"for",
"the",
"session",
"to",
"end"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/session.go#L189-L234
|
train
|
gravitational/teleport
|
lib/client/session.go
|
runShell
|
func (ns *NodeSession) runShell(callback ShellCreatedCallback) error {
return ns.interactiveSession(func(s *ssh.Session, shell io.ReadWriteCloser) error {
// start the shell on the server:
if err := s.Shell(); err != nil {
return trace.Wrap(err)
}
// call the client-supplied callback
if callback != nil {
exit, err := callback(s, ns.NodeClient().Client, shell)
if exit {
return trace.Wrap(err)
}
}
return nil
})
}
|
go
|
func (ns *NodeSession) runShell(callback ShellCreatedCallback) error {
return ns.interactiveSession(func(s *ssh.Session, shell io.ReadWriteCloser) error {
// start the shell on the server:
if err := s.Shell(); err != nil {
return trace.Wrap(err)
}
// call the client-supplied callback
if callback != nil {
exit, err := callback(s, ns.NodeClient().Client, shell)
if exit {
return trace.Wrap(err)
}
}
return nil
})
}
|
[
"func",
"(",
"ns",
"*",
"NodeSession",
")",
"runShell",
"(",
"callback",
"ShellCreatedCallback",
")",
"error",
"{",
"return",
"ns",
".",
"interactiveSession",
"(",
"func",
"(",
"s",
"*",
"ssh",
".",
"Session",
",",
"shell",
"io",
".",
"ReadWriteCloser",
")",
"error",
"{",
"if",
"err",
":=",
"s",
".",
"Shell",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"callback",
"!=",
"nil",
"{",
"exit",
",",
"err",
":=",
"callback",
"(",
"s",
",",
"ns",
".",
"NodeClient",
"(",
")",
".",
"Client",
",",
"shell",
")",
"\n",
"if",
"exit",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}"
] |
// runShell executes user's shell on the remote node under an interactive session
|
[
"runShell",
"executes",
"user",
"s",
"shell",
"on",
"the",
"remote",
"node",
"under",
"an",
"interactive",
"session"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/session.go#L397-L412
|
train
|
gravitational/teleport
|
lib/client/session.go
|
watchSignals
|
func (ns *NodeSession) watchSignals(shell io.Writer) {
exitSignals := make(chan os.Signal, 1)
// catch SIGTERM
signal.Notify(exitSignals, syscall.SIGTERM)
go func() {
defer ns.closer.Close()
<-exitSignals
}()
// Catch Ctrl-C signal
ctrlCSignal := make(chan os.Signal, 1)
signal.Notify(ctrlCSignal, syscall.SIGINT)
go func() {
for {
<-ctrlCSignal
_, err := shell.Write([]byte{3})
if err != nil {
log.Errorf(err.Error())
}
}
}()
// Catch Ctrl-Z signal
ctrlZSignal := make(chan os.Signal, 1)
signal.Notify(ctrlZSignal, syscall.SIGTSTP)
go func() {
for {
<-ctrlZSignal
_, err := shell.Write([]byte{26})
if err != nil {
log.Errorf(err.Error())
}
}
}()
}
|
go
|
func (ns *NodeSession) watchSignals(shell io.Writer) {
exitSignals := make(chan os.Signal, 1)
// catch SIGTERM
signal.Notify(exitSignals, syscall.SIGTERM)
go func() {
defer ns.closer.Close()
<-exitSignals
}()
// Catch Ctrl-C signal
ctrlCSignal := make(chan os.Signal, 1)
signal.Notify(ctrlCSignal, syscall.SIGINT)
go func() {
for {
<-ctrlCSignal
_, err := shell.Write([]byte{3})
if err != nil {
log.Errorf(err.Error())
}
}
}()
// Catch Ctrl-Z signal
ctrlZSignal := make(chan os.Signal, 1)
signal.Notify(ctrlZSignal, syscall.SIGTSTP)
go func() {
for {
<-ctrlZSignal
_, err := shell.Write([]byte{26})
if err != nil {
log.Errorf(err.Error())
}
}
}()
}
|
[
"func",
"(",
"ns",
"*",
"NodeSession",
")",
"watchSignals",
"(",
"shell",
"io",
".",
"Writer",
")",
"{",
"exitSignals",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"exitSignals",
",",
"syscall",
".",
"SIGTERM",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"ns",
".",
"closer",
".",
"Close",
"(",
")",
"\n",
"<-",
"exitSignals",
"\n",
"}",
"(",
")",
"\n",
"ctrlCSignal",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"ctrlCSignal",
",",
"syscall",
".",
"SIGINT",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"<-",
"ctrlCSignal",
"\n",
"_",
",",
"err",
":=",
"shell",
".",
"Write",
"(",
"[",
"]",
"byte",
"{",
"3",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"ctrlZSignal",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"ctrlZSignal",
",",
"syscall",
".",
"SIGTSTP",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"<-",
"ctrlZSignal",
"\n",
"_",
",",
"err",
":=",
"shell",
".",
"Write",
"(",
"[",
"]",
"byte",
"{",
"26",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] |
// watchSignals register UNIX signal handlers and properly terminates a remote shell session
// must be called as a goroutine right after a remote shell is created
|
[
"watchSignals",
"register",
"UNIX",
"signal",
"handlers",
"and",
"properly",
"terminates",
"a",
"remote",
"shell",
"session",
"must",
"be",
"called",
"as",
"a",
"goroutine",
"right",
"after",
"a",
"remote",
"shell",
"is",
"created"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/session.go#L488-L520
|
train
|
gravitational/teleport
|
lib/multiplexer/multiplexer.go
|
CheckAndSetDefaults
|
func (c *Config) CheckAndSetDefaults() error {
if c.Listener == nil {
return trace.BadParameter("missing parameter Listener")
}
if c.Context == nil {
c.Context = context.TODO()
}
if c.ReadDeadline == 0 {
c.ReadDeadline = defaults.ReadHeadersTimeout
}
if c.Clock == nil {
c.Clock = clockwork.NewRealClock()
}
return nil
}
|
go
|
func (c *Config) CheckAndSetDefaults() error {
if c.Listener == nil {
return trace.BadParameter("missing parameter Listener")
}
if c.Context == nil {
c.Context = context.TODO()
}
if c.ReadDeadline == 0 {
c.ReadDeadline = defaults.ReadHeadersTimeout
}
if c.Clock == nil {
c.Clock = clockwork.NewRealClock()
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Config",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Listener",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Listener\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"Context",
"==",
"nil",
"{",
"c",
".",
"Context",
"=",
"context",
".",
"TODO",
"(",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"ReadDeadline",
"==",
"0",
"{",
"c",
".",
"ReadDeadline",
"=",
"defaults",
".",
"ReadHeadersTimeout",
"\n",
"}",
"\n",
"if",
"c",
".",
"Clock",
"==",
"nil",
"{",
"c",
".",
"Clock",
"=",
"clockwork",
".",
"NewRealClock",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckAndSetDefaults verifies configuration and sets defaults
|
[
"CheckAndSetDefaults",
"verifies",
"configuration",
"and",
"sets",
"defaults"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/multiplexer.go#L66-L80
|
train
|
gravitational/teleport
|
lib/multiplexer/multiplexer.go
|
New
|
func New(cfg Config) (*Mux, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
waitContext, waitCancel := context.WithCancel(context.TODO())
return &Mux{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component("mx", cfg.ID),
}),
Config: cfg,
context: ctx,
cancel: cancel,
sshListener: newListener(ctx, cfg.Listener.Addr()),
tlsListener: newListener(ctx, cfg.Listener.Addr()),
waitContext: waitContext,
waitCancel: waitCancel,
}, nil
}
|
go
|
func New(cfg Config) (*Mux, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
waitContext, waitCancel := context.WithCancel(context.TODO())
return &Mux{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component("mx", cfg.ID),
}),
Config: cfg,
context: ctx,
cancel: cancel,
sshListener: newListener(ctx, cfg.Listener.Addr()),
tlsListener: newListener(ctx, cfg.Listener.Addr()),
waitContext: waitContext,
waitCancel: waitCancel,
}, nil
}
|
[
"func",
"New",
"(",
"cfg",
"Config",
")",
"(",
"*",
"Mux",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"cfg",
".",
"Context",
")",
"\n",
"waitContext",
",",
"waitCancel",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"return",
"&",
"Mux",
"{",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"\"mx\"",
",",
"cfg",
".",
"ID",
")",
",",
"}",
")",
",",
"Config",
":",
"cfg",
",",
"context",
":",
"ctx",
",",
"cancel",
":",
"cancel",
",",
"sshListener",
":",
"newListener",
"(",
"ctx",
",",
"cfg",
".",
"Listener",
".",
"Addr",
"(",
")",
")",
",",
"tlsListener",
":",
"newListener",
"(",
"ctx",
",",
"cfg",
".",
"Listener",
".",
"Addr",
"(",
")",
")",
",",
"waitContext",
":",
"waitContext",
",",
"waitCancel",
":",
"waitCancel",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// New returns a new instance of multiplexer
|
[
"New",
"returns",
"a",
"new",
"instance",
"of",
"multiplexer"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/multiplexer.go#L83-L102
|
train
|
gravitational/teleport
|
lib/multiplexer/multiplexer.go
|
Serve
|
func (m *Mux) Serve() error {
defer m.waitCancel()
backoffTimer := time.NewTicker(5 * time.Second)
defer backoffTimer.Stop()
for {
conn, err := m.Listener.Accept()
if err == nil {
if tcpConn, ok := conn.(*net.TCPConn); ok {
tcpConn.SetKeepAlive(true)
tcpConn.SetKeepAlivePeriod(3 * time.Minute)
}
go m.detectAndForward(conn)
continue
}
if m.isClosed() {
return nil
}
select {
case <-backoffTimer.C:
m.Debugf("backoff on accept error: %v", trace.DebugReport(err))
case <-m.context.Done():
return nil
}
}
}
|
go
|
func (m *Mux) Serve() error {
defer m.waitCancel()
backoffTimer := time.NewTicker(5 * time.Second)
defer backoffTimer.Stop()
for {
conn, err := m.Listener.Accept()
if err == nil {
if tcpConn, ok := conn.(*net.TCPConn); ok {
tcpConn.SetKeepAlive(true)
tcpConn.SetKeepAlivePeriod(3 * time.Minute)
}
go m.detectAndForward(conn)
continue
}
if m.isClosed() {
return nil
}
select {
case <-backoffTimer.C:
m.Debugf("backoff on accept error: %v", trace.DebugReport(err))
case <-m.context.Done():
return nil
}
}
}
|
[
"func",
"(",
"m",
"*",
"Mux",
")",
"Serve",
"(",
")",
"error",
"{",
"defer",
"m",
".",
"waitCancel",
"(",
")",
"\n",
"backoffTimer",
":=",
"time",
".",
"NewTicker",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"defer",
"backoffTimer",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"conn",
",",
"err",
":=",
"m",
".",
"Listener",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"tcpConn",
",",
"ok",
":=",
"conn",
".",
"(",
"*",
"net",
".",
"TCPConn",
")",
";",
"ok",
"{",
"tcpConn",
".",
"SetKeepAlive",
"(",
"true",
")",
"\n",
"tcpConn",
".",
"SetKeepAlivePeriod",
"(",
"3",
"*",
"time",
".",
"Minute",
")",
"\n",
"}",
"\n",
"go",
"m",
".",
"detectAndForward",
"(",
"conn",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"m",
".",
"isClosed",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"backoffTimer",
".",
"C",
":",
"m",
".",
"Debugf",
"(",
"\"backoff on accept error: %v\"",
",",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"case",
"<-",
"m",
".",
"context",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Serve is a blocking function that serves on the listening socket
// and accepts requests. Every request is served in a separate goroutine
|
[
"Serve",
"is",
"a",
"blocking",
"function",
"that",
"serves",
"on",
"the",
"listening",
"socket",
"and",
"accepts",
"requests",
".",
"Every",
"request",
"is",
"served",
"in",
"a",
"separate",
"goroutine"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/multiplexer/multiplexer.go#L164-L188
|
train
|
gravitational/teleport
|
lib/auth/grpcserver.go
|
SendKeepAlives
|
func (g *GRPCServer) SendKeepAlives(stream proto.AuthService_SendKeepAlivesServer) error {
defer stream.SendAndClose(&empty.Empty{})
auth, err := g.authenticate(stream.Context())
if err != nil {
return trail.ToGRPC(err)
}
g.Debugf("Got heartbeat connection from %v.", auth.User.GetName())
for {
keepAlive, err := stream.Recv()
if err == io.EOF {
g.Debugf("Connection closed.")
return nil
}
if err != nil {
g.Debugf("Failed to receive heartbeat: %v", err)
return trail.ToGRPC(err)
}
err = auth.KeepAliveNode(stream.Context(), *keepAlive)
if err != nil {
return trail.ToGRPC(err)
}
}
}
|
go
|
func (g *GRPCServer) SendKeepAlives(stream proto.AuthService_SendKeepAlivesServer) error {
defer stream.SendAndClose(&empty.Empty{})
auth, err := g.authenticate(stream.Context())
if err != nil {
return trail.ToGRPC(err)
}
g.Debugf("Got heartbeat connection from %v.", auth.User.GetName())
for {
keepAlive, err := stream.Recv()
if err == io.EOF {
g.Debugf("Connection closed.")
return nil
}
if err != nil {
g.Debugf("Failed to receive heartbeat: %v", err)
return trail.ToGRPC(err)
}
err = auth.KeepAliveNode(stream.Context(), *keepAlive)
if err != nil {
return trail.ToGRPC(err)
}
}
}
|
[
"func",
"(",
"g",
"*",
"GRPCServer",
")",
"SendKeepAlives",
"(",
"stream",
"proto",
".",
"AuthService_SendKeepAlivesServer",
")",
"error",
"{",
"defer",
"stream",
".",
"SendAndClose",
"(",
"&",
"empty",
".",
"Empty",
"{",
"}",
")",
"\n",
"auth",
",",
"err",
":=",
"g",
".",
"authenticate",
"(",
"stream",
".",
"Context",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"g",
".",
"Debugf",
"(",
"\"Got heartbeat connection from %v.\"",
",",
"auth",
".",
"User",
".",
"GetName",
"(",
")",
")",
"\n",
"for",
"{",
"keepAlive",
",",
"err",
":=",
"stream",
".",
"Recv",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"g",
".",
"Debugf",
"(",
"\"Connection closed.\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"g",
".",
"Debugf",
"(",
"\"Failed to receive heartbeat: %v\"",
",",
"err",
")",
"\n",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"auth",
".",
"KeepAliveNode",
"(",
"stream",
".",
"Context",
"(",
")",
",",
"*",
"keepAlive",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// SendKeepAlives allows node to send a stream of keep alive requests
|
[
"SendKeepAlives",
"allows",
"node",
"to",
"send",
"a",
"stream",
"of",
"keep",
"alive",
"requests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/grpcserver.go#L48-L70
|
train
|
gravitational/teleport
|
lib/auth/grpcserver.go
|
WatchEvents
|
func (g *GRPCServer) WatchEvents(watch *proto.Watch, stream proto.AuthService_WatchEventsServer) error {
auth, err := g.authenticate(stream.Context())
if err != nil {
return trail.ToGRPC(err)
}
servicesWatch := services.Watch{
Name: auth.User.GetName(),
}
for _, kind := range watch.Kinds {
servicesWatch.Kinds = append(servicesWatch.Kinds, services.WatchKind{
Name: kind.Name,
Kind: kind.Kind,
LoadSecrets: kind.LoadSecrets,
})
}
watcher, err := auth.NewWatcher(stream.Context(), servicesWatch)
if err != nil {
return trail.ToGRPC(err)
}
defer watcher.Close()
for {
select {
case <-stream.Context().Done():
return nil
case <-watcher.Done():
return trail.ToGRPC(watcher.Error())
case event := <-watcher.Events():
out, err := eventToGRPC(event)
if err != nil {
return trail.ToGRPC(err)
}
if err := stream.Send(out); err != nil {
return trail.ToGRPC(err)
}
}
}
}
|
go
|
func (g *GRPCServer) WatchEvents(watch *proto.Watch, stream proto.AuthService_WatchEventsServer) error {
auth, err := g.authenticate(stream.Context())
if err != nil {
return trail.ToGRPC(err)
}
servicesWatch := services.Watch{
Name: auth.User.GetName(),
}
for _, kind := range watch.Kinds {
servicesWatch.Kinds = append(servicesWatch.Kinds, services.WatchKind{
Name: kind.Name,
Kind: kind.Kind,
LoadSecrets: kind.LoadSecrets,
})
}
watcher, err := auth.NewWatcher(stream.Context(), servicesWatch)
if err != nil {
return trail.ToGRPC(err)
}
defer watcher.Close()
for {
select {
case <-stream.Context().Done():
return nil
case <-watcher.Done():
return trail.ToGRPC(watcher.Error())
case event := <-watcher.Events():
out, err := eventToGRPC(event)
if err != nil {
return trail.ToGRPC(err)
}
if err := stream.Send(out); err != nil {
return trail.ToGRPC(err)
}
}
}
}
|
[
"func",
"(",
"g",
"*",
"GRPCServer",
")",
"WatchEvents",
"(",
"watch",
"*",
"proto",
".",
"Watch",
",",
"stream",
"proto",
".",
"AuthService_WatchEventsServer",
")",
"error",
"{",
"auth",
",",
"err",
":=",
"g",
".",
"authenticate",
"(",
"stream",
".",
"Context",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"servicesWatch",
":=",
"services",
".",
"Watch",
"{",
"Name",
":",
"auth",
".",
"User",
".",
"GetName",
"(",
")",
",",
"}",
"\n",
"for",
"_",
",",
"kind",
":=",
"range",
"watch",
".",
"Kinds",
"{",
"servicesWatch",
".",
"Kinds",
"=",
"append",
"(",
"servicesWatch",
".",
"Kinds",
",",
"services",
".",
"WatchKind",
"{",
"Name",
":",
"kind",
".",
"Name",
",",
"Kind",
":",
"kind",
".",
"Kind",
",",
"LoadSecrets",
":",
"kind",
".",
"LoadSecrets",
",",
"}",
")",
"\n",
"}",
"\n",
"watcher",
",",
"err",
":=",
"auth",
".",
"NewWatcher",
"(",
"stream",
".",
"Context",
"(",
")",
",",
"servicesWatch",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"watcher",
".",
"Close",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"stream",
".",
"Context",
"(",
")",
".",
"Done",
"(",
")",
":",
"return",
"nil",
"\n",
"case",
"<-",
"watcher",
".",
"Done",
"(",
")",
":",
"return",
"trail",
".",
"ToGRPC",
"(",
"watcher",
".",
"Error",
"(",
")",
")",
"\n",
"case",
"event",
":=",
"<-",
"watcher",
".",
"Events",
"(",
")",
":",
"out",
",",
"err",
":=",
"eventToGRPC",
"(",
"event",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"stream",
".",
"Send",
"(",
"out",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// WatchEvents returns a new stream of cluster events
|
[
"WatchEvents",
"returns",
"a",
"new",
"stream",
"of",
"cluster",
"events"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/grpcserver.go#L73-L110
|
train
|
gravitational/teleport
|
lib/auth/grpcserver.go
|
UpsertNode
|
func (g *GRPCServer) UpsertNode(ctx context.Context, server *services.ServerV2) (*services.KeepAlive, error) {
auth, err := g.authenticate(ctx)
if err != nil {
return nil, trail.ToGRPC(err)
}
keepAlive, err := auth.UpsertNode(server)
if err != nil {
return nil, trail.ToGRPC(err)
}
return keepAlive, nil
}
|
go
|
func (g *GRPCServer) UpsertNode(ctx context.Context, server *services.ServerV2) (*services.KeepAlive, error) {
auth, err := g.authenticate(ctx)
if err != nil {
return nil, trail.ToGRPC(err)
}
keepAlive, err := auth.UpsertNode(server)
if err != nil {
return nil, trail.ToGRPC(err)
}
return keepAlive, nil
}
|
[
"func",
"(",
"g",
"*",
"GRPCServer",
")",
"UpsertNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"server",
"*",
"services",
".",
"ServerV2",
")",
"(",
"*",
"services",
".",
"KeepAlive",
",",
"error",
")",
"{",
"auth",
",",
"err",
":=",
"g",
".",
"authenticate",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"keepAlive",
",",
"err",
":=",
"auth",
".",
"UpsertNode",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trail",
".",
"ToGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"keepAlive",
",",
"nil",
"\n",
"}"
] |
// UpsertNode upserts node
|
[
"UpsertNode",
"upserts",
"node"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/grpcserver.go#L113-L123
|
train
|
gravitational/teleport
|
lib/auth/grpcserver.go
|
authenticate
|
func (g *GRPCServer) authenticate(ctx context.Context) (*grpcContext, error) {
// HTTPS server expects auth context to be set by the auth middleware
authContext, err := g.Authorizer.Authorize(ctx)
if err != nil {
// propagate connection problem error so we can differentiate
// between connection failed and access denied
if trace.IsConnectionProblem(err) {
return nil, trace.ConnectionProblem(err, "[10] failed to connect to the database")
} else if trace.IsAccessDenied(err) {
// don't print stack trace, just log the warning
log.Warn(err)
} else {
log.Warn(trace.DebugReport(err))
}
return nil, trace.AccessDenied("[10] access denied")
}
return &grpcContext{
AuthContext: authContext,
AuthWithRoles: &AuthWithRoles{
authServer: g.AuthServer,
user: authContext.User,
checker: authContext.Checker,
sessions: g.SessionService,
alog: g.AuthServer.IAuditLog,
},
}, nil
}
|
go
|
func (g *GRPCServer) authenticate(ctx context.Context) (*grpcContext, error) {
// HTTPS server expects auth context to be set by the auth middleware
authContext, err := g.Authorizer.Authorize(ctx)
if err != nil {
// propagate connection problem error so we can differentiate
// between connection failed and access denied
if trace.IsConnectionProblem(err) {
return nil, trace.ConnectionProblem(err, "[10] failed to connect to the database")
} else if trace.IsAccessDenied(err) {
// don't print stack trace, just log the warning
log.Warn(err)
} else {
log.Warn(trace.DebugReport(err))
}
return nil, trace.AccessDenied("[10] access denied")
}
return &grpcContext{
AuthContext: authContext,
AuthWithRoles: &AuthWithRoles{
authServer: g.AuthServer,
user: authContext.User,
checker: authContext.Checker,
sessions: g.SessionService,
alog: g.AuthServer.IAuditLog,
},
}, nil
}
|
[
"func",
"(",
"g",
"*",
"GRPCServer",
")",
"authenticate",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"grpcContext",
",",
"error",
")",
"{",
"authContext",
",",
"err",
":=",
"g",
".",
"Authorizer",
".",
"Authorize",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"err",
",",
"\"[10] failed to connect to the database\"",
")",
"\n",
"}",
"else",
"if",
"trace",
".",
"IsAccessDenied",
"(",
"err",
")",
"{",
"log",
".",
"Warn",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Warn",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"[10] access denied\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"grpcContext",
"{",
"AuthContext",
":",
"authContext",
",",
"AuthWithRoles",
":",
"&",
"AuthWithRoles",
"{",
"authServer",
":",
"g",
".",
"AuthServer",
",",
"user",
":",
"authContext",
".",
"User",
",",
"checker",
":",
"authContext",
".",
"Checker",
",",
"sessions",
":",
"g",
".",
"SessionService",
",",
"alog",
":",
"g",
".",
"AuthServer",
".",
"IAuditLog",
",",
"}",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// authenticate extracts authentication context and returns initialized auth server
|
[
"authenticate",
"extracts",
"authentication",
"context",
"and",
"returns",
"initialized",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/grpcserver.go#L131-L157
|
train
|
gravitational/teleport
|
lib/auth/grpcserver.go
|
NewGRPCServer
|
func NewGRPCServer(cfg APIConfig) http.Handler {
authServer := &GRPCServer{
APIConfig: cfg,
Entry: logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentAuth, teleport.ComponentGRPC),
}),
httpHandler: NewAPIServer(&cfg),
grpcHandler: grpc.NewServer(),
}
proto.RegisterAuthServiceServer(authServer.grpcHandler, authServer)
return authServer
}
|
go
|
func NewGRPCServer(cfg APIConfig) http.Handler {
authServer := &GRPCServer{
APIConfig: cfg,
Entry: logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentAuth, teleport.ComponentGRPC),
}),
httpHandler: NewAPIServer(&cfg),
grpcHandler: grpc.NewServer(),
}
proto.RegisterAuthServiceServer(authServer.grpcHandler, authServer)
return authServer
}
|
[
"func",
"NewGRPCServer",
"(",
"cfg",
"APIConfig",
")",
"http",
".",
"Handler",
"{",
"authServer",
":=",
"&",
"GRPCServer",
"{",
"APIConfig",
":",
"cfg",
",",
"Entry",
":",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"Component",
"(",
"teleport",
".",
"ComponentAuth",
",",
"teleport",
".",
"ComponentGRPC",
")",
",",
"}",
")",
",",
"httpHandler",
":",
"NewAPIServer",
"(",
"&",
"cfg",
")",
",",
"grpcHandler",
":",
"grpc",
".",
"NewServer",
"(",
")",
",",
"}",
"\n",
"proto",
".",
"RegisterAuthServiceServer",
"(",
"authServer",
".",
"grpcHandler",
",",
"authServer",
")",
"\n",
"return",
"authServer",
"\n",
"}"
] |
// NewGRPCServer returns a new instance of GRPC server
|
[
"NewGRPCServer",
"returns",
"a",
"new",
"instance",
"of",
"GRPC",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/grpcserver.go#L160-L171
|
train
|
gravitational/teleport
|
lib/auth/grpcserver.go
|
ServeHTTP
|
func (g *GRPCServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// magic combo match signifying GRPC request
// https://grpc.io/blog/coreos
if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
g.grpcHandler.ServeHTTP(w, r)
} else {
g.httpHandler.ServeHTTP(w, r)
}
}
|
go
|
func (g *GRPCServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// magic combo match signifying GRPC request
// https://grpc.io/blog/coreos
if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
g.grpcHandler.ServeHTTP(w, r)
} else {
g.httpHandler.ServeHTTP(w, r)
}
}
|
[
"func",
"(",
"g",
"*",
"GRPCServer",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"r",
".",
"ProtoMajor",
"==",
"2",
"&&",
"strings",
".",
"Contains",
"(",
"r",
".",
"Header",
".",
"Get",
"(",
"\"Content-Type\"",
")",
",",
"\"application/grpc\"",
")",
"{",
"g",
".",
"grpcHandler",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"else",
"{",
"g",
".",
"httpHandler",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"\n",
"}"
] |
// ServeHTTP dispatches requests based on the request type
|
[
"ServeHTTP",
"dispatches",
"requests",
"based",
"on",
"the",
"request",
"type"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/grpcserver.go#L174-L182
|
train
|
gravitational/teleport
|
lib/srv/regular/sites.go
|
Start
|
func (t *proxySitesSubsys) Start(sconn *ssh.ServerConn, ch ssh.Channel, req *ssh.Request, ctx *srv.ServerContext) error {
log.Debugf("proxysites.start(%v)", ctx)
remoteSites := t.srv.proxyTun.GetSites()
// build an arary of services.Site structures:
retval := make([]services.Site, 0, len(remoteSites))
for _, s := range remoteSites {
retval = append(retval, services.Site{
Name: s.GetName(),
Status: s.GetStatus(),
LastConnected: s.GetLastConnected(),
})
}
// serialize them into JSON and write back:
data, err := json.Marshal(retval)
if err != nil {
return trace.Wrap(err)
}
if _, err := ch.Write(data); err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (t *proxySitesSubsys) Start(sconn *ssh.ServerConn, ch ssh.Channel, req *ssh.Request, ctx *srv.ServerContext) error {
log.Debugf("proxysites.start(%v)", ctx)
remoteSites := t.srv.proxyTun.GetSites()
// build an arary of services.Site structures:
retval := make([]services.Site, 0, len(remoteSites))
for _, s := range remoteSites {
retval = append(retval, services.Site{
Name: s.GetName(),
Status: s.GetStatus(),
LastConnected: s.GetLastConnected(),
})
}
// serialize them into JSON and write back:
data, err := json.Marshal(retval)
if err != nil {
return trace.Wrap(err)
}
if _, err := ch.Write(data); err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"proxySitesSubsys",
")",
"Start",
"(",
"sconn",
"*",
"ssh",
".",
"ServerConn",
",",
"ch",
"ssh",
".",
"Channel",
",",
"req",
"*",
"ssh",
".",
"Request",
",",
"ctx",
"*",
"srv",
".",
"ServerContext",
")",
"error",
"{",
"log",
".",
"Debugf",
"(",
"\"proxysites.start(%v)\"",
",",
"ctx",
")",
"\n",
"remoteSites",
":=",
"t",
".",
"srv",
".",
"proxyTun",
".",
"GetSites",
"(",
")",
"\n",
"retval",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Site",
",",
"0",
",",
"len",
"(",
"remoteSites",
")",
")",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"remoteSites",
"{",
"retval",
"=",
"append",
"(",
"retval",
",",
"services",
".",
"Site",
"{",
"Name",
":",
"s",
".",
"GetName",
"(",
")",
",",
"Status",
":",
"s",
".",
"GetStatus",
"(",
")",
",",
"LastConnected",
":",
"s",
".",
"GetLastConnected",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"data",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"retval",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"ch",
".",
"Write",
"(",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Start serves a request for "proxysites" custom SSH subsystem. It builds an array of
// service.Site structures, and writes it serialized as JSON back to the SSH client
|
[
"Start",
"serves",
"a",
"request",
"for",
"proxysites",
"custom",
"SSH",
"subsystem",
".",
"It",
"builds",
"an",
"array",
"of",
"service",
".",
"Site",
"structures",
"and",
"writes",
"it",
"serialized",
"as",
"JSON",
"back",
"to",
"the",
"SSH",
"client"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sites.go#L53-L75
|
train
|
gravitational/teleport
|
lib/events/multilog.go
|
Close
|
func (m *MultiLog) Close() error {
var errors []error
for _, log := range m.loggers {
errors = append(errors, log.Close())
}
return trace.NewAggregate(errors...)
}
|
go
|
func (m *MultiLog) Close() error {
var errors []error
for _, log := range m.loggers {
errors = append(errors, log.Close())
}
return trace.NewAggregate(errors...)
}
|
[
"func",
"(",
"m",
"*",
"MultiLog",
")",
"Close",
"(",
")",
"error",
"{",
"var",
"errors",
"[",
"]",
"error",
"\n",
"for",
"_",
",",
"log",
":=",
"range",
"m",
".",
"loggers",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"log",
".",
"Close",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] |
// Closer releases connections and resources associated with logs if any
|
[
"Closer",
"releases",
"connections",
"and",
"resources",
"associated",
"with",
"logs",
"if",
"any"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/multilog.go#L49-L55
|
train
|
gravitational/teleport
|
lib/client/client.go
|
FindServersByLabels
|
func (proxy *ProxyClient) FindServersByLabels(ctx context.Context, namespace string, labels map[string]string) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter(auth.MissingNamespaceError)
}
nodes := make([]services.Server, 0)
site, err := proxy.CurrentClusterAccessPoint(ctx, false)
if err != nil {
return nil, trace.Wrap(err)
}
siteNodes, err := site.GetNodes(namespace, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
// look at every node on this site and see which ones match:
for _, node := range siteNodes {
if node.MatchAgainst(labels) {
nodes = append(nodes, node)
}
}
return nodes, nil
}
|
go
|
func (proxy *ProxyClient) FindServersByLabels(ctx context.Context, namespace string, labels map[string]string) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter(auth.MissingNamespaceError)
}
nodes := make([]services.Server, 0)
site, err := proxy.CurrentClusterAccessPoint(ctx, false)
if err != nil {
return nil, trace.Wrap(err)
}
siteNodes, err := site.GetNodes(namespace, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
// look at every node on this site and see which ones match:
for _, node := range siteNodes {
if node.MatchAgainst(labels) {
nodes = append(nodes, node)
}
}
return nodes, nil
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"FindServersByLabels",
"(",
"ctx",
"context",
".",
"Context",
",",
"namespace",
"string",
",",
"labels",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"auth",
".",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"nodes",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"0",
")",
"\n",
"site",
",",
"err",
":=",
"proxy",
".",
"CurrentClusterAccessPoint",
"(",
"ctx",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"siteNodes",
",",
"err",
":=",
"site",
".",
"GetNodes",
"(",
"namespace",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"node",
":=",
"range",
"siteNodes",
"{",
"if",
"node",
".",
"MatchAgainst",
"(",
"labels",
")",
"{",
"nodes",
"=",
"append",
"(",
"nodes",
",",
"node",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nodes",
",",
"nil",
"\n",
"}"
] |
// FindServersByLabels returns list of the nodes which have labels exactly matching
// the given label set.
//
// A server is matched when ALL labels match.
// If no labels are passed, ALL nodes are returned.
|
[
"FindServersByLabels",
"returns",
"list",
"of",
"the",
"nodes",
"which",
"have",
"labels",
"exactly",
"matching",
"the",
"given",
"label",
"set",
".",
"A",
"server",
"is",
"matched",
"when",
"ALL",
"labels",
"match",
".",
"If",
"no",
"labels",
"are",
"passed",
"ALL",
"nodes",
"are",
"returned",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L116-L138
|
train
|
gravitational/teleport
|
lib/client/client.go
|
CurrentClusterAccessPoint
|
func (proxy *ProxyClient) CurrentClusterAccessPoint(ctx context.Context, quiet bool) (auth.AccessPoint, error) {
// get the current cluster:
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ClusterAccessPoint(ctx, cluster.Name, quiet)
}
|
go
|
func (proxy *ProxyClient) CurrentClusterAccessPoint(ctx context.Context, quiet bool) (auth.AccessPoint, error) {
// get the current cluster:
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ClusterAccessPoint(ctx, cluster.Name, quiet)
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"CurrentClusterAccessPoint",
"(",
"ctx",
"context",
".",
"Context",
",",
"quiet",
"bool",
")",
"(",
"auth",
".",
"AccessPoint",
",",
"error",
")",
"{",
"cluster",
",",
"err",
":=",
"proxy",
".",
"currentCluster",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"proxy",
".",
"ClusterAccessPoint",
"(",
"ctx",
",",
"cluster",
".",
"Name",
",",
"quiet",
")",
"\n",
"}"
] |
// CurrentClusterAccessPoint returns cluster access point to the currently
// selected cluster and is used for discovery
// and could be cached based on the access policy
|
[
"CurrentClusterAccessPoint",
"returns",
"cluster",
"access",
"point",
"to",
"the",
"currently",
"selected",
"cluster",
"and",
"is",
"used",
"for",
"discovery",
"and",
"could",
"be",
"cached",
"based",
"on",
"the",
"access",
"policy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L143-L150
|
train
|
gravitational/teleport
|
lib/client/client.go
|
ClusterAccessPoint
|
func (proxy *ProxyClient) ClusterAccessPoint(ctx context.Context, clusterName string, quiet bool) (auth.AccessPoint, error) {
if clusterName == "" {
return nil, trace.BadParameter("parameter clusterName is missing")
}
clt, err := proxy.ConnectToCluster(ctx, clusterName, quiet)
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.teleportClient.accessPoint(clt, proxy.proxyAddress, clusterName)
}
|
go
|
func (proxy *ProxyClient) ClusterAccessPoint(ctx context.Context, clusterName string, quiet bool) (auth.AccessPoint, error) {
if clusterName == "" {
return nil, trace.BadParameter("parameter clusterName is missing")
}
clt, err := proxy.ConnectToCluster(ctx, clusterName, quiet)
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.teleportClient.accessPoint(clt, proxy.proxyAddress, clusterName)
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"ClusterAccessPoint",
"(",
"ctx",
"context",
".",
"Context",
",",
"clusterName",
"string",
",",
"quiet",
"bool",
")",
"(",
"auth",
".",
"AccessPoint",
",",
"error",
")",
"{",
"if",
"clusterName",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"parameter clusterName is missing\"",
")",
"\n",
"}",
"\n",
"clt",
",",
"err",
":=",
"proxy",
".",
"ConnectToCluster",
"(",
"ctx",
",",
"clusterName",
",",
"quiet",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"proxy",
".",
"teleportClient",
".",
"accessPoint",
"(",
"clt",
",",
"proxy",
".",
"proxyAddress",
",",
"clusterName",
")",
"\n",
"}"
] |
// ClusterAccessPoint returns cluster access point used for discovery
// and could be cached based on the access policy
|
[
"ClusterAccessPoint",
"returns",
"cluster",
"access",
"point",
"used",
"for",
"discovery",
"and",
"could",
"be",
"cached",
"based",
"on",
"the",
"access",
"policy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L154-L163
|
train
|
gravitational/teleport
|
lib/client/client.go
|
ConnectToCurrentCluster
|
func (proxy *ProxyClient) ConnectToCurrentCluster(ctx context.Context, quiet bool) (auth.ClientI, error) {
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ConnectToCluster(ctx, cluster.Name, quiet)
}
|
go
|
func (proxy *ProxyClient) ConnectToCurrentCluster(ctx context.Context, quiet bool) (auth.ClientI, error) {
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ConnectToCluster(ctx, cluster.Name, quiet)
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"ConnectToCurrentCluster",
"(",
"ctx",
"context",
".",
"Context",
",",
"quiet",
"bool",
")",
"(",
"auth",
".",
"ClientI",
",",
"error",
")",
"{",
"cluster",
",",
"err",
":=",
"proxy",
".",
"currentCluster",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"proxy",
".",
"ConnectToCluster",
"(",
"ctx",
",",
"cluster",
".",
"Name",
",",
"quiet",
")",
"\n",
"}"
] |
// ConnectToCurrentCluster connects to the auth server of the currently selected
// cluster via proxy. It returns connected and authenticated auth server client
//
// if 'quiet' is set to true, no errors will be printed to stdout, otherwise
// any connection errors are visible to a user.
|
[
"ConnectToCurrentCluster",
"connects",
"to",
"the",
"auth",
"server",
"of",
"the",
"currently",
"selected",
"cluster",
"via",
"proxy",
".",
"It",
"returns",
"connected",
"and",
"authenticated",
"auth",
"server",
"client",
"if",
"quiet",
"is",
"set",
"to",
"true",
"no",
"errors",
"will",
"be",
"printed",
"to",
"stdout",
"otherwise",
"any",
"connection",
"errors",
"are",
"visible",
"to",
"a",
"user",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L170-L176
|
train
|
gravitational/teleport
|
lib/client/client.go
|
ConnectToCluster
|
func (proxy *ProxyClient) ConnectToCluster(ctx context.Context, clusterName string, quiet bool) (auth.ClientI, error) {
dialer := func(ctx context.Context, network, _ string) (net.Conn, error) {
return proxy.dialAuthServer(ctx, clusterName)
}
if proxy.teleportClient.SkipLocalAuth {
return auth.NewTLSClient(auth.ClientConfig{
DialContext: dialer,
TLS: proxy.teleportClient.TLS,
})
}
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
localAgent := proxy.teleportClient.LocalAgent()
pool, err := localAgent.GetCerts()
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.RootCAs = pool
key, err := localAgent.GetKey()
if err != nil {
return nil, trace.Wrap(err, "failed to fetch TLS key for %v", proxy.teleportClient.Username)
}
if len(key.TLSCert) != 0 {
tlsCert, err := tls.X509KeyPair(key.TLSCert, key.Priv)
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
}
if len(tlsConfig.Certificates) == 0 {
return nil, trace.BadParameter("no TLS keys found for user %v, please relogin to get new credentials", proxy.teleportClient.Username)
}
clt, err := auth.NewTLSClient(auth.ClientConfig{
DialContext: dialer,
TLS: tlsConfig,
})
if err != nil {
return nil, trace.Wrap(err)
}
return clt, nil
}
|
go
|
func (proxy *ProxyClient) ConnectToCluster(ctx context.Context, clusterName string, quiet bool) (auth.ClientI, error) {
dialer := func(ctx context.Context, network, _ string) (net.Conn, error) {
return proxy.dialAuthServer(ctx, clusterName)
}
if proxy.teleportClient.SkipLocalAuth {
return auth.NewTLSClient(auth.ClientConfig{
DialContext: dialer,
TLS: proxy.teleportClient.TLS,
})
}
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
localAgent := proxy.teleportClient.LocalAgent()
pool, err := localAgent.GetCerts()
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.RootCAs = pool
key, err := localAgent.GetKey()
if err != nil {
return nil, trace.Wrap(err, "failed to fetch TLS key for %v", proxy.teleportClient.Username)
}
if len(key.TLSCert) != 0 {
tlsCert, err := tls.X509KeyPair(key.TLSCert, key.Priv)
if err != nil {
return nil, trace.Wrap(err, "failed to parse TLS cert and key")
}
tlsConfig.Certificates = append(tlsConfig.Certificates, tlsCert)
}
if len(tlsConfig.Certificates) == 0 {
return nil, trace.BadParameter("no TLS keys found for user %v, please relogin to get new credentials", proxy.teleportClient.Username)
}
clt, err := auth.NewTLSClient(auth.ClientConfig{
DialContext: dialer,
TLS: tlsConfig,
})
if err != nil {
return nil, trace.Wrap(err)
}
return clt, nil
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"ConnectToCluster",
"(",
"ctx",
"context",
".",
"Context",
",",
"clusterName",
"string",
",",
"quiet",
"bool",
")",
"(",
"auth",
".",
"ClientI",
",",
"error",
")",
"{",
"dialer",
":=",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"network",
",",
"_",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"proxy",
".",
"dialAuthServer",
"(",
"ctx",
",",
"clusterName",
")",
"\n",
"}",
"\n",
"if",
"proxy",
".",
"teleportClient",
".",
"SkipLocalAuth",
"{",
"return",
"auth",
".",
"NewTLSClient",
"(",
"auth",
".",
"ClientConfig",
"{",
"DialContext",
":",
"dialer",
",",
"TLS",
":",
"proxy",
".",
"teleportClient",
".",
"TLS",
",",
"}",
")",
"\n",
"}",
"\n",
"tlsConfig",
":=",
"utils",
".",
"TLSConfig",
"(",
"nil",
")",
"\n",
"localAgent",
":=",
"proxy",
".",
"teleportClient",
".",
"LocalAgent",
"(",
")",
"\n",
"pool",
",",
"err",
":=",
"localAgent",
".",
"GetCerts",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"RootCAs",
"=",
"pool",
"\n",
"key",
",",
"err",
":=",
"localAgent",
".",
"GetKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"failed to fetch TLS key for %v\"",
",",
"proxy",
".",
"teleportClient",
".",
"Username",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"key",
".",
"TLSCert",
")",
"!=",
"0",
"{",
"tlsCert",
",",
"err",
":=",
"tls",
".",
"X509KeyPair",
"(",
"key",
".",
"TLSCert",
",",
"key",
".",
"Priv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"failed to parse TLS cert and key\"",
")",
"\n",
"}",
"\n",
"tlsConfig",
".",
"Certificates",
"=",
"append",
"(",
"tlsConfig",
".",
"Certificates",
",",
"tlsCert",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"tlsConfig",
".",
"Certificates",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"no TLS keys found for user %v, please relogin to get new credentials\"",
",",
"proxy",
".",
"teleportClient",
".",
"Username",
")",
"\n",
"}",
"\n",
"clt",
",",
"err",
":=",
"auth",
".",
"NewTLSClient",
"(",
"auth",
".",
"ClientConfig",
"{",
"DialContext",
":",
"dialer",
",",
"TLS",
":",
"tlsConfig",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"clt",
",",
"nil",
"\n",
"}"
] |
// ConnectToCluster connects to the auth server of the given cluster via proxy.
// It returns connected and authenticated auth server client
//
// if 'quiet' is set to true, no errors will be printed to stdout, otherwise
// any connection errors are visible to a user.
|
[
"ConnectToCluster",
"connects",
"to",
"the",
"auth",
"server",
"of",
"the",
"given",
"cluster",
"via",
"proxy",
".",
"It",
"returns",
"connected",
"and",
"authenticated",
"auth",
"server",
"client",
"if",
"quiet",
"is",
"set",
"to",
"true",
"no",
"errors",
"will",
"be",
"printed",
"to",
"stdout",
"otherwise",
"any",
"connection",
"errors",
"are",
"visible",
"to",
"a",
"user",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L183-L226
|
train
|
gravitational/teleport
|
lib/client/client.go
|
addCloser
|
func (c *closerConn) addCloser(closer io.Closer) {
c.closers = append(c.closers, closer)
}
|
go
|
func (c *closerConn) addCloser(closer io.Closer) {
c.closers = append(c.closers, closer)
}
|
[
"func",
"(",
"c",
"*",
"closerConn",
")",
"addCloser",
"(",
"closer",
"io",
".",
"Closer",
")",
"{",
"c",
".",
"closers",
"=",
"append",
"(",
"c",
".",
"closers",
",",
"closer",
")",
"\n",
"}"
] |
// addCloser adds any closer in ctx that will be called
// whenever server closes session channel
|
[
"addCloser",
"adds",
"any",
"closer",
"in",
"ctx",
"that",
"will",
"be",
"called",
"whenever",
"server",
"closes",
"session",
"channel"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L236-L238
|
train
|
gravitational/teleport
|
lib/client/client.go
|
nodeName
|
func nodeName(node string) string {
n, _, err := net.SplitHostPort(node)
if err != nil {
return node
}
return n
}
|
go
|
func nodeName(node string) string {
n, _, err := net.SplitHostPort(node)
if err != nil {
return node
}
return n
}
|
[
"func",
"nodeName",
"(",
"node",
"string",
")",
"string",
"{",
"n",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"node",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"node",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}"
] |
// nodeName removes the port number from the hostname, if present
|
[
"nodeName",
"removes",
"the",
"port",
"number",
"from",
"the",
"hostname",
"if",
"present"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L250-L256
|
train
|
gravitational/teleport
|
lib/client/client.go
|
isRecordingProxy
|
func (proxy *ProxyClient) isRecordingProxy() (bool, error) {
responseCh := make(chan proxyResponse)
// we have to run this in a goroutine because older version of Teleport handled
// global out-of-band requests incorrectly: Teleport would ignore requests it
// does not know about and never reply to them. So if we wait a second and
// don't hear anything back, most likley we are trying to connect to an older
// version of Teleport and we should not try and forward our agent.
go func() {
ok, responseBytes, err := proxy.Client.SendRequest(teleport.RecordingProxyReqType, true, nil)
if err != nil {
responseCh <- proxyResponse{isRecord: false, err: trace.Wrap(err)}
return
}
if !ok {
responseCh <- proxyResponse{isRecord: false, err: trace.AccessDenied("unable to determine proxy type")}
return
}
recordingProxy, err := strconv.ParseBool(string(responseBytes))
if err != nil {
responseCh <- proxyResponse{isRecord: false, err: trace.Wrap(err)}
return
}
responseCh <- proxyResponse{isRecord: recordingProxy, err: nil}
}()
select {
case resp := <-responseCh:
if resp.err != nil {
return false, trace.Wrap(resp.err)
}
return resp.isRecord, nil
case <-time.After(1 * time.Second):
// probably the older version of the proxy or at least someone that is
// responding incorrectly, don't forward agent to it
return false, nil
}
}
|
go
|
func (proxy *ProxyClient) isRecordingProxy() (bool, error) {
responseCh := make(chan proxyResponse)
// we have to run this in a goroutine because older version of Teleport handled
// global out-of-band requests incorrectly: Teleport would ignore requests it
// does not know about and never reply to them. So if we wait a second and
// don't hear anything back, most likley we are trying to connect to an older
// version of Teleport and we should not try and forward our agent.
go func() {
ok, responseBytes, err := proxy.Client.SendRequest(teleport.RecordingProxyReqType, true, nil)
if err != nil {
responseCh <- proxyResponse{isRecord: false, err: trace.Wrap(err)}
return
}
if !ok {
responseCh <- proxyResponse{isRecord: false, err: trace.AccessDenied("unable to determine proxy type")}
return
}
recordingProxy, err := strconv.ParseBool(string(responseBytes))
if err != nil {
responseCh <- proxyResponse{isRecord: false, err: trace.Wrap(err)}
return
}
responseCh <- proxyResponse{isRecord: recordingProxy, err: nil}
}()
select {
case resp := <-responseCh:
if resp.err != nil {
return false, trace.Wrap(resp.err)
}
return resp.isRecord, nil
case <-time.After(1 * time.Second):
// probably the older version of the proxy or at least someone that is
// responding incorrectly, don't forward agent to it
return false, nil
}
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"isRecordingProxy",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"responseCh",
":=",
"make",
"(",
"chan",
"proxyResponse",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"ok",
",",
"responseBytes",
",",
"err",
":=",
"proxy",
".",
"Client",
".",
"SendRequest",
"(",
"teleport",
".",
"RecordingProxyReqType",
",",
"true",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"responseCh",
"<-",
"proxyResponse",
"{",
"isRecord",
":",
"false",
",",
"err",
":",
"trace",
".",
"Wrap",
"(",
"err",
")",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"!",
"ok",
"{",
"responseCh",
"<-",
"proxyResponse",
"{",
"isRecord",
":",
"false",
",",
"err",
":",
"trace",
".",
"AccessDenied",
"(",
"\"unable to determine proxy type\"",
")",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"recordingProxy",
",",
"err",
":=",
"strconv",
".",
"ParseBool",
"(",
"string",
"(",
"responseBytes",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"responseCh",
"<-",
"proxyResponse",
"{",
"isRecord",
":",
"false",
",",
"err",
":",
"trace",
".",
"Wrap",
"(",
"err",
")",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"responseCh",
"<-",
"proxyResponse",
"{",
"isRecord",
":",
"recordingProxy",
",",
"err",
":",
"nil",
"}",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"resp",
":=",
"<-",
"responseCh",
":",
"if",
"resp",
".",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"trace",
".",
"Wrap",
"(",
"resp",
".",
"err",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"isRecord",
",",
"nil",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"1",
"*",
"time",
".",
"Second",
")",
":",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"}"
] |
// isRecordingProxy returns true if the proxy is in recording mode. Note, this
// function can only be called after authentication has occurred and should be
// called before the first session is created.
|
[
"isRecordingProxy",
"returns",
"true",
"if",
"the",
"proxy",
"is",
"in",
"recording",
"mode",
".",
"Note",
"this",
"function",
"can",
"only",
"be",
"called",
"after",
"authentication",
"has",
"occurred",
"and",
"should",
"be",
"called",
"before",
"the",
"first",
"session",
"is",
"created",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L266-L305
|
train
|
gravitational/teleport
|
lib/client/client.go
|
dialAuthServer
|
func (proxy *ProxyClient) dialAuthServer(ctx context.Context, clusterName string) (net.Conn, error) {
log.Debugf("Client %v is connecting to auth server on cluster %q.", proxy.clientAddr, clusterName)
address := "@" + clusterName
// parse destination first:
localAddr, err := utils.ParseAddr("tcp://" + proxy.proxyAddress)
if err != nil {
return nil, trace.Wrap(err)
}
fakeAddr, err := utils.ParseAddr("tcp://" + address)
if err != nil {
return nil, trace.Wrap(err)
}
proxySession, err := proxy.Client.NewSession()
if err != nil {
return nil, trace.Wrap(err)
}
proxyWriter, err := proxySession.StdinPipe()
if err != nil {
return nil, trace.Wrap(err)
}
proxyReader, err := proxySession.StdoutPipe()
if err != nil {
return nil, trace.Wrap(err)
}
proxyErr, err := proxySession.StderrPipe()
if err != nil {
return nil, trace.Wrap(err)
}
err = proxySession.RequestSubsystem("proxy:" + address)
if err != nil {
// read the stderr output from the failed SSH session and append
// it to the end of our own message:
serverErrorMsg, _ := ioutil.ReadAll(proxyErr)
return nil, trace.ConnectionProblem(err, "failed connecting to node %v. %s",
nodeName(strings.Split(address, "@")[0]), serverErrorMsg)
}
return utils.NewPipeNetConn(
proxyReader,
proxyWriter,
proxySession,
localAddr,
fakeAddr,
), nil
}
|
go
|
func (proxy *ProxyClient) dialAuthServer(ctx context.Context, clusterName string) (net.Conn, error) {
log.Debugf("Client %v is connecting to auth server on cluster %q.", proxy.clientAddr, clusterName)
address := "@" + clusterName
// parse destination first:
localAddr, err := utils.ParseAddr("tcp://" + proxy.proxyAddress)
if err != nil {
return nil, trace.Wrap(err)
}
fakeAddr, err := utils.ParseAddr("tcp://" + address)
if err != nil {
return nil, trace.Wrap(err)
}
proxySession, err := proxy.Client.NewSession()
if err != nil {
return nil, trace.Wrap(err)
}
proxyWriter, err := proxySession.StdinPipe()
if err != nil {
return nil, trace.Wrap(err)
}
proxyReader, err := proxySession.StdoutPipe()
if err != nil {
return nil, trace.Wrap(err)
}
proxyErr, err := proxySession.StderrPipe()
if err != nil {
return nil, trace.Wrap(err)
}
err = proxySession.RequestSubsystem("proxy:" + address)
if err != nil {
// read the stderr output from the failed SSH session and append
// it to the end of our own message:
serverErrorMsg, _ := ioutil.ReadAll(proxyErr)
return nil, trace.ConnectionProblem(err, "failed connecting to node %v. %s",
nodeName(strings.Split(address, "@")[0]), serverErrorMsg)
}
return utils.NewPipeNetConn(
proxyReader,
proxyWriter,
proxySession,
localAddr,
fakeAddr,
), nil
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"dialAuthServer",
"(",
"ctx",
"context",
".",
"Context",
",",
"clusterName",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"Client %v is connecting to auth server on cluster %q.\"",
",",
"proxy",
".",
"clientAddr",
",",
"clusterName",
")",
"\n",
"address",
":=",
"\"@\"",
"+",
"clusterName",
"\n",
"localAddr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"\"tcp://\"",
"+",
"proxy",
".",
"proxyAddress",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fakeAddr",
",",
"err",
":=",
"utils",
".",
"ParseAddr",
"(",
"\"tcp://\"",
"+",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"proxySession",
",",
"err",
":=",
"proxy",
".",
"Client",
".",
"NewSession",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"proxyWriter",
",",
"err",
":=",
"proxySession",
".",
"StdinPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"proxyReader",
",",
"err",
":=",
"proxySession",
".",
"StdoutPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"proxyErr",
",",
"err",
":=",
"proxySession",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"proxySession",
".",
"RequestSubsystem",
"(",
"\"proxy:\"",
"+",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"serverErrorMsg",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"proxyErr",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"err",
",",
"\"failed connecting to node %v. %s\"",
",",
"nodeName",
"(",
"strings",
".",
"Split",
"(",
"address",
",",
"\"@\"",
")",
"[",
"0",
"]",
")",
",",
"serverErrorMsg",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"NewPipeNetConn",
"(",
"proxyReader",
",",
"proxyWriter",
",",
"proxySession",
",",
"localAddr",
",",
"fakeAddr",
",",
")",
",",
"nil",
"\n",
"}"
] |
// dialAuthServer returns auth server connection forwarded via proxy
|
[
"dialAuthServer",
"returns",
"auth",
"server",
"connection",
"forwarded",
"via",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L308-L355
|
train
|
gravitational/teleport
|
lib/client/client.go
|
newClientConn
|
func newClientConn(ctx context.Context,
conn net.Conn,
nodeAddress string,
config *ssh.ClientConfig) (ssh.Conn, <-chan ssh.NewChannel, <-chan *ssh.Request, error) {
type response struct {
conn ssh.Conn
chanCh <-chan ssh.NewChannel
reqCh <-chan *ssh.Request
err error
}
respCh := make(chan response, 1)
go func() {
conn, chans, reqs, err := ssh.NewClientConn(conn, nodeAddress, config)
respCh <- response{conn, chans, reqs, err}
}()
select {
case resp := <-respCh:
if resp.err != nil {
return nil, nil, nil, trace.Wrap(resp.err, "failed to connect to %q", nodeAddress)
}
return resp.conn, resp.chanCh, resp.reqCh, nil
case <-ctx.Done():
errClose := conn.Close()
if errClose != nil {
log.Error(errClose)
}
// drain the channel
resp := <-respCh
return nil, nil, nil, trace.ConnectionProblem(resp.err, "failed to connect to %q", nodeAddress)
}
}
|
go
|
func newClientConn(ctx context.Context,
conn net.Conn,
nodeAddress string,
config *ssh.ClientConfig) (ssh.Conn, <-chan ssh.NewChannel, <-chan *ssh.Request, error) {
type response struct {
conn ssh.Conn
chanCh <-chan ssh.NewChannel
reqCh <-chan *ssh.Request
err error
}
respCh := make(chan response, 1)
go func() {
conn, chans, reqs, err := ssh.NewClientConn(conn, nodeAddress, config)
respCh <- response{conn, chans, reqs, err}
}()
select {
case resp := <-respCh:
if resp.err != nil {
return nil, nil, nil, trace.Wrap(resp.err, "failed to connect to %q", nodeAddress)
}
return resp.conn, resp.chanCh, resp.reqCh, nil
case <-ctx.Done():
errClose := conn.Close()
if errClose != nil {
log.Error(errClose)
}
// drain the channel
resp := <-respCh
return nil, nil, nil, trace.ConnectionProblem(resp.err, "failed to connect to %q", nodeAddress)
}
}
|
[
"func",
"newClientConn",
"(",
"ctx",
"context",
".",
"Context",
",",
"conn",
"net",
".",
"Conn",
",",
"nodeAddress",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"ssh",
".",
"Conn",
",",
"<-",
"chan",
"ssh",
".",
"NewChannel",
",",
"<-",
"chan",
"*",
"ssh",
".",
"Request",
",",
"error",
")",
"{",
"type",
"response",
"struct",
"{",
"conn",
"ssh",
".",
"Conn",
"\n",
"chanCh",
"<-",
"chan",
"ssh",
".",
"NewChannel",
"\n",
"reqCh",
"<-",
"chan",
"*",
"ssh",
".",
"Request",
"\n",
"err",
"error",
"\n",
"}",
"\n",
"respCh",
":=",
"make",
"(",
"chan",
"response",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"conn",
",",
"chans",
",",
"reqs",
",",
"err",
":=",
"ssh",
".",
"NewClientConn",
"(",
"conn",
",",
"nodeAddress",
",",
"config",
")",
"\n",
"respCh",
"<-",
"response",
"{",
"conn",
",",
"chans",
",",
"reqs",
",",
"err",
"}",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"resp",
":=",
"<-",
"respCh",
":",
"if",
"resp",
".",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"resp",
".",
"err",
",",
"\"failed to connect to %q\"",
",",
"nodeAddress",
")",
"\n",
"}",
"\n",
"return",
"resp",
".",
"conn",
",",
"resp",
".",
"chanCh",
",",
"resp",
".",
"reqCh",
",",
"nil",
"\n",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"errClose",
":=",
"conn",
".",
"Close",
"(",
")",
"\n",
"if",
"errClose",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"errClose",
")",
"\n",
"}",
"\n",
"resp",
":=",
"<-",
"respCh",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"resp",
".",
"err",
",",
"\"failed to connect to %q\"",
",",
"nodeAddress",
")",
"\n",
"}",
"\n",
"}"
] |
// newClientConn is a wrapper around ssh.NewClientConn
|
[
"newClientConn",
"is",
"a",
"wrapper",
"around",
"ssh",
".",
"NewClientConn"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L517-L550
|
train
|
gravitational/teleport
|
lib/client/client.go
|
listenAndForward
|
func (c *NodeClient) listenAndForward(ctx context.Context, ln net.Listener, remoteAddr string) {
defer ln.Close()
defer c.Close()
for {
// Accept connections from the client.
conn, err := ln.Accept()
if err != nil {
log.Errorf("Port forwarding failed: %v.", err)
break
}
// Proxy the connection to the remote address.
go func() {
err := c.proxyConnection(ctx, conn, remoteAddr)
if err != nil {
log.Warnf("Failed to proxy connection: %v.", err)
}
}()
}
}
|
go
|
func (c *NodeClient) listenAndForward(ctx context.Context, ln net.Listener, remoteAddr string) {
defer ln.Close()
defer c.Close()
for {
// Accept connections from the client.
conn, err := ln.Accept()
if err != nil {
log.Errorf("Port forwarding failed: %v.", err)
break
}
// Proxy the connection to the remote address.
go func() {
err := c.proxyConnection(ctx, conn, remoteAddr)
if err != nil {
log.Warnf("Failed to proxy connection: %v.", err)
}
}()
}
}
|
[
"func",
"(",
"c",
"*",
"NodeClient",
")",
"listenAndForward",
"(",
"ctx",
"context",
".",
"Context",
",",
"ln",
"net",
".",
"Listener",
",",
"remoteAddr",
"string",
")",
"{",
"defer",
"ln",
".",
"Close",
"(",
")",
"\n",
"defer",
"c",
".",
"Close",
"(",
")",
"\n",
"for",
"{",
"conn",
",",
"err",
":=",
"ln",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Port forwarding failed: %v.\"",
",",
"err",
")",
"\n",
"break",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"err",
":=",
"c",
".",
"proxyConnection",
"(",
"ctx",
",",
"conn",
",",
"remoteAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Failed to proxy connection: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// listenAndForward listens on a given socket and forwards all incoming
// commands to the remote address through the SSH tunnel.
|
[
"listenAndForward",
"listens",
"on",
"a",
"given",
"socket",
"and",
"forwards",
"all",
"incoming",
"commands",
"to",
"the",
"remote",
"address",
"through",
"the",
"SSH",
"tunnel",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L675-L695
|
train
|
gravitational/teleport
|
lib/client/client.go
|
dynamicListenAndForward
|
func (c *NodeClient) dynamicListenAndForward(ctx context.Context, ln net.Listener) {
defer ln.Close()
defer c.Close()
for {
// Accept connection from the client. Here the client is typically
// something like a web browser or other SOCKS5 aware application.
conn, err := ln.Accept()
if err != nil {
log.Errorf("Dynamic port forwarding (SOCKS5) failed: %v.", err)
break
}
// Perform the SOCKS5 handshake with the client to find out the remote
// address to proxy.
remoteAddr, err := socks.Handshake(conn)
if err != nil {
log.Errorf("SOCKS5 handshake failed: %v.", err)
break
}
log.Debugf("SOCKS5 proxy forwarding requests to %v.", remoteAddr)
// Proxy the connection to the remote address.
go func() {
err := c.proxyConnection(ctx, conn, remoteAddr)
if err != nil {
log.Warnf("Failed to proxy connection: %v.", err)
}
}()
}
}
|
go
|
func (c *NodeClient) dynamicListenAndForward(ctx context.Context, ln net.Listener) {
defer ln.Close()
defer c.Close()
for {
// Accept connection from the client. Here the client is typically
// something like a web browser or other SOCKS5 aware application.
conn, err := ln.Accept()
if err != nil {
log.Errorf("Dynamic port forwarding (SOCKS5) failed: %v.", err)
break
}
// Perform the SOCKS5 handshake with the client to find out the remote
// address to proxy.
remoteAddr, err := socks.Handshake(conn)
if err != nil {
log.Errorf("SOCKS5 handshake failed: %v.", err)
break
}
log.Debugf("SOCKS5 proxy forwarding requests to %v.", remoteAddr)
// Proxy the connection to the remote address.
go func() {
err := c.proxyConnection(ctx, conn, remoteAddr)
if err != nil {
log.Warnf("Failed to proxy connection: %v.", err)
}
}()
}
}
|
[
"func",
"(",
"c",
"*",
"NodeClient",
")",
"dynamicListenAndForward",
"(",
"ctx",
"context",
".",
"Context",
",",
"ln",
"net",
".",
"Listener",
")",
"{",
"defer",
"ln",
".",
"Close",
"(",
")",
"\n",
"defer",
"c",
".",
"Close",
"(",
")",
"\n",
"for",
"{",
"conn",
",",
"err",
":=",
"ln",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Dynamic port forwarding (SOCKS5) failed: %v.\"",
",",
"err",
")",
"\n",
"break",
"\n",
"}",
"\n",
"remoteAddr",
",",
"err",
":=",
"socks",
".",
"Handshake",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"SOCKS5 handshake failed: %v.\"",
",",
"err",
")",
"\n",
"break",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"SOCKS5 proxy forwarding requests to %v.\"",
",",
"remoteAddr",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"err",
":=",
"c",
".",
"proxyConnection",
"(",
"ctx",
",",
"conn",
",",
"remoteAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Failed to proxy connection: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// dynamicListenAndForward listens for connections, performs a SOCKS5
// handshake, and then proxies the connection to the requested address.
|
[
"dynamicListenAndForward",
"listens",
"for",
"connections",
"performs",
"a",
"SOCKS5",
"handshake",
"and",
"then",
"proxies",
"the",
"connection",
"to",
"the",
"requested",
"address",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L699-L729
|
train
|
gravitational/teleport
|
lib/client/client.go
|
currentCluster
|
func (proxy *ProxyClient) currentCluster() (*services.Site, error) {
sites, err := proxy.GetSites()
if err != nil {
return nil, trace.Wrap(err)
}
if len(sites) == 0 {
return nil, trace.NotFound("no clusters registered")
}
if proxy.siteName == "" {
return &sites[0], nil
}
for _, site := range sites {
if site.Name == proxy.siteName {
return &site, nil
}
}
return nil, trace.NotFound("cluster %v not found", proxy.siteName)
}
|
go
|
func (proxy *ProxyClient) currentCluster() (*services.Site, error) {
sites, err := proxy.GetSites()
if err != nil {
return nil, trace.Wrap(err)
}
if len(sites) == 0 {
return nil, trace.NotFound("no clusters registered")
}
if proxy.siteName == "" {
return &sites[0], nil
}
for _, site := range sites {
if site.Name == proxy.siteName {
return &site, nil
}
}
return nil, trace.NotFound("cluster %v not found", proxy.siteName)
}
|
[
"func",
"(",
"proxy",
"*",
"ProxyClient",
")",
"currentCluster",
"(",
")",
"(",
"*",
"services",
".",
"Site",
",",
"error",
")",
"{",
"sites",
",",
"err",
":=",
"proxy",
".",
"GetSites",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"sites",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"no clusters registered\"",
")",
"\n",
"}",
"\n",
"if",
"proxy",
".",
"siteName",
"==",
"\"\"",
"{",
"return",
"&",
"sites",
"[",
"0",
"]",
",",
"nil",
"\n",
"}",
"\n",
"for",
"_",
",",
"site",
":=",
"range",
"sites",
"{",
"if",
"site",
".",
"Name",
"==",
"proxy",
".",
"siteName",
"{",
"return",
"&",
"site",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"cluster %v not found\"",
",",
"proxy",
".",
"siteName",
")",
"\n",
"}"
] |
// currentCluster returns the connection to the API of the current cluster
|
[
"currentCluster",
"returns",
"the",
"connection",
"to",
"the",
"API",
"of",
"the",
"current",
"cluster"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/client.go#L737-L754
|
train
|
gravitational/teleport
|
lib/sshutils/scp/scp.go
|
CreateDownloadCommand
|
func CreateDownloadCommand(cfg Config) (Command, error) {
cfg.Flags.Sink = true
cfg.Flags.Source = false
cmd, err := CreateCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
}
|
go
|
func CreateDownloadCommand(cfg Config) (Command, error) {
cfg.Flags.Sink = true
cfg.Flags.Source = false
cmd, err := CreateCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
}
|
[
"func",
"CreateDownloadCommand",
"(",
"cfg",
"Config",
")",
"(",
"Command",
",",
"error",
")",
"{",
"cfg",
".",
"Flags",
".",
"Sink",
"=",
"true",
"\n",
"cfg",
".",
"Flags",
".",
"Source",
"=",
"false",
"\n",
"cmd",
",",
"err",
":=",
"CreateCommand",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cmd",
",",
"nil",
"\n",
"}"
] |
// CreateDownloadCommand configures and returns a command used
// to download a file
|
[
"CreateDownloadCommand",
"configures",
"and",
"returns",
"a",
"command",
"used",
"to",
"download",
"a",
"file"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/scp.go#L129-L138
|
train
|
gravitational/teleport
|
lib/sshutils/scp/scp.go
|
CreateCommand
|
func CreateCommand(cfg Config) (Command, error) {
err := cfg.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
cmd := command{
Config: cfg,
}
cmd.log = log.WithFields(log.Fields{
trace.Component: "SCP",
trace.ComponentFields: log.Fields{
"LocalAddr": cfg.Flags.LocalAddr,
"RemoteAddr": cfg.Flags.RemoteAddr,
"Target": cfg.Flags.Target,
"User": cfg.User,
"RunOnServer": cfg.RunOnServer,
"RemoteLocation": cfg.RemoteLocation,
},
})
return &cmd, nil
}
|
go
|
func CreateCommand(cfg Config) (Command, error) {
err := cfg.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
cmd := command{
Config: cfg,
}
cmd.log = log.WithFields(log.Fields{
trace.Component: "SCP",
trace.ComponentFields: log.Fields{
"LocalAddr": cfg.Flags.LocalAddr,
"RemoteAddr": cfg.Flags.RemoteAddr,
"Target": cfg.Flags.Target,
"User": cfg.User,
"RunOnServer": cfg.RunOnServer,
"RemoteLocation": cfg.RemoteLocation,
},
})
return &cmd, nil
}
|
[
"func",
"CreateCommand",
"(",
"cfg",
"Config",
")",
"(",
"Command",
",",
"error",
")",
"{",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cmd",
":=",
"command",
"{",
"Config",
":",
"cfg",
",",
"}",
"\n",
"cmd",
".",
"log",
"=",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"\"SCP\"",
",",
"trace",
".",
"ComponentFields",
":",
"log",
".",
"Fields",
"{",
"\"LocalAddr\"",
":",
"cfg",
".",
"Flags",
".",
"LocalAddr",
",",
"\"RemoteAddr\"",
":",
"cfg",
".",
"Flags",
".",
"RemoteAddr",
",",
"\"Target\"",
":",
"cfg",
".",
"Flags",
".",
"Target",
",",
"\"User\"",
":",
"cfg",
".",
"User",
",",
"\"RunOnServer\"",
":",
"cfg",
".",
"RunOnServer",
",",
"\"RemoteLocation\"",
":",
"cfg",
".",
"RemoteLocation",
",",
"}",
",",
"}",
")",
"\n",
"return",
"&",
"cmd",
",",
"nil",
"\n",
"}"
] |
// CreateCommand creates and returns a new Command
|
[
"CreateCommand",
"creates",
"and",
"returns",
"a",
"new",
"Command"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/scp.go#L167-L190
|
train
|
gravitational/teleport
|
lib/sshutils/scp/scp.go
|
sendError
|
func (cmd *command) sendError(ch io.ReadWriter, err error) error {
if err == nil {
return nil
}
cmd.log.Error(err)
message := err.Error()
bytes := make([]byte, 0, len(message)+2)
bytes = append(bytes, ErrByte)
bytes = append(bytes, message...)
bytes = append(bytes, []byte{'\n'}...)
_, writeErr := ch.Write(bytes)
if writeErr != nil {
cmd.log.Error(writeErr)
}
return trace.Wrap(err)
}
|
go
|
func (cmd *command) sendError(ch io.ReadWriter, err error) error {
if err == nil {
return nil
}
cmd.log.Error(err)
message := err.Error()
bytes := make([]byte, 0, len(message)+2)
bytes = append(bytes, ErrByte)
bytes = append(bytes, message...)
bytes = append(bytes, []byte{'\n'}...)
_, writeErr := ch.Write(bytes)
if writeErr != nil {
cmd.log.Error(writeErr)
}
return trace.Wrap(err)
}
|
[
"func",
"(",
"cmd",
"*",
"command",
")",
"sendError",
"(",
"ch",
"io",
".",
"ReadWriter",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"cmd",
".",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"message",
":=",
"err",
".",
"Error",
"(",
")",
"\n",
"bytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"message",
")",
"+",
"2",
")",
"\n",
"bytes",
"=",
"append",
"(",
"bytes",
",",
"ErrByte",
")",
"\n",
"bytes",
"=",
"append",
"(",
"bytes",
",",
"message",
"...",
")",
"\n",
"bytes",
"=",
"append",
"(",
"bytes",
",",
"[",
"]",
"byte",
"{",
"'\\n'",
"}",
"...",
")",
"\n",
"_",
",",
"writeErr",
":=",
"ch",
".",
"Write",
"(",
"bytes",
")",
"\n",
"if",
"writeErr",
"!=",
"nil",
"{",
"cmd",
".",
"log",
".",
"Error",
"(",
"writeErr",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// sendError gets called during all errors during SCP transmission.
// It writes it back to the SCP client
|
[
"sendError",
"gets",
"called",
"during",
"all",
"errors",
"during",
"SCP",
"transmission",
".",
"It",
"writes",
"it",
"back",
"to",
"the",
"SCP",
"client"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/scp.go#L515-L530
|
train
|
gravitational/teleport
|
lib/sshutils/scp/scp.go
|
read
|
func (r *reader) read() error {
n, err := r.r.Read(r.b)
if err != nil {
return trace.Wrap(err)
}
if n < 1 {
return trace.Errorf("unexpected error, read 0 bytes")
}
switch r.b[0] {
case OKByte:
return nil
case WarnByte, ErrByte:
r.s.Scan()
if err := r.s.Err(); err != nil {
return trace.Wrap(err)
}
return trace.Errorf(r.s.Text())
}
return trace.Errorf("unrecognized command: %#v", r.b)
}
|
go
|
func (r *reader) read() error {
n, err := r.r.Read(r.b)
if err != nil {
return trace.Wrap(err)
}
if n < 1 {
return trace.Errorf("unexpected error, read 0 bytes")
}
switch r.b[0] {
case OKByte:
return nil
case WarnByte, ErrByte:
r.s.Scan()
if err := r.s.Err(); err != nil {
return trace.Wrap(err)
}
return trace.Errorf(r.s.Text())
}
return trace.Errorf("unrecognized command: %#v", r.b)
}
|
[
"func",
"(",
"r",
"*",
"reader",
")",
"read",
"(",
")",
"error",
"{",
"n",
",",
"err",
":=",
"r",
".",
"r",
".",
"Read",
"(",
"r",
".",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"n",
"<",
"1",
"{",
"return",
"trace",
".",
"Errorf",
"(",
"\"unexpected error, read 0 bytes\"",
")",
"\n",
"}",
"\n",
"switch",
"r",
".",
"b",
"[",
"0",
"]",
"{",
"case",
"OKByte",
":",
"return",
"nil",
"\n",
"case",
"WarnByte",
",",
"ErrByte",
":",
"r",
".",
"s",
".",
"Scan",
"(",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"s",
".",
"Err",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Errorf",
"(",
"r",
".",
"s",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Errorf",
"(",
"\"unrecognized command: %#v\"",
",",
"r",
".",
"b",
")",
"\n",
"}"
] |
// read is used to "ask" for response messages after each SCP transmission
// it only reads text data until a newline and returns 'nil' for "OK" responses
// and errors for everything else
|
[
"read",
"is",
"used",
"to",
"ask",
"for",
"response",
"messages",
"after",
"each",
"SCP",
"transmission",
"it",
"only",
"reads",
"text",
"data",
"until",
"a",
"newline",
"and",
"returns",
"nil",
"for",
"OK",
"responses",
"and",
"errors",
"for",
"everything",
"else"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/scp.go#L639-L659
|
train
|
gravitational/teleport
|
lib/client/keystore.go
|
AddKey
|
func (fs *FSLocalKeyStore) AddKey(host, username string, key *Key) error {
dirPath, err := fs.dirFor(host, true)
if err != nil {
return trace.Wrap(err)
}
writeBytes := func(fname string, data []byte) error {
fp := filepath.Join(dirPath, fname)
err := ioutil.WriteFile(fp, data, keyFilePerms)
if err != nil {
fs.log.Error(err)
}
return err
}
if err = writeBytes(username+fileExtCert, key.Cert); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username+fileExtTLSCert, key.TLSCert); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username+fileExtPub, key.Pub); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username, key.Priv); err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (fs *FSLocalKeyStore) AddKey(host, username string, key *Key) error {
dirPath, err := fs.dirFor(host, true)
if err != nil {
return trace.Wrap(err)
}
writeBytes := func(fname string, data []byte) error {
fp := filepath.Join(dirPath, fname)
err := ioutil.WriteFile(fp, data, keyFilePerms)
if err != nil {
fs.log.Error(err)
}
return err
}
if err = writeBytes(username+fileExtCert, key.Cert); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username+fileExtTLSCert, key.TLSCert); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username+fileExtPub, key.Pub); err != nil {
return trace.Wrap(err)
}
if err = writeBytes(username, key.Priv); err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"fs",
"*",
"FSLocalKeyStore",
")",
"AddKey",
"(",
"host",
",",
"username",
"string",
",",
"key",
"*",
"Key",
")",
"error",
"{",
"dirPath",
",",
"err",
":=",
"fs",
".",
"dirFor",
"(",
"host",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"writeBytes",
":=",
"func",
"(",
"fname",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"fp",
":=",
"filepath",
".",
"Join",
"(",
"dirPath",
",",
"fname",
")",
"\n",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"fp",
",",
"data",
",",
"keyFilePerms",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fs",
".",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"writeBytes",
"(",
"username",
"+",
"fileExtCert",
",",
"key",
".",
"Cert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"writeBytes",
"(",
"username",
"+",
"fileExtTLSCert",
",",
"key",
".",
"TLSCert",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"writeBytes",
"(",
"username",
"+",
"fileExtPub",
",",
"key",
".",
"Pub",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"writeBytes",
"(",
"username",
",",
"key",
".",
"Priv",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// AddKey adds a new key to the session store. If a key for the host is already
// stored, overwrites it.
|
[
"AddKey",
"adds",
"a",
"new",
"key",
"to",
"the",
"session",
"store",
".",
"If",
"a",
"key",
"for",
"the",
"host",
"is",
"already",
"stored",
"overwrites",
"it",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keystore.go#L142-L168
|
train
|
gravitational/teleport
|
lib/client/keystore.go
|
DeleteKey
|
func (fs *FSLocalKeyStore) DeleteKey(host string, username string) error {
dirPath, err := fs.dirFor(host, false)
if err != nil {
return trace.Wrap(err)
}
files := []string{
filepath.Join(dirPath, username+fileExtCert),
filepath.Join(dirPath, username+fileExtTLSCert),
filepath.Join(dirPath, username+fileExtPub),
filepath.Join(dirPath, username),
}
for _, fn := range files {
if err = os.Remove(fn); err != nil {
return trace.Wrap(err)
}
}
return nil
}
|
go
|
func (fs *FSLocalKeyStore) DeleteKey(host string, username string) error {
dirPath, err := fs.dirFor(host, false)
if err != nil {
return trace.Wrap(err)
}
files := []string{
filepath.Join(dirPath, username+fileExtCert),
filepath.Join(dirPath, username+fileExtTLSCert),
filepath.Join(dirPath, username+fileExtPub),
filepath.Join(dirPath, username),
}
for _, fn := range files {
if err = os.Remove(fn); err != nil {
return trace.Wrap(err)
}
}
return nil
}
|
[
"func",
"(",
"fs",
"*",
"FSLocalKeyStore",
")",
"DeleteKey",
"(",
"host",
"string",
",",
"username",
"string",
")",
"error",
"{",
"dirPath",
",",
"err",
":=",
"fs",
".",
"dirFor",
"(",
"host",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"files",
":=",
"[",
"]",
"string",
"{",
"filepath",
".",
"Join",
"(",
"dirPath",
",",
"username",
"+",
"fileExtCert",
")",
",",
"filepath",
".",
"Join",
"(",
"dirPath",
",",
"username",
"+",
"fileExtTLSCert",
")",
",",
"filepath",
".",
"Join",
"(",
"dirPath",
",",
"username",
"+",
"fileExtPub",
")",
",",
"filepath",
".",
"Join",
"(",
"dirPath",
",",
"username",
")",
",",
"}",
"\n",
"for",
"_",
",",
"fn",
":=",
"range",
"files",
"{",
"if",
"err",
"=",
"os",
".",
"Remove",
"(",
"fn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// DeleteKey deletes a key from the local store
|
[
"DeleteKey",
"deletes",
"a",
"key",
"from",
"the",
"local",
"store"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keystore.go#L171-L188
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.