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/kube/utils/utils.go
|
GetKubeConfig
|
func GetKubeConfig(configPath string) (*rest.Config, error) {
// if path to kubeconfig was provided, init config from it
if configPath != "" {
return clientcmd.BuildConfigFromFlags("", configPath)
}
return rest.InClusterConfig()
}
|
go
|
func GetKubeConfig(configPath string) (*rest.Config, error) {
// if path to kubeconfig was provided, init config from it
if configPath != "" {
return clientcmd.BuildConfigFromFlags("", configPath)
}
return rest.InClusterConfig()
}
|
[
"func",
"GetKubeConfig",
"(",
"configPath",
"string",
")",
"(",
"*",
"rest",
".",
"Config",
",",
"error",
")",
"{",
"if",
"configPath",
"!=",
"\"\"",
"{",
"return",
"clientcmd",
".",
"BuildConfigFromFlags",
"(",
"\"\"",
",",
"configPath",
")",
"\n",
"}",
"\n",
"return",
"rest",
".",
"InClusterConfig",
"(",
")",
"\n",
"}"
] |
// GetKubeConfig returns kubernetes configuration
// from configPath file or, by default reads in-cluster configuration
|
[
"GetKubeConfig",
"returns",
"kubernetes",
"configuration",
"from",
"configPath",
"file",
"or",
"by",
"default",
"reads",
"in",
"-",
"cluster",
"configuration"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/kube/utils/utils.go#L40-L46
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
MustCreateProvisionToken
|
func MustCreateProvisionToken(token string, roles teleport.Roles, expires time.Time) ProvisionToken {
t, err := NewProvisionToken(token, roles, expires)
if err != nil {
panic(err)
}
return t
}
|
go
|
func MustCreateProvisionToken(token string, roles teleport.Roles, expires time.Time) ProvisionToken {
t, err := NewProvisionToken(token, roles, expires)
if err != nil {
panic(err)
}
return t
}
|
[
"func",
"MustCreateProvisionToken",
"(",
"token",
"string",
",",
"roles",
"teleport",
".",
"Roles",
",",
"expires",
"time",
".",
"Time",
")",
"ProvisionToken",
"{",
"t",
",",
"err",
":=",
"NewProvisionToken",
"(",
"token",
",",
"roles",
",",
"expires",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"t",
"\n",
"}"
] |
// MustCreateProvisionToken returns a new valid provision token
// or panics, used in testes
|
[
"MustCreateProvisionToken",
"returns",
"a",
"new",
"valid",
"provision",
"token",
"or",
"panics",
"used",
"in",
"testes"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L33-L39
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
NewProvisionToken
|
func NewProvisionToken(token string, roles teleport.Roles, expires time.Time) (ProvisionToken, error) {
t := &ProvisionTokenV2{
Kind: KindToken,
Version: V2,
Metadata: Metadata{
Name: token,
Expires: &expires,
Namespace: defaults.Namespace,
},
Spec: ProvisionTokenSpecV2{
Roles: roles,
},
}
if err := t.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return t, nil
}
|
go
|
func NewProvisionToken(token string, roles teleport.Roles, expires time.Time) (ProvisionToken, error) {
t := &ProvisionTokenV2{
Kind: KindToken,
Version: V2,
Metadata: Metadata{
Name: token,
Expires: &expires,
Namespace: defaults.Namespace,
},
Spec: ProvisionTokenSpecV2{
Roles: roles,
},
}
if err := t.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return t, nil
}
|
[
"func",
"NewProvisionToken",
"(",
"token",
"string",
",",
"roles",
"teleport",
".",
"Roles",
",",
"expires",
"time",
".",
"Time",
")",
"(",
"ProvisionToken",
",",
"error",
")",
"{",
"t",
":=",
"&",
"ProvisionTokenV2",
"{",
"Kind",
":",
"KindToken",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"token",
",",
"Expires",
":",
"&",
"expires",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"ProvisionTokenSpecV2",
"{",
"Roles",
":",
"roles",
",",
"}",
",",
"}",
"\n",
"if",
"err",
":=",
"t",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"t",
",",
"nil",
"\n",
"}"
] |
// NewProvisionToken returns a new instance of provision token resource
|
[
"NewProvisionToken",
"returns",
"a",
"new",
"instance",
"of",
"provision",
"token",
"resource"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L42-L59
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
ProvisionTokensToV1
|
func ProvisionTokensToV1(in []ProvisionToken) []ProvisionTokenV1 {
if in == nil {
return nil
}
out := make([]ProvisionTokenV1, len(in))
for i := range in {
out[i] = *in[i].V1()
}
return out
}
|
go
|
func ProvisionTokensToV1(in []ProvisionToken) []ProvisionTokenV1 {
if in == nil {
return nil
}
out := make([]ProvisionTokenV1, len(in))
for i := range in {
out[i] = *in[i].V1()
}
return out
}
|
[
"func",
"ProvisionTokensToV1",
"(",
"in",
"[",
"]",
"ProvisionToken",
")",
"[",
"]",
"ProvisionTokenV1",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"ProvisionTokenV1",
",",
"len",
"(",
"in",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"in",
"{",
"out",
"[",
"i",
"]",
"=",
"*",
"in",
"[",
"i",
"]",
".",
"V1",
"(",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] |
// ProvisionTokensToV1 converts provision tokens to V1 list
|
[
"ProvisionTokensToV1",
"converts",
"provision",
"tokens",
"to",
"V1",
"list"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L97-L106
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
ProvisionTokensFromV1
|
func ProvisionTokensFromV1(in []ProvisionTokenV1) []ProvisionToken {
if in == nil {
return nil
}
out := make([]ProvisionToken, len(in))
for i := range in {
out[i] = in[i].V2()
}
return out
}
|
go
|
func ProvisionTokensFromV1(in []ProvisionTokenV1) []ProvisionToken {
if in == nil {
return nil
}
out := make([]ProvisionToken, len(in))
for i := range in {
out[i] = in[i].V2()
}
return out
}
|
[
"func",
"ProvisionTokensFromV1",
"(",
"in",
"[",
"]",
"ProvisionTokenV1",
")",
"[",
"]",
"ProvisionToken",
"{",
"if",
"in",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"ProvisionToken",
",",
"len",
"(",
"in",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"in",
"{",
"out",
"[",
"i",
"]",
"=",
"in",
"[",
"i",
"]",
".",
"V2",
"(",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] |
// ProvisionTokensFromV1 converts V1 provision tokens to resource list
|
[
"ProvisionTokensFromV1",
"converts",
"V1",
"provision",
"tokens",
"to",
"resource",
"list"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L109-L118
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
SetRoles
|
func (p *ProvisionTokenV2) SetRoles(r teleport.Roles) {
p.Spec.Roles = r
}
|
go
|
func (p *ProvisionTokenV2) SetRoles(r teleport.Roles) {
p.Spec.Roles = r
}
|
[
"func",
"(",
"p",
"*",
"ProvisionTokenV2",
")",
"SetRoles",
"(",
"r",
"teleport",
".",
"Roles",
")",
"{",
"p",
".",
"Spec",
".",
"Roles",
"=",
"r",
"\n",
"}"
] |
// SetRoles sets teleport roles
|
[
"SetRoles",
"sets",
"teleport",
"roles"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L149-L151
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
UnmarshalProvisionToken
|
func UnmarshalProvisionToken(data []byte, opts ...MarshalOption) (ProvisionToken, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing provision token data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var p ProvisionTokenV1
err := utils.FastUnmarshal(data, &p)
if err != nil {
return nil, trace.Wrap(err)
}
v2 := p.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
return v2, nil
case V2:
var p ProvisionTokenV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &p); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetProvisionTokenSchema(), &p, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := p.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
p.SetResourceID(cfg.ID)
}
return &p, nil
}
return nil, trace.BadParameter("server resource version %v is not supported", h.Version)
}
|
go
|
func UnmarshalProvisionToken(data []byte, opts ...MarshalOption) (ProvisionToken, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing provision token data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var p ProvisionTokenV1
err := utils.FastUnmarshal(data, &p)
if err != nil {
return nil, trace.Wrap(err)
}
v2 := p.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
return v2, nil
case V2:
var p ProvisionTokenV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &p); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetProvisionTokenSchema(), &p, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := p.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
p.SetResourceID(cfg.ID)
}
return &p, nil
}
return nil, trace.BadParameter("server resource version %v is not supported", h.Version)
}
|
[
"func",
"UnmarshalProvisionToken",
"(",
"data",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"ProvisionToken",
",",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing provision token data\"",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"h",
"ResourceHeader",
"\n",
"err",
"=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"p",
"ProvisionTokenV1",
"\n",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"v2",
":=",
"p",
".",
"V2",
"(",
")",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"v2",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"return",
"v2",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"p",
"ProvisionTokenV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"p",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetProvisionTokenSchema",
"(",
")",
",",
"&",
"p",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"p",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"p",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"return",
"&",
"p",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"server resource version %v is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] |
// UnmarshalProvisionToken unmarshals provision token from JSON or YAML,
// sets defaults and checks the schema
|
[
"UnmarshalProvisionToken",
"unmarshals",
"provision",
"token",
"from",
"JSON",
"or",
"YAML",
"sets",
"defaults",
"and",
"checks",
"the",
"schema"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L281-L329
|
train
|
gravitational/teleport
|
lib/services/provisioning.go
|
MarshalProvisionToken
|
func MarshalProvisionToken(t ProvisionToken, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type token1 interface {
V1() *ProvisionTokenV1
}
type token2 interface {
V2() *ProvisionTokenV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := t.(token1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return utils.FastMarshal(v.V1())
case V2:
v, ok := t.(token2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
return utils.FastMarshal(v.V2())
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
}
|
go
|
func MarshalProvisionToken(t ProvisionToken, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type token1 interface {
V1() *ProvisionTokenV1
}
type token2 interface {
V2() *ProvisionTokenV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := t.(token1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return utils.FastMarshal(v.V1())
case V2:
v, ok := t.(token2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
return utils.FastMarshal(v.V2())
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
}
|
[
"func",
"MarshalProvisionToken",
"(",
"t",
"ProvisionToken",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"token1",
"interface",
"{",
"V1",
"(",
")",
"*",
"ProvisionTokenV1",
"\n",
"}",
"\n",
"type",
"token2",
"interface",
"{",
"V2",
"(",
")",
"*",
"ProvisionTokenV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"t",
".",
"(",
"token1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"t",
".",
"(",
"token2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v",
".",
"V2",
"(",
")",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"version %v is not supported\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] |
// MarshalProvisionToken marshals provisioning token into JSON.
|
[
"MarshalProvisionToken",
"marshals",
"provisioning",
"token",
"into",
"JSON",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/provisioning.go#L332-L360
|
train
|
gravitational/teleport
|
lib/utils/proxy/proxy.go
|
NewClientConnWithDeadline
|
func NewClientConnWithDeadline(conn net.Conn, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
if config.Timeout > 0 {
conn.SetReadDeadline(time.Now().Add(config.Timeout))
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
if config.Timeout > 0 {
conn.SetReadDeadline(time.Time{})
}
return ssh.NewClient(c, chans, reqs), nil
}
|
go
|
func NewClientConnWithDeadline(conn net.Conn, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
if config.Timeout > 0 {
conn.SetReadDeadline(time.Now().Add(config.Timeout))
}
c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
if err != nil {
return nil, err
}
if config.Timeout > 0 {
conn.SetReadDeadline(time.Time{})
}
return ssh.NewClient(c, chans, reqs), nil
}
|
[
"func",
"NewClientConnWithDeadline",
"(",
"conn",
"net",
".",
"Conn",
",",
"addr",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"Client",
",",
"error",
")",
"{",
"if",
"config",
".",
"Timeout",
">",
"0",
"{",
"conn",
".",
"SetReadDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"config",
".",
"Timeout",
")",
")",
"\n",
"}",
"\n",
"c",
",",
"chans",
",",
"reqs",
",",
"err",
":=",
"ssh",
".",
"NewClientConn",
"(",
"conn",
",",
"addr",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"config",
".",
"Timeout",
">",
"0",
"{",
"conn",
".",
"SetReadDeadline",
"(",
"time",
".",
"Time",
"{",
"}",
")",
"\n",
"}",
"\n",
"return",
"ssh",
".",
"NewClient",
"(",
"c",
",",
"chans",
",",
"reqs",
")",
",",
"nil",
"\n",
"}"
] |
// NewClientConnWithDeadline establishes new client connection with specified deadline
|
[
"NewClientConnWithDeadline",
"establishes",
"new",
"client",
"connection",
"with",
"specified",
"deadline"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/proxy/proxy.go#L41-L53
|
train
|
gravitational/teleport
|
lib/utils/proxy/proxy.go
|
DialWithDeadline
|
func DialWithDeadline(network string, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
conn, err := net.DialTimeout(network, addr, config.Timeout)
if err != nil {
return nil, err
}
return NewClientConnWithDeadline(conn, addr, config)
}
|
go
|
func DialWithDeadline(network string, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
conn, err := net.DialTimeout(network, addr, config.Timeout)
if err != nil {
return nil, err
}
return NewClientConnWithDeadline(conn, addr, config)
}
|
[
"func",
"DialWithDeadline",
"(",
"network",
"string",
",",
"addr",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"Client",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"net",
".",
"DialTimeout",
"(",
"network",
",",
"addr",
",",
"config",
".",
"Timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewClientConnWithDeadline",
"(",
"conn",
",",
"addr",
",",
"config",
")",
"\n",
"}"
] |
// DialWithDeadline works around the case when net.DialWithTimeout
// succeeds, but key exchange hangs. Setting deadline on connection
// prevents this case from happening
|
[
"DialWithDeadline",
"works",
"around",
"the",
"case",
"when",
"net",
".",
"DialWithTimeout",
"succeeds",
"but",
"key",
"exchange",
"hangs",
".",
"Setting",
"deadline",
"on",
"connection",
"prevents",
"this",
"case",
"from",
"happening"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/proxy/proxy.go#L58-L64
|
train
|
gravitational/teleport
|
lib/utils/proxy/proxy.go
|
Dial
|
func (d directDial) Dial(network string, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
return DialWithDeadline(network, addr, config)
}
|
go
|
func (d directDial) Dial(network string, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
return DialWithDeadline(network, addr, config)
}
|
[
"func",
"(",
"d",
"directDial",
")",
"Dial",
"(",
"network",
"string",
",",
"addr",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"Client",
",",
"error",
")",
"{",
"return",
"DialWithDeadline",
"(",
"network",
",",
"addr",
",",
"config",
")",
"\n",
"}"
] |
// Dial calls ssh.Dial directly.
|
[
"Dial",
"calls",
"ssh",
".",
"Dial",
"directly",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/proxy/proxy.go#L78-L80
|
train
|
gravitational/teleport
|
lib/utils/proxy/proxy.go
|
Dial
|
func (d proxyDial) Dial(network string, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
// Build a proxy connection first.
pconn, err := dialProxy(context.Background(), d.proxyHost, addr)
if err != nil {
return nil, trace.Wrap(err)
}
if config.Timeout > 0 {
pconn.SetReadDeadline(time.Now().Add(config.Timeout))
}
// Do the same as ssh.Dial but pass in proxy connection.
c, chans, reqs, err := ssh.NewClientConn(pconn, addr, config)
if err != nil {
return nil, trace.Wrap(err)
}
if config.Timeout > 0 {
pconn.SetReadDeadline(time.Time{})
}
return ssh.NewClient(c, chans, reqs), nil
}
|
go
|
func (d proxyDial) Dial(network string, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
// Build a proxy connection first.
pconn, err := dialProxy(context.Background(), d.proxyHost, addr)
if err != nil {
return nil, trace.Wrap(err)
}
if config.Timeout > 0 {
pconn.SetReadDeadline(time.Now().Add(config.Timeout))
}
// Do the same as ssh.Dial but pass in proxy connection.
c, chans, reqs, err := ssh.NewClientConn(pconn, addr, config)
if err != nil {
return nil, trace.Wrap(err)
}
if config.Timeout > 0 {
pconn.SetReadDeadline(time.Time{})
}
return ssh.NewClient(c, chans, reqs), nil
}
|
[
"func",
"(",
"d",
"proxyDial",
")",
"Dial",
"(",
"network",
"string",
",",
"addr",
"string",
",",
"config",
"*",
"ssh",
".",
"ClientConfig",
")",
"(",
"*",
"ssh",
".",
"Client",
",",
"error",
")",
"{",
"pconn",
",",
"err",
":=",
"dialProxy",
"(",
"context",
".",
"Background",
"(",
")",
",",
"d",
".",
"proxyHost",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Timeout",
">",
"0",
"{",
"pconn",
".",
"SetReadDeadline",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"config",
".",
"Timeout",
")",
")",
"\n",
"}",
"\n",
"c",
",",
"chans",
",",
"reqs",
",",
"err",
":=",
"ssh",
".",
"NewClientConn",
"(",
"pconn",
",",
"addr",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"config",
".",
"Timeout",
">",
"0",
"{",
"pconn",
".",
"SetReadDeadline",
"(",
"time",
".",
"Time",
"{",
"}",
")",
"\n",
"}",
"\n",
"return",
"ssh",
".",
"NewClient",
"(",
"c",
",",
"chans",
",",
"reqs",
")",
",",
"nil",
"\n",
"}"
] |
// Dial first connects to a proxy, then uses the connection to establish a new
// SSH connection.
|
[
"Dial",
"first",
"connects",
"to",
"a",
"proxy",
"then",
"uses",
"the",
"connection",
"to",
"establish",
"a",
"new",
"SSH",
"connection",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/proxy/proxy.go#L105-L123
|
train
|
gravitational/teleport
|
lib/utils/proxy/proxy.go
|
DialerFromEnvironment
|
func DialerFromEnvironment(addr string) Dialer {
// Try and get proxy addr from the environment.
proxyAddr := getProxyAddress(addr)
// If no proxy settings are in environment return regular ssh dialer,
// otherwise return a proxy dialer.
if proxyAddr == "" {
log.Debugf("No proxy set in environment, returning direct dialer.")
return directDial{}
}
log.Debugf("Found proxy %q in environment, returning proxy dialer.", proxyAddr)
return proxyDial{proxyHost: proxyAddr}
}
|
go
|
func DialerFromEnvironment(addr string) Dialer {
// Try and get proxy addr from the environment.
proxyAddr := getProxyAddress(addr)
// If no proxy settings are in environment return regular ssh dialer,
// otherwise return a proxy dialer.
if proxyAddr == "" {
log.Debugf("No proxy set in environment, returning direct dialer.")
return directDial{}
}
log.Debugf("Found proxy %q in environment, returning proxy dialer.", proxyAddr)
return proxyDial{proxyHost: proxyAddr}
}
|
[
"func",
"DialerFromEnvironment",
"(",
"addr",
"string",
")",
"Dialer",
"{",
"proxyAddr",
":=",
"getProxyAddress",
"(",
"addr",
")",
"\n",
"if",
"proxyAddr",
"==",
"\"\"",
"{",
"log",
".",
"Debugf",
"(",
"\"No proxy set in environment, returning direct dialer.\"",
")",
"\n",
"return",
"directDial",
"{",
"}",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Found proxy %q in environment, returning proxy dialer.\"",
",",
"proxyAddr",
")",
"\n",
"return",
"proxyDial",
"{",
"proxyHost",
":",
"proxyAddr",
"}",
"\n",
"}"
] |
// DialerFromEnvironment returns a Dial function. If the https_proxy or http_proxy
// environment variable are set, it returns a function that will dial through
// said proxy server. If neither variable is set, it will connect to the SSH
// server directly.
|
[
"DialerFromEnvironment",
"returns",
"a",
"Dial",
"function",
".",
"If",
"the",
"https_proxy",
"or",
"http_proxy",
"environment",
"variable",
"are",
"set",
"it",
"returns",
"a",
"function",
"that",
"will",
"dial",
"through",
"said",
"proxy",
"server",
".",
"If",
"neither",
"variable",
"is",
"set",
"it",
"will",
"connect",
"to",
"the",
"SSH",
"server",
"directly",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/proxy/proxy.go#L129-L141
|
train
|
gravitational/teleport
|
lib/backend/etcdbk/etcd.go
|
New
|
func New(ctx context.Context, params backend.Params) (*EtcdBackend, error) {
var err error
if params == nil {
return nil, trace.BadParameter("missing etcd configuration")
}
// convert generic backend parameters structure to etcd config:
var cfg *Config
if err = utils.ObjectToStruct(params, &cfg); err != nil {
return nil, trace.BadParameter("invalid etcd configuration: %v", err)
}
if err = cfg.Validate(); err != nil {
return nil, trace.Wrap(err)
}
buf, err := backend.NewCircularBuffer(ctx, cfg.BufferSize)
if err != nil {
return nil, trace.Wrap(err)
}
closeCtx, cancel := context.WithCancel(ctx)
watchStarted, signalWatchStart := context.WithCancel(ctx)
b := &EtcdBackend{
Entry: log.WithFields(log.Fields{trace.Component: GetName()}),
cfg: cfg,
nodes: cfg.Nodes,
cancelC: make(chan bool, 1),
stopC: make(chan bool, 1),
clock: clockwork.NewRealClock(),
cancel: cancel,
ctx: closeCtx,
watchStarted: watchStarted,
signalWatchStart: signalWatchStart,
buf: buf,
}
if err = b.reconnect(); err != nil {
return nil, trace.Wrap(err)
}
// Wrap backend in a input sanitizer and return it.
return b, nil
}
|
go
|
func New(ctx context.Context, params backend.Params) (*EtcdBackend, error) {
var err error
if params == nil {
return nil, trace.BadParameter("missing etcd configuration")
}
// convert generic backend parameters structure to etcd config:
var cfg *Config
if err = utils.ObjectToStruct(params, &cfg); err != nil {
return nil, trace.BadParameter("invalid etcd configuration: %v", err)
}
if err = cfg.Validate(); err != nil {
return nil, trace.Wrap(err)
}
buf, err := backend.NewCircularBuffer(ctx, cfg.BufferSize)
if err != nil {
return nil, trace.Wrap(err)
}
closeCtx, cancel := context.WithCancel(ctx)
watchStarted, signalWatchStart := context.WithCancel(ctx)
b := &EtcdBackend{
Entry: log.WithFields(log.Fields{trace.Component: GetName()}),
cfg: cfg,
nodes: cfg.Nodes,
cancelC: make(chan bool, 1),
stopC: make(chan bool, 1),
clock: clockwork.NewRealClock(),
cancel: cancel,
ctx: closeCtx,
watchStarted: watchStarted,
signalWatchStart: signalWatchStart,
buf: buf,
}
if err = b.reconnect(); err != nil {
return nil, trace.Wrap(err)
}
// Wrap backend in a input sanitizer and return it.
return b, nil
}
|
[
"func",
"New",
"(",
"ctx",
"context",
".",
"Context",
",",
"params",
"backend",
".",
"Params",
")",
"(",
"*",
"EtcdBackend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"params",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing etcd configuration\"",
")",
"\n",
"}",
"\n",
"var",
"cfg",
"*",
"Config",
"\n",
"if",
"err",
"=",
"utils",
".",
"ObjectToStruct",
"(",
"params",
",",
"&",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid etcd configuration: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"cfg",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"buf",
",",
"err",
":=",
"backend",
".",
"NewCircularBuffer",
"(",
"ctx",
",",
"cfg",
".",
"BufferSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"closeCtx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"watchStarted",
",",
"signalWatchStart",
":=",
"context",
".",
"WithCancel",
"(",
"ctx",
")",
"\n",
"b",
":=",
"&",
"EtcdBackend",
"{",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"GetName",
"(",
")",
"}",
")",
",",
"cfg",
":",
"cfg",
",",
"nodes",
":",
"cfg",
".",
"Nodes",
",",
"cancelC",
":",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
",",
"stopC",
":",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
",",
"clock",
":",
"clockwork",
".",
"NewRealClock",
"(",
")",
",",
"cancel",
":",
"cancel",
",",
"ctx",
":",
"closeCtx",
",",
"watchStarted",
":",
"watchStarted",
",",
"signalWatchStart",
":",
"signalWatchStart",
",",
"buf",
":",
"buf",
",",
"}",
"\n",
"if",
"err",
"=",
"b",
".",
"reconnect",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] |
// New returns new instance of Etcd-powered backend
|
[
"New",
"returns",
"new",
"instance",
"of",
"Etcd",
"-",
"powered",
"backend"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/etcdbk/etcd.go#L168-L207
|
train
|
gravitational/teleport
|
lib/backend/etcdbk/etcd.go
|
KeepAlive
|
func (b *EtcdBackend) KeepAlive(ctx context.Context, lease backend.Lease, expires time.Time) error {
if lease.ID == 0 {
return trace.BadParameter("lease is not specified")
}
re, err := b.client.Get(ctx, prependPrefix(lease.Key), clientv3.WithSerializable(), clientv3.WithKeysOnly())
if err != nil {
return convertErr(err)
}
if len(re.Kvs) == 0 {
return trace.NotFound("item %q is not found", string(lease.Key))
}
// instead of keep-alive on the old lease, setup a new lease
// because we would like the event to be generated
// which does not happen in case of lease keep-alive
var opts []clientv3.OpOption
var newLease backend.Lease
if err := b.setupLease(ctx, backend.Item{Expires: expires}, &newLease, &opts); err != nil {
return trace.Wrap(err)
}
opts = append(opts, clientv3.WithIgnoreValue())
kv := re.Kvs[0]
_, err = b.client.Put(ctx, string(kv.Key), "", opts...)
return convertErr(err)
}
|
go
|
func (b *EtcdBackend) KeepAlive(ctx context.Context, lease backend.Lease, expires time.Time) error {
if lease.ID == 0 {
return trace.BadParameter("lease is not specified")
}
re, err := b.client.Get(ctx, prependPrefix(lease.Key), clientv3.WithSerializable(), clientv3.WithKeysOnly())
if err != nil {
return convertErr(err)
}
if len(re.Kvs) == 0 {
return trace.NotFound("item %q is not found", string(lease.Key))
}
// instead of keep-alive on the old lease, setup a new lease
// because we would like the event to be generated
// which does not happen in case of lease keep-alive
var opts []clientv3.OpOption
var newLease backend.Lease
if err := b.setupLease(ctx, backend.Item{Expires: expires}, &newLease, &opts); err != nil {
return trace.Wrap(err)
}
opts = append(opts, clientv3.WithIgnoreValue())
kv := re.Kvs[0]
_, err = b.client.Put(ctx, string(kv.Key), "", opts...)
return convertErr(err)
}
|
[
"func",
"(",
"b",
"*",
"EtcdBackend",
")",
"KeepAlive",
"(",
"ctx",
"context",
".",
"Context",
",",
"lease",
"backend",
".",
"Lease",
",",
"expires",
"time",
".",
"Time",
")",
"error",
"{",
"if",
"lease",
".",
"ID",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"lease is not specified\"",
")",
"\n",
"}",
"\n",
"re",
",",
"err",
":=",
"b",
".",
"client",
".",
"Get",
"(",
"ctx",
",",
"prependPrefix",
"(",
"lease",
".",
"Key",
")",
",",
"clientv3",
".",
"WithSerializable",
"(",
")",
",",
"clientv3",
".",
"WithKeysOnly",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"convertErr",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"re",
".",
"Kvs",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"item %q is not found\"",
",",
"string",
"(",
"lease",
".",
"Key",
")",
")",
"\n",
"}",
"\n",
"var",
"opts",
"[",
"]",
"clientv3",
".",
"OpOption",
"\n",
"var",
"newLease",
"backend",
".",
"Lease",
"\n",
"if",
"err",
":=",
"b",
".",
"setupLease",
"(",
"ctx",
",",
"backend",
".",
"Item",
"{",
"Expires",
":",
"expires",
"}",
",",
"&",
"newLease",
",",
"&",
"opts",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"opts",
"=",
"append",
"(",
"opts",
",",
"clientv3",
".",
"WithIgnoreValue",
"(",
")",
")",
"\n",
"kv",
":=",
"re",
".",
"Kvs",
"[",
"0",
"]",
"\n",
"_",
",",
"err",
"=",
"b",
".",
"client",
".",
"Put",
"(",
"ctx",
",",
"string",
"(",
"kv",
".",
"Key",
")",
",",
"\"\"",
",",
"opts",
"...",
")",
"\n",
"return",
"convertErr",
"(",
"err",
")",
"\n",
"}"
] |
// KeepAlive updates TTL on the lease ID
|
[
"KeepAlive",
"updates",
"TTL",
"on",
"the",
"lease",
"ID"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/etcdbk/etcd.go#L487-L510
|
train
|
gravitational/teleport
|
lib/backend/etcdbk/etcd.go
|
seconds
|
func seconds(ttl time.Duration) int64 {
i := int64(ttl / time.Second)
if i <= 0 {
i = 1
}
return i
}
|
go
|
func seconds(ttl time.Duration) int64 {
i := int64(ttl / time.Second)
if i <= 0 {
i = 1
}
return i
}
|
[
"func",
"seconds",
"(",
"ttl",
"time",
".",
"Duration",
")",
"int64",
"{",
"i",
":=",
"int64",
"(",
"ttl",
"/",
"time",
".",
"Second",
")",
"\n",
"if",
"i",
"<=",
"0",
"{",
"i",
"=",
"1",
"\n",
"}",
"\n",
"return",
"i",
"\n",
"}"
] |
// seconds converts duration to seconds, rounds up to 1 second
|
[
"seconds",
"converts",
"duration",
"to",
"seconds",
"rounds",
"up",
"to",
"1",
"second"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/etcdbk/etcd.go#L606-L612
|
train
|
gravitational/teleport
|
tool/tctl/common/auth_command.go
|
GenerateKeys
|
func (a *AuthCommand) GenerateKeys() error {
keygen, err := native.New(context.TODO(), native.PrecomputeKeys(0))
if err != nil {
return trace.Wrap(err)
}
defer keygen.Close()
privBytes, pubBytes, err := keygen.GenerateKeyPair("")
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(a.genPubPath, pubBytes, 0600)
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(a.genPrivPath, privBytes, 0600)
if err != nil {
return trace.Wrap(err)
}
fmt.Printf("wrote public key to: %v and private key to: %v\n", a.genPubPath, a.genPrivPath)
return nil
}
|
go
|
func (a *AuthCommand) GenerateKeys() error {
keygen, err := native.New(context.TODO(), native.PrecomputeKeys(0))
if err != nil {
return trace.Wrap(err)
}
defer keygen.Close()
privBytes, pubBytes, err := keygen.GenerateKeyPair("")
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(a.genPubPath, pubBytes, 0600)
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(a.genPrivPath, privBytes, 0600)
if err != nil {
return trace.Wrap(err)
}
fmt.Printf("wrote public key to: %v and private key to: %v\n", a.genPubPath, a.genPrivPath)
return nil
}
|
[
"func",
"(",
"a",
"*",
"AuthCommand",
")",
"GenerateKeys",
"(",
")",
"error",
"{",
"keygen",
",",
"err",
":=",
"native",
".",
"New",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"native",
".",
"PrecomputeKeys",
"(",
"0",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"keygen",
".",
"Close",
"(",
")",
"\n",
"privBytes",
",",
"pubBytes",
",",
"err",
":=",
"keygen",
".",
"GenerateKeyPair",
"(",
"\"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"a",
".",
"genPubPath",
",",
"pubBytes",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"ioutil",
".",
"WriteFile",
"(",
"a",
".",
"genPrivPath",
",",
"privBytes",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"wrote public key to: %v and private key to: %v\\n\"",
",",
"\\n",
",",
"a",
".",
"genPubPath",
")",
"\n",
"a",
".",
"genPrivPath",
"\n",
"}"
] |
// GenerateKeys generates a new keypair
|
[
"GenerateKeys",
"generates",
"a",
"new",
"keypair"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/auth_command.go#L219-L241
|
train
|
gravitational/teleport
|
tool/tctl/common/auth_command.go
|
GenerateAndSignKeys
|
func (a *AuthCommand) GenerateAndSignKeys(clusterApi auth.ClientI) error {
switch {
case a.genUser != "" && a.genHost == "":
return a.generateUserKeys(clusterApi)
case a.genUser == "" && a.genHost != "":
return a.generateHostKeys(clusterApi)
default:
return trace.BadParameter("--user or --host must be specified")
}
}
|
go
|
func (a *AuthCommand) GenerateAndSignKeys(clusterApi auth.ClientI) error {
switch {
case a.genUser != "" && a.genHost == "":
return a.generateUserKeys(clusterApi)
case a.genUser == "" && a.genHost != "":
return a.generateHostKeys(clusterApi)
default:
return trace.BadParameter("--user or --host must be specified")
}
}
|
[
"func",
"(",
"a",
"*",
"AuthCommand",
")",
"GenerateAndSignKeys",
"(",
"clusterApi",
"auth",
".",
"ClientI",
")",
"error",
"{",
"switch",
"{",
"case",
"a",
".",
"genUser",
"!=",
"\"\"",
"&&",
"a",
".",
"genHost",
"==",
"\"\"",
":",
"return",
"a",
".",
"generateUserKeys",
"(",
"clusterApi",
")",
"\n",
"case",
"a",
".",
"genUser",
"==",
"\"\"",
"&&",
"a",
".",
"genHost",
"!=",
"\"\"",
":",
"return",
"a",
".",
"generateHostKeys",
"(",
"clusterApi",
")",
"\n",
"default",
":",
"return",
"trace",
".",
"BadParameter",
"(",
"\"--user or --host must be specified\"",
")",
"\n",
"}",
"\n",
"}"
] |
// GenerateAndSignKeys generates a new keypair and signs it for role
|
[
"GenerateAndSignKeys",
"generates",
"a",
"new",
"keypair",
"and",
"signs",
"it",
"for",
"role"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/auth_command.go#L244-L253
|
train
|
gravitational/teleport
|
tool/tctl/common/auth_command.go
|
RotateCertAuthority
|
func (a *AuthCommand) RotateCertAuthority(client auth.ClientI) error {
req := auth.RotateRequest{
Type: services.CertAuthType(a.rotateType),
GracePeriod: &a.rotateGracePeriod,
TargetPhase: a.rotateTargetPhase,
}
if a.rotateManualMode {
req.Mode = services.RotationModeManual
} else {
req.Mode = services.RotationModeAuto
}
if err := client.RotateCertAuthority(req); err != nil {
return err
}
if a.rotateTargetPhase != "" {
fmt.Printf("Updated rotation phase to %q. To check status use 'tctl status'\n", a.rotateTargetPhase)
} else {
fmt.Printf("Initiated certificate authority rotation. To check status use 'tctl status'\n")
}
return nil
}
|
go
|
func (a *AuthCommand) RotateCertAuthority(client auth.ClientI) error {
req := auth.RotateRequest{
Type: services.CertAuthType(a.rotateType),
GracePeriod: &a.rotateGracePeriod,
TargetPhase: a.rotateTargetPhase,
}
if a.rotateManualMode {
req.Mode = services.RotationModeManual
} else {
req.Mode = services.RotationModeAuto
}
if err := client.RotateCertAuthority(req); err != nil {
return err
}
if a.rotateTargetPhase != "" {
fmt.Printf("Updated rotation phase to %q. To check status use 'tctl status'\n", a.rotateTargetPhase)
} else {
fmt.Printf("Initiated certificate authority rotation. To check status use 'tctl status'\n")
}
return nil
}
|
[
"func",
"(",
"a",
"*",
"AuthCommand",
")",
"RotateCertAuthority",
"(",
"client",
"auth",
".",
"ClientI",
")",
"error",
"{",
"req",
":=",
"auth",
".",
"RotateRequest",
"{",
"Type",
":",
"services",
".",
"CertAuthType",
"(",
"a",
".",
"rotateType",
")",
",",
"GracePeriod",
":",
"&",
"a",
".",
"rotateGracePeriod",
",",
"TargetPhase",
":",
"a",
".",
"rotateTargetPhase",
",",
"}",
"\n",
"if",
"a",
".",
"rotateManualMode",
"{",
"req",
".",
"Mode",
"=",
"services",
".",
"RotationModeManual",
"\n",
"}",
"else",
"{",
"req",
".",
"Mode",
"=",
"services",
".",
"RotationModeAuto",
"\n",
"}",
"\n",
"if",
"err",
":=",
"client",
".",
"RotateCertAuthority",
"(",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"a",
".",
"rotateTargetPhase",
"!=",
"\"\"",
"{",
"fmt",
".",
"Printf",
"(",
"\"Updated rotation phase to %q. To check status use 'tctl status'\\n\"",
",",
"\\n",
")",
"\n",
"}",
"else",
"a",
".",
"rotateTargetPhase",
"\n",
"{",
"fmt",
".",
"Printf",
"(",
"\"Initiated certificate authority rotation. To check status use 'tctl status'\\n\"",
")",
"\n",
"}",
"\n",
"}"
] |
// RotateCertAuthority starts or restarts certificate authority rotation process
|
[
"RotateCertAuthority",
"starts",
"or",
"restarts",
"certificate",
"authority",
"rotation",
"process"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/auth_command.go#L256-L277
|
train
|
gravitational/teleport
|
lib/backend/legacy/legacy.go
|
CollectOptions
|
func CollectOptions(opts []OpOption) (*OpConfig, error) {
cfg := OpConfig{}
for _, o := range opts {
if err := o(&cfg); err != nil {
return nil, trace.Wrap(err)
}
}
return &cfg, nil
}
|
go
|
func CollectOptions(opts []OpOption) (*OpConfig, error) {
cfg := OpConfig{}
for _, o := range opts {
if err := o(&cfg); err != nil {
return nil, trace.Wrap(err)
}
}
return &cfg, nil
}
|
[
"func",
"CollectOptions",
"(",
"opts",
"[",
"]",
"OpOption",
")",
"(",
"*",
"OpConfig",
",",
"error",
")",
"{",
"cfg",
":=",
"OpConfig",
"{",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"if",
"err",
":=",
"o",
"(",
"&",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"cfg",
",",
"nil",
"\n",
"}"
] |
// CollectOptions collects all options from functional
// arg and returns config
|
[
"CollectOptions",
"collects",
"all",
"options",
"from",
"functional",
"arg",
"and",
"returns",
"config"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/legacy.go#L96-L104
|
train
|
gravitational/teleport
|
lib/backend/legacy/legacy.go
|
ValidateLockTTL
|
func ValidateLockTTL(ttl time.Duration) error {
if ttl == Forever || ttl > MaxLockDuration {
return trace.BadParameter("locks cannot exceed %v", MaxLockDuration)
}
return nil
}
|
go
|
func ValidateLockTTL(ttl time.Duration) error {
if ttl == Forever || ttl > MaxLockDuration {
return trace.BadParameter("locks cannot exceed %v", MaxLockDuration)
}
return nil
}
|
[
"func",
"ValidateLockTTL",
"(",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"ttl",
"==",
"Forever",
"||",
"ttl",
">",
"MaxLockDuration",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"locks cannot exceed %v\"",
",",
"MaxLockDuration",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ValidateLockTTL helper allows all backends to validate lock TTL parameter
|
[
"ValidateLockTTL",
"helper",
"allows",
"all",
"backends",
"to",
"validate",
"lock",
"TTL",
"parameter"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/legacy.go#L160-L165
|
train
|
gravitational/teleport
|
lib/backend/legacy/legacy.go
|
TTL
|
func TTL(clock clockwork.Clock, t time.Time) time.Duration {
if t.IsZero() {
return Forever
}
diff := t.UTC().Sub(clock.Now().UTC())
if diff < 0 {
return Forever
}
return diff
}
|
go
|
func TTL(clock clockwork.Clock, t time.Time) time.Duration {
if t.IsZero() {
return Forever
}
diff := t.UTC().Sub(clock.Now().UTC())
if diff < 0 {
return Forever
}
return diff
}
|
[
"func",
"TTL",
"(",
"clock",
"clockwork",
".",
"Clock",
",",
"t",
"time",
".",
"Time",
")",
"time",
".",
"Duration",
"{",
"if",
"t",
".",
"IsZero",
"(",
")",
"{",
"return",
"Forever",
"\n",
"}",
"\n",
"diff",
":=",
"t",
".",
"UTC",
"(",
")",
".",
"Sub",
"(",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
")",
"\n",
"if",
"diff",
"<",
"0",
"{",
"return",
"Forever",
"\n",
"}",
"\n",
"return",
"diff",
"\n",
"}"
] |
// TTL converts time to TTL from current time supplied
// by provider, if t is zero, returns forever
|
[
"TTL",
"converts",
"time",
"to",
"TTL",
"from",
"current",
"time",
"supplied",
"by",
"provider",
"if",
"t",
"is",
"zero",
"returns",
"forever"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/legacy.go#L180-L189
|
train
|
gravitational/teleport
|
lib/backend/legacy/legacy.go
|
AnyTTL
|
func AnyTTL(clock clockwork.Clock, times ...time.Time) time.Duration {
for _, t := range times {
if !t.IsZero() {
return TTL(clock, t)
}
}
return Forever
}
|
go
|
func AnyTTL(clock clockwork.Clock, times ...time.Time) time.Duration {
for _, t := range times {
if !t.IsZero() {
return TTL(clock, t)
}
}
return Forever
}
|
[
"func",
"AnyTTL",
"(",
"clock",
"clockwork",
".",
"Clock",
",",
"times",
"...",
"time",
".",
"Time",
")",
"time",
".",
"Duration",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"times",
"{",
"if",
"!",
"t",
".",
"IsZero",
"(",
")",
"{",
"return",
"TTL",
"(",
"clock",
",",
"t",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"Forever",
"\n",
"}"
] |
// AnyTTL returns TTL if any of the suplied times pass expiry time
// otherwise returns forever
|
[
"AnyTTL",
"returns",
"TTL",
"if",
"any",
"of",
"the",
"suplied",
"times",
"pass",
"expiry",
"time",
"otherwise",
"returns",
"forever"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/legacy.go#L193-L200
|
train
|
gravitational/teleport
|
lib/limiter/connlimiter.go
|
NewConnectionsLimiter
|
func NewConnectionsLimiter(config LimiterConfig) (*ConnectionsLimiter, error) {
limiter := ConnectionsLimiter{
Mutex: &sync.Mutex{},
maxConnections: config.MaxConnections,
connections: make(map[string]int64),
}
ipExtractor, err := utils.NewExtractor("client.ip")
if err != nil {
return nil, trace.Wrap(err)
}
limiter.ConnLimiter, err = connlimit.New(
nil, ipExtractor, config.MaxConnections)
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
}
|
go
|
func NewConnectionsLimiter(config LimiterConfig) (*ConnectionsLimiter, error) {
limiter := ConnectionsLimiter{
Mutex: &sync.Mutex{},
maxConnections: config.MaxConnections,
connections: make(map[string]int64),
}
ipExtractor, err := utils.NewExtractor("client.ip")
if err != nil {
return nil, trace.Wrap(err)
}
limiter.ConnLimiter, err = connlimit.New(
nil, ipExtractor, config.MaxConnections)
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
}
|
[
"func",
"NewConnectionsLimiter",
"(",
"config",
"LimiterConfig",
")",
"(",
"*",
"ConnectionsLimiter",
",",
"error",
")",
"{",
"limiter",
":=",
"ConnectionsLimiter",
"{",
"Mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"maxConnections",
":",
"config",
".",
"MaxConnections",
",",
"connections",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"int64",
")",
",",
"}",
"\n",
"ipExtractor",
",",
"err",
":=",
"utils",
".",
"NewExtractor",
"(",
"\"client.ip\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"limiter",
".",
"ConnLimiter",
",",
"err",
"=",
"connlimit",
".",
"New",
"(",
"nil",
",",
"ipExtractor",
",",
"config",
".",
"MaxConnections",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"limiter",
",",
"nil",
"\n",
"}"
] |
// NewConnectionsLimiter returns new connection limiter, in case if connection
// limits are not set, they won't be tracked
|
[
"NewConnectionsLimiter",
"returns",
"new",
"connection",
"limiter",
"in",
"case",
"if",
"connection",
"limits",
"are",
"not",
"set",
"they",
"won",
"t",
"be",
"tracked"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/connlimiter.go#L39-L58
|
train
|
gravitational/teleport
|
lib/limiter/connlimiter.go
|
WrapHandle
|
func (l *ConnectionsLimiter) WrapHandle(h http.Handler) {
l.ConnLimiter.Wrap(h)
}
|
go
|
func (l *ConnectionsLimiter) WrapHandle(h http.Handler) {
l.ConnLimiter.Wrap(h)
}
|
[
"func",
"(",
"l",
"*",
"ConnectionsLimiter",
")",
"WrapHandle",
"(",
"h",
"http",
".",
"Handler",
")",
"{",
"l",
".",
"ConnLimiter",
".",
"Wrap",
"(",
"h",
")",
"\n",
"}"
] |
// WrapHandle adds connection limiter to the handle
|
[
"WrapHandle",
"adds",
"connection",
"limiter",
"to",
"the",
"handle"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/connlimiter.go#L61-L63
|
train
|
gravitational/teleport
|
lib/limiter/connlimiter.go
|
AcquireConnection
|
func (l *ConnectionsLimiter) AcquireConnection(token string) error {
l.Lock()
defer l.Unlock()
if l.maxConnections == 0 {
return nil
}
numberOfConnections, exists := l.connections[token]
if !exists {
l.connections[token] = 1
return nil
}
if numberOfConnections >= l.maxConnections {
return trace.LimitExceeded(
"too many connections from %v: %v, max is %v",
token, numberOfConnections, l.maxConnections)
}
l.connections[token] = numberOfConnections + 1
return nil
}
|
go
|
func (l *ConnectionsLimiter) AcquireConnection(token string) error {
l.Lock()
defer l.Unlock()
if l.maxConnections == 0 {
return nil
}
numberOfConnections, exists := l.connections[token]
if !exists {
l.connections[token] = 1
return nil
}
if numberOfConnections >= l.maxConnections {
return trace.LimitExceeded(
"too many connections from %v: %v, max is %v",
token, numberOfConnections, l.maxConnections)
}
l.connections[token] = numberOfConnections + 1
return nil
}
|
[
"func",
"(",
"l",
"*",
"ConnectionsLimiter",
")",
"AcquireConnection",
"(",
"token",
"string",
")",
"error",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"if",
"l",
".",
"maxConnections",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"numberOfConnections",
",",
"exists",
":=",
"l",
".",
"connections",
"[",
"token",
"]",
"\n",
"if",
"!",
"exists",
"{",
"l",
".",
"connections",
"[",
"token",
"]",
"=",
"1",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"numberOfConnections",
">=",
"l",
".",
"maxConnections",
"{",
"return",
"trace",
".",
"LimitExceeded",
"(",
"\"too many connections from %v: %v, max is %v\"",
",",
"token",
",",
"numberOfConnections",
",",
"l",
".",
"maxConnections",
")",
"\n",
"}",
"\n",
"l",
".",
"connections",
"[",
"token",
"]",
"=",
"numberOfConnections",
"+",
"1",
"\n",
"return",
"nil",
"\n",
"}"
] |
// AcquireConnection acquires connection and bumps counter
|
[
"AcquireConnection",
"acquires",
"connection",
"and",
"bumps",
"counter"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/connlimiter.go#L66-L86
|
train
|
gravitational/teleport
|
lib/limiter/connlimiter.go
|
ReleaseConnection
|
func (l *ConnectionsLimiter) ReleaseConnection(token string) {
l.Lock()
defer l.Unlock()
if l.maxConnections == 0 {
return
}
numberOfConnections, exists := l.connections[token]
if !exists {
log.Errorf("Trying to set negative number of connections")
} else {
if numberOfConnections <= 1 {
delete(l.connections, token)
} else {
l.connections[token] = numberOfConnections - 1
}
}
}
|
go
|
func (l *ConnectionsLimiter) ReleaseConnection(token string) {
l.Lock()
defer l.Unlock()
if l.maxConnections == 0 {
return
}
numberOfConnections, exists := l.connections[token]
if !exists {
log.Errorf("Trying to set negative number of connections")
} else {
if numberOfConnections <= 1 {
delete(l.connections, token)
} else {
l.connections[token] = numberOfConnections - 1
}
}
}
|
[
"func",
"(",
"l",
"*",
"ConnectionsLimiter",
")",
"ReleaseConnection",
"(",
"token",
"string",
")",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"if",
"l",
".",
"maxConnections",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"numberOfConnections",
",",
"exists",
":=",
"l",
".",
"connections",
"[",
"token",
"]",
"\n",
"if",
"!",
"exists",
"{",
"log",
".",
"Errorf",
"(",
"\"Trying to set negative number of connections\"",
")",
"\n",
"}",
"else",
"{",
"if",
"numberOfConnections",
"<=",
"1",
"{",
"delete",
"(",
"l",
".",
"connections",
",",
"token",
")",
"\n",
"}",
"else",
"{",
"l",
".",
"connections",
"[",
"token",
"]",
"=",
"numberOfConnections",
"-",
"1",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// ReleaseConnection decrements the counter
|
[
"ReleaseConnection",
"decrements",
"the",
"counter"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/connlimiter.go#L89-L108
|
train
|
gravitational/teleport
|
lib/utils/time.go
|
MinTTL
|
func MinTTL(a, b time.Duration) time.Duration {
if a == 0 {
return b
}
if b == 0 {
return a
}
if a < b {
return a
}
return b
}
|
go
|
func MinTTL(a, b time.Duration) time.Duration {
if a == 0 {
return b
}
if b == 0 {
return a
}
if a < b {
return a
}
return b
}
|
[
"func",
"MinTTL",
"(",
"a",
",",
"b",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"if",
"a",
"==",
"0",
"{",
"return",
"b",
"\n",
"}",
"\n",
"if",
"b",
"==",
"0",
"{",
"return",
"a",
"\n",
"}",
"\n",
"if",
"a",
"<",
"b",
"{",
"return",
"a",
"\n",
"}",
"\n",
"return",
"b",
"\n",
"}"
] |
// MinTTL finds min non 0 TTL duration,
// if both durations are 0, fails
|
[
"MinTTL",
"finds",
"min",
"non",
"0",
"TTL",
"duration",
"if",
"both",
"durations",
"are",
"0",
"fails"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/time.go#L11-L22
|
train
|
gravitational/teleport
|
lib/utils/time.go
|
ToTTL
|
func ToTTL(c clockwork.Clock, tm time.Time) time.Duration {
now := c.Now().UTC()
if tm.IsZero() || tm.Before(now) {
return 0
}
return tm.Sub(now)
}
|
go
|
func ToTTL(c clockwork.Clock, tm time.Time) time.Duration {
now := c.Now().UTC()
if tm.IsZero() || tm.Before(now) {
return 0
}
return tm.Sub(now)
}
|
[
"func",
"ToTTL",
"(",
"c",
"clockwork",
".",
"Clock",
",",
"tm",
"time",
".",
"Time",
")",
"time",
".",
"Duration",
"{",
"now",
":=",
"c",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"if",
"tm",
".",
"IsZero",
"(",
")",
"||",
"tm",
".",
"Before",
"(",
"now",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"tm",
".",
"Sub",
"(",
"now",
")",
"\n",
"}"
] |
// ToTTL converts expiration time to TTL duration
// relative to current time as provided by clock
|
[
"ToTTL",
"converts",
"expiration",
"time",
"to",
"TTL",
"duration",
"relative",
"to",
"current",
"time",
"as",
"provided",
"by",
"clock"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/time.go#L26-L32
|
train
|
gravitational/teleport
|
lib/utils/time.go
|
UTC
|
func UTC(t *time.Time) {
if t == nil {
return
}
if t.IsZero() {
// to fix issue with timezones for tests
*t = time.Time{}
return
}
*t = t.UTC()
}
|
go
|
func UTC(t *time.Time) {
if t == nil {
return
}
if t.IsZero() {
// to fix issue with timezones for tests
*t = time.Time{}
return
}
*t = t.UTC()
}
|
[
"func",
"UTC",
"(",
"t",
"*",
"time",
".",
"Time",
")",
"{",
"if",
"t",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"t",
".",
"IsZero",
"(",
")",
"{",
"*",
"t",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"*",
"t",
"=",
"t",
".",
"UTC",
"(",
")",
"\n",
"}"
] |
// UTC converts time to UTC timezone
|
[
"UTC",
"converts",
"time",
"to",
"UTC",
"timezone"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/time.go#L35-L46
|
train
|
gravitational/teleport
|
lib/auth/password.go
|
ChangePassword
|
func (s *AuthServer) ChangePassword(req services.ChangePasswordReq) error {
// validate new password
err := services.VerifyPassword(req.NewPassword)
if err != nil {
return trace.Wrap(err)
}
authPreference, err := s.GetAuthPreference()
if err != nil {
return trace.Wrap(err)
}
userID := req.User
fn := func() error {
secondFactor := authPreference.GetSecondFactor()
switch secondFactor {
case teleport.OFF:
return s.CheckPasswordWOToken(userID, req.OldPassword)
case teleport.OTP:
return s.CheckPassword(userID, req.OldPassword, req.SecondFactorToken)
case teleport.U2F:
if req.U2FSignResponse == nil {
return trace.BadParameter("missing U2F sign response")
}
return s.CheckU2FSignResponse(userID, req.U2FSignResponse)
}
return trace.BadParameter("unsupported second factor method: %q", secondFactor)
}
err = s.WithUserLock(userID, fn)
if err != nil {
return trace.Wrap(err)
}
return trace.Wrap(s.UpsertPassword(userID, req.NewPassword))
}
|
go
|
func (s *AuthServer) ChangePassword(req services.ChangePasswordReq) error {
// validate new password
err := services.VerifyPassword(req.NewPassword)
if err != nil {
return trace.Wrap(err)
}
authPreference, err := s.GetAuthPreference()
if err != nil {
return trace.Wrap(err)
}
userID := req.User
fn := func() error {
secondFactor := authPreference.GetSecondFactor()
switch secondFactor {
case teleport.OFF:
return s.CheckPasswordWOToken(userID, req.OldPassword)
case teleport.OTP:
return s.CheckPassword(userID, req.OldPassword, req.SecondFactorToken)
case teleport.U2F:
if req.U2FSignResponse == nil {
return trace.BadParameter("missing U2F sign response")
}
return s.CheckU2FSignResponse(userID, req.U2FSignResponse)
}
return trace.BadParameter("unsupported second factor method: %q", secondFactor)
}
err = s.WithUserLock(userID, fn)
if err != nil {
return trace.Wrap(err)
}
return trace.Wrap(s.UpsertPassword(userID, req.NewPassword))
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"ChangePassword",
"(",
"req",
"services",
".",
"ChangePasswordReq",
")",
"error",
"{",
"err",
":=",
"services",
".",
"VerifyPassword",
"(",
"req",
".",
"NewPassword",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authPreference",
",",
"err",
":=",
"s",
".",
"GetAuthPreference",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"userID",
":=",
"req",
".",
"User",
"\n",
"fn",
":=",
"func",
"(",
")",
"error",
"{",
"secondFactor",
":=",
"authPreference",
".",
"GetSecondFactor",
"(",
")",
"\n",
"switch",
"secondFactor",
"{",
"case",
"teleport",
".",
"OFF",
":",
"return",
"s",
".",
"CheckPasswordWOToken",
"(",
"userID",
",",
"req",
".",
"OldPassword",
")",
"\n",
"case",
"teleport",
".",
"OTP",
":",
"return",
"s",
".",
"CheckPassword",
"(",
"userID",
",",
"req",
".",
"OldPassword",
",",
"req",
".",
"SecondFactorToken",
")",
"\n",
"case",
"teleport",
".",
"U2F",
":",
"if",
"req",
".",
"U2FSignResponse",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing U2F sign response\"",
")",
"\n",
"}",
"\n",
"return",
"s",
".",
"CheckU2FSignResponse",
"(",
"userID",
",",
"req",
".",
"U2FSignResponse",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"unsupported second factor method: %q\"",
",",
"secondFactor",
")",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"WithUserLock",
"(",
"userID",
",",
"fn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"s",
".",
"UpsertPassword",
"(",
"userID",
",",
"req",
".",
"NewPassword",
")",
")",
"\n",
"}"
] |
// ChangePassword changes user passsword
|
[
"ChangePassword",
"changes",
"user",
"passsword"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/password.go#L21-L58
|
train
|
gravitational/teleport
|
lib/auth/password.go
|
CheckPasswordWOToken
|
func (s *AuthServer) CheckPasswordWOToken(user string, password []byte) error {
const errMsg = "invalid username or password"
err := services.VerifyPassword(password)
if err != nil {
return trace.BadParameter(errMsg)
}
hash, err := s.GetPasswordHash(user)
if err != nil && !trace.IsNotFound(err) {
return trace.Wrap(err)
}
if trace.IsNotFound(err) {
log.Debugf("Username %q not found, using fake hash to mitigate timing attacks.", user)
hash = fakePasswordHash
}
if err = bcrypt.CompareHashAndPassword(hash, password); err != nil {
log.Debugf("Password for %q does not match", user)
return trace.BadParameter(errMsg)
}
return nil
}
|
go
|
func (s *AuthServer) CheckPasswordWOToken(user string, password []byte) error {
const errMsg = "invalid username or password"
err := services.VerifyPassword(password)
if err != nil {
return trace.BadParameter(errMsg)
}
hash, err := s.GetPasswordHash(user)
if err != nil && !trace.IsNotFound(err) {
return trace.Wrap(err)
}
if trace.IsNotFound(err) {
log.Debugf("Username %q not found, using fake hash to mitigate timing attacks.", user)
hash = fakePasswordHash
}
if err = bcrypt.CompareHashAndPassword(hash, password); err != nil {
log.Debugf("Password for %q does not match", user)
return trace.BadParameter(errMsg)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"CheckPasswordWOToken",
"(",
"user",
"string",
",",
"password",
"[",
"]",
"byte",
")",
"error",
"{",
"const",
"errMsg",
"=",
"\"invalid username or password\"",
"\n",
"err",
":=",
"services",
".",
"VerifyPassword",
"(",
"password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"errMsg",
")",
"\n",
"}",
"\n",
"hash",
",",
"err",
":=",
"s",
".",
"GetPasswordHash",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"Username %q not found, using fake hash to mitigate timing attacks.\"",
",",
"user",
")",
"\n",
"hash",
"=",
"fakePasswordHash",
"\n",
"}",
"\n",
"if",
"err",
"=",
"bcrypt",
".",
"CompareHashAndPassword",
"(",
"hash",
",",
"password",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"Password for %q does not match\"",
",",
"user",
")",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"errMsg",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckPasswordWOToken checks just password without checking OTP tokens
// used in case of SSH authentication, when token has been validated.
|
[
"CheckPasswordWOToken",
"checks",
"just",
"password",
"without",
"checking",
"OTP",
"tokens",
"used",
"in",
"case",
"of",
"SSH",
"authentication",
"when",
"token",
"has",
"been",
"validated",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/password.go#L62-L85
|
train
|
gravitational/teleport
|
lib/auth/password.go
|
GetOTPData
|
func (s *AuthServer) GetOTPData(user string) (string, []byte, error) {
// get otp key from backend
otpSecret, err := s.GetTOTP(user)
if err != nil {
return "", nil, trace.Wrap(err)
}
// create otp url
params := map[string][]byte{"secret": []byte(otpSecret)}
otpURL := utils.GenerateOTPURL("totp", user, params)
// create the qr code
otpQR, err := utils.GenerateQRCode(otpURL)
if err != nil {
return "", nil, trace.Wrap(err)
}
return otpURL, otpQR, nil
}
|
go
|
func (s *AuthServer) GetOTPData(user string) (string, []byte, error) {
// get otp key from backend
otpSecret, err := s.GetTOTP(user)
if err != nil {
return "", nil, trace.Wrap(err)
}
// create otp url
params := map[string][]byte{"secret": []byte(otpSecret)}
otpURL := utils.GenerateOTPURL("totp", user, params)
// create the qr code
otpQR, err := utils.GenerateQRCode(otpURL)
if err != nil {
return "", nil, trace.Wrap(err)
}
return otpURL, otpQR, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"GetOTPData",
"(",
"user",
"string",
")",
"(",
"string",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"otpSecret",
",",
"err",
":=",
"s",
".",
"GetTOTP",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"params",
":=",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"\"secret\"",
":",
"[",
"]",
"byte",
"(",
"otpSecret",
")",
"}",
"\n",
"otpURL",
":=",
"utils",
".",
"GenerateOTPURL",
"(",
"\"totp\"",
",",
"user",
",",
"params",
")",
"\n",
"otpQR",
",",
"err",
":=",
"utils",
".",
"GenerateQRCode",
"(",
"otpURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"otpURL",
",",
"otpQR",
",",
"nil",
"\n",
"}"
] |
// GetOTPData returns the OTP Key, Key URL, and the QR code.
|
[
"GetOTPData",
"returns",
"the",
"OTP",
"Key",
"Key",
"URL",
"and",
"the",
"QR",
"code",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/password.go#L182-L200
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
NewWhereParser
|
func NewWhereParser(ctx RuleContext) (predicate.Parser, error) {
return predicate.NewParser(predicate.Def{
Operators: predicate.Operators{
AND: predicate.And,
OR: predicate.Or,
NOT: predicate.Not,
},
Functions: map[string]interface{}{
"equals": predicate.Equals,
"contains": predicate.Contains,
// system.catype is a function that returns cert authority type,
// it returns empty values for unrecognized values to
// pass static rule checks.
"system.catype": func() (interface{}, error) {
resource, err := ctx.GetResource()
if err != nil {
if trace.IsNotFound(err) {
return "", nil
}
return nil, trace.Wrap(err)
}
ca, ok := resource.(CertAuthority)
if !ok {
return "", nil
}
return string(ca.GetType()), nil
},
},
GetIdentifier: ctx.GetIdentifier,
GetProperty: GetStringMapValue,
})
}
|
go
|
func NewWhereParser(ctx RuleContext) (predicate.Parser, error) {
return predicate.NewParser(predicate.Def{
Operators: predicate.Operators{
AND: predicate.And,
OR: predicate.Or,
NOT: predicate.Not,
},
Functions: map[string]interface{}{
"equals": predicate.Equals,
"contains": predicate.Contains,
// system.catype is a function that returns cert authority type,
// it returns empty values for unrecognized values to
// pass static rule checks.
"system.catype": func() (interface{}, error) {
resource, err := ctx.GetResource()
if err != nil {
if trace.IsNotFound(err) {
return "", nil
}
return nil, trace.Wrap(err)
}
ca, ok := resource.(CertAuthority)
if !ok {
return "", nil
}
return string(ca.GetType()), nil
},
},
GetIdentifier: ctx.GetIdentifier,
GetProperty: GetStringMapValue,
})
}
|
[
"func",
"NewWhereParser",
"(",
"ctx",
"RuleContext",
")",
"(",
"predicate",
".",
"Parser",
",",
"error",
")",
"{",
"return",
"predicate",
".",
"NewParser",
"(",
"predicate",
".",
"Def",
"{",
"Operators",
":",
"predicate",
".",
"Operators",
"{",
"AND",
":",
"predicate",
".",
"And",
",",
"OR",
":",
"predicate",
".",
"Or",
",",
"NOT",
":",
"predicate",
".",
"Not",
",",
"}",
",",
"Functions",
":",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"equals\"",
":",
"predicate",
".",
"Equals",
",",
"\"contains\"",
":",
"predicate",
".",
"Contains",
",",
"\"system.catype\"",
":",
"func",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"resource",
",",
"err",
":=",
"ctx",
".",
"GetResource",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"\"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ca",
",",
"ok",
":=",
"resource",
".",
"(",
"CertAuthority",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"\"",
",",
"nil",
"\n",
"}",
"\n",
"return",
"string",
"(",
"ca",
".",
"GetType",
"(",
")",
")",
",",
"nil",
"\n",
"}",
",",
"}",
",",
"GetIdentifier",
":",
"ctx",
".",
"GetIdentifier",
",",
"GetProperty",
":",
"GetStringMapValue",
",",
"}",
")",
"\n",
"}"
] |
// NewWhereParser returns standard parser for `where` section in access rules.
|
[
"NewWhereParser",
"returns",
"standard",
"parser",
"for",
"where",
"section",
"in",
"access",
"rules",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L56-L87
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
NewActionsParser
|
func NewActionsParser(ctx RuleContext) (predicate.Parser, error) {
return predicate.NewParser(predicate.Def{
Operators: predicate.Operators{},
Functions: map[string]interface{}{
"log": NewLogActionFn(ctx),
},
GetIdentifier: ctx.GetIdentifier,
GetProperty: predicate.GetStringMapValue,
})
}
|
go
|
func NewActionsParser(ctx RuleContext) (predicate.Parser, error) {
return predicate.NewParser(predicate.Def{
Operators: predicate.Operators{},
Functions: map[string]interface{}{
"log": NewLogActionFn(ctx),
},
GetIdentifier: ctx.GetIdentifier,
GetProperty: predicate.GetStringMapValue,
})
}
|
[
"func",
"NewActionsParser",
"(",
"ctx",
"RuleContext",
")",
"(",
"predicate",
".",
"Parser",
",",
"error",
")",
"{",
"return",
"predicate",
".",
"NewParser",
"(",
"predicate",
".",
"Def",
"{",
"Operators",
":",
"predicate",
".",
"Operators",
"{",
"}",
",",
"Functions",
":",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"log\"",
":",
"NewLogActionFn",
"(",
"ctx",
")",
",",
"}",
",",
"GetIdentifier",
":",
"ctx",
".",
"GetIdentifier",
",",
"GetProperty",
":",
"predicate",
".",
"GetStringMapValue",
",",
"}",
")",
"\n",
"}"
] |
// NewActionsParser returns standard parser for 'actions' section in access rules
|
[
"NewActionsParser",
"returns",
"standard",
"parser",
"for",
"actions",
"section",
"in",
"access",
"rules"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L125-L134
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
NewLogActionFn
|
func NewLogActionFn(ctx RuleContext) interface{} {
l := &LogAction{ctx: ctx}
writer, ok := ctx.(io.Writer)
if ok && writer != nil {
l.writer = writer
}
return l.Log
}
|
go
|
func NewLogActionFn(ctx RuleContext) interface{} {
l := &LogAction{ctx: ctx}
writer, ok := ctx.(io.Writer)
if ok && writer != nil {
l.writer = writer
}
return l.Log
}
|
[
"func",
"NewLogActionFn",
"(",
"ctx",
"RuleContext",
")",
"interface",
"{",
"}",
"{",
"l",
":=",
"&",
"LogAction",
"{",
"ctx",
":",
"ctx",
"}",
"\n",
"writer",
",",
"ok",
":=",
"ctx",
".",
"(",
"io",
".",
"Writer",
")",
"\n",
"if",
"ok",
"&&",
"writer",
"!=",
"nil",
"{",
"l",
".",
"writer",
"=",
"writer",
"\n",
"}",
"\n",
"return",
"l",
".",
"Log",
"\n",
"}"
] |
// NewLogActionFn creates logger functions
|
[
"NewLogActionFn",
"creates",
"logger",
"functions"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L137-L144
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
Log
|
func (l *LogAction) Log(level, format string, args ...interface{}) predicate.BoolPredicate {
return func() bool {
ilevel, err := log.ParseLevel(level)
if err != nil {
ilevel = log.DebugLevel
}
var writer io.Writer
if l.writer != nil {
writer = l.writer
} else {
writer = log.StandardLogger().WriterLevel(ilevel)
}
writer.Write([]byte(fmt.Sprintf(format, args...)))
return true
}
}
|
go
|
func (l *LogAction) Log(level, format string, args ...interface{}) predicate.BoolPredicate {
return func() bool {
ilevel, err := log.ParseLevel(level)
if err != nil {
ilevel = log.DebugLevel
}
var writer io.Writer
if l.writer != nil {
writer = l.writer
} else {
writer = log.StandardLogger().WriterLevel(ilevel)
}
writer.Write([]byte(fmt.Sprintf(format, args...)))
return true
}
}
|
[
"func",
"(",
"l",
"*",
"LogAction",
")",
"Log",
"(",
"level",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"predicate",
".",
"BoolPredicate",
"{",
"return",
"func",
"(",
")",
"bool",
"{",
"ilevel",
",",
"err",
":=",
"log",
".",
"ParseLevel",
"(",
"level",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"ilevel",
"=",
"log",
".",
"DebugLevel",
"\n",
"}",
"\n",
"var",
"writer",
"io",
".",
"Writer",
"\n",
"if",
"l",
".",
"writer",
"!=",
"nil",
"{",
"writer",
"=",
"l",
".",
"writer",
"\n",
"}",
"else",
"{",
"writer",
"=",
"log",
".",
"StandardLogger",
"(",
")",
".",
"WriterLevel",
"(",
"ilevel",
")",
"\n",
"}",
"\n",
"writer",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
")",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}"
] |
// Log logs with specified level and formatting string with arguments
|
[
"Log",
"logs",
"with",
"specified",
"level",
"and",
"formatting",
"string",
"with",
"arguments"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L154-L169
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
String
|
func (ctx *Context) String() string {
return fmt.Sprintf("user %v, resource: %v", ctx.User, ctx.Resource)
}
|
go
|
func (ctx *Context) String() string {
return fmt.Sprintf("user %v, resource: %v", ctx.User, ctx.Resource)
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"user %v, resource: %v\"",
",",
"ctx",
".",
"User",
",",
"ctx",
".",
"Resource",
")",
"\n",
"}"
] |
// String returns user friendly representation of this context
|
[
"String",
"returns",
"user",
"friendly",
"representation",
"of",
"this",
"context"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L181-L183
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
GetResource
|
func (ctx *Context) GetResource() (Resource, error) {
if ctx.Resource == nil {
return nil, trace.NotFound("resource is not set in the context")
}
return ctx.Resource, nil
}
|
go
|
func (ctx *Context) GetResource() (Resource, error) {
if ctx.Resource == nil {
return nil, trace.NotFound("resource is not set in the context")
}
return ctx.Resource, nil
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"GetResource",
"(",
")",
"(",
"Resource",
",",
"error",
")",
"{",
"if",
"ctx",
".",
"Resource",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"resource is not set in the context\"",
")",
"\n",
"}",
"\n",
"return",
"ctx",
".",
"Resource",
",",
"nil",
"\n",
"}"
] |
// GetResource returns resource specified in the context,
// returns error if not specified.
|
[
"GetResource",
"returns",
"resource",
"specified",
"in",
"the",
"context",
"returns",
"error",
"if",
"not",
"specified",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L194-L199
|
train
|
gravitational/teleport
|
lib/services/parser.go
|
GetIdentifier
|
func (ctx *Context) GetIdentifier(fields []string) (interface{}, error) {
switch fields[0] {
case UserIdentifier:
var user User
if ctx.User == nil {
user = emptyUser
} else {
user = ctx.User
}
return predicate.GetFieldByTag(user, teleport.JSON, fields[1:])
case ResourceIdentifier:
var resource Resource
if ctx.Resource == nil {
resource = emptyResource
} else {
resource = ctx.Resource
}
return predicate.GetFieldByTag(resource, "json", fields[1:])
default:
return nil, trace.NotFound("%v is not defined", strings.Join(fields, "."))
}
}
|
go
|
func (ctx *Context) GetIdentifier(fields []string) (interface{}, error) {
switch fields[0] {
case UserIdentifier:
var user User
if ctx.User == nil {
user = emptyUser
} else {
user = ctx.User
}
return predicate.GetFieldByTag(user, teleport.JSON, fields[1:])
case ResourceIdentifier:
var resource Resource
if ctx.Resource == nil {
resource = emptyResource
} else {
resource = ctx.Resource
}
return predicate.GetFieldByTag(resource, "json", fields[1:])
default:
return nil, trace.NotFound("%v is not defined", strings.Join(fields, "."))
}
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"GetIdentifier",
"(",
"fields",
"[",
"]",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"switch",
"fields",
"[",
"0",
"]",
"{",
"case",
"UserIdentifier",
":",
"var",
"user",
"User",
"\n",
"if",
"ctx",
".",
"User",
"==",
"nil",
"{",
"user",
"=",
"emptyUser",
"\n",
"}",
"else",
"{",
"user",
"=",
"ctx",
".",
"User",
"\n",
"}",
"\n",
"return",
"predicate",
".",
"GetFieldByTag",
"(",
"user",
",",
"teleport",
".",
"JSON",
",",
"fields",
"[",
"1",
":",
"]",
")",
"\n",
"case",
"ResourceIdentifier",
":",
"var",
"resource",
"Resource",
"\n",
"if",
"ctx",
".",
"Resource",
"==",
"nil",
"{",
"resource",
"=",
"emptyResource",
"\n",
"}",
"else",
"{",
"resource",
"=",
"ctx",
".",
"Resource",
"\n",
"}",
"\n",
"return",
"predicate",
".",
"GetFieldByTag",
"(",
"resource",
",",
"\"json\"",
",",
"fields",
"[",
"1",
":",
"]",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"%v is not defined\"",
",",
"strings",
".",
"Join",
"(",
"fields",
",",
"\".\"",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// GetIdentifier returns identifier defined in a context
|
[
"GetIdentifier",
"returns",
"identifier",
"defined",
"in",
"a",
"context"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/parser.go#L202-L223
|
train
|
gravitational/teleport
|
lib/secret/secret.go
|
ParseKey
|
func ParseKey(k []byte) (Key, error) {
key, err := hex.DecodeString(string(k))
if err != nil {
return nil, trace.Wrap(err)
}
return Key(key), nil
}
|
go
|
func ParseKey(k []byte) (Key, error) {
key, err := hex.DecodeString(string(k))
if err != nil {
return nil, trace.Wrap(err)
}
return Key(key), nil
}
|
[
"func",
"ParseKey",
"(",
"k",
"[",
"]",
"byte",
")",
"(",
"Key",
",",
"error",
")",
"{",
"key",
",",
"err",
":=",
"hex",
".",
"DecodeString",
"(",
"string",
"(",
"k",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"Key",
"(",
"key",
")",
",",
"nil",
"\n",
"}"
] |
// ParseKey reads in an existing hex encoded key.
|
[
"ParseKey",
"reads",
"in",
"an",
"existing",
"hex",
"encoded",
"key",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/secret/secret.go#L54-L61
|
train
|
gravitational/teleport
|
lib/secret/secret.go
|
Seal
|
func (k Key) Seal(plaintext []byte) ([]byte, error) {
block, err := aes.NewCipher([]byte(k))
if err != nil {
return nil, trace.Wrap(err)
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return nil, trace.Wrap(err)
}
nonce := make([]byte, aesgcm.NonceSize())
_, err = io.ReadFull(rand.Reader, nonce)
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err := json.Marshal(&sealedData{
Ciphertext: aesgcm.Seal(nil, nonce, plaintext, nil),
Nonce: nonce,
})
if err != nil {
return nil, trace.Wrap(err)
}
return ciphertext, nil
}
|
go
|
func (k Key) Seal(plaintext []byte) ([]byte, error) {
block, err := aes.NewCipher([]byte(k))
if err != nil {
return nil, trace.Wrap(err)
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return nil, trace.Wrap(err)
}
nonce := make([]byte, aesgcm.NonceSize())
_, err = io.ReadFull(rand.Reader, nonce)
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err := json.Marshal(&sealedData{
Ciphertext: aesgcm.Seal(nil, nonce, plaintext, nil),
Nonce: nonce,
})
if err != nil {
return nil, trace.Wrap(err)
}
return ciphertext, nil
}
|
[
"func",
"(",
"k",
"Key",
")",
"Seal",
"(",
"plaintext",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"[",
"]",
"byte",
"(",
"k",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"aesgcm",
",",
"err",
":=",
"cipher",
".",
"NewGCM",
"(",
"block",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"nonce",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"aesgcm",
".",
"NonceSize",
"(",
")",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"rand",
".",
"Reader",
",",
"nonce",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ciphertext",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"&",
"sealedData",
"{",
"Ciphertext",
":",
"aesgcm",
".",
"Seal",
"(",
"nil",
",",
"nonce",
",",
"plaintext",
",",
"nil",
")",
",",
"Nonce",
":",
"nonce",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ciphertext",
",",
"nil",
"\n",
"}"
] |
// Seal will encrypt then authenticate the ciphertext.
|
[
"Seal",
"will",
"encrypt",
"then",
"authenticate",
"the",
"ciphertext",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/secret/secret.go#L64-L90
|
train
|
gravitational/teleport
|
lib/secret/secret.go
|
Open
|
func (k Key) Open(ciphertext []byte) ([]byte, error) {
var data sealedData
err := json.Unmarshal(ciphertext, &data)
if err != nil {
return nil, trace.Wrap(err)
}
block, err := aes.NewCipher(k)
if err != nil {
return nil, trace.Wrap(err)
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return nil, trace.Wrap(err)
}
plaintext, err := aesgcm.Open(nil, data.Nonce, data.Ciphertext, nil)
if err != nil {
return nil, trace.Wrap(err)
}
return plaintext, nil
}
|
go
|
func (k Key) Open(ciphertext []byte) ([]byte, error) {
var data sealedData
err := json.Unmarshal(ciphertext, &data)
if err != nil {
return nil, trace.Wrap(err)
}
block, err := aes.NewCipher(k)
if err != nil {
return nil, trace.Wrap(err)
}
aesgcm, err := cipher.NewGCM(block)
if err != nil {
return nil, trace.Wrap(err)
}
plaintext, err := aesgcm.Open(nil, data.Nonce, data.Ciphertext, nil)
if err != nil {
return nil, trace.Wrap(err)
}
return plaintext, nil
}
|
[
"func",
"(",
"k",
"Key",
")",
"Open",
"(",
"ciphertext",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"data",
"sealedData",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"ciphertext",
",",
"&",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"aesgcm",
",",
"err",
":=",
"cipher",
".",
"NewGCM",
"(",
"block",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"plaintext",
",",
"err",
":=",
"aesgcm",
".",
"Open",
"(",
"nil",
",",
"data",
".",
"Nonce",
",",
"data",
".",
"Ciphertext",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"plaintext",
",",
"nil",
"\n",
"}"
] |
// Open will authenticate then decrypt the ciphertext.
|
[
"Open",
"will",
"authenticate",
"then",
"decrypt",
"the",
"ciphertext",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/secret/secret.go#L93-L117
|
train
|
gravitational/teleport
|
lib/events/forward.go
|
NewForwarder
|
func NewForwarder(cfg ForwarderConfig) (*Forwarder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
diskLogger, err := NewDiskSessionLogger(DiskSessionLoggerConfig{
SessionID: cfg.SessionID,
DataDir: cfg.DataDir,
RecordSessions: cfg.RecordSessions,
Namespace: cfg.Namespace,
ServerID: cfg.ServerID,
Clock: cfg.Clock,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &Forwarder{
ForwarderConfig: cfg,
sessionLogger: diskLogger,
}, nil
}
|
go
|
func NewForwarder(cfg ForwarderConfig) (*Forwarder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
diskLogger, err := NewDiskSessionLogger(DiskSessionLoggerConfig{
SessionID: cfg.SessionID,
DataDir: cfg.DataDir,
RecordSessions: cfg.RecordSessions,
Namespace: cfg.Namespace,
ServerID: cfg.ServerID,
Clock: cfg.Clock,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &Forwarder{
ForwarderConfig: cfg,
sessionLogger: diskLogger,
}, nil
}
|
[
"func",
"NewForwarder",
"(",
"cfg",
"ForwarderConfig",
")",
"(",
"*",
"Forwarder",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"diskLogger",
",",
"err",
":=",
"NewDiskSessionLogger",
"(",
"DiskSessionLoggerConfig",
"{",
"SessionID",
":",
"cfg",
".",
"SessionID",
",",
"DataDir",
":",
"cfg",
".",
"DataDir",
",",
"RecordSessions",
":",
"cfg",
".",
"RecordSessions",
",",
"Namespace",
":",
"cfg",
".",
"Namespace",
",",
"ServerID",
":",
"cfg",
".",
"ServerID",
",",
"Clock",
":",
"cfg",
".",
"Clock",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"Forwarder",
"{",
"ForwarderConfig",
":",
"cfg",
",",
"sessionLogger",
":",
"diskLogger",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewForwarder returns a new instance of session forwarder
|
[
"NewForwarder",
"returns",
"a",
"new",
"instance",
"of",
"session",
"forwarder"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/forward.go#L71-L90
|
train
|
gravitational/teleport
|
lib/events/forward.go
|
Close
|
func (l *Forwarder) Close() error {
l.Lock()
defer l.Unlock()
if l.isClosed {
return nil
}
l.isClosed = true
return l.sessionLogger.Finalize()
}
|
go
|
func (l *Forwarder) Close() error {
l.Lock()
defer l.Unlock()
if l.isClosed {
return nil
}
l.isClosed = true
return l.sessionLogger.Finalize()
}
|
[
"func",
"(",
"l",
"*",
"Forwarder",
")",
"Close",
"(",
")",
"error",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"if",
"l",
".",
"isClosed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"l",
".",
"isClosed",
"=",
"true",
"\n",
"return",
"l",
".",
"sessionLogger",
".",
"Finalize",
"(",
")",
"\n",
"}"
] |
// Closer releases connection and resources associated with log if any
|
[
"Closer",
"releases",
"connection",
"and",
"resources",
"associated",
"with",
"log",
"if",
"any"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/forward.go#L104-L112
|
train
|
gravitational/teleport
|
lib/events/forward.go
|
WaitForDelivery
|
func (l *Forwarder) WaitForDelivery(ctx context.Context) error {
return l.ForwardTo.WaitForDelivery(ctx)
}
|
go
|
func (l *Forwarder) WaitForDelivery(ctx context.Context) error {
return l.ForwardTo.WaitForDelivery(ctx)
}
|
[
"func",
"(",
"l",
"*",
"Forwarder",
")",
"WaitForDelivery",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"return",
"l",
".",
"ForwardTo",
".",
"WaitForDelivery",
"(",
"ctx",
")",
"\n",
"}"
] |
// WaitForDelivery waits for resources to be released and outstanding requests to
// complete after calling Close method
|
[
"WaitForDelivery",
"waits",
"for",
"resources",
"to",
"be",
"released",
"and",
"outstanding",
"requests",
"to",
"complete",
"after",
"calling",
"Close",
"method"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/events/forward.go#L241-L243
|
train
|
gravitational/teleport
|
lib/backend/legacy/boltbk/boltbk.go
|
Exists
|
func Exists(path string) (bool, error) {
path, err := filepath.Abs(filepath.Join(path, keysBoltFile))
if err != nil {
return false, trace.Wrap(err)
}
f, err := os.Open(path)
err = trace.ConvertSystemError(err)
if err != nil {
if trace.IsNotFound(err) {
return false, nil
}
return false, trace.Wrap(err)
}
defer f.Close()
return true, nil
}
|
go
|
func Exists(path string) (bool, error) {
path, err := filepath.Abs(filepath.Join(path, keysBoltFile))
if err != nil {
return false, trace.Wrap(err)
}
f, err := os.Open(path)
err = trace.ConvertSystemError(err)
if err != nil {
if trace.IsNotFound(err) {
return false, nil
}
return false, trace.Wrap(err)
}
defer f.Close()
return true, nil
}
|
[
"func",
"Exists",
"(",
"path",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"path",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"keysBoltFile",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"err",
"=",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"return",
"false",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] |
// Exists returns true if backend has been used before
|
[
"Exists",
"returns",
"true",
"if",
"backend",
"has",
"been",
"used",
"before"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/boltbk/boltbk.go#L66-L81
|
train
|
gravitational/teleport
|
lib/backend/legacy/boltbk/boltbk.go
|
New
|
func New(params legacy.Params) (*BoltBackend, error) {
// look at 'path' parameter, if it's missing use 'data_dir' (default):
path := params.GetString("path")
if len(path) == 0 {
path = params.GetString(teleport.DataDirParameterName)
}
// still nothing? return an error:
if path == "" {
return nil, trace.BadParameter("BoltDB backend: 'path' is not set")
}
if !utils.IsDir(path) {
return nil, trace.BadParameter("%v is not a valid directory", path)
}
path, err := filepath.Abs(filepath.Join(path, keysBoltFile))
if err != nil {
return nil, trace.Wrap(err)
}
db, err := bolt.Open(path, openFileMode, &bolt.Options{Timeout: openTimeout})
if err != nil {
if err == bolt.ErrTimeout {
return nil, trace.Errorf("Local storage is locked. Another instance is running? (%v)", path)
}
return nil, trace.Wrap(err)
}
// Wrap the backend in a input sanitizer and return it.
return &BoltBackend{
locks: make(map[string]time.Time),
clock: clockwork.NewRealClock(),
db: db,
}, nil
}
|
go
|
func New(params legacy.Params) (*BoltBackend, error) {
// look at 'path' parameter, if it's missing use 'data_dir' (default):
path := params.GetString("path")
if len(path) == 0 {
path = params.GetString(teleport.DataDirParameterName)
}
// still nothing? return an error:
if path == "" {
return nil, trace.BadParameter("BoltDB backend: 'path' is not set")
}
if !utils.IsDir(path) {
return nil, trace.BadParameter("%v is not a valid directory", path)
}
path, err := filepath.Abs(filepath.Join(path, keysBoltFile))
if err != nil {
return nil, trace.Wrap(err)
}
db, err := bolt.Open(path, openFileMode, &bolt.Options{Timeout: openTimeout})
if err != nil {
if err == bolt.ErrTimeout {
return nil, trace.Errorf("Local storage is locked. Another instance is running? (%v)", path)
}
return nil, trace.Wrap(err)
}
// Wrap the backend in a input sanitizer and return it.
return &BoltBackend{
locks: make(map[string]time.Time),
clock: clockwork.NewRealClock(),
db: db,
}, nil
}
|
[
"func",
"New",
"(",
"params",
"legacy",
".",
"Params",
")",
"(",
"*",
"BoltBackend",
",",
"error",
")",
"{",
"path",
":=",
"params",
".",
"GetString",
"(",
"\"path\"",
")",
"\n",
"if",
"len",
"(",
"path",
")",
"==",
"0",
"{",
"path",
"=",
"params",
".",
"GetString",
"(",
"teleport",
".",
"DataDirParameterName",
")",
"\n",
"}",
"\n",
"if",
"path",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"BoltDB backend: 'path' is not set\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"utils",
".",
"IsDir",
"(",
"path",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"%v is not a valid directory\"",
",",
"path",
")",
"\n",
"}",
"\n",
"path",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"keysBoltFile",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"db",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"path",
",",
"openFileMode",
",",
"&",
"bolt",
".",
"Options",
"{",
"Timeout",
":",
"openTimeout",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"bolt",
".",
"ErrTimeout",
"{",
"return",
"nil",
",",
"trace",
".",
"Errorf",
"(",
"\"Local storage is locked. Another instance is running? (%v)\"",
",",
"path",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"BoltBackend",
"{",
"locks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"time",
".",
"Time",
")",
",",
"clock",
":",
"clockwork",
".",
"NewRealClock",
"(",
")",
",",
"db",
":",
"db",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// New initializes and returns a fully created BoltDB backend. It's
// a properly implemented Backend.NewFunc, part of a backend API
|
[
"New",
"initializes",
"and",
"returns",
"a",
"fully",
"created",
"BoltDB",
"backend",
".",
"It",
"s",
"a",
"properly",
"implemented",
"Backend",
".",
"NewFunc",
"part",
"of",
"a",
"backend",
"API"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/boltbk/boltbk.go#L85-L117
|
train
|
gravitational/teleport
|
lib/backend/legacy/boltbk/boltbk.go
|
GetItems
|
func (b *BoltBackend) GetItems(path []string, opts ...legacy.OpOption) ([]legacy.Item, error) {
cfg, err := legacy.CollectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.Recursive {
return b.getItemsRecursive(path)
}
keys, err := b.GetKeys(path)
if err != nil {
return nil, trace.Wrap(err)
}
// This is a very inefficient approach. It's here to satisfy the
// backend.Backend interface since the Bolt backend is slated for removal
// in 2.7.0 anyway.
items := make([]legacy.Item, 0, len(keys))
for _, e := range keys {
val, err := b.GetVal(path, e)
if err != nil {
continue
}
items = append(items, legacy.Item{
Key: e,
Value: val,
})
}
return items, nil
}
|
go
|
func (b *BoltBackend) GetItems(path []string, opts ...legacy.OpOption) ([]legacy.Item, error) {
cfg, err := legacy.CollectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.Recursive {
return b.getItemsRecursive(path)
}
keys, err := b.GetKeys(path)
if err != nil {
return nil, trace.Wrap(err)
}
// This is a very inefficient approach. It's here to satisfy the
// backend.Backend interface since the Bolt backend is slated for removal
// in 2.7.0 anyway.
items := make([]legacy.Item, 0, len(keys))
for _, e := range keys {
val, err := b.GetVal(path, e)
if err != nil {
continue
}
items = append(items, legacy.Item{
Key: e,
Value: val,
})
}
return items, nil
}
|
[
"func",
"(",
"b",
"*",
"BoltBackend",
")",
"GetItems",
"(",
"path",
"[",
"]",
"string",
",",
"opts",
"...",
"legacy",
".",
"OpOption",
")",
"(",
"[",
"]",
"legacy",
".",
"Item",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"legacy",
".",
"CollectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Recursive",
"{",
"return",
"b",
".",
"getItemsRecursive",
"(",
"path",
")",
"\n",
"}",
"\n",
"keys",
",",
"err",
":=",
"b",
".",
"GetKeys",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"legacy",
".",
"Item",
",",
"0",
",",
"len",
"(",
"keys",
")",
")",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"keys",
"{",
"val",
",",
"err",
":=",
"b",
".",
"GetVal",
"(",
"path",
",",
"e",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"items",
"=",
"append",
"(",
"items",
",",
"legacy",
".",
"Item",
"{",
"Key",
":",
"e",
",",
"Value",
":",
"val",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] |
// GetItems fetches keys and values and returns them to the caller.
|
[
"GetItems",
"fetches",
"keys",
"and",
"values",
"and",
"returns",
"them",
"to",
"the",
"caller",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/boltbk/boltbk.go#L278-L309
|
train
|
gravitational/teleport
|
lib/backend/legacy/boltbk/boltbk.go
|
CompareAndSwapVal
|
func (b *BoltBackend) CompareAndSwapVal(bucket []string, key string, newData []byte, prevData []byte, ttl time.Duration) error {
if len(prevData) == 0 {
return trace.BadParameter("missing prevData parameter, to atomically create item, use CreateVal method")
}
v := &kv{
Created: b.clock.Now().UTC(),
Value: newData,
TTL: ttl,
}
newEncodedData, err := json.Marshal(v)
if err != nil {
return trace.Wrap(err)
}
err = b.db.Update(func(tx *bolt.Tx) error {
bkt, err := GetBucket(tx, bucket)
if err != nil {
if trace.IsNotFound(err) {
return trace.CompareFailed("key %q is not found", key)
}
return trace.Wrap(err)
}
currentData := bkt.Get([]byte(key))
if currentData == nil {
_, err := GetBucket(tx, append(bucket, key))
if err == nil {
return trace.BadParameter("key %q is a bucket", key)
}
return trace.CompareFailed("%v %v is not found", bucket, key)
}
var currentVal kv
if err := json.Unmarshal(currentData, ¤tVal); err != nil {
return trace.Wrap(err)
}
if bytes.Compare(prevData, currentVal.Value) != 0 {
return trace.CompareFailed("%q is not matching expected value", key)
}
return boltErr(bkt.Put([]byte(key), newEncodedData))
})
return trace.Wrap(err)
}
|
go
|
func (b *BoltBackend) CompareAndSwapVal(bucket []string, key string, newData []byte, prevData []byte, ttl time.Duration) error {
if len(prevData) == 0 {
return trace.BadParameter("missing prevData parameter, to atomically create item, use CreateVal method")
}
v := &kv{
Created: b.clock.Now().UTC(),
Value: newData,
TTL: ttl,
}
newEncodedData, err := json.Marshal(v)
if err != nil {
return trace.Wrap(err)
}
err = b.db.Update(func(tx *bolt.Tx) error {
bkt, err := GetBucket(tx, bucket)
if err != nil {
if trace.IsNotFound(err) {
return trace.CompareFailed("key %q is not found", key)
}
return trace.Wrap(err)
}
currentData := bkt.Get([]byte(key))
if currentData == nil {
_, err := GetBucket(tx, append(bucket, key))
if err == nil {
return trace.BadParameter("key %q is a bucket", key)
}
return trace.CompareFailed("%v %v is not found", bucket, key)
}
var currentVal kv
if err := json.Unmarshal(currentData, ¤tVal); err != nil {
return trace.Wrap(err)
}
if bytes.Compare(prevData, currentVal.Value) != 0 {
return trace.CompareFailed("%q is not matching expected value", key)
}
return boltErr(bkt.Put([]byte(key), newEncodedData))
})
return trace.Wrap(err)
}
|
[
"func",
"(",
"b",
"*",
"BoltBackend",
")",
"CompareAndSwapVal",
"(",
"bucket",
"[",
"]",
"string",
",",
"key",
"string",
",",
"newData",
"[",
"]",
"byte",
",",
"prevData",
"[",
"]",
"byte",
",",
"ttl",
"time",
".",
"Duration",
")",
"error",
"{",
"if",
"len",
"(",
"prevData",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing prevData parameter, to atomically create item, use CreateVal method\"",
")",
"\n",
"}",
"\n",
"v",
":=",
"&",
"kv",
"{",
"Created",
":",
"b",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"Value",
":",
"newData",
",",
"TTL",
":",
"ttl",
",",
"}",
"\n",
"newEncodedData",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"b",
".",
"db",
".",
"Update",
"(",
"func",
"(",
"tx",
"*",
"bolt",
".",
"Tx",
")",
"error",
"{",
"bkt",
",",
"err",
":=",
"GetBucket",
"(",
"tx",
",",
"bucket",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"CompareFailed",
"(",
"\"key %q is not found\"",
",",
"key",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"currentData",
":=",
"bkt",
".",
"Get",
"(",
"[",
"]",
"byte",
"(",
"key",
")",
")",
"\n",
"if",
"currentData",
"==",
"nil",
"{",
"_",
",",
"err",
":=",
"GetBucket",
"(",
"tx",
",",
"append",
"(",
"bucket",
",",
"key",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"key %q is a bucket\"",
",",
"key",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"CompareFailed",
"(",
"\"%v %v is not found\"",
",",
"bucket",
",",
"key",
")",
"\n",
"}",
"\n",
"var",
"currentVal",
"kv",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"currentData",
",",
"&",
"currentVal",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"bytes",
".",
"Compare",
"(",
"prevData",
",",
"currentVal",
".",
"Value",
")",
"!=",
"0",
"{",
"return",
"trace",
".",
"CompareFailed",
"(",
"\"%q is not matching expected value\"",
",",
"key",
")",
"\n",
"}",
"\n",
"return",
"boltErr",
"(",
"bkt",
".",
"Put",
"(",
"[",
"]",
"byte",
"(",
"key",
")",
",",
"newEncodedData",
")",
")",
"\n",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// CompareAndSwapVal compares and swap values in atomic operation,
// succeeds if prevData matches the value stored in the databases,
// requires prevData as a non-empty value. Returns trace.CompareFailed
// in case if value did not match
|
[
"CompareAndSwapVal",
"compares",
"and",
"swap",
"values",
"in",
"atomic",
"operation",
"succeeds",
"if",
"prevData",
"matches",
"the",
"value",
"stored",
"in",
"the",
"databases",
"requires",
"prevData",
"as",
"a",
"non",
"-",
"empty",
"value",
".",
"Returns",
"trace",
".",
"CompareFailed",
"in",
"case",
"if",
"value",
"did",
"not",
"match"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/legacy/boltbk/boltbk.go#L357-L396
|
train
|
gravitational/teleport
|
lib/services/invite.go
|
NewInviteToken
|
func NewInviteToken(token, signupURL string, expires time.Time) *InviteTokenV3 {
tok := InviteTokenV3{
Kind: KindInviteToken,
Version: V3,
Metadata: Metadata{
Name: token,
},
Spec: InviteTokenSpecV3{
URL: signupURL,
},
}
if !expires.IsZero() {
tok.Metadata.SetExpiry(expires)
}
return &tok
}
|
go
|
func NewInviteToken(token, signupURL string, expires time.Time) *InviteTokenV3 {
tok := InviteTokenV3{
Kind: KindInviteToken,
Version: V3,
Metadata: Metadata{
Name: token,
},
Spec: InviteTokenSpecV3{
URL: signupURL,
},
}
if !expires.IsZero() {
tok.Metadata.SetExpiry(expires)
}
return &tok
}
|
[
"func",
"NewInviteToken",
"(",
"token",
",",
"signupURL",
"string",
",",
"expires",
"time",
".",
"Time",
")",
"*",
"InviteTokenV3",
"{",
"tok",
":=",
"InviteTokenV3",
"{",
"Kind",
":",
"KindInviteToken",
",",
"Version",
":",
"V3",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"token",
",",
"}",
",",
"Spec",
":",
"InviteTokenSpecV3",
"{",
"URL",
":",
"signupURL",
",",
"}",
",",
"}",
"\n",
"if",
"!",
"expires",
".",
"IsZero",
"(",
")",
"{",
"tok",
".",
"Metadata",
".",
"SetExpiry",
"(",
"expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"tok",
"\n",
"}"
] |
// NewInviteToken returns a new instance of the invite token
|
[
"NewInviteToken",
"returns",
"a",
"new",
"instance",
"of",
"the",
"invite",
"token"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/invite.go#L48-L63
|
train
|
gravitational/teleport
|
lib/sshutils/scp/http.go
|
CreateHTTPUpload
|
func CreateHTTPUpload(req HTTPTransferRequest) (Command, error) {
if req.HTTPRequest == nil {
return nil, trace.BadParameter("missing parameter HTTPRequest")
}
if req.FileName == "" {
return nil, trace.BadParameter("missing file name")
}
if req.RemoteLocation == "" {
return nil, trace.BadParameter("missing remote location")
}
contentLength := req.HTTPRequest.Header.Get("Content-Length")
fileSize, err := strconv.ParseInt(contentLength, 10, 0)
if err != nil {
return nil, trace.BadParameter("failed to parse Content-Length header: %q", contentLength)
}
fs := &httpFileSystem{
reader: req.HTTPRequest.Body,
fileName: req.FileName,
fileSize: fileSize,
}
flags := Flags{
// scp treats it as a list of files to upload
Target: []string{req.FileName},
}
cfg := Config{
Flags: flags,
FileSystem: fs,
User: req.User,
ProgressWriter: req.Progress,
RemoteLocation: req.RemoteLocation,
AuditLog: req.AuditLog,
}
cmd, err := CreateUploadCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
}
|
go
|
func CreateHTTPUpload(req HTTPTransferRequest) (Command, error) {
if req.HTTPRequest == nil {
return nil, trace.BadParameter("missing parameter HTTPRequest")
}
if req.FileName == "" {
return nil, trace.BadParameter("missing file name")
}
if req.RemoteLocation == "" {
return nil, trace.BadParameter("missing remote location")
}
contentLength := req.HTTPRequest.Header.Get("Content-Length")
fileSize, err := strconv.ParseInt(contentLength, 10, 0)
if err != nil {
return nil, trace.BadParameter("failed to parse Content-Length header: %q", contentLength)
}
fs := &httpFileSystem{
reader: req.HTTPRequest.Body,
fileName: req.FileName,
fileSize: fileSize,
}
flags := Flags{
// scp treats it as a list of files to upload
Target: []string{req.FileName},
}
cfg := Config{
Flags: flags,
FileSystem: fs,
User: req.User,
ProgressWriter: req.Progress,
RemoteLocation: req.RemoteLocation,
AuditLog: req.AuditLog,
}
cmd, err := CreateUploadCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
}
|
[
"func",
"CreateHTTPUpload",
"(",
"req",
"HTTPTransferRequest",
")",
"(",
"Command",
",",
"error",
")",
"{",
"if",
"req",
".",
"HTTPRequest",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter HTTPRequest\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"FileName",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing file name\"",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"RemoteLocation",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing remote location\"",
")",
"\n",
"}",
"\n",
"contentLength",
":=",
"req",
".",
"HTTPRequest",
".",
"Header",
".",
"Get",
"(",
"\"Content-Length\"",
")",
"\n",
"fileSize",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"contentLength",
",",
"10",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse Content-Length header: %q\"",
",",
"contentLength",
")",
"\n",
"}",
"\n",
"fs",
":=",
"&",
"httpFileSystem",
"{",
"reader",
":",
"req",
".",
"HTTPRequest",
".",
"Body",
",",
"fileName",
":",
"req",
".",
"FileName",
",",
"fileSize",
":",
"fileSize",
",",
"}",
"\n",
"flags",
":=",
"Flags",
"{",
"Target",
":",
"[",
"]",
"string",
"{",
"req",
".",
"FileName",
"}",
",",
"}",
"\n",
"cfg",
":=",
"Config",
"{",
"Flags",
":",
"flags",
",",
"FileSystem",
":",
"fs",
",",
"User",
":",
"req",
".",
"User",
",",
"ProgressWriter",
":",
"req",
".",
"Progress",
",",
"RemoteLocation",
":",
"req",
".",
"RemoteLocation",
",",
"AuditLog",
":",
"req",
".",
"AuditLog",
",",
"}",
"\n",
"cmd",
",",
"err",
":=",
"CreateUploadCommand",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cmd",
",",
"nil",
"\n",
"}"
] |
// CreateHTTPUpload creates HTTP download command
|
[
"CreateHTTPUpload",
"creates",
"HTTP",
"download",
"command"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/http.go#L69-L114
|
train
|
gravitational/teleport
|
lib/sshutils/scp/http.go
|
CreateHTTPDownload
|
func CreateHTTPDownload(req HTTPTransferRequest) (Command, error) {
_, filename, err := req.parseRemoteLocation()
if err != nil {
return nil, trace.Wrap(err)
}
flags := Flags{
Target: []string{filename},
}
cfg := Config{
Flags: flags,
User: req.User,
ProgressWriter: req.Progress,
RemoteLocation: req.RemoteLocation,
FileSystem: &httpFileSystem{
writer: req.HTTPResponse,
},
}
cmd, err := CreateDownloadCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
}
|
go
|
func CreateHTTPDownload(req HTTPTransferRequest) (Command, error) {
_, filename, err := req.parseRemoteLocation()
if err != nil {
return nil, trace.Wrap(err)
}
flags := Flags{
Target: []string{filename},
}
cfg := Config{
Flags: flags,
User: req.User,
ProgressWriter: req.Progress,
RemoteLocation: req.RemoteLocation,
FileSystem: &httpFileSystem{
writer: req.HTTPResponse,
},
}
cmd, err := CreateDownloadCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
}
|
[
"func",
"CreateHTTPDownload",
"(",
"req",
"HTTPTransferRequest",
")",
"(",
"Command",
",",
"error",
")",
"{",
"_",
",",
"filename",
",",
"err",
":=",
"req",
".",
"parseRemoteLocation",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"flags",
":=",
"Flags",
"{",
"Target",
":",
"[",
"]",
"string",
"{",
"filename",
"}",
",",
"}",
"\n",
"cfg",
":=",
"Config",
"{",
"Flags",
":",
"flags",
",",
"User",
":",
"req",
".",
"User",
",",
"ProgressWriter",
":",
"req",
".",
"Progress",
",",
"RemoteLocation",
":",
"req",
".",
"RemoteLocation",
",",
"FileSystem",
":",
"&",
"httpFileSystem",
"{",
"writer",
":",
"req",
".",
"HTTPResponse",
",",
"}",
",",
"}",
"\n",
"cmd",
",",
"err",
":=",
"CreateDownloadCommand",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cmd",
",",
"nil",
"\n",
"}"
] |
// CreateHTTPDownload creates HTTP upload command
|
[
"CreateHTTPDownload",
"creates",
"HTTP",
"upload",
"command"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/http.go#L117-L143
|
train
|
gravitational/teleport
|
lib/sshutils/scp/http.go
|
MkDir
|
func (l *httpFileSystem) MkDir(path string, mode int) error {
return trace.BadParameter("directories are not supported in http file transfer")
}
|
go
|
func (l *httpFileSystem) MkDir(path string, mode int) error {
return trace.BadParameter("directories are not supported in http file transfer")
}
|
[
"func",
"(",
"l",
"*",
"httpFileSystem",
")",
"MkDir",
"(",
"path",
"string",
",",
"mode",
"int",
")",
"error",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"directories are not supported in http file transfer\"",
")",
"\n",
"}"
] |
// MkDir creates a directory. This method is not implemented as creating directories
// is not supported during HTTP downloads.
|
[
"MkDir",
"creates",
"a",
"directory",
".",
"This",
"method",
"is",
"not",
"implemented",
"as",
"creating",
"directories",
"is",
"not",
"supported",
"during",
"HTTP",
"downloads",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/http.go#L161-L163
|
train
|
gravitational/teleport
|
lib/sshutils/scp/http.go
|
OpenFile
|
func (l *httpFileSystem) OpenFile(filePath string) (io.ReadCloser, error) {
if l.reader == nil {
return nil, trace.BadParameter("missing reader")
}
return l.reader, nil
}
|
go
|
func (l *httpFileSystem) OpenFile(filePath string) (io.ReadCloser, error) {
if l.reader == nil {
return nil, trace.BadParameter("missing reader")
}
return l.reader, nil
}
|
[
"func",
"(",
"l",
"*",
"httpFileSystem",
")",
"OpenFile",
"(",
"filePath",
"string",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"if",
"l",
".",
"reader",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing reader\"",
")",
"\n",
"}",
"\n",
"return",
"l",
".",
"reader",
",",
"nil",
"\n",
"}"
] |
// OpenFile returns file reader
|
[
"OpenFile",
"returns",
"file",
"reader"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/http.go#L172-L178
|
train
|
gravitational/teleport
|
lib/sshutils/scp/http.go
|
CreateFile
|
func (l *httpFileSystem) CreateFile(filePath string, length uint64) (io.WriteCloser, error) {
_, filename := filepath.Split(filePath)
contentLength := strconv.FormatUint(length, 10)
header := l.writer.Header()
httplib.SetNoCacheHeaders(header)
httplib.SetNoSniff(header)
header.Set("Content-Length", contentLength)
header.Set("Content-Type", "application/octet-stream")
filename = url.QueryEscape(filename)
header.Set("Content-Disposition", fmt.Sprintf(`attachment;filename="%v"`, filename))
return &nopWriteCloser{Writer: l.writer}, nil
}
|
go
|
func (l *httpFileSystem) CreateFile(filePath string, length uint64) (io.WriteCloser, error) {
_, filename := filepath.Split(filePath)
contentLength := strconv.FormatUint(length, 10)
header := l.writer.Header()
httplib.SetNoCacheHeaders(header)
httplib.SetNoSniff(header)
header.Set("Content-Length", contentLength)
header.Set("Content-Type", "application/octet-stream")
filename = url.QueryEscape(filename)
header.Set("Content-Disposition", fmt.Sprintf(`attachment;filename="%v"`, filename))
return &nopWriteCloser{Writer: l.writer}, nil
}
|
[
"func",
"(",
"l",
"*",
"httpFileSystem",
")",
"CreateFile",
"(",
"filePath",
"string",
",",
"length",
"uint64",
")",
"(",
"io",
".",
"WriteCloser",
",",
"error",
")",
"{",
"_",
",",
"filename",
":=",
"filepath",
".",
"Split",
"(",
"filePath",
")",
"\n",
"contentLength",
":=",
"strconv",
".",
"FormatUint",
"(",
"length",
",",
"10",
")",
"\n",
"header",
":=",
"l",
".",
"writer",
".",
"Header",
"(",
")",
"\n",
"httplib",
".",
"SetNoCacheHeaders",
"(",
"header",
")",
"\n",
"httplib",
".",
"SetNoSniff",
"(",
"header",
")",
"\n",
"header",
".",
"Set",
"(",
"\"Content-Length\"",
",",
"contentLength",
")",
"\n",
"header",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"application/octet-stream\"",
")",
"\n",
"filename",
"=",
"url",
".",
"QueryEscape",
"(",
"filename",
")",
"\n",
"header",
".",
"Set",
"(",
"\"Content-Disposition\"",
",",
"fmt",
".",
"Sprintf",
"(",
"`attachment;filename=\"%v\"`",
",",
"filename",
")",
")",
"\n",
"return",
"&",
"nopWriteCloser",
"{",
"Writer",
":",
"l",
".",
"writer",
"}",
",",
"nil",
"\n",
"}"
] |
// CreateFile sets proper HTTP headers and returns HTTP writer to stream incoming
// file content
|
[
"CreateFile",
"sets",
"proper",
"HTTP",
"headers",
"and",
"returns",
"HTTP",
"writer",
"to",
"stream",
"incoming",
"file",
"content"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/http.go#L182-L195
|
train
|
gravitational/teleport
|
lib/sshutils/scp/http.go
|
GetFileInfo
|
func (l *httpFileSystem) GetFileInfo(filePath string) (FileInfo, error) {
return &httpFileInfo{
name: l.fileName,
path: l.fileName,
size: l.fileSize,
}, nil
}
|
go
|
func (l *httpFileSystem) GetFileInfo(filePath string) (FileInfo, error) {
return &httpFileInfo{
name: l.fileName,
path: l.fileName,
size: l.fileSize,
}, nil
}
|
[
"func",
"(",
"l",
"*",
"httpFileSystem",
")",
"GetFileInfo",
"(",
"filePath",
"string",
")",
"(",
"FileInfo",
",",
"error",
")",
"{",
"return",
"&",
"httpFileInfo",
"{",
"name",
":",
"l",
".",
"fileName",
",",
"path",
":",
"l",
".",
"fileName",
",",
"size",
":",
"l",
".",
"fileSize",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// GetFileInfo returns file information
|
[
"GetFileInfo",
"returns",
"file",
"information"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/sshutils/scp/http.go#L198-L204
|
train
|
gravitational/teleport
|
lib/utils/writer.go
|
Write
|
func (w *BroadcastWriter) Write(p []byte) (n int, err error) {
for _, writer := range w.writers {
n, err = writer.Write(p)
if err != nil {
return
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
}
|
go
|
func (w *BroadcastWriter) Write(p []byte) (n int, err error) {
for _, writer := range w.writers {
n, err = writer.Write(p)
if err != nil {
return
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
}
|
[
"func",
"(",
"w",
"*",
"BroadcastWriter",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"for",
"_",
",",
"writer",
":=",
"range",
"w",
".",
"writers",
"{",
"n",
",",
"err",
"=",
"writer",
".",
"Write",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"n",
"!=",
"len",
"(",
"p",
")",
"{",
"err",
"=",
"io",
".",
"ErrShortWrite",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"len",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] |
// Write multiplexes the input to multiple sub-writers. If any of the write
// fails, it won't attempt to write to other writers
|
[
"Write",
"multiplexes",
"the",
"input",
"to",
"multiple",
"sub",
"-",
"writers",
".",
"If",
"any",
"of",
"the",
"write",
"fails",
"it",
"won",
"t",
"attempt",
"to",
"write",
"to",
"other",
"writers"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/writer.go#L37-L49
|
train
|
gravitational/teleport
|
lib/backend/memory/memory.go
|
New
|
func New(cfg Config) (*Memory, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
buf, err := backend.NewCircularBuffer(ctx, cfg.BufferSize)
if err != nil {
cancel()
return nil, trace.Wrap(err)
}
m := &Memory{
Mutex: &sync.Mutex{},
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentMemory,
}),
Config: cfg,
tree: btree.New(cfg.BTreeDegree),
heap: newMinHeap(),
cancel: cancel,
ctx: ctx,
buf: buf,
}
return m, nil
}
|
go
|
func New(cfg Config) (*Memory, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
buf, err := backend.NewCircularBuffer(ctx, cfg.BufferSize)
if err != nil {
cancel()
return nil, trace.Wrap(err)
}
m := &Memory{
Mutex: &sync.Mutex{},
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentMemory,
}),
Config: cfg,
tree: btree.New(cfg.BTreeDegree),
heap: newMinHeap(),
cancel: cancel,
ctx: ctx,
buf: buf,
}
return m, nil
}
|
[
"func",
"New",
"(",
"cfg",
"Config",
")",
"(",
"*",
"Memory",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"cfg",
".",
"Context",
")",
"\n",
"buf",
",",
"err",
":=",
"backend",
".",
"NewCircularBuffer",
"(",
"ctx",
",",
"cfg",
".",
"BufferSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cancel",
"(",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"m",
":=",
"&",
"Memory",
"{",
"Mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentMemory",
",",
"}",
")",
",",
"Config",
":",
"cfg",
",",
"tree",
":",
"btree",
".",
"New",
"(",
"cfg",
".",
"BTreeDegree",
")",
",",
"heap",
":",
"newMinHeap",
"(",
")",
",",
"cancel",
":",
"cancel",
",",
"ctx",
":",
"ctx",
",",
"buf",
":",
"buf",
",",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// New creates a new memory backend
|
[
"New",
"creates",
"a",
"new",
"memory",
"backend"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/memory/memory.go#L83-L106
|
train
|
gravitational/teleport
|
lib/backend/memory/memory.go
|
Close
|
func (m *Memory) Close() error {
m.cancel()
m.Lock()
defer m.Unlock()
m.buf.Close()
return nil
}
|
go
|
func (m *Memory) Close() error {
m.cancel()
m.Lock()
defer m.Unlock()
m.buf.Close()
return nil
}
|
[
"func",
"(",
"m",
"*",
"Memory",
")",
"Close",
"(",
")",
"error",
"{",
"m",
".",
"cancel",
"(",
")",
"\n",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"buf",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close closes memory backend
|
[
"Close",
"closes",
"memory",
"backend"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/memory/memory.go#L128-L134
|
train
|
gravitational/teleport
|
lib/backend/memory/memory.go
|
Update
|
func (m *Memory) Update(ctx context.Context, i backend.Item) (*backend.Lease, error) {
if len(i.Key) == 0 {
return nil, trace.BadParameter("missing parameter key")
}
m.Lock()
defer m.Unlock()
m.removeExpired()
if m.tree.Get(&btreeItem{Item: i}) == nil {
return nil, trace.NotFound("key %q is not found", string(i.Key))
}
if !m.Mirror {
i.ID = m.generateID()
}
event := backend.Event{
Type: backend.OpPut,
Item: i,
}
m.processEvent(event)
if !m.EventsOff {
m.buf.Push(event)
}
return m.newLease(i), nil
}
|
go
|
func (m *Memory) Update(ctx context.Context, i backend.Item) (*backend.Lease, error) {
if len(i.Key) == 0 {
return nil, trace.BadParameter("missing parameter key")
}
m.Lock()
defer m.Unlock()
m.removeExpired()
if m.tree.Get(&btreeItem{Item: i}) == nil {
return nil, trace.NotFound("key %q is not found", string(i.Key))
}
if !m.Mirror {
i.ID = m.generateID()
}
event := backend.Event{
Type: backend.OpPut,
Item: i,
}
m.processEvent(event)
if !m.EventsOff {
m.buf.Push(event)
}
return m.newLease(i), nil
}
|
[
"func",
"(",
"m",
"*",
"Memory",
")",
"Update",
"(",
"ctx",
"context",
".",
"Context",
",",
"i",
"backend",
".",
"Item",
")",
"(",
"*",
"backend",
".",
"Lease",
",",
"error",
")",
"{",
"if",
"len",
"(",
"i",
".",
"Key",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter key\"",
")",
"\n",
"}",
"\n",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"removeExpired",
"(",
")",
"\n",
"if",
"m",
".",
"tree",
".",
"Get",
"(",
"&",
"btreeItem",
"{",
"Item",
":",
"i",
"}",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"key %q is not found\"",
",",
"string",
"(",
"i",
".",
"Key",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"m",
".",
"Mirror",
"{",
"i",
".",
"ID",
"=",
"m",
".",
"generateID",
"(",
")",
"\n",
"}",
"\n",
"event",
":=",
"backend",
".",
"Event",
"{",
"Type",
":",
"backend",
".",
"OpPut",
",",
"Item",
":",
"i",
",",
"}",
"\n",
"m",
".",
"processEvent",
"(",
"event",
")",
"\n",
"if",
"!",
"m",
".",
"EventsOff",
"{",
"m",
".",
"buf",
".",
"Push",
"(",
"event",
")",
"\n",
"}",
"\n",
"return",
"m",
".",
"newLease",
"(",
"i",
")",
",",
"nil",
"\n",
"}"
] |
// Update updates item if it exists, or returns NotFound error
|
[
"Update",
"updates",
"item",
"if",
"it",
"exists",
"or",
"returns",
"NotFound",
"error"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/memory/memory.go#L182-L204
|
train
|
gravitational/teleport
|
lib/backend/memory/memory.go
|
CompareAndSwap
|
func (m *Memory) CompareAndSwap(ctx context.Context, expected backend.Item, replaceWith backend.Item) (*backend.Lease, error) {
if len(expected.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if len(replaceWith.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if bytes.Compare(expected.Key, replaceWith.Key) != 0 {
return nil, trace.BadParameter("expected and replaceWith keys should match")
}
m.Lock()
defer m.Unlock()
m.removeExpired()
i := m.tree.Get(&btreeItem{Item: expected})
if i == nil {
return nil, trace.CompareFailed("key %q is not found", string(expected.Key))
}
existingItem := i.(*btreeItem).Item
if bytes.Compare(existingItem.Value, expected.Value) != 0 {
return nil, trace.CompareFailed("current value does not match expected for %v", string(expected.Key))
}
event := backend.Event{
Type: backend.OpPut,
Item: replaceWith,
}
m.processEvent(event)
if !m.EventsOff {
m.buf.Push(event)
}
return m.newLease(replaceWith), nil
}
|
go
|
func (m *Memory) CompareAndSwap(ctx context.Context, expected backend.Item, replaceWith backend.Item) (*backend.Lease, error) {
if len(expected.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if len(replaceWith.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if bytes.Compare(expected.Key, replaceWith.Key) != 0 {
return nil, trace.BadParameter("expected and replaceWith keys should match")
}
m.Lock()
defer m.Unlock()
m.removeExpired()
i := m.tree.Get(&btreeItem{Item: expected})
if i == nil {
return nil, trace.CompareFailed("key %q is not found", string(expected.Key))
}
existingItem := i.(*btreeItem).Item
if bytes.Compare(existingItem.Value, expected.Value) != 0 {
return nil, trace.CompareFailed("current value does not match expected for %v", string(expected.Key))
}
event := backend.Event{
Type: backend.OpPut,
Item: replaceWith,
}
m.processEvent(event)
if !m.EventsOff {
m.buf.Push(event)
}
return m.newLease(replaceWith), nil
}
|
[
"func",
"(",
"m",
"*",
"Memory",
")",
"CompareAndSwap",
"(",
"ctx",
"context",
".",
"Context",
",",
"expected",
"backend",
".",
"Item",
",",
"replaceWith",
"backend",
".",
"Item",
")",
"(",
"*",
"backend",
".",
"Lease",
",",
"error",
")",
"{",
"if",
"len",
"(",
"expected",
".",
"Key",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Key\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"replaceWith",
".",
"Key",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Key\"",
")",
"\n",
"}",
"\n",
"if",
"bytes",
".",
"Compare",
"(",
"expected",
".",
"Key",
",",
"replaceWith",
".",
"Key",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"expected and replaceWith keys should match\"",
")",
"\n",
"}",
"\n",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"removeExpired",
"(",
")",
"\n",
"i",
":=",
"m",
".",
"tree",
".",
"Get",
"(",
"&",
"btreeItem",
"{",
"Item",
":",
"expected",
"}",
")",
"\n",
"if",
"i",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"CompareFailed",
"(",
"\"key %q is not found\"",
",",
"string",
"(",
"expected",
".",
"Key",
")",
")",
"\n",
"}",
"\n",
"existingItem",
":=",
"i",
".",
"(",
"*",
"btreeItem",
")",
".",
"Item",
"\n",
"if",
"bytes",
".",
"Compare",
"(",
"existingItem",
".",
"Value",
",",
"expected",
".",
"Value",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"CompareFailed",
"(",
"\"current value does not match expected for %v\"",
",",
"string",
"(",
"expected",
".",
"Key",
")",
")",
"\n",
"}",
"\n",
"event",
":=",
"backend",
".",
"Event",
"{",
"Type",
":",
"backend",
".",
"OpPut",
",",
"Item",
":",
"replaceWith",
",",
"}",
"\n",
"m",
".",
"processEvent",
"(",
"event",
")",
"\n",
"if",
"!",
"m",
".",
"EventsOff",
"{",
"m",
".",
"buf",
".",
"Push",
"(",
"event",
")",
"\n",
"}",
"\n",
"return",
"m",
".",
"newLease",
"(",
"replaceWith",
")",
",",
"nil",
"\n",
"}"
] |
// CompareAndSwap compares item with existing item and replaces it with replaceWith item
|
[
"CompareAndSwap",
"compares",
"item",
"with",
"existing",
"item",
"and",
"replaces",
"it",
"with",
"replaceWith",
"item"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/memory/memory.go#L344-L374
|
train
|
gravitational/teleport
|
lib/backend/memory/memory.go
|
removeExpired
|
func (m *Memory) removeExpired() int {
removed := 0
now := m.Clock().Now().UTC()
for {
if len(*m.heap) == 0 {
break
}
item := m.heap.PeekEl()
if now.Before(item.Expires) {
break
}
m.heap.PopEl()
m.tree.Delete(item)
m.Debugf("Removed expired %v %v item.", string(item.Key), item.Expires)
removed++
}
if removed > 0 {
m.Debugf("Removed %v expired items.", removed)
}
return removed
}
|
go
|
func (m *Memory) removeExpired() int {
removed := 0
now := m.Clock().Now().UTC()
for {
if len(*m.heap) == 0 {
break
}
item := m.heap.PeekEl()
if now.Before(item.Expires) {
break
}
m.heap.PopEl()
m.tree.Delete(item)
m.Debugf("Removed expired %v %v item.", string(item.Key), item.Expires)
removed++
}
if removed > 0 {
m.Debugf("Removed %v expired items.", removed)
}
return removed
}
|
[
"func",
"(",
"m",
"*",
"Memory",
")",
"removeExpired",
"(",
")",
"int",
"{",
"removed",
":=",
"0",
"\n",
"now",
":=",
"m",
".",
"Clock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"for",
"{",
"if",
"len",
"(",
"*",
"m",
".",
"heap",
")",
"==",
"0",
"{",
"break",
"\n",
"}",
"\n",
"item",
":=",
"m",
".",
"heap",
".",
"PeekEl",
"(",
")",
"\n",
"if",
"now",
".",
"Before",
"(",
"item",
".",
"Expires",
")",
"{",
"break",
"\n",
"}",
"\n",
"m",
".",
"heap",
".",
"PopEl",
"(",
")",
"\n",
"m",
".",
"tree",
".",
"Delete",
"(",
"item",
")",
"\n",
"m",
".",
"Debugf",
"(",
"\"Removed expired %v %v item.\"",
",",
"string",
"(",
"item",
".",
"Key",
")",
",",
"item",
".",
"Expires",
")",
"\n",
"removed",
"++",
"\n",
"}",
"\n",
"if",
"removed",
">",
"0",
"{",
"m",
".",
"Debugf",
"(",
"\"Removed %v expired items.\"",
",",
"removed",
")",
"\n",
"}",
"\n",
"return",
"removed",
"\n",
"}"
] |
// removeExpired makes a pass through map and removes expired elements
// returns the number of expired elements removed
|
[
"removeExpired",
"makes",
"a",
"pass",
"through",
"map",
"and",
"removes",
"expired",
"elements",
"returns",
"the",
"number",
"of",
"expired",
"elements",
"removed"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/backend/memory/memory.go#L412-L432
|
train
|
gravitational/teleport
|
lib/session/session.go
|
Set
|
func (s *ID) Set(v string) error {
id, err := ParseID(v)
if err != nil {
return trace.Wrap(err)
}
*s = *id
return nil
}
|
go
|
func (s *ID) Set(v string) error {
id, err := ParseID(v)
if err != nil {
return trace.Wrap(err)
}
*s = *id
return nil
}
|
[
"func",
"(",
"s",
"*",
"ID",
")",
"Set",
"(",
"v",
"string",
")",
"error",
"{",
"id",
",",
"err",
":=",
"ParseID",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"*",
"s",
"=",
"*",
"id",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Set makes ID cli compatible, lets to set value from string
|
[
"Set",
"makes",
"ID",
"cli",
"compatible",
"lets",
"to",
"set",
"value",
"from",
"string"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L58-L65
|
train
|
gravitational/teleport
|
lib/session/session.go
|
Time
|
func (s *ID) Time() time.Time {
tm, ok := s.UUID().Time()
if !ok {
return time.Time{}
}
sec, nsec := tm.UnixTime()
return time.Unix(sec, nsec).UTC()
}
|
go
|
func (s *ID) Time() time.Time {
tm, ok := s.UUID().Time()
if !ok {
return time.Time{}
}
sec, nsec := tm.UnixTime()
return time.Unix(sec, nsec).UTC()
}
|
[
"func",
"(",
"s",
"*",
"ID",
")",
"Time",
"(",
")",
"time",
".",
"Time",
"{",
"tm",
",",
"ok",
":=",
"s",
".",
"UUID",
"(",
")",
".",
"Time",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n",
"sec",
",",
"nsec",
":=",
"tm",
".",
"UnixTime",
"(",
")",
"\n",
"return",
"time",
".",
"Unix",
"(",
"sec",
",",
"nsec",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] |
// Time returns time portion of this ID
|
[
"Time",
"returns",
"time",
"portion",
"of",
"this",
"ID"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L68-L75
|
train
|
gravitational/teleport
|
lib/session/session.go
|
Check
|
func (s *ID) Check() error {
_, err := ParseID(string(*s))
return trace.Wrap(err)
}
|
go
|
func (s *ID) Check() error {
_, err := ParseID(string(*s))
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"ID",
")",
"Check",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"ParseID",
"(",
"string",
"(",
"*",
"s",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// Check checks if it's a valid UUID
|
[
"Check",
"checks",
"if",
"it",
"s",
"a",
"valid",
"UUID"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L78-L81
|
train
|
gravitational/teleport
|
lib/session/session.go
|
ParseID
|
func ParseID(id string) (*ID, error) {
val := uuid.Parse(id)
if val == nil {
return nil, trace.BadParameter("'%v' is not a valid Time UUID v1", id)
}
if ver, ok := val.Version(); !ok || ver != 1 {
return nil, trace.BadParameter("'%v' is not a be a valid Time UUID v1", id)
}
uid := ID(id)
return &uid, nil
}
|
go
|
func ParseID(id string) (*ID, error) {
val := uuid.Parse(id)
if val == nil {
return nil, trace.BadParameter("'%v' is not a valid Time UUID v1", id)
}
if ver, ok := val.Version(); !ok || ver != 1 {
return nil, trace.BadParameter("'%v' is not a be a valid Time UUID v1", id)
}
uid := ID(id)
return &uid, nil
}
|
[
"func",
"ParseID",
"(",
"id",
"string",
")",
"(",
"*",
"ID",
",",
"error",
")",
"{",
"val",
":=",
"uuid",
".",
"Parse",
"(",
"id",
")",
"\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"'%v' is not a valid Time UUID v1\"",
",",
"id",
")",
"\n",
"}",
"\n",
"if",
"ver",
",",
"ok",
":=",
"val",
".",
"Version",
"(",
")",
";",
"!",
"ok",
"||",
"ver",
"!=",
"1",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"'%v' is not a be a valid Time UUID v1\"",
",",
"id",
")",
"\n",
"}",
"\n",
"uid",
":=",
"ID",
"(",
"id",
")",
"\n",
"return",
"&",
"uid",
",",
"nil",
"\n",
"}"
] |
// ParseID parses ID and checks if it's correct
|
[
"ParseID",
"parses",
"ID",
"and",
"checks",
"if",
"it",
"s",
"correct"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L84-L94
|
train
|
gravitational/teleport
|
lib/session/session.go
|
RemoveParty
|
func (s *Session) RemoveParty(pid ID) bool {
for i := range s.Parties {
if s.Parties[i].ID == pid {
s.Parties = append(s.Parties[:i], s.Parties[i+1:]...)
return true
}
}
return false
}
|
go
|
func (s *Session) RemoveParty(pid ID) bool {
for i := range s.Parties {
if s.Parties[i].ID == pid {
s.Parties = append(s.Parties[:i], s.Parties[i+1:]...)
return true
}
}
return false
}
|
[
"func",
"(",
"s",
"*",
"Session",
")",
"RemoveParty",
"(",
"pid",
"ID",
")",
"bool",
"{",
"for",
"i",
":=",
"range",
"s",
".",
"Parties",
"{",
"if",
"s",
".",
"Parties",
"[",
"i",
"]",
".",
"ID",
"==",
"pid",
"{",
"s",
".",
"Parties",
"=",
"append",
"(",
"s",
".",
"Parties",
"[",
":",
"i",
"]",
",",
"s",
".",
"Parties",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// RemoveParty helper allows to remove a party by it's ID from the
// session's list. Returns 'false' if pid couldn't be found
|
[
"RemoveParty",
"helper",
"allows",
"to",
"remove",
"a",
"party",
"by",
"it",
"s",
"ID",
"from",
"the",
"session",
"s",
"list",
".",
"Returns",
"false",
"if",
"pid",
"couldn",
"t",
"be",
"found"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L128-L136
|
train
|
gravitational/teleport
|
lib/session/session.go
|
String
|
func (p *Party) String() string {
return fmt.Sprintf(
"party(id=%v, remote=%v, user=%v, server=%v, last_active=%v)",
p.ID, p.RemoteAddr, p.User, p.ServerID, p.LastActive,
)
}
|
go
|
func (p *Party) String() string {
return fmt.Sprintf(
"party(id=%v, remote=%v, user=%v, server=%v, last_active=%v)",
p.ID, p.RemoteAddr, p.User, p.ServerID, p.LastActive,
)
}
|
[
"func",
"(",
"p",
"*",
"Party",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"party(id=%v, remote=%v, user=%v, server=%v, last_active=%v)\"",
",",
"p",
".",
"ID",
",",
"p",
".",
"RemoteAddr",
",",
"p",
".",
"User",
",",
"p",
".",
"ServerID",
",",
"p",
".",
"LastActive",
",",
")",
"\n",
"}"
] |
// String returns debug friendly representation
|
[
"String",
"returns",
"debug",
"friendly",
"representation"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L154-L159
|
train
|
gravitational/teleport
|
lib/session/session.go
|
String
|
func (p *TerminalParams) String() string {
return fmt.Sprintf("TerminalParams(w=%v, h=%v)", p.W, p.H)
}
|
go
|
func (p *TerminalParams) String() string {
return fmt.Sprintf("TerminalParams(w=%v, h=%v)", p.W, p.H)
}
|
[
"func",
"(",
"p",
"*",
"TerminalParams",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"TerminalParams(w=%v, h=%v)\"",
",",
"p",
".",
"W",
",",
"p",
".",
"H",
")",
"\n",
"}"
] |
// String returns debug friendly representation of terminal
|
[
"String",
"returns",
"debug",
"friendly",
"representation",
"of",
"terminal"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L199-L201
|
train
|
gravitational/teleport
|
lib/session/session.go
|
Winsize
|
func (p *TerminalParams) Winsize() *term.Winsize {
return &term.Winsize{
Width: uint16(p.W),
Height: uint16(p.H),
}
}
|
go
|
func (p *TerminalParams) Winsize() *term.Winsize {
return &term.Winsize{
Width: uint16(p.W),
Height: uint16(p.H),
}
}
|
[
"func",
"(",
"p",
"*",
"TerminalParams",
")",
"Winsize",
"(",
")",
"*",
"term",
".",
"Winsize",
"{",
"return",
"&",
"term",
".",
"Winsize",
"{",
"Width",
":",
"uint16",
"(",
"p",
".",
"W",
")",
",",
"Height",
":",
"uint16",
"(",
"p",
".",
"H",
")",
",",
"}",
"\n",
"}"
] |
// Winsize returns low-level parameters for changing PTY
|
[
"Winsize",
"returns",
"low",
"-",
"level",
"parameters",
"for",
"changing",
"PTY"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L204-L209
|
train
|
gravitational/teleport
|
lib/session/session.go
|
Check
|
func (u *UpdateRequest) Check() error {
if err := u.ID.Check(); err != nil {
return trace.Wrap(err)
}
if u.Namespace == "" {
return trace.BadParameter("missing parameter Namespace")
}
if u.TerminalParams != nil {
_, err := NewTerminalParamsFromInt(u.TerminalParams.W, u.TerminalParams.H)
if err != nil {
return trace.Wrap(err)
}
}
return nil
}
|
go
|
func (u *UpdateRequest) Check() error {
if err := u.ID.Check(); err != nil {
return trace.Wrap(err)
}
if u.Namespace == "" {
return trace.BadParameter("missing parameter Namespace")
}
if u.TerminalParams != nil {
_, err := NewTerminalParamsFromInt(u.TerminalParams.W, u.TerminalParams.H)
if err != nil {
return trace.Wrap(err)
}
}
return nil
}
|
[
"func",
"(",
"u",
"*",
"UpdateRequest",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"u",
".",
"ID",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Namespace\"",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"TerminalParams",
"!=",
"nil",
"{",
"_",
",",
"err",
":=",
"NewTerminalParamsFromInt",
"(",
"u",
".",
"TerminalParams",
".",
"W",
",",
"u",
".",
"TerminalParams",
".",
"H",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Check returns nil if request is valid, error otherwize
|
[
"Check",
"returns",
"nil",
"if",
"request",
"is",
"valid",
"error",
"otherwize"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L230-L244
|
train
|
gravitational/teleport
|
lib/session/session.go
|
New
|
func New(bk backend.Backend) (Service, error) {
s := &server{
bk: bk,
clock: clockwork.NewRealClock(),
}
if s.activeSessionTTL == 0 {
s.activeSessionTTL = defaults.ActiveSessionTTL
}
return s, nil
}
|
go
|
func New(bk backend.Backend) (Service, error) {
s := &server{
bk: bk,
clock: clockwork.NewRealClock(),
}
if s.activeSessionTTL == 0 {
s.activeSessionTTL = defaults.ActiveSessionTTL
}
return s, nil
}
|
[
"func",
"New",
"(",
"bk",
"backend",
".",
"Backend",
")",
"(",
"Service",
",",
"error",
")",
"{",
"s",
":=",
"&",
"server",
"{",
"bk",
":",
"bk",
",",
"clock",
":",
"clockwork",
".",
"NewRealClock",
"(",
")",
",",
"}",
"\n",
"if",
"s",
".",
"activeSessionTTL",
"==",
"0",
"{",
"s",
".",
"activeSessionTTL",
"=",
"defaults",
".",
"ActiveSessionTTL",
"\n",
"}",
"\n",
"return",
"s",
",",
"nil",
"\n",
"}"
] |
// New returns new session server that uses sqlite to manage
// active sessions
|
[
"New",
"returns",
"new",
"session",
"server",
"that",
"uses",
"sqlite",
"to",
"manage",
"active",
"sessions"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L277-L286
|
train
|
gravitational/teleport
|
lib/session/session.go
|
GetSessions
|
func (s *server) GetSessions(namespace string) ([]Session, error) {
prefix := activePrefix(namespace)
result, err := s.bk.GetRange(context.TODO(), prefix, backend.RangeEnd(prefix), MaxSessionSliceLength)
if err != nil {
return nil, trace.Wrap(err)
}
out := make(Sessions, 0, len(result.Items))
for i := range result.Items {
var session Session
if err := json.Unmarshal(result.Items[i].Value, &session); err != nil {
return nil, trace.Wrap(err)
}
out = append(out, session)
}
sort.Stable(out)
return out, nil
}
|
go
|
func (s *server) GetSessions(namespace string) ([]Session, error) {
prefix := activePrefix(namespace)
result, err := s.bk.GetRange(context.TODO(), prefix, backend.RangeEnd(prefix), MaxSessionSliceLength)
if err != nil {
return nil, trace.Wrap(err)
}
out := make(Sessions, 0, len(result.Items))
for i := range result.Items {
var session Session
if err := json.Unmarshal(result.Items[i].Value, &session); err != nil {
return nil, trace.Wrap(err)
}
out = append(out, session)
}
sort.Stable(out)
return out, nil
}
|
[
"func",
"(",
"s",
"*",
"server",
")",
"GetSessions",
"(",
"namespace",
"string",
")",
"(",
"[",
"]",
"Session",
",",
"error",
")",
"{",
"prefix",
":=",
"activePrefix",
"(",
"namespace",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"bk",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"prefix",
",",
"backend",
".",
"RangeEnd",
"(",
"prefix",
")",
",",
"MaxSessionSliceLength",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"Sessions",
",",
"0",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"result",
".",
"Items",
"{",
"var",
"session",
"Session",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"result",
".",
"Items",
"[",
"i",
"]",
".",
"Value",
",",
"&",
"session",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"session",
")",
"\n",
"}",
"\n",
"sort",
".",
"Stable",
"(",
"out",
")",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// GetSessions returns a list of active sessions. Returns an empty slice
// if no sessions are active
|
[
"GetSessions",
"returns",
"a",
"list",
"of",
"active",
"sessions",
".",
"Returns",
"an",
"empty",
"slice",
"if",
"no",
"sessions",
"are",
"active"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L298-L316
|
train
|
gravitational/teleport
|
lib/session/session.go
|
GetSession
|
func (s *server) GetSession(namespace string, id ID) (*Session, error) {
item, err := s.bk.Get(context.TODO(), activeKey(namespace, string(id)))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("session(%v, %v) is not found", namespace, id)
}
return nil, trace.Wrap(err)
}
var sess Session
if err := json.Unmarshal(item.Value, &sess); err != nil {
return nil, trace.Wrap(err)
}
return &sess, nil
}
|
go
|
func (s *server) GetSession(namespace string, id ID) (*Session, error) {
item, err := s.bk.Get(context.TODO(), activeKey(namespace, string(id)))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("session(%v, %v) is not found", namespace, id)
}
return nil, trace.Wrap(err)
}
var sess Session
if err := json.Unmarshal(item.Value, &sess); err != nil {
return nil, trace.Wrap(err)
}
return &sess, nil
}
|
[
"func",
"(",
"s",
"*",
"server",
")",
"GetSession",
"(",
"namespace",
"string",
",",
"id",
"ID",
")",
"(",
"*",
"Session",
",",
"error",
")",
"{",
"item",
",",
"err",
":=",
"s",
".",
"bk",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"activeKey",
"(",
"namespace",
",",
"string",
"(",
"id",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"session(%v, %v) is not found\"",
",",
"namespace",
",",
"id",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"sess",
"Session",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"sess",
",",
"nil",
"\n",
"}"
] |
// GetSession returns the session by it's id. Returns NotFound if a session
// is not found
|
[
"GetSession",
"returns",
"the",
"session",
"by",
"it",
"s",
"id",
".",
"Returns",
"NotFound",
"if",
"a",
"session",
"is",
"not",
"found"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L341-L354
|
train
|
gravitational/teleport
|
lib/session/session.go
|
CreateSession
|
func (s *server) CreateSession(sess Session) error {
if err := sess.ID.Check(); err != nil {
return trace.Wrap(err)
}
if sess.Namespace == "" {
return trace.BadParameter("session namespace can not be empty")
}
if sess.Login == "" {
return trace.BadParameter("session login can not be empty")
}
if sess.Created.IsZero() {
return trace.BadParameter("created can not be empty")
}
if sess.LastActive.IsZero() {
return trace.BadParameter("last_active can not be empty")
}
_, err := NewTerminalParamsFromInt(sess.TerminalParams.W, sess.TerminalParams.H)
if err != nil {
return trace.Wrap(err)
}
sess.Parties = nil
data, err := json.Marshal(sess)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: activeKey(sess.Namespace, string(sess.ID)),
Value: data,
Expires: s.clock.Now().UTC().Add(s.activeSessionTTL),
}
_, err = s.bk.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *server) CreateSession(sess Session) error {
if err := sess.ID.Check(); err != nil {
return trace.Wrap(err)
}
if sess.Namespace == "" {
return trace.BadParameter("session namespace can not be empty")
}
if sess.Login == "" {
return trace.BadParameter("session login can not be empty")
}
if sess.Created.IsZero() {
return trace.BadParameter("created can not be empty")
}
if sess.LastActive.IsZero() {
return trace.BadParameter("last_active can not be empty")
}
_, err := NewTerminalParamsFromInt(sess.TerminalParams.W, sess.TerminalParams.H)
if err != nil {
return trace.Wrap(err)
}
sess.Parties = nil
data, err := json.Marshal(sess)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: activeKey(sess.Namespace, string(sess.ID)),
Value: data,
Expires: s.clock.Now().UTC().Add(s.activeSessionTTL),
}
_, err = s.bk.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"server",
")",
"CreateSession",
"(",
"sess",
"Session",
")",
"error",
"{",
"if",
"err",
":=",
"sess",
".",
"ID",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"Namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"session namespace can not be empty\"",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"Login",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"session login can not be empty\"",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"Created",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"created can not be empty\"",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"LastActive",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"last_active can not be empty\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"NewTerminalParamsFromInt",
"(",
"sess",
".",
"TerminalParams",
".",
"W",
",",
"sess",
".",
"TerminalParams",
".",
"H",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
".",
"Parties",
"=",
"nil",
"\n",
"data",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"item",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"activeKey",
"(",
"sess",
".",
"Namespace",
",",
"string",
"(",
"sess",
".",
"ID",
")",
")",
",",
"Value",
":",
"data",
",",
"Expires",
":",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"s",
".",
"activeSessionTTL",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"bk",
".",
"Create",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"item",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CreateSession creates a new session if it does not exist, if the session
// exists the function will return AlreadyExists error
// The session will be marked as active for TTL period of time
|
[
"CreateSession",
"creates",
"a",
"new",
"session",
"if",
"it",
"does",
"not",
"exist",
"if",
"the",
"session",
"exists",
"the",
"function",
"will",
"return",
"AlreadyExists",
"error",
"The",
"session",
"will",
"be",
"marked",
"as",
"active",
"for",
"TTL",
"period",
"of",
"time"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L359-L394
|
train
|
gravitational/teleport
|
lib/session/session.go
|
UpdateSession
|
func (s *server) UpdateSession(req UpdateRequest) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
key := activeKey(req.Namespace, string(req.ID))
// Try several times, then give up
for i := 0; i < sessionUpdateAttempts; i++ {
item, err := s.bk.Get(context.TODO(), key)
if err != nil {
return trace.Wrap(err)
}
var session Session
if err := json.Unmarshal(item.Value, &session); err != nil {
return trace.Wrap(err)
}
if req.TerminalParams != nil {
session.TerminalParams = *req.TerminalParams
}
if req.Active != nil {
session.Active = *req.Active
}
if req.Parties != nil {
session.Parties = *req.Parties
}
newValue, err := json.Marshal(session)
if err != nil {
return trace.Wrap(err)
}
newItem := backend.Item{
Key: key,
Value: newValue,
Expires: s.clock.Now().UTC().Add(s.activeSessionTTL),
}
_, err = s.bk.CompareAndSwap(context.TODO(), *item, newItem)
if err != nil {
if trace.IsCompareFailed(err) || trace.IsConnectionProblem(err) {
s.clock.Sleep(sessionUpdateRetryPeriod)
continue
}
return trace.Wrap(err)
} else {
return nil
}
}
return trace.ConnectionProblem(nil, "failed concurrently update the session")
}
|
go
|
func (s *server) UpdateSession(req UpdateRequest) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
key := activeKey(req.Namespace, string(req.ID))
// Try several times, then give up
for i := 0; i < sessionUpdateAttempts; i++ {
item, err := s.bk.Get(context.TODO(), key)
if err != nil {
return trace.Wrap(err)
}
var session Session
if err := json.Unmarshal(item.Value, &session); err != nil {
return trace.Wrap(err)
}
if req.TerminalParams != nil {
session.TerminalParams = *req.TerminalParams
}
if req.Active != nil {
session.Active = *req.Active
}
if req.Parties != nil {
session.Parties = *req.Parties
}
newValue, err := json.Marshal(session)
if err != nil {
return trace.Wrap(err)
}
newItem := backend.Item{
Key: key,
Value: newValue,
Expires: s.clock.Now().UTC().Add(s.activeSessionTTL),
}
_, err = s.bk.CompareAndSwap(context.TODO(), *item, newItem)
if err != nil {
if trace.IsCompareFailed(err) || trace.IsConnectionProblem(err) {
s.clock.Sleep(sessionUpdateRetryPeriod)
continue
}
return trace.Wrap(err)
} else {
return nil
}
}
return trace.ConnectionProblem(nil, "failed concurrently update the session")
}
|
[
"func",
"(",
"s",
"*",
"server",
")",
"UpdateSession",
"(",
"req",
"UpdateRequest",
")",
"error",
"{",
"if",
"err",
":=",
"req",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"key",
":=",
"activeKey",
"(",
"req",
".",
"Namespace",
",",
"string",
"(",
"req",
".",
"ID",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"sessionUpdateAttempts",
";",
"i",
"++",
"{",
"item",
",",
"err",
":=",
"s",
".",
"bk",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"session",
"Session",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"session",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"TerminalParams",
"!=",
"nil",
"{",
"session",
".",
"TerminalParams",
"=",
"*",
"req",
".",
"TerminalParams",
"\n",
"}",
"\n",
"if",
"req",
".",
"Active",
"!=",
"nil",
"{",
"session",
".",
"Active",
"=",
"*",
"req",
".",
"Active",
"\n",
"}",
"\n",
"if",
"req",
".",
"Parties",
"!=",
"nil",
"{",
"session",
".",
"Parties",
"=",
"*",
"req",
".",
"Parties",
"\n",
"}",
"\n",
"newValue",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"session",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"newItem",
":=",
"backend",
".",
"Item",
"{",
"Key",
":",
"key",
",",
"Value",
":",
"newValue",
",",
"Expires",
":",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"s",
".",
"activeSessionTTL",
")",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"bk",
".",
"CompareAndSwap",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"*",
"item",
",",
"newItem",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsCompareFailed",
"(",
"err",
")",
"||",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
"{",
"s",
".",
"clock",
".",
"Sleep",
"(",
"sessionUpdateRetryPeriod",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"failed concurrently update the session\"",
")",
"\n",
"}"
] |
// UpdateSession updates session parameters - can mark it as inactive and update it's terminal parameters
|
[
"UpdateSession",
"updates",
"session",
"parameters",
"-",
"can",
"mark",
"it",
"as",
"inactive",
"and",
"update",
"it",
"s",
"terminal",
"parameters"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L402-L452
|
train
|
gravitational/teleport
|
lib/session/session.go
|
GetSession
|
func (d *discardSessionServer) GetSession(namespace string, id ID) (*Session, error) {
return &Session{}, nil
}
|
go
|
func (d *discardSessionServer) GetSession(namespace string, id ID) (*Session, error) {
return &Session{}, nil
}
|
[
"func",
"(",
"d",
"*",
"discardSessionServer",
")",
"GetSession",
"(",
"namespace",
"string",
",",
"id",
"ID",
")",
"(",
"*",
"Session",
",",
"error",
")",
"{",
"return",
"&",
"Session",
"{",
"}",
",",
"nil",
"\n",
"}"
] |
// GetSession always returns a zero session.
|
[
"GetSession",
"always",
"returns",
"a",
"zero",
"session",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L471-L473
|
train
|
gravitational/teleport
|
lib/session/session.go
|
NewTerminalParamsFromUint32
|
func NewTerminalParamsFromUint32(w uint32, h uint32) (*TerminalParams, error) {
if w > maxSize || w < minSize {
return nil, trace.BadParameter("bad width")
}
if h > maxSize || h < minSize {
return nil, trace.BadParameter("bad height")
}
return &TerminalParams{W: int(w), H: int(h)}, nil
}
|
go
|
func NewTerminalParamsFromUint32(w uint32, h uint32) (*TerminalParams, error) {
if w > maxSize || w < minSize {
return nil, trace.BadParameter("bad width")
}
if h > maxSize || h < minSize {
return nil, trace.BadParameter("bad height")
}
return &TerminalParams{W: int(w), H: int(h)}, nil
}
|
[
"func",
"NewTerminalParamsFromUint32",
"(",
"w",
"uint32",
",",
"h",
"uint32",
")",
"(",
"*",
"TerminalParams",
",",
"error",
")",
"{",
"if",
"w",
">",
"maxSize",
"||",
"w",
"<",
"minSize",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"bad width\"",
")",
"\n",
"}",
"\n",
"if",
"h",
">",
"maxSize",
"||",
"h",
"<",
"minSize",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"bad height\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"TerminalParams",
"{",
"W",
":",
"int",
"(",
"w",
")",
",",
"H",
":",
"int",
"(",
"h",
")",
"}",
",",
"nil",
"\n",
"}"
] |
// NewTerminalParamsFromUint32 returns new terminal parameters from uint32 width and height
|
[
"NewTerminalParamsFromUint32",
"returns",
"new",
"terminal",
"parameters",
"from",
"uint32",
"width",
"and",
"height"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/session/session.go#L486-L494
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
isAuditedAtProxy
|
func (s *Server) isAuditedAtProxy() bool {
// always be safe, better to double record than not record at all
clusterConfig, err := s.GetAccessPoint().GetClusterConfig()
if err != nil {
return false
}
isRecordAtProxy := clusterConfig.GetSessionRecording() == services.RecordAtProxy
isTeleportNode := s.Component() == teleport.ComponentNode
if isRecordAtProxy && isTeleportNode {
return true
}
return false
}
|
go
|
func (s *Server) isAuditedAtProxy() bool {
// always be safe, better to double record than not record at all
clusterConfig, err := s.GetAccessPoint().GetClusterConfig()
if err != nil {
return false
}
isRecordAtProxy := clusterConfig.GetSessionRecording() == services.RecordAtProxy
isTeleportNode := s.Component() == teleport.ComponentNode
if isRecordAtProxy && isTeleportNode {
return true
}
return false
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"isAuditedAtProxy",
"(",
")",
"bool",
"{",
"clusterConfig",
",",
"err",
":=",
"s",
".",
"GetAccessPoint",
"(",
")",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"isRecordAtProxy",
":=",
"clusterConfig",
".",
"GetSessionRecording",
"(",
")",
"==",
"services",
".",
"RecordAtProxy",
"\n",
"isTeleportNode",
":=",
"s",
".",
"Component",
"(",
")",
"==",
"teleport",
".",
"ComponentNode",
"\n",
"if",
"isRecordAtProxy",
"&&",
"isTeleportNode",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// isAuditedAtProxy returns true if sessions are being recorded at the proxy
// and this is a Teleport node.
|
[
"isAuditedAtProxy",
"returns",
"true",
"if",
"sessions",
"are",
"being",
"recorded",
"at",
"the",
"proxy",
"and",
"this",
"is",
"a",
"Teleport",
"node",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L188-L202
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
Shutdown
|
func (s *Server) Shutdown(ctx context.Context) error {
// wait until connections drain off
err := s.srv.Shutdown(ctx)
s.cancel()
s.reg.Close()
if s.heartbeat != nil {
if err := s.heartbeat.Close(); err != nil {
s.Warningf("Failed to close heartbeat: %v.", err)
}
s.heartbeat = nil
}
return err
}
|
go
|
func (s *Server) Shutdown(ctx context.Context) error {
// wait until connections drain off
err := s.srv.Shutdown(ctx)
s.cancel()
s.reg.Close()
if s.heartbeat != nil {
if err := s.heartbeat.Close(); err != nil {
s.Warningf("Failed to close heartbeat: %v.", err)
}
s.heartbeat = nil
}
return err
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Shutdown",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"err",
":=",
"s",
".",
"srv",
".",
"Shutdown",
"(",
"ctx",
")",
"\n",
"s",
".",
"cancel",
"(",
")",
"\n",
"s",
".",
"reg",
".",
"Close",
"(",
")",
"\n",
"if",
"s",
".",
"heartbeat",
"!=",
"nil",
"{",
"if",
"err",
":=",
"s",
".",
"heartbeat",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"s",
".",
"Warningf",
"(",
"\"Failed to close heartbeat: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"heartbeat",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Shutdown performs graceful shutdown
|
[
"Shutdown",
"performs",
"graceful",
"shutdown"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L221-L233
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
Start
|
func (s *Server) Start() error {
if len(s.getCommandLabels()) > 0 {
s.updateLabels()
}
go s.heartbeat.Run()
// If the server requested connections to it arrive over a reverse tunnel,
// don't call Start() which listens on a socket, return right away.
if s.useTunnel {
return nil
}
return s.srv.Start()
}
|
go
|
func (s *Server) Start() error {
if len(s.getCommandLabels()) > 0 {
s.updateLabels()
}
go s.heartbeat.Run()
// If the server requested connections to it arrive over a reverse tunnel,
// don't call Start() which listens on a socket, return right away.
if s.useTunnel {
return nil
}
return s.srv.Start()
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Start",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"s",
".",
"getCommandLabels",
"(",
")",
")",
">",
"0",
"{",
"s",
".",
"updateLabels",
"(",
")",
"\n",
"}",
"\n",
"go",
"s",
".",
"heartbeat",
".",
"Run",
"(",
")",
"\n",
"if",
"s",
".",
"useTunnel",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"s",
".",
"srv",
".",
"Start",
"(",
")",
"\n",
"}"
] |
// Start starts server
|
[
"Start",
"starts",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L236-L248
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
Serve
|
func (s *Server) Serve(l net.Listener) error {
if len(s.getCommandLabels()) > 0 {
s.updateLabels()
}
go s.heartbeat.Run()
return s.srv.Serve(l)
}
|
go
|
func (s *Server) Serve(l net.Listener) error {
if len(s.getCommandLabels()) > 0 {
s.updateLabels()
}
go s.heartbeat.Run()
return s.srv.Serve(l)
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"Serve",
"(",
"l",
"net",
".",
"Listener",
")",
"error",
"{",
"if",
"len",
"(",
"s",
".",
"getCommandLabels",
"(",
")",
")",
">",
"0",
"{",
"s",
".",
"updateLabels",
"(",
")",
"\n",
"}",
"\n",
"go",
"s",
".",
"heartbeat",
".",
"Run",
"(",
")",
"\n",
"return",
"s",
".",
"srv",
".",
"Serve",
"(",
"l",
")",
"\n",
"}"
] |
// Serve servers service on started listener
|
[
"Serve",
"servers",
"service",
"on",
"started",
"listener"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L251-L257
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
HandleConnection
|
func (s *Server) HandleConnection(conn net.Conn) {
s.srv.HandleConnection(conn)
}
|
go
|
func (s *Server) HandleConnection(conn net.Conn) {
s.srv.HandleConnection(conn)
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"HandleConnection",
"(",
"conn",
"net",
".",
"Conn",
")",
"{",
"s",
".",
"srv",
".",
"HandleConnection",
"(",
"conn",
")",
"\n",
"}"
] |
// HandleConnection is called after a connection has been accepted and starts
// to perform the SSH handshake immediately.
|
[
"HandleConnection",
"is",
"called",
"after",
"a",
"connection",
"has",
"been",
"accepted",
"and",
"starts",
"to",
"perform",
"the",
"SSH",
"handshake",
"immediately",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L266-L268
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetRotationGetter
|
func SetRotationGetter(getter RotationGetter) ServerOption {
return func(s *Server) error {
s.getRotation = getter
return nil
}
}
|
go
|
func SetRotationGetter(getter RotationGetter) ServerOption {
return func(s *Server) error {
s.getRotation = getter
return nil
}
}
|
[
"func",
"SetRotationGetter",
"(",
"getter",
"RotationGetter",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"getRotation",
"=",
"getter",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetRotationGetter sets rotation state getter
|
[
"SetRotationGetter",
"sets",
"rotation",
"state",
"getter"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L274-L279
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetShell
|
func SetShell(shell string) ServerOption {
return func(s *Server) error {
s.shell = shell
return nil
}
}
|
go
|
func SetShell(shell string) ServerOption {
return func(s *Server) error {
s.shell = shell
return nil
}
}
|
[
"func",
"SetShell",
"(",
"shell",
"string",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"shell",
"=",
"shell",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetShell sets default shell that will be executed for interactive
// sessions
|
[
"SetShell",
"sets",
"default",
"shell",
"that",
"will",
"be",
"executed",
"for",
"interactive",
"sessions"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L283-L288
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetSessionServer
|
func SetSessionServer(sessionServer rsession.Service) ServerOption {
return func(s *Server) error {
s.sessionServer = sessionServer
return nil
}
}
|
go
|
func SetSessionServer(sessionServer rsession.Service) ServerOption {
return func(s *Server) error {
s.sessionServer = sessionServer
return nil
}
}
|
[
"func",
"SetSessionServer",
"(",
"sessionServer",
"rsession",
".",
"Service",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"sessionServer",
"=",
"sessionServer",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetSessionServer represents realtime session registry server
|
[
"SetSessionServer",
"represents",
"realtime",
"session",
"registry",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L291-L296
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetProxyMode
|
func SetProxyMode(tsrv reversetunnel.Server) ServerOption {
return func(s *Server) error {
// always set proxy mode to true,
// because in some tests reverse tunnel is disabled,
// but proxy is still used without it.
s.proxyMode = true
s.proxyTun = tsrv
return nil
}
}
|
go
|
func SetProxyMode(tsrv reversetunnel.Server) ServerOption {
return func(s *Server) error {
// always set proxy mode to true,
// because in some tests reverse tunnel is disabled,
// but proxy is still used without it.
s.proxyMode = true
s.proxyTun = tsrv
return nil
}
}
|
[
"func",
"SetProxyMode",
"(",
"tsrv",
"reversetunnel",
".",
"Server",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"proxyMode",
"=",
"true",
"\n",
"s",
".",
"proxyTun",
"=",
"tsrv",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetProxyMode starts this server in SSH proxying mode
|
[
"SetProxyMode",
"starts",
"this",
"server",
"in",
"SSH",
"proxying",
"mode"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L299-L308
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetLabels
|
func SetLabels(labels map[string]string,
cmdLabels services.CommandLabels) ServerOption {
return func(s *Server) error {
// make sure to clone labels to avoid
// concurrent writes to the map during reloads
cmdLabels = cmdLabels.Clone()
for name, label := range cmdLabels {
if label.GetPeriod() < time.Second {
label.SetPeriod(time.Second)
cmdLabels[name] = label
log.Warningf("label period can't be less that 1 second. Period for label '%v' was set to 1 second", name)
}
}
s.labels = labels
s.cmdLabels = cmdLabels
return nil
}
}
|
go
|
func SetLabels(labels map[string]string,
cmdLabels services.CommandLabels) ServerOption {
return func(s *Server) error {
// make sure to clone labels to avoid
// concurrent writes to the map during reloads
cmdLabels = cmdLabels.Clone()
for name, label := range cmdLabels {
if label.GetPeriod() < time.Second {
label.SetPeriod(time.Second)
cmdLabels[name] = label
log.Warningf("label period can't be less that 1 second. Period for label '%v' was set to 1 second", name)
}
}
s.labels = labels
s.cmdLabels = cmdLabels
return nil
}
}
|
[
"func",
"SetLabels",
"(",
"labels",
"map",
"[",
"string",
"]",
"string",
",",
"cmdLabels",
"services",
".",
"CommandLabels",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"cmdLabels",
"=",
"cmdLabels",
".",
"Clone",
"(",
")",
"\n",
"for",
"name",
",",
"label",
":=",
"range",
"cmdLabels",
"{",
"if",
"label",
".",
"GetPeriod",
"(",
")",
"<",
"time",
".",
"Second",
"{",
"label",
".",
"SetPeriod",
"(",
"time",
".",
"Second",
")",
"\n",
"cmdLabels",
"[",
"name",
"]",
"=",
"label",
"\n",
"log",
".",
"Warningf",
"(",
"\"label period can't be less that 1 second. Period for label '%v' was set to 1 second\"",
",",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"s",
".",
"labels",
"=",
"labels",
"\n",
"s",
".",
"cmdLabels",
"=",
"cmdLabels",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetLabels sets dynamic and static labels that server will report to the
// auth servers
|
[
"SetLabels",
"sets",
"dynamic",
"and",
"static",
"labels",
"that",
"server",
"will",
"report",
"to",
"the",
"auth",
"servers"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L312-L329
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetAuditLog
|
func SetAuditLog(alog events.IAuditLog) ServerOption {
return func(s *Server) error {
s.alog = alog
return nil
}
}
|
go
|
func SetAuditLog(alog events.IAuditLog) ServerOption {
return func(s *Server) error {
s.alog = alog
return nil
}
}
|
[
"func",
"SetAuditLog",
"(",
"alog",
"events",
".",
"IAuditLog",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"alog",
"=",
"alog",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetAuditLog assigns an audit log interfaces to this server
|
[
"SetAuditLog",
"assigns",
"an",
"audit",
"log",
"interfaces",
"to",
"this",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L340-L345
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetUUID
|
func SetUUID(uuid string) ServerOption {
return func(s *Server) error {
s.uuid = uuid
return nil
}
}
|
go
|
func SetUUID(uuid string) ServerOption {
return func(s *Server) error {
s.uuid = uuid
return nil
}
}
|
[
"func",
"SetUUID",
"(",
"uuid",
"string",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"uuid",
"=",
"uuid",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetUUID sets server unique ID
|
[
"SetUUID",
"sets",
"server",
"unique",
"ID"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L348-L353
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
SetPermitUserEnvironment
|
func SetPermitUserEnvironment(permitUserEnvironment bool) ServerOption {
return func(s *Server) error {
s.permitUserEnvironment = permitUserEnvironment
return nil
}
}
|
go
|
func SetPermitUserEnvironment(permitUserEnvironment bool) ServerOption {
return func(s *Server) error {
s.permitUserEnvironment = permitUserEnvironment
return nil
}
}
|
[
"func",
"SetPermitUserEnvironment",
"(",
"permitUserEnvironment",
"bool",
")",
"ServerOption",
"{",
"return",
"func",
"(",
"s",
"*",
"Server",
")",
"error",
"{",
"s",
".",
"permitUserEnvironment",
"=",
"permitUserEnvironment",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// SetPermitUserEnvironment allows you to set the value of permitUserEnvironment.
|
[
"SetPermitUserEnvironment",
"allows",
"you",
"to",
"set",
"the",
"value",
"of",
"permitUserEnvironment",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L363-L368
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
serveAgent
|
func (s *Server) serveAgent(ctx *srv.ServerContext) error {
// gather information about user and process. this will be used to set the
// socket path and permissions
systemUser, err := user.Lookup(ctx.Identity.Login)
if err != nil {
return trace.ConvertSystemError(err)
}
uid, err := strconv.Atoi(systemUser.Uid)
if err != nil {
return trace.Wrap(err)
}
gid, err := strconv.Atoi(systemUser.Gid)
if err != nil {
return trace.Wrap(err)
}
pid := os.Getpid()
// build the socket path and set permissions
socketDir, err := ioutil.TempDir(os.TempDir(), "teleport-")
if err != nil {
return trace.Wrap(err)
}
dirCloser := &utils.RemoveDirCloser{Path: socketDir}
socketPath := filepath.Join(socketDir, fmt.Sprintf("teleport-%v.socket", pid))
if err := os.Chown(socketDir, uid, gid); err != nil {
if err := dirCloser.Close(); err != nil {
log.Warnf("failed to remove directory: %v", err)
}
return trace.ConvertSystemError(err)
}
// start an agent on a unix socket
agentServer := &teleagent.AgentServer{Agent: ctx.GetAgent()}
err = agentServer.ListenUnixSocket(socketPath, uid, gid, 0600)
if err != nil {
return trace.Wrap(err)
}
ctx.SetEnv(teleport.SSHAuthSock, socketPath)
ctx.SetEnv(teleport.SSHAgentPID, fmt.Sprintf("%v", pid))
ctx.AddCloser(agentServer)
ctx.AddCloser(dirCloser)
ctx.Debugf("Opened agent channel for Teleport user %v and socket %v.", ctx.Identity.TeleportUser, socketPath)
go agentServer.Serve()
return nil
}
|
go
|
func (s *Server) serveAgent(ctx *srv.ServerContext) error {
// gather information about user and process. this will be used to set the
// socket path and permissions
systemUser, err := user.Lookup(ctx.Identity.Login)
if err != nil {
return trace.ConvertSystemError(err)
}
uid, err := strconv.Atoi(systemUser.Uid)
if err != nil {
return trace.Wrap(err)
}
gid, err := strconv.Atoi(systemUser.Gid)
if err != nil {
return trace.Wrap(err)
}
pid := os.Getpid()
// build the socket path and set permissions
socketDir, err := ioutil.TempDir(os.TempDir(), "teleport-")
if err != nil {
return trace.Wrap(err)
}
dirCloser := &utils.RemoveDirCloser{Path: socketDir}
socketPath := filepath.Join(socketDir, fmt.Sprintf("teleport-%v.socket", pid))
if err := os.Chown(socketDir, uid, gid); err != nil {
if err := dirCloser.Close(); err != nil {
log.Warnf("failed to remove directory: %v", err)
}
return trace.ConvertSystemError(err)
}
// start an agent on a unix socket
agentServer := &teleagent.AgentServer{Agent: ctx.GetAgent()}
err = agentServer.ListenUnixSocket(socketPath, uid, gid, 0600)
if err != nil {
return trace.Wrap(err)
}
ctx.SetEnv(teleport.SSHAuthSock, socketPath)
ctx.SetEnv(teleport.SSHAgentPID, fmt.Sprintf("%v", pid))
ctx.AddCloser(agentServer)
ctx.AddCloser(dirCloser)
ctx.Debugf("Opened agent channel for Teleport user %v and socket %v.", ctx.Identity.TeleportUser, socketPath)
go agentServer.Serve()
return nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"serveAgent",
"(",
"ctx",
"*",
"srv",
".",
"ServerContext",
")",
"error",
"{",
"systemUser",
",",
"err",
":=",
"user",
".",
"Lookup",
"(",
"ctx",
".",
"Identity",
".",
"Login",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"uid",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"systemUser",
".",
"Uid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"gid",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"systemUser",
".",
"Gid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"pid",
":=",
"os",
".",
"Getpid",
"(",
")",
"\n",
"socketDir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"os",
".",
"TempDir",
"(",
")",
",",
"\"teleport-\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"dirCloser",
":=",
"&",
"utils",
".",
"RemoveDirCloser",
"{",
"Path",
":",
"socketDir",
"}",
"\n",
"socketPath",
":=",
"filepath",
".",
"Join",
"(",
"socketDir",
",",
"fmt",
".",
"Sprintf",
"(",
"\"teleport-%v.socket\"",
",",
"pid",
")",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Chown",
"(",
"socketDir",
",",
"uid",
",",
"gid",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
":=",
"dirCloser",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"failed to remove directory: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"agentServer",
":=",
"&",
"teleagent",
".",
"AgentServer",
"{",
"Agent",
":",
"ctx",
".",
"GetAgent",
"(",
")",
"}",
"\n",
"err",
"=",
"agentServer",
".",
"ListenUnixSocket",
"(",
"socketPath",
",",
"uid",
",",
"gid",
",",
"0600",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
".",
"SetEnv",
"(",
"teleport",
".",
"SSHAuthSock",
",",
"socketPath",
")",
"\n",
"ctx",
".",
"SetEnv",
"(",
"teleport",
".",
"SSHAgentPID",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%v\"",
",",
"pid",
")",
")",
"\n",
"ctx",
".",
"AddCloser",
"(",
"agentServer",
")",
"\n",
"ctx",
".",
"AddCloser",
"(",
"dirCloser",
")",
"\n",
"ctx",
".",
"Debugf",
"(",
"\"Opened agent channel for Teleport user %v and socket %v.\"",
",",
"ctx",
".",
"Identity",
".",
"TeleportUser",
",",
"socketPath",
")",
"\n",
"go",
"agentServer",
".",
"Serve",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// serveAgent will build the a sock path for this user and serve an SSH agent on unix socket.
|
[
"serveAgent",
"will",
"build",
"the",
"a",
"sock",
"path",
"for",
"this",
"user",
"and",
"serve",
"an",
"SSH",
"agent",
"on",
"unix",
"socket",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L683-L728
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
EmitAuditEvent
|
func (s *Server) EmitAuditEvent(event events.Event, fields events.EventFields) {
log.Debugf("server.EmitAuditEvent(%v)", event.Name)
alog := s.alog
if alog != nil {
// record the event time with ms precision
fields[events.EventTime] = s.clock.Now().In(time.UTC).Round(time.Millisecond)
if err := alog.EmitAuditEvent(event, fields); err != nil {
log.Error(trace.DebugReport(err))
}
} else {
log.Warn("SSH server has no audit log")
}
}
|
go
|
func (s *Server) EmitAuditEvent(event events.Event, fields events.EventFields) {
log.Debugf("server.EmitAuditEvent(%v)", event.Name)
alog := s.alog
if alog != nil {
// record the event time with ms precision
fields[events.EventTime] = s.clock.Now().In(time.UTC).Round(time.Millisecond)
if err := alog.EmitAuditEvent(event, fields); err != nil {
log.Error(trace.DebugReport(err))
}
} else {
log.Warn("SSH server has no audit log")
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"EmitAuditEvent",
"(",
"event",
"events",
".",
"Event",
",",
"fields",
"events",
".",
"EventFields",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"server.EmitAuditEvent(%v)\"",
",",
"event",
".",
"Name",
")",
"\n",
"alog",
":=",
"s",
".",
"alog",
"\n",
"if",
"alog",
"!=",
"nil",
"{",
"fields",
"[",
"events",
".",
"EventTime",
"]",
"=",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"In",
"(",
"time",
".",
"UTC",
")",
".",
"Round",
"(",
"time",
".",
"Millisecond",
")",
"\n",
"if",
"err",
":=",
"alog",
".",
"EmitAuditEvent",
"(",
"event",
",",
"fields",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"log",
".",
"Warn",
"(",
"\"SSH server has no audit log\"",
")",
"\n",
"}",
"\n",
"}"
] |
// EmitAuditEvent logs a given event to the audit log attached to the
// server who owns these sessions
|
[
"EmitAuditEvent",
"logs",
"a",
"given",
"event",
"to",
"the",
"audit",
"log",
"attached",
"to",
"the",
"server",
"who",
"owns",
"these",
"sessions"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L732-L744
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
HandleNewChan
|
func (s *Server) HandleNewChan(wconn net.Conn, sconn *ssh.ServerConn, nch ssh.NewChannel) {
identityContext, err := s.authHandlers.CreateIdentityContext(sconn)
if err != nil {
nch.Reject(ssh.Prohibited, fmt.Sprintf("Unable to create identity from connection: %v", err))
return
}
channelType := nch.ChannelType()
if s.proxyMode {
// Channels of type "session" handle requests that are involved in running
// commands on a server. In the case of proxy mode subsystem and agent
// forwarding requests occur over the "session" channel.
if channelType == "session" {
ch, requests, err := nch.Accept()
if err != nil {
log.Warnf("Unable to accept channel: %v.", err)
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleSessionRequests(wconn, sconn, identityContext, ch, requests)
} else {
nch.Reject(ssh.UnknownChannelType, fmt.Sprintf("unknown channel type: %v", channelType))
}
return
}
switch channelType {
// Channels of type "session" handle requests that are involved in running
// commands on a server, subsystem requests, and agent forwarding.
case "session":
ch, requests, err := nch.Accept()
if err != nil {
log.Warnf("Unable to accept channel: %v.", err)
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleSessionRequests(wconn, sconn, identityContext, ch, requests)
// Channels of type "direct-tcpip" handles request for port forwarding.
case "direct-tcpip":
req, err := sshutils.ParseDirectTCPIPReq(nch.ExtraData())
if err != nil {
log.Errorf("Failed to parse request data: %v, err: %v.", string(nch.ExtraData()), err)
nch.Reject(ssh.UnknownChannelType, "failed to parse direct-tcpip request")
return
}
ch, _, err := nch.Accept()
if err != nil {
log.Warnf("Unable to accept channel: %v.", err)
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleDirectTCPIPRequest(wconn, sconn, identityContext, ch, req)
default:
nch.Reject(ssh.UnknownChannelType, fmt.Sprintf("unknown channel type: %v", channelType))
}
}
|
go
|
func (s *Server) HandleNewChan(wconn net.Conn, sconn *ssh.ServerConn, nch ssh.NewChannel) {
identityContext, err := s.authHandlers.CreateIdentityContext(sconn)
if err != nil {
nch.Reject(ssh.Prohibited, fmt.Sprintf("Unable to create identity from connection: %v", err))
return
}
channelType := nch.ChannelType()
if s.proxyMode {
// Channels of type "session" handle requests that are involved in running
// commands on a server. In the case of proxy mode subsystem and agent
// forwarding requests occur over the "session" channel.
if channelType == "session" {
ch, requests, err := nch.Accept()
if err != nil {
log.Warnf("Unable to accept channel: %v.", err)
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleSessionRequests(wconn, sconn, identityContext, ch, requests)
} else {
nch.Reject(ssh.UnknownChannelType, fmt.Sprintf("unknown channel type: %v", channelType))
}
return
}
switch channelType {
// Channels of type "session" handle requests that are involved in running
// commands on a server, subsystem requests, and agent forwarding.
case "session":
ch, requests, err := nch.Accept()
if err != nil {
log.Warnf("Unable to accept channel: %v.", err)
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleSessionRequests(wconn, sconn, identityContext, ch, requests)
// Channels of type "direct-tcpip" handles request for port forwarding.
case "direct-tcpip":
req, err := sshutils.ParseDirectTCPIPReq(nch.ExtraData())
if err != nil {
log.Errorf("Failed to parse request data: %v, err: %v.", string(nch.ExtraData()), err)
nch.Reject(ssh.UnknownChannelType, "failed to parse direct-tcpip request")
return
}
ch, _, err := nch.Accept()
if err != nil {
log.Warnf("Unable to accept channel: %v.", err)
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleDirectTCPIPRequest(wconn, sconn, identityContext, ch, req)
default:
nch.Reject(ssh.UnknownChannelType, fmt.Sprintf("unknown channel type: %v", channelType))
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"HandleNewChan",
"(",
"wconn",
"net",
".",
"Conn",
",",
"sconn",
"*",
"ssh",
".",
"ServerConn",
",",
"nch",
"ssh",
".",
"NewChannel",
")",
"{",
"identityContext",
",",
"err",
":=",
"s",
".",
"authHandlers",
".",
"CreateIdentityContext",
"(",
"sconn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"Prohibited",
",",
"fmt",
".",
"Sprintf",
"(",
"\"Unable to create identity from connection: %v\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"channelType",
":=",
"nch",
".",
"ChannelType",
"(",
")",
"\n",
"if",
"s",
".",
"proxyMode",
"{",
"if",
"channelType",
"==",
"\"session\"",
"{",
"ch",
",",
"requests",
",",
"err",
":=",
"nch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to accept channel: %v.\"",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"ConnectionFailed",
",",
"fmt",
".",
"Sprintf",
"(",
"\"unable to accept channel: %v\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"s",
".",
"handleSessionRequests",
"(",
"wconn",
",",
"sconn",
",",
"identityContext",
",",
"ch",
",",
"requests",
")",
"\n",
"}",
"else",
"{",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"UnknownChannelType",
",",
"fmt",
".",
"Sprintf",
"(",
"\"unknown channel type: %v\"",
",",
"channelType",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"switch",
"channelType",
"{",
"case",
"\"session\"",
":",
"ch",
",",
"requests",
",",
"err",
":=",
"nch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to accept channel: %v.\"",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"ConnectionFailed",
",",
"fmt",
".",
"Sprintf",
"(",
"\"unable to accept channel: %v\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"s",
".",
"handleSessionRequests",
"(",
"wconn",
",",
"sconn",
",",
"identityContext",
",",
"ch",
",",
"requests",
")",
"\n",
"case",
"\"direct-tcpip\"",
":",
"req",
",",
"err",
":=",
"sshutils",
".",
"ParseDirectTCPIPReq",
"(",
"nch",
".",
"ExtraData",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to parse request data: %v, err: %v.\"",
",",
"string",
"(",
"nch",
".",
"ExtraData",
"(",
")",
")",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"UnknownChannelType",
",",
"\"failed to parse direct-tcpip request\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"ch",
",",
"_",
",",
"err",
":=",
"nch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to accept channel: %v.\"",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"ConnectionFailed",
",",
"fmt",
".",
"Sprintf",
"(",
"\"unable to accept channel: %v\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"s",
".",
"handleDirectTCPIPRequest",
"(",
"wconn",
",",
"sconn",
",",
"identityContext",
",",
"ch",
",",
"req",
")",
"\n",
"default",
":",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"UnknownChannelType",
",",
"fmt",
".",
"Sprintf",
"(",
"\"unknown channel type: %v\"",
",",
"channelType",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// HandleNewChan is called when new channel is opened
|
[
"HandleNewChan",
"is",
"called",
"when",
"new",
"channel",
"is",
"opened"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L768-L823
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
handleAgentForwardNode
|
func (s *Server) handleAgentForwardNode(req *ssh.Request, ctx *srv.ServerContext) error {
// check if the user's RBAC role allows agent forwarding
err := s.authHandlers.CheckAgentForward(ctx)
if err != nil {
return trace.Wrap(err)
}
// open a channel to the client where the client will serve an agent
authChannel, _, err := ctx.Conn.OpenChannel(sshutils.AuthAgentRequest, nil)
if err != nil {
return trace.Wrap(err)
}
// save the agent in the context so it can be used later
ctx.SetAgent(agent.NewClient(authChannel), authChannel)
// serve an agent on a unix socket on this node
err = s.serveAgent(ctx)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (s *Server) handleAgentForwardNode(req *ssh.Request, ctx *srv.ServerContext) error {
// check if the user's RBAC role allows agent forwarding
err := s.authHandlers.CheckAgentForward(ctx)
if err != nil {
return trace.Wrap(err)
}
// open a channel to the client where the client will serve an agent
authChannel, _, err := ctx.Conn.OpenChannel(sshutils.AuthAgentRequest, nil)
if err != nil {
return trace.Wrap(err)
}
// save the agent in the context so it can be used later
ctx.SetAgent(agent.NewClient(authChannel), authChannel)
// serve an agent on a unix socket on this node
err = s.serveAgent(ctx)
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"handleAgentForwardNode",
"(",
"req",
"*",
"ssh",
".",
"Request",
",",
"ctx",
"*",
"srv",
".",
"ServerContext",
")",
"error",
"{",
"err",
":=",
"s",
".",
"authHandlers",
".",
"CheckAgentForward",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authChannel",
",",
"_",
",",
"err",
":=",
"ctx",
".",
"Conn",
".",
"OpenChannel",
"(",
"sshutils",
".",
"AuthAgentRequest",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ctx",
".",
"SetAgent",
"(",
"agent",
".",
"NewClient",
"(",
"authChannel",
")",
",",
"authChannel",
")",
"\n",
"err",
"=",
"s",
".",
"serveAgent",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// handleAgentForwardNode will create a unix socket and serve the agent running
// on the client on it.
|
[
"handleAgentForwardNode",
"will",
"create",
"a",
"unix",
"socket",
"and",
"serve",
"the",
"agent",
"running",
"on",
"the",
"client",
"on",
"it",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L1079-L1102
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
handleKeepAlive
|
func (s *Server) handleKeepAlive(req *ssh.Request) {
log.Debugf("Received %q: WantReply: %v", req.Type, req.WantReply)
// only reply if the sender actually wants a response
if req.WantReply {
err := req.Reply(true, nil)
if err != nil {
log.Warnf("Unable to reply to %q request: %v", req.Type, err)
return
}
}
log.Debugf("Replied to %q", req.Type)
}
|
go
|
func (s *Server) handleKeepAlive(req *ssh.Request) {
log.Debugf("Received %q: WantReply: %v", req.Type, req.WantReply)
// only reply if the sender actually wants a response
if req.WantReply {
err := req.Reply(true, nil)
if err != nil {
log.Warnf("Unable to reply to %q request: %v", req.Type, err)
return
}
}
log.Debugf("Replied to %q", req.Type)
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"handleKeepAlive",
"(",
"req",
"*",
"ssh",
".",
"Request",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"Received %q: WantReply: %v\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
")",
"\n",
"if",
"req",
".",
"WantReply",
"{",
"err",
":=",
"req",
".",
"Reply",
"(",
"true",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to reply to %q request: %v\"",
",",
"req",
".",
"Type",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Replied to %q\"",
",",
"req",
".",
"Type",
")",
"\n",
"}"
] |
// handleKeepAlive accepts and replies to keepalive@openssh.com requests.
|
[
"handleKeepAlive",
"accepts",
"and",
"replies",
"to",
"keepalive"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L1171-L1184
|
train
|
gravitational/teleport
|
lib/srv/regular/sshserver.go
|
handleRecordingProxy
|
func (s *Server) handleRecordingProxy(req *ssh.Request) {
var recordingProxy bool
log.Debugf("Global request (%v, %v) received", req.Type, req.WantReply)
if req.WantReply {
// get the cluster config, if we can't get it, reply false
clusterConfig, err := s.authService.GetClusterConfig()
if err != nil {
err := req.Reply(false, nil)
if err != nil {
log.Warnf("Unable to respond to global request (%v, %v): %v", req.Type, req.WantReply, err)
}
return
}
// reply true that we were able to process the message and reply with a
// bool if we are in recording mode or not
recordingProxy = clusterConfig.GetSessionRecording() == services.RecordAtProxy
err = req.Reply(true, []byte(strconv.FormatBool(recordingProxy)))
if err != nil {
log.Warnf("Unable to respond to global request (%v, %v): %v: %v", req.Type, req.WantReply, recordingProxy, err)
return
}
}
log.Debugf("Replied to global request (%v, %v): %v", req.Type, req.WantReply, recordingProxy)
}
|
go
|
func (s *Server) handleRecordingProxy(req *ssh.Request) {
var recordingProxy bool
log.Debugf("Global request (%v, %v) received", req.Type, req.WantReply)
if req.WantReply {
// get the cluster config, if we can't get it, reply false
clusterConfig, err := s.authService.GetClusterConfig()
if err != nil {
err := req.Reply(false, nil)
if err != nil {
log.Warnf("Unable to respond to global request (%v, %v): %v", req.Type, req.WantReply, err)
}
return
}
// reply true that we were able to process the message and reply with a
// bool if we are in recording mode or not
recordingProxy = clusterConfig.GetSessionRecording() == services.RecordAtProxy
err = req.Reply(true, []byte(strconv.FormatBool(recordingProxy)))
if err != nil {
log.Warnf("Unable to respond to global request (%v, %v): %v: %v", req.Type, req.WantReply, recordingProxy, err)
return
}
}
log.Debugf("Replied to global request (%v, %v): %v", req.Type, req.WantReply, recordingProxy)
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"handleRecordingProxy",
"(",
"req",
"*",
"ssh",
".",
"Request",
")",
"{",
"var",
"recordingProxy",
"bool",
"\n",
"log",
".",
"Debugf",
"(",
"\"Global request (%v, %v) received\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
")",
"\n",
"if",
"req",
".",
"WantReply",
"{",
"clusterConfig",
",",
"err",
":=",
"s",
".",
"authService",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
":=",
"req",
".",
"Reply",
"(",
"false",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to respond to global request (%v, %v): %v\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"recordingProxy",
"=",
"clusterConfig",
".",
"GetSessionRecording",
"(",
")",
"==",
"services",
".",
"RecordAtProxy",
"\n",
"err",
"=",
"req",
".",
"Reply",
"(",
"true",
",",
"[",
"]",
"byte",
"(",
"strconv",
".",
"FormatBool",
"(",
"recordingProxy",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to respond to global request (%v, %v): %v: %v\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
",",
"recordingProxy",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Replied to global request (%v, %v): %v\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
",",
"recordingProxy",
")",
"\n",
"}"
] |
// handleRecordingProxy responds to global out-of-band with a bool which
// indicates if it is in recording mode or not.
|
[
"handleRecordingProxy",
"responds",
"to",
"global",
"out",
"-",
"of",
"-",
"band",
"with",
"a",
"bool",
"which",
"indicates",
"if",
"it",
"is",
"in",
"recording",
"mode",
"or",
"not",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/regular/sshserver.go#L1188-L1215
|
train
|
gravitational/teleport
|
lib/services/wrappers.go
|
UnmarshalJSON
|
func (s *Strings) UnmarshalJSON(data []byte) error {
if len(data) == 0 {
return nil
}
var stringVar string
if err := json.Unmarshal(data, &stringVar); err == nil {
*s = []string{stringVar}
return nil
}
var stringsVar []string
if err := json.Unmarshal(data, &stringsVar); err != nil {
return trace.Wrap(err)
}
*s = stringsVar
return nil
}
|
go
|
func (s *Strings) UnmarshalJSON(data []byte) error {
if len(data) == 0 {
return nil
}
var stringVar string
if err := json.Unmarshal(data, &stringVar); err == nil {
*s = []string{stringVar}
return nil
}
var stringsVar []string
if err := json.Unmarshal(data, &stringsVar); err != nil {
return trace.Wrap(err)
}
*s = stringsVar
return nil
}
|
[
"func",
"(",
"s",
"*",
"Strings",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"stringVar",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"stringVar",
")",
";",
"err",
"==",
"nil",
"{",
"*",
"s",
"=",
"[",
"]",
"string",
"{",
"stringVar",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"stringsVar",
"[",
"]",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"stringsVar",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"*",
"s",
"=",
"stringsVar",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UnmarshalJSON unmarshals scalar string or strings slice to Strings
|
[
"UnmarshalJSON",
"unmarshals",
"scalar",
"string",
"or",
"strings",
"slice",
"to",
"Strings"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/wrappers.go#L99-L114
|
train
|
gravitational/teleport
|
lib/services/wrappers.go
|
UnmarshalYAML
|
func (s *Strings) UnmarshalYAML(unmarshal func(interface{}) error) error {
// try unmarshal as string
var val string
err := unmarshal(&val)
if err == nil {
*s = []string{val}
return nil
}
// try unmarshal as slice
var slice []string
err = unmarshal(&slice)
if err == nil {
*s = slice
return nil
}
return err
}
|
go
|
func (s *Strings) UnmarshalYAML(unmarshal func(interface{}) error) error {
// try unmarshal as string
var val string
err := unmarshal(&val)
if err == nil {
*s = []string{val}
return nil
}
// try unmarshal as slice
var slice []string
err = unmarshal(&slice)
if err == nil {
*s = slice
return nil
}
return err
}
|
[
"func",
"(",
"s",
"*",
"Strings",
")",
"UnmarshalYAML",
"(",
"unmarshal",
"func",
"(",
"interface",
"{",
"}",
")",
"error",
")",
"error",
"{",
"var",
"val",
"string",
"\n",
"err",
":=",
"unmarshal",
"(",
"&",
"val",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"s",
"=",
"[",
"]",
"string",
"{",
"val",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"slice",
"[",
"]",
"string",
"\n",
"err",
"=",
"unmarshal",
"(",
"&",
"slice",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"s",
"=",
"slice",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// UnmarshalYAML is used to allow Strings to unmarshal from
// scalar string value or from the list
|
[
"UnmarshalYAML",
"is",
"used",
"to",
"allow",
"Strings",
"to",
"unmarshal",
"from",
"scalar",
"string",
"value",
"or",
"from",
"the",
"list"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/wrappers.go#L118-L136
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.