repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/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\n",
"ipExtractor",
",",
"err",
":=",
"utils",
".",
"NewExtractor",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"limiter",
".",
"ConnLimiter",
",",
"err",
"=",
"connlimit",
".",
"New",
"(",
"nil",
",",
"ipExtractor",
",",
"config",
".",
"MaxConnections",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\n",
"if",
"l",
".",
"maxConnections",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
",",
"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\n",
"if",
"l",
".",
"maxConnections",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"numberOfConnections",
",",
"exists",
":=",
"l",
".",
"connections",
"[",
"token",
"]",
"\n",
"if",
"!",
"exists",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\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\n",
"if",
"t",
".",
"IsZero",
"(",
")",
"{",
"// to fix issue with timezones for tests",
"*",
"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",
"{",
"// validate new password",
"err",
":=",
"services",
".",
"VerifyPassword",
"(",
"req",
".",
"NewPassword",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"authPreference",
",",
"err",
":=",
"s",
".",
"GetAuthPreference",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"CheckU2FSignResponse",
"(",
"userID",
",",
"req",
".",
"U2FSignResponse",
")",
"\n",
"}",
"\n\n",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"secondFactor",
")",
"\n",
"}",
"\n\n",
"err",
"=",
"s",
".",
"WithUserLock",
"(",
"userID",
",",
"fn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"=",
"\"",
"\"",
"\n\n",
"err",
":=",
"services",
".",
"VerifyPassword",
"(",
"password",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"errMsg",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
",",
"user",
")",
"\n",
"hash",
"=",
"fakePasswordHash",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"bcrypt",
".",
"CompareHashAndPassword",
"(",
"hash",
",",
"password",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"user",
")",
"\n",
"return",
"trace",
".",
"BadParameter",
"(",
"errMsg",
")",
"\n",
"}",
"\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",
")",
"{",
"// get otp key from backend",
"otpSecret",
",",
"err",
":=",
"s",
".",
"GetTOTP",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// create otp url",
"params",
":=",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"\"",
"\"",
":",
"[",
"]",
"byte",
"(",
"otpSecret",
")",
"}",
"\n",
"otpURL",
":=",
"utils",
".",
"GenerateOTPURL",
"(",
"\"",
"\"",
",",
"user",
",",
"params",
")",
"\n\n",
"// create the qr code",
"otpQR",
",",
"err",
":=",
"utils",
".",
"GenerateQRCode",
"(",
"otpURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"{",
"}",
"{",
"\"",
"\"",
":",
"predicate",
".",
"Equals",
",",
"\"",
"\"",
":",
"predicate",
".",
"Contains",
",",
"// system.catype is a function that returns cert authority type,",
"// it returns empty values for unrecognized values to",
"// pass static rule checks.",
"\"",
"\"",
":",
"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",
"{",
"}",
"{",
"\"",
"\"",
":",
"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",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
")",
"\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",
",",
"\"",
"\"",
",",
"fields",
"[",
"1",
":",
"]",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"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\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\n",
"aesgcm",
",",
"err",
":=",
"cipher",
".",
"NewGCM",
"(",
"block",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\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\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\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"ciphertext",
",",
"&",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"block",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"k",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"aesgcm",
",",
"err",
":=",
"cipher",
".",
"NewGCM",
"(",
"block",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"plaintext",
",",
"err",
":=",
"aesgcm",
".",
"Open",
"(",
"nil",
",",
"data",
".",
"Nonce",
",",
"data",
".",
"Ciphertext",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
")",
"{",
"// look at 'path' parameter, if it's missing use 'data_dir' (default):",
"path",
":=",
"params",
".",
"GetString",
"(",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"path",
")",
"==",
"0",
"{",
"path",
"=",
"params",
".",
"GetString",
"(",
"teleport",
".",
"DataDirParameterName",
")",
"\n",
"}",
"\n",
"// still nothing? return an error:",
"if",
"path",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"!",
"utils",
".",
"IsDir",
"(",
"path",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"\n",
"path",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"keysBoltFile",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"db",
",",
"err",
":=",
"bolt",
".",
"Open",
"(",
"path",
",",
"openFileMode",
",",
"&",
"bolt",
".",
"Options",
"{",
"Timeout",
":",
"openTimeout",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"bolt",
".",
"ErrTimeout",
"{",
"return",
"nil",
",",
"trace",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Wrap the backend in a input sanitizer and return it.",
"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\n",
"keys",
",",
"err",
":=",
"b",
".",
"GetKeys",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// 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",
")",
")",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"keys",
"{",
"val",
",",
"err",
":=",
"b",
".",
"GetVal",
"(",
"path",
",",
"e",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"items",
"=",
"append",
"(",
"items",
",",
"legacy",
".",
"Item",
"{",
"Key",
":",
"e",
",",
"Value",
":",
"val",
",",
"}",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
")",
"\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",
")",
"\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",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"CompareFailed",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"FileName",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"RemoteLocation",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"contentLength",
":=",
"req",
".",
"HTTPRequest",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"fileSize",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"contentLength",
",",
"10",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"contentLength",
")",
"\n",
"}",
"\n\n",
"fs",
":=",
"&",
"httpFileSystem",
"{",
"reader",
":",
"req",
".",
"HTTPRequest",
".",
"Body",
",",
"fileName",
":",
"req",
".",
"FileName",
",",
"fileSize",
":",
"fileSize",
",",
"}",
"\n\n",
"flags",
":=",
"Flags",
"{",
"// scp treats it as a list of files to upload",
"Target",
":",
"[",
"]",
"string",
"{",
"req",
".",
"FileName",
"}",
",",
"}",
"\n\n",
"cfg",
":=",
"Config",
"{",
"Flags",
":",
"flags",
",",
"FileSystem",
":",
"fs",
",",
"User",
":",
"req",
".",
"User",
",",
"ProgressWriter",
":",
"req",
".",
"Progress",
",",
"RemoteLocation",
":",
"req",
".",
"RemoteLocation",
",",
"AuditLog",
":",
"req",
".",
"AuditLog",
",",
"}",
"\n\n",
"cmd",
",",
"err",
":=",
"CreateUploadCommand",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\n",
"flags",
":=",
"Flags",
"{",
"Target",
":",
"[",
"]",
"string",
"{",
"filename",
"}",
",",
"}",
"\n\n",
"cfg",
":=",
"Config",
"{",
"Flags",
":",
"flags",
",",
"User",
":",
"req",
".",
"User",
",",
"ProgressWriter",
":",
"req",
".",
"Progress",
",",
"RemoteLocation",
":",
"req",
".",
"RemoteLocation",
",",
"FileSystem",
":",
"&",
"httpFileSystem",
"{",
"writer",
":",
"req",
".",
"HTTPResponse",
",",
"}",
",",
"}",
"\n\n",
"cmd",
",",
"err",
":=",
"CreateDownloadCommand",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
")",
"\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\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\n",
"httplib",
".",
"SetNoCacheHeaders",
"(",
"header",
")",
"\n",
"httplib",
".",
"SetNoSniff",
"(",
"header",
")",
"\n",
"header",
".",
"Set",
"(",
"\"",
"\"",
",",
"contentLength",
")",
"\n",
"header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"filename",
"=",
"url",
".",
"QueryEscape",
"(",
"filename",
")",
"\n",
"header",
".",
"Set",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"`attachment;filename=\"%v\"`",
",",
"filename",
")",
")",
"\n\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"m",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"Unlock",
"(",
")",
"\n",
"m",
".",
"removeExpired",
"(",
")",
"\n",
"if",
"m",
".",
"tree",
".",
"Get",
"(",
"&",
"btreeItem",
"{",
"Item",
":",
"i",
"}",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"replaceWith",
".",
"Key",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"bytes",
".",
"Compare",
"(",
"expected",
".",
"Key",
",",
"replaceWith",
".",
"Key",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"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",
"(",
"\"",
"\"",
",",
"string",
"(",
"expected",
".",
"Key",
")",
")",
"\n",
"}",
"\n",
"existingItem",
":=",
"i",
".",
"(",
"*",
"btreeItem",
")",
".",
"Item",
"\n",
"if",
"bytes",
".",
"Compare",
"(",
"existingItem",
".",
"Value",
",",
"expected",
".",
"Value",
")",
"!=",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"CompareFailed",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"string",
"(",
"item",
".",
"Key",
")",
",",
"item",
".",
"Expires",
")",
"\n",
"removed",
"++",
"\n",
"}",
"\n",
"if",
"removed",
">",
"0",
"{",
"m",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n",
"if",
"ver",
",",
"ok",
":=",
"val",
".",
"Version",
"(",
")",
";",
"!",
"ok",
"||",
"ver",
"!=",
"1",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
")",
"\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\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\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",
"(",
"\"",
"\"",
",",
"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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"Login",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"Created",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"sess",
".",
"LastActive",
".",
"IsZero",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\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\n",
"key",
":=",
"activeKey",
"(",
"req",
".",
"Namespace",
",",
"string",
"(",
"req",
".",
"ID",
")",
")",
"\n\n",
"// Try several times, then give up",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"sessionUpdateAttempts",
";",
"i",
"++",
"{",
"item",
",",
"err",
":=",
"s",
".",
"bk",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"var",
"session",
"Session",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"item",
".",
"Value",
",",
"&",
"session",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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\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",
",",
"\"",
"\"",
")",
"\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",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"h",
">",
"maxSize",
"||",
"h",
"<",
"minSize",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\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",
"{",
"// always be safe, better to double record than not record at all",
"clusterConfig",
",",
"err",
":=",
"s",
".",
"GetAccessPoint",
"(",
")",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"isRecordAtProxy",
":=",
"clusterConfig",
".",
"GetSessionRecording",
"(",
")",
"==",
"services",
".",
"RecordAtProxy",
"\n",
"isTeleportNode",
":=",
"s",
".",
"Component",
"(",
")",
"==",
"teleport",
".",
"ComponentNode",
"\n\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",
"{",
"// wait until connections drain off",
"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",
"(",
"\"",
"\"",
",",
"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\n",
"// 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",
"\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",
"{",
"// always set proxy mode to true,",
"// because in some tests reverse tunnel is disabled,",
"// but proxy is still used without it.",
"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",
"{",
"// make sure to clone labels to avoid",
"// concurrent writes to the map during reloads",
"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",
"(",
"\"",
"\"",
",",
"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",
"{",
"// gather information about user and process. this will be used to set the",
"// socket path and permissions",
"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\n",
"// build the socket path and set permissions",
"socketDir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"os",
".",
"TempDir",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"dirCloser",
":=",
"&",
"utils",
".",
"RemoveDirCloser",
"{",
"Path",
":",
"socketDir",
"}",
"\n",
"socketPath",
":=",
"filepath",
".",
"Join",
"(",
"socketDir",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pid",
")",
")",
"\n",
"if",
"err",
":=",
"os",
".",
"Chown",
"(",
"socketDir",
",",
"uid",
",",
"gid",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
":=",
"dirCloser",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// start an agent on a unix socket",
"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",
"(",
"\"",
"\"",
",",
"pid",
")",
")",
"\n",
"ctx",
".",
"AddCloser",
"(",
"agentServer",
")",
"\n",
"ctx",
".",
"AddCloser",
"(",
"dirCloser",
")",
"\n",
"ctx",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"ctx",
".",
"Identity",
".",
"TeleportUser",
",",
"socketPath",
")",
"\n",
"go",
"agentServer",
".",
"Serve",
"(",
")",
"\n\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",
"(",
"\"",
"\"",
",",
"event",
".",
"Name",
")",
"\n",
"alog",
":=",
"s",
".",
"alog",
"\n",
"if",
"alog",
"!=",
"nil",
"{",
"// record the event time with ms precision",
"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",
"(",
"\"",
"\"",
")",
"\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",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"channelType",
":=",
"nch",
".",
"ChannelType",
"(",
")",
"\n",
"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",
"==",
"\"",
"\"",
"{",
"ch",
",",
"requests",
",",
"err",
":=",
"nch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"ConnectionFailed",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"s",
".",
"handleSessionRequests",
"(",
"wconn",
",",
"sconn",
",",
"identityContext",
",",
"ch",
",",
"requests",
")",
"\n",
"}",
"else",
"{",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"UnknownChannelType",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"channelType",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n\n",
"switch",
"channelType",
"{",
"// Channels of type \"session\" handle requests that are involved in running",
"// commands on a server, subsystem requests, and agent forwarding.",
"case",
"\"",
"\"",
":",
"ch",
",",
"requests",
",",
"err",
":=",
"nch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"ConnectionFailed",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"s",
".",
"handleSessionRequests",
"(",
"wconn",
",",
"sconn",
",",
"identityContext",
",",
"ch",
",",
"requests",
")",
"\n",
"// Channels of type \"direct-tcpip\" handles request for port forwarding.",
"case",
"\"",
"\"",
":",
"req",
",",
"err",
":=",
"sshutils",
".",
"ParseDirectTCPIPReq",
"(",
"nch",
".",
"ExtraData",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"nch",
".",
"ExtraData",
"(",
")",
")",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"UnknownChannelType",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"ch",
",",
"_",
",",
"err",
":=",
"nch",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"ConnectionFailed",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"s",
".",
"handleDirectTCPIPRequest",
"(",
"wconn",
",",
"sconn",
",",
"identityContext",
",",
"ch",
",",
"req",
")",
"\n",
"default",
":",
"nch",
".",
"Reject",
"(",
"ssh",
".",
"UnknownChannelType",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"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",
"{",
"// check if the user's RBAC role allows agent forwarding",
"err",
":=",
"s",
".",
"authHandlers",
".",
"CheckAgentForward",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// open a channel to the client where the client will serve an agent",
"authChannel",
",",
"_",
",",
"err",
":=",
"ctx",
".",
"Conn",
".",
"OpenChannel",
"(",
"sshutils",
".",
"AuthAgentRequest",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// save the agent in the context so it can be used later",
"ctx",
".",
"SetAgent",
"(",
"agent",
".",
"NewClient",
"(",
"authChannel",
")",
",",
"authChannel",
")",
"\n\n",
"// serve an agent on a unix socket on this node",
"err",
"=",
"s",
".",
"serveAgent",
"(",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\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",
"(",
"\"",
"\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
")",
"\n\n",
"// only reply if the sender actually wants a response",
"if",
"req",
".",
"WantReply",
"{",
"err",
":=",
"req",
".",
"Reply",
"(",
"true",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"req",
".",
"Type",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"req",
".",
"Type",
")",
"\n",
"}"
] | // handleKeepAlive accepts and replies to [email protected] 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\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
")",
"\n\n",
"if",
"req",
".",
"WantReply",
"{",
"// get the cluster config, if we can't get it, reply false",
"clusterConfig",
",",
"err",
":=",
"s",
".",
"authService",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
":=",
"req",
".",
"Reply",
"(",
"false",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n\n",
"// 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",
"\n",
"err",
"=",
"req",
".",
"Reply",
"(",
"true",
",",
"[",
"]",
"byte",
"(",
"strconv",
".",
"FormatBool",
"(",
"recordingProxy",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"req",
".",
"Type",
",",
"req",
".",
"WantReply",
",",
"recordingProxy",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"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",
"{",
"// try unmarshal as string",
"var",
"val",
"string",
"\n",
"err",
":=",
"unmarshal",
"(",
"&",
"val",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"s",
"=",
"[",
"]",
"string",
"{",
"val",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// try unmarshal as slice",
"var",
"slice",
"[",
"]",
"string",
"\n",
"err",
"=",
"unmarshal",
"(",
"&",
"slice",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"s",
"=",
"slice",
"\n",
"return",
"nil",
"\n",
"}",
"\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 |
gravitational/teleport | lib/services/wrappers.go | MarshalJSON | func (s Strings) MarshalJSON() ([]byte, error) {
if len(s) == 1 {
return json.Marshal(s[0])
}
return json.Marshal([]string(s))
} | go | func (s Strings) MarshalJSON() ([]byte, error) {
if len(s) == 1 {
return json.Marshal(s[0])
}
return json.Marshal([]string(s))
} | [
"func",
"(",
"s",
"Strings",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"len",
"(",
"s",
")",
"==",
"1",
"{",
"return",
"json",
".",
"Marshal",
"(",
"s",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"[",
"]",
"string",
"(",
"s",
")",
")",
"\n",
"}"
] | // MarshalJSON marshals to scalar value
// if there is only one value in the list
// to list otherwise | [
"MarshalJSON",
"marshals",
"to",
"scalar",
"value",
"if",
"there",
"is",
"only",
"one",
"value",
"in",
"the",
"list",
"to",
"list",
"otherwise"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/wrappers.go#L141-L146 | train |
gravitational/teleport | lib/services/wrappers.go | MarshalYAML | func (s Strings) MarshalYAML() (interface{}, error) {
if len(s) == 1 {
return s[0], nil
}
return []string(s), nil
} | go | func (s Strings) MarshalYAML() (interface{}, error) {
if len(s) == 1 {
return s[0], nil
}
return []string(s), nil
} | [
"func",
"(",
"s",
"Strings",
")",
"MarshalYAML",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"len",
"(",
"s",
")",
"==",
"1",
"{",
"return",
"s",
"[",
"0",
"]",
",",
"nil",
"\n",
"}",
"\n",
"return",
"[",
"]",
"string",
"(",
"s",
")",
",",
"nil",
"\n",
"}"
] | // MarshalYAML marshals to scalar value
// if there is only one value in the list,
// marshals to list otherwise | [
"MarshalYAML",
"marshals",
"to",
"scalar",
"value",
"if",
"there",
"is",
"only",
"one",
"value",
"in",
"the",
"list",
"marshals",
"to",
"list",
"otherwise"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/wrappers.go#L151-L156 | train |
gravitational/teleport | lib/utils/utils.go | NewTracer | func NewTracer(description string) *Tracer {
return &Tracer{Started: time.Now().UTC(), Description: description}
} | go | func NewTracer(description string) *Tracer {
return &Tracer{Started: time.Now().UTC(), Description: description}
} | [
"func",
"NewTracer",
"(",
"description",
"string",
")",
"*",
"Tracer",
"{",
"return",
"&",
"Tracer",
"{",
"Started",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"Description",
":",
"description",
"}",
"\n",
"}"
] | // NewTracer returns a new tracer | [
"NewTracer",
"returns",
"a",
"new",
"tracer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L50-L52 | train |
gravitational/teleport | lib/utils/utils.go | Stop | func (t *Tracer) Stop() *Tracer {
log.Debugf("Tracer completed %v in %v.", t.Description, time.Now().Sub(t.Started))
return t
} | go | func (t *Tracer) Stop() *Tracer {
log.Debugf("Tracer completed %v in %v.", t.Description, time.Now().Sub(t.Started))
return t
} | [
"func",
"(",
"t",
"*",
"Tracer",
")",
"Stop",
"(",
")",
"*",
"Tracer",
"{",
"log",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"t",
".",
"Description",
",",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"t",
".",
"Started",
")",
")",
"\n",
"return",
"t",
"\n",
"}"
] | // Stop logs stop of the trace | [
"Stop",
"logs",
"stop",
"of",
"the",
"trace"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L61-L64 | train |
gravitational/teleport | lib/utils/utils.go | ThisFunction | func ThisFunction() string {
var pc [32]uintptr
runtime.Callers(2, pc[:])
return runtime.FuncForPC(pc[0]).Name()
} | go | func ThisFunction() string {
var pc [32]uintptr
runtime.Callers(2, pc[:])
return runtime.FuncForPC(pc[0]).Name()
} | [
"func",
"ThisFunction",
"(",
")",
"string",
"{",
"var",
"pc",
"[",
"32",
"]",
"uintptr",
"\n",
"runtime",
".",
"Callers",
"(",
"2",
",",
"pc",
"[",
":",
"]",
")",
"\n",
"return",
"runtime",
".",
"FuncForPC",
"(",
"pc",
"[",
"0",
"]",
")",
".",
"Name",
"(",
")",
"\n",
"}"
] | // ThisFunction returns calling function name | [
"ThisFunction",
"returns",
"calling",
"function",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L67-L71 | train |
gravitational/teleport | lib/utils/utils.go | Value | func (s *SyncString) Value() string {
s.Lock()
defer s.Unlock()
return s.string
} | go | func (s *SyncString) Value() string {
s.Lock()
defer s.Unlock()
return s.string
} | [
"func",
"(",
"s",
"*",
"SyncString",
")",
"Value",
"(",
")",
"string",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"return",
"s",
".",
"string",
"\n",
"}"
] | // Value returns value of the string | [
"Value",
"returns",
"value",
"of",
"the",
"string"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L81-L85 | train |
gravitational/teleport | lib/utils/utils.go | Set | func (s *SyncString) Set(v string) {
s.Lock()
defer s.Unlock()
s.string = v
} | go | func (s *SyncString) Set(v string) {
s.Lock()
defer s.Unlock()
s.string = v
} | [
"func",
"(",
"s",
"*",
"SyncString",
")",
"Set",
"(",
"v",
"string",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"string",
"=",
"v",
"\n",
"}"
] | // Set sets the value of the string | [
"Set",
"sets",
"the",
"value",
"of",
"the",
"string"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L88-L92 | train |
gravitational/teleport | lib/utils/utils.go | AsBool | func AsBool(v string) bool {
if v == "" {
return false
}
out, _ := ParseBool(v)
return out
} | go | func AsBool(v string) bool {
if v == "" {
return false
}
out, _ := ParseBool(v)
return out
} | [
"func",
"AsBool",
"(",
"v",
"string",
")",
"bool",
"{",
"if",
"v",
"==",
"\"",
"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"out",
",",
"_",
":=",
"ParseBool",
"(",
"v",
")",
"\n",
"return",
"out",
"\n",
"}"
] | // AsBool converts string to bool, in case of the value is empty
// or unknown, defaults to false | [
"AsBool",
"converts",
"string",
"to",
"bool",
"in",
"case",
"of",
"the",
"value",
"is",
"empty",
"or",
"unknown",
"defaults",
"to",
"false"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L118-L124 | train |
gravitational/teleport | lib/utils/utils.go | ParseBool | func ParseBool(value string) (bool, error) {
switch strings.ToLower(value) {
case "yes", "yeah", "y", "true", "1", "on":
return true, nil
case "no", "nope", "n", "false", "0", "off":
return false, nil
default:
return false, trace.BadParameter("unsupported value: %q", value)
}
} | go | func ParseBool(value string) (bool, error) {
switch strings.ToLower(value) {
case "yes", "yeah", "y", "true", "1", "on":
return true, nil
case "no", "nope", "n", "false", "0", "off":
return false, nil
default:
return false, trace.BadParameter("unsupported value: %q", value)
}
} | [
"func",
"ParseBool",
"(",
"value",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"value",
")",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"true",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"false",
",",
"nil",
"\n",
"default",
":",
"return",
"false",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"value",
")",
"\n",
"}",
"\n",
"}"
] | // ParseBool parses string as boolean value,
// returns error in case if value is not recognized | [
"ParseBool",
"parses",
"string",
"as",
"boolean",
"value",
"returns",
"error",
"in",
"case",
"if",
"value",
"is",
"not",
"recognized"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L128-L137 | train |
gravitational/teleport | lib/utils/utils.go | ParseAdvertiseAddr | func ParseAdvertiseAddr(advertiseIP string) (string, string, error) {
advertiseIP = strings.TrimSpace(advertiseIP)
host := advertiseIP
port := ""
if len(net.ParseIP(host)) == 0 && strings.Contains(advertiseIP, ":") {
var err error
host, port, err = net.SplitHostPort(advertiseIP)
if err != nil {
return "", "", trace.BadParameter("failed to parse address %q", advertiseIP)
}
if _, err := strconv.Atoi(port); err != nil {
return "", "", trace.BadParameter("bad port %q, expected integer", port)
}
if host == "" {
return "", "", trace.BadParameter("missing host parameter")
}
}
ip := net.ParseIP(host)
if len(ip) != 0 {
if ip.IsUnspecified() || ip.IsMulticast() {
return "", "", trace.BadParameter("unreachable advertise IP: %v", advertiseIP)
}
}
return host, port, nil
} | go | func ParseAdvertiseAddr(advertiseIP string) (string, string, error) {
advertiseIP = strings.TrimSpace(advertiseIP)
host := advertiseIP
port := ""
if len(net.ParseIP(host)) == 0 && strings.Contains(advertiseIP, ":") {
var err error
host, port, err = net.SplitHostPort(advertiseIP)
if err != nil {
return "", "", trace.BadParameter("failed to parse address %q", advertiseIP)
}
if _, err := strconv.Atoi(port); err != nil {
return "", "", trace.BadParameter("bad port %q, expected integer", port)
}
if host == "" {
return "", "", trace.BadParameter("missing host parameter")
}
}
ip := net.ParseIP(host)
if len(ip) != 0 {
if ip.IsUnspecified() || ip.IsMulticast() {
return "", "", trace.BadParameter("unreachable advertise IP: %v", advertiseIP)
}
}
return host, port, nil
} | [
"func",
"ParseAdvertiseAddr",
"(",
"advertiseIP",
"string",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"advertiseIP",
"=",
"strings",
".",
"TrimSpace",
"(",
"advertiseIP",
")",
"\n",
"host",
":=",
"advertiseIP",
"\n",
"port",
":=",
"\"",
"\"",
"\n",
"if",
"len",
"(",
"net",
".",
"ParseIP",
"(",
"host",
")",
")",
"==",
"0",
"&&",
"strings",
".",
"Contains",
"(",
"advertiseIP",
",",
"\"",
"\"",
")",
"{",
"var",
"err",
"error",
"\n",
"host",
",",
"port",
",",
"err",
"=",
"net",
".",
"SplitHostPort",
"(",
"advertiseIP",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"advertiseIP",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"port",
")",
"\n",
"}",
"\n",
"if",
"host",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"host",
")",
"\n",
"if",
"len",
"(",
"ip",
")",
"!=",
"0",
"{",
"if",
"ip",
".",
"IsUnspecified",
"(",
")",
"||",
"ip",
".",
"IsMulticast",
"(",
")",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"advertiseIP",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"host",
",",
"port",
",",
"nil",
"\n",
"}"
] | // ParseAdvertiseAddr validates advertise address,
// makes sure it's not an unreachable or multicast address
// returns address split into host and port, port could be empty
// if not specified | [
"ParseAdvertiseAddr",
"validates",
"advertise",
"address",
"makes",
"sure",
"it",
"s",
"not",
"an",
"unreachable",
"or",
"multicast",
"address",
"returns",
"address",
"split",
"into",
"host",
"and",
"port",
"port",
"could",
"be",
"empty",
"if",
"not",
"specified"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L143-L167 | train |
gravitational/teleport | lib/utils/utils.go | ParseOnOff | func ParseOnOff(parameterName, val string, defaultValue bool) (bool, error) {
switch val {
case teleport.On:
return true, nil
case teleport.Off:
return false, nil
case "":
return defaultValue, nil
default:
return false, trace.BadParameter("bad %q parameter value: %q, supported values are on or off", parameterName, val)
}
} | go | func ParseOnOff(parameterName, val string, defaultValue bool) (bool, error) {
switch val {
case teleport.On:
return true, nil
case teleport.Off:
return false, nil
case "":
return defaultValue, nil
default:
return false, trace.BadParameter("bad %q parameter value: %q, supported values are on or off", parameterName, val)
}
} | [
"func",
"ParseOnOff",
"(",
"parameterName",
",",
"val",
"string",
",",
"defaultValue",
"bool",
")",
"(",
"bool",
",",
"error",
")",
"{",
"switch",
"val",
"{",
"case",
"teleport",
".",
"On",
":",
"return",
"true",
",",
"nil",
"\n",
"case",
"teleport",
".",
"Off",
":",
"return",
"false",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"return",
"defaultValue",
",",
"nil",
"\n",
"default",
":",
"return",
"false",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"parameterName",
",",
"val",
")",
"\n",
"}",
"\n",
"}"
] | // ParseOnOff parses whether value is "on" or "off", parameterName is passed for error
// reporting purposes, defaultValue is returned when no value is set | [
"ParseOnOff",
"parses",
"whether",
"value",
"is",
"on",
"or",
"off",
"parameterName",
"is",
"passed",
"for",
"error",
"reporting",
"purposes",
"defaultValue",
"is",
"returned",
"when",
"no",
"value",
"is",
"set"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L184-L195 | train |
gravitational/teleport | lib/utils/utils.go | IsGroupMember | func IsGroupMember(gid int) (bool, error) {
groups, err := os.Getgroups()
if err != nil {
return false, trace.ConvertSystemError(err)
}
for _, group := range groups {
if group == gid {
return true, nil
}
}
return false, nil
} | go | func IsGroupMember(gid int) (bool, error) {
groups, err := os.Getgroups()
if err != nil {
return false, trace.ConvertSystemError(err)
}
for _, group := range groups {
if group == gid {
return true, nil
}
}
return false, nil
} | [
"func",
"IsGroupMember",
"(",
"gid",
"int",
")",
"(",
"bool",
",",
"error",
")",
"{",
"groups",
",",
"err",
":=",
"os",
".",
"Getgroups",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"group",
":=",
"range",
"groups",
"{",
"if",
"group",
"==",
"gid",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // IsGroupMember returns whether currently logged user is a member of a group | [
"IsGroupMember",
"returns",
"whether",
"currently",
"logged",
"user",
"is",
"a",
"member",
"of",
"a",
"group"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L198-L209 | train |
gravitational/teleport | lib/utils/utils.go | SplitHostPort | func SplitHostPort(hostname string) (string, string, error) {
host, port, err := net.SplitHostPort(hostname)
if err != nil {
return "", "", trace.Wrap(err)
}
if host == "" {
return "", "", trace.BadParameter("empty hostname")
}
return host, port, nil
} | go | func SplitHostPort(hostname string) (string, string, error) {
host, port, err := net.SplitHostPort(hostname)
if err != nil {
return "", "", trace.Wrap(err)
}
if host == "" {
return "", "", trace.BadParameter("empty hostname")
}
return host, port, nil
} | [
"func",
"SplitHostPort",
"(",
"hostname",
"string",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"host",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"hostname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"host",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"host",
",",
"port",
",",
"nil",
"\n",
"}"
] | // SplitHostPort splits host and port and checks that host is not empty | [
"SplitHostPort",
"splits",
"host",
"and",
"port",
"and",
"checks",
"that",
"host",
"is",
"not",
"empty"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L224-L233 | train |
gravitational/teleport | lib/utils/utils.go | ReadPath | func ReadPath(path string) ([]byte, error) {
if path == "" {
return nil, trace.NotFound("empty path")
}
s, err := filepath.Abs(path)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
abs, err := filepath.EvalSymlinks(s)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
bytes, err := ioutil.ReadFile(abs)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
return bytes, nil
} | go | func ReadPath(path string) ([]byte, error) {
if path == "" {
return nil, trace.NotFound("empty path")
}
s, err := filepath.Abs(path)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
abs, err := filepath.EvalSymlinks(s)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
bytes, err := ioutil.ReadFile(abs)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
return bytes, nil
} | [
"func",
"ReadPath",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"path",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"s",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"abs",
",",
"err",
":=",
"filepath",
".",
"EvalSymlinks",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"abs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"bytes",
",",
"nil",
"\n",
"}"
] | // ReadPath reads file contents | [
"ReadPath",
"reads",
"file",
"contents"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L236-L253 | train |
gravitational/teleport | lib/utils/utils.go | IsHandshakeFailedError | func IsHandshakeFailedError(err error) bool {
if err == nil {
return false
}
return strings.Contains(trace.Unwrap(err).Error(), "ssh: handshake failed")
} | go | func IsHandshakeFailedError(err error) bool {
if err == nil {
return false
}
return strings.Contains(trace.Unwrap(err).Error(), "ssh: handshake failed")
} | [
"func",
"IsHandshakeFailedError",
"(",
"err",
"error",
")",
"bool",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Contains",
"(",
"trace",
".",
"Unwrap",
"(",
"err",
")",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // IsHandshakeFailedError specifies whether this error indicates
// failed handshake | [
"IsHandshakeFailedError",
"specifies",
"whether",
"this",
"error",
"indicates",
"failed",
"handshake"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L277-L282 | train |
gravitational/teleport | lib/utils/utils.go | Pop | func (p *PortList) Pop() string {
if len(*p) == 0 {
panic("list is empty")
}
val := (*p)[len(*p)-1]
*p = (*p)[:len(*p)-1]
return val
} | go | func (p *PortList) Pop() string {
if len(*p) == 0 {
panic("list is empty")
}
val := (*p)[len(*p)-1]
*p = (*p)[:len(*p)-1]
return val
} | [
"func",
"(",
"p",
"*",
"PortList",
")",
"Pop",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"*",
"p",
")",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"val",
":=",
"(",
"*",
"p",
")",
"[",
"len",
"(",
"*",
"p",
")",
"-",
"1",
"]",
"\n",
"*",
"p",
"=",
"(",
"*",
"p",
")",
"[",
":",
"len",
"(",
"*",
"p",
")",
"-",
"1",
"]",
"\n",
"return",
"val",
"\n",
"}"
] | // Pop returns a value from the list, it panics if the value is not there | [
"Pop",
"returns",
"a",
"value",
"from",
"the",
"list",
"it",
"panics",
"if",
"the",
"value",
"is",
"not",
"there"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L303-L310 | train |
gravitational/teleport | lib/utils/utils.go | PopInt | func (p *PortList) PopInt() int {
i, err := strconv.Atoi(p.Pop())
if err != nil {
panic(err)
}
return i
} | go | func (p *PortList) PopInt() int {
i, err := strconv.Atoi(p.Pop())
if err != nil {
panic(err)
}
return i
} | [
"func",
"(",
"p",
"*",
"PortList",
")",
"PopInt",
"(",
")",
"int",
"{",
"i",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"p",
".",
"Pop",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"i",
"\n",
"}"
] | // PopInt returns a value from the list, it panics if not enough values
// were allocated | [
"PopInt",
"returns",
"a",
"value",
"from",
"the",
"list",
"it",
"panics",
"if",
"not",
"enough",
"values",
"were",
"allocated"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L314-L320 | train |
gravitational/teleport | lib/utils/utils.go | PopIntSlice | func (p *PortList) PopIntSlice(num int) []int {
ports := make([]int, num)
for i := range ports {
ports[i] = p.PopInt()
}
return ports
} | go | func (p *PortList) PopIntSlice(num int) []int {
ports := make([]int, num)
for i := range ports {
ports[i] = p.PopInt()
}
return ports
} | [
"func",
"(",
"p",
"*",
"PortList",
")",
"PopIntSlice",
"(",
"num",
"int",
")",
"[",
"]",
"int",
"{",
"ports",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"num",
")",
"\n",
"for",
"i",
":=",
"range",
"ports",
"{",
"ports",
"[",
"i",
"]",
"=",
"p",
".",
"PopInt",
"(",
")",
"\n",
"}",
"\n",
"return",
"ports",
"\n",
"}"
] | // PopIntSlice returns a slice of values from the list, it panics if not enough
// ports were allocated | [
"PopIntSlice",
"returns",
"a",
"slice",
"of",
"values",
"from",
"the",
"list",
"it",
"panics",
"if",
"not",
"enough",
"ports",
"were",
"allocated"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L324-L330 | train |
gravitational/teleport | lib/utils/utils.go | GetFreeTCPPorts | func GetFreeTCPPorts(n int, offset ...int) (PortList, error) {
list := make(PortList, 0, n)
start := PortStartingNumber
if len(offset) != 0 {
start = offset[0]
}
for i := start; i < start+n; i++ {
list = append(list, strconv.Itoa(i))
}
return list, nil
} | go | func GetFreeTCPPorts(n int, offset ...int) (PortList, error) {
list := make(PortList, 0, n)
start := PortStartingNumber
if len(offset) != 0 {
start = offset[0]
}
for i := start; i < start+n; i++ {
list = append(list, strconv.Itoa(i))
}
return list, nil
} | [
"func",
"GetFreeTCPPorts",
"(",
"n",
"int",
",",
"offset",
"...",
"int",
")",
"(",
"PortList",
",",
"error",
")",
"{",
"list",
":=",
"make",
"(",
"PortList",
",",
"0",
",",
"n",
")",
"\n",
"start",
":=",
"PortStartingNumber",
"\n",
"if",
"len",
"(",
"offset",
")",
"!=",
"0",
"{",
"start",
"=",
"offset",
"[",
"0",
"]",
"\n",
"}",
"\n",
"for",
"i",
":=",
"start",
";",
"i",
"<",
"start",
"+",
"n",
";",
"i",
"++",
"{",
"list",
"=",
"append",
"(",
"list",
",",
"strconv",
".",
"Itoa",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"list",
",",
"nil",
"\n",
"}"
] | // GetFreeTCPPorts returns n ports starting from port 20000. | [
"GetFreeTCPPorts",
"returns",
"n",
"ports",
"starting",
"from",
"port",
"20000",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L336-L346 | train |
gravitational/teleport | lib/utils/utils.go | ReadHostUUID | func ReadHostUUID(dataDir string) (string, error) {
out, err := ReadPath(filepath.Join(dataDir, HostUUIDFile))
if err != nil {
return "", trace.Wrap(err)
}
return strings.TrimSpace(string(out)), nil
} | go | func ReadHostUUID(dataDir string) (string, error) {
out, err := ReadPath(filepath.Join(dataDir, HostUUIDFile))
if err != nil {
return "", trace.Wrap(err)
}
return strings.TrimSpace(string(out)), nil
} | [
"func",
"ReadHostUUID",
"(",
"dataDir",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"ReadPath",
"(",
"filepath",
".",
"Join",
"(",
"dataDir",
",",
"HostUUIDFile",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"out",
")",
")",
",",
"nil",
"\n",
"}"
] | // ReadHostUUID reads host UUID from the file in the data dir | [
"ReadHostUUID",
"reads",
"host",
"UUID",
"from",
"the",
"file",
"in",
"the",
"data",
"dir"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L349-L355 | train |
gravitational/teleport | lib/utils/utils.go | WriteHostUUID | func WriteHostUUID(dataDir string, id string) error {
err := ioutil.WriteFile(filepath.Join(dataDir, HostUUIDFile), []byte(id), os.ModeExclusive|0400)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | func WriteHostUUID(dataDir string, id string) error {
err := ioutil.WriteFile(filepath.Join(dataDir, HostUUIDFile), []byte(id), os.ModeExclusive|0400)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"WriteHostUUID",
"(",
"dataDir",
"string",
",",
"id",
"string",
")",
"error",
"{",
"err",
":=",
"ioutil",
".",
"WriteFile",
"(",
"filepath",
".",
"Join",
"(",
"dataDir",
",",
"HostUUIDFile",
")",
",",
"[",
"]",
"byte",
"(",
"id",
")",
",",
"os",
".",
"ModeExclusive",
"|",
"0400",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteHostUUID writes host UUID into a file | [
"WriteHostUUID",
"writes",
"host",
"UUID",
"into",
"a",
"file"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L358-L364 | train |
gravitational/teleport | lib/utils/utils.go | ReadOrMakeHostUUID | func ReadOrMakeHostUUID(dataDir string) (string, error) {
id, err := ReadHostUUID(dataDir)
if err == nil {
return id, nil
}
if !trace.IsNotFound(err) {
return "", trace.Wrap(err)
}
id = uuid.New()
if err = WriteHostUUID(dataDir, id); err != nil {
return "", trace.Wrap(err)
}
return id, nil
} | go | func ReadOrMakeHostUUID(dataDir string) (string, error) {
id, err := ReadHostUUID(dataDir)
if err == nil {
return id, nil
}
if !trace.IsNotFound(err) {
return "", trace.Wrap(err)
}
id = uuid.New()
if err = WriteHostUUID(dataDir, id); err != nil {
return "", trace.Wrap(err)
}
return id, nil
} | [
"func",
"ReadOrMakeHostUUID",
"(",
"dataDir",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"id",
",",
"err",
":=",
"ReadHostUUID",
"(",
"dataDir",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"id",
",",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"id",
"=",
"uuid",
".",
"New",
"(",
")",
"\n",
"if",
"err",
"=",
"WriteHostUUID",
"(",
"dataDir",
",",
"id",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"id",
",",
"nil",
"\n",
"}"
] | // ReadOrMakeHostUUID looks for a hostid file in the data dir. If present,
// returns the UUID from it, otherwise generates one | [
"ReadOrMakeHostUUID",
"looks",
"for",
"a",
"hostid",
"file",
"in",
"the",
"data",
"dir",
".",
"If",
"present",
"returns",
"the",
"UUID",
"from",
"it",
"otherwise",
"generates",
"one"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L368-L381 | train |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.