repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
gravitational/teleport | lib/services/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",
"(",
"\"Tracer completed %v in %v.\"",
",",
"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",
"\"yes\"",
",",
"\"yeah\"",
",",
"\"y\"",
",",
"\"true\"",
",",
"\"1\"",
",",
"\"on\"",
":",
"return",
"true",
",",
"nil",
"\n",
"case",
"\"no\"",
",",
"\"nope\"",
",",
"\"n\"",
",",
"\"false\"",
",",
"\"0\"",
",",
"\"off\"",
":",
"return",
"false",
",",
"nil",
"\n",
"default",
":",
"return",
"false",
",",
"trace",
".",
"BadParameter",
"(",
"\"unsupported value: %q\"",
",",
"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",
"(",
"\"failed to parse address %q\"",
",",
"advertiseIP",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"bad port %q, expected integer\"",
",",
"port",
")",
"\n",
"}",
"\n",
"if",
"host",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing host parameter\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"host",
")",
"\n",
"if",
"len",
"(",
"ip",
")",
"!=",
"0",
"{",
"if",
"ip",
".",
"IsUnspecified",
"(",
")",
"||",
"ip",
".",
"IsMulticast",
"(",
")",
"{",
"return",
"\"\"",
",",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"unreachable advertise IP: %v\"",
",",
"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",
"(",
"\"bad %q parameter value: %q, supported values are on or off\"",
",",
"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",
"(",
"\"empty hostname\"",
")",
"\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",
"(",
"\"empty path\"",
")",
"\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",
"(",
")",
",",
"\"ssh: handshake failed\"",
")",
"\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",
"(",
"\"list is empty\"",
")",
"\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 |
gravitational/teleport | lib/utils/utils.go | Deduplicate | func Deduplicate(in []string) []string {
if len(in) == 0 {
return in
}
out := make([]string, 0, len(in))
seen := make(map[string]bool, len(in))
for _, val := range in {
if _, ok := seen[val]; !ok {
out = append(out, val)
seen[val] = true
}
}
return out
} | go | func Deduplicate(in []string) []string {
if len(in) == 0 {
return in
}
out := make([]string, 0, len(in))
seen := make(map[string]bool, len(in))
for _, val := range in {
if _, ok := seen[val]; !ok {
out = append(out, val)
seen[val] = true
}
}
return out
} | [
"func",
"Deduplicate",
"(",
"in",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"if",
"len",
"(",
"in",
")",
"==",
"0",
"{",
"return",
"in",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"in",
")",
")",
"\n",
"seen",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
",",
"len",
"(",
"in",
")",
")",
"\n",
"for",
"_",
",",
"val",
":=",
"range",
"in",
"{",
"if",
"_",
",",
"ok",
":=",
"seen",
"[",
"val",
"]",
";",
"!",
"ok",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"val",
")",
"\n",
"seen",
"[",
"val",
"]",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // Deduplicate deduplicates list of strings | [
"Deduplicate",
"deduplicates",
"list",
"of",
"strings"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L394-L407 | train |
gravitational/teleport | lib/utils/utils.go | SliceContainsStr | func SliceContainsStr(slice []string, value string) bool {
for i := range slice {
if slice[i] == value {
return true
}
}
return false
} | go | func SliceContainsStr(slice []string, value string) bool {
for i := range slice {
if slice[i] == value {
return true
}
}
return false
} | [
"func",
"SliceContainsStr",
"(",
"slice",
"[",
"]",
"string",
",",
"value",
"string",
")",
"bool",
"{",
"for",
"i",
":=",
"range",
"slice",
"{",
"if",
"slice",
"[",
"i",
"]",
"==",
"value",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // SliceContainsStr returns 'true' if the slice contains the given value | [
"SliceContainsStr",
"returns",
"true",
"if",
"the",
"slice",
"contains",
"the",
"given",
"value"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L410-L417 | train |
gravitational/teleport | lib/utils/utils.go | RemoveFromSlice | func RemoveFromSlice(slice []string, values ...string) []string {
output := make([]string, 0, len(slice))
remove := make(map[string]bool)
for _, value := range values {
remove[value] = true
}
for _, s := range slice {
_, ok := remove[s]
if ok {
continue
}
output = append(output, s)
}
return output
} | go | func RemoveFromSlice(slice []string, values ...string) []string {
output := make([]string, 0, len(slice))
remove := make(map[string]bool)
for _, value := range values {
remove[value] = true
}
for _, s := range slice {
_, ok := remove[s]
if ok {
continue
}
output = append(output, s)
}
return output
} | [
"func",
"RemoveFromSlice",
"(",
"slice",
"[",
"]",
"string",
",",
"values",
"...",
"string",
")",
"[",
"]",
"string",
"{",
"output",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"slice",
")",
")",
"\n",
"remove",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"values",
"{",
"remove",
"[",
"value",
"]",
"=",
"true",
"\n",
"}",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"slice",
"{",
"_",
",",
"ok",
":=",
"remove",
"[",
"s",
"]",
"\n",
"if",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"output",
"=",
"append",
"(",
"output",
",",
"s",
")",
"\n",
"}",
"\n",
"return",
"output",
"\n",
"}"
] | // RemoveFromSlice makes a copy of the slice and removes the passed in values from the copy. | [
"RemoveFromSlice",
"makes",
"a",
"copy",
"of",
"the",
"slice",
"and",
"removes",
"the",
"passed",
"in",
"values",
"from",
"the",
"copy",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L420-L437 | train |
gravitational/teleport | lib/utils/utils.go | CheckCertificateFormatFlag | func CheckCertificateFormatFlag(s string) (string, error) {
switch s {
case teleport.CertificateFormatStandard, teleport.CertificateFormatOldSSH, teleport.CertificateFormatUnspecified:
return s, nil
default:
return "", trace.BadParameter("invalid certificate format parameter: %q", s)
}
} | go | func CheckCertificateFormatFlag(s string) (string, error) {
switch s {
case teleport.CertificateFormatStandard, teleport.CertificateFormatOldSSH, teleport.CertificateFormatUnspecified:
return s, nil
default:
return "", trace.BadParameter("invalid certificate format parameter: %q", s)
}
} | [
"func",
"CheckCertificateFormatFlag",
"(",
"s",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"switch",
"s",
"{",
"case",
"teleport",
".",
"CertificateFormatStandard",
",",
"teleport",
".",
"CertificateFormatOldSSH",
",",
"teleport",
".",
"CertificateFormatUnspecified",
":",
"return",
"s",
",",
"nil",
"\n",
"default",
":",
"return",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid certificate format parameter: %q\"",
",",
"s",
")",
"\n",
"}",
"\n",
"}"
] | // CheckCertificateFormatFlag checks if the certificate format is valid. | [
"CheckCertificateFormatFlag",
"checks",
"if",
"the",
"certificate",
"format",
"is",
"valid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L440-L447 | train |
gravitational/teleport | lib/utils/utils.go | Addrs | func (s Strings) Addrs(defaultPort int) ([]NetAddr, error) {
addrs := make([]NetAddr, len(s))
for i, val := range s {
addr, err := ParseHostPortAddr(val, defaultPort)
if err != nil {
return nil, trace.Wrap(err)
}
addrs[i] = *addr
}
return addrs, nil
} | go | func (s Strings) Addrs(defaultPort int) ([]NetAddr, error) {
addrs := make([]NetAddr, len(s))
for i, val := range s {
addr, err := ParseHostPortAddr(val, defaultPort)
if err != nil {
return nil, trace.Wrap(err)
}
addrs[i] = *addr
}
return addrs, nil
} | [
"func",
"(",
"s",
"Strings",
")",
"Addrs",
"(",
"defaultPort",
"int",
")",
"(",
"[",
"]",
"NetAddr",
",",
"error",
")",
"{",
"addrs",
":=",
"make",
"(",
"[",
"]",
"NetAddr",
",",
"len",
"(",
"s",
")",
")",
"\n",
"for",
"i",
",",
"val",
":=",
"range",
"s",
"{",
"addr",
",",
"err",
":=",
"ParseHostPortAddr",
"(",
"val",
",",
"defaultPort",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"addrs",
"[",
"i",
"]",
"=",
"*",
"addr",
"\n",
"}",
"\n",
"return",
"addrs",
",",
"nil",
"\n",
"}"
] | // Addrs returns strings list converted to address list | [
"Addrs",
"returns",
"strings",
"list",
"converted",
"to",
"address",
"list"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/utils.go#L514-L524 | train |
gravitational/teleport | tool/tctl/common/tctl.go | connectToAuthService | func connectToAuthService(cfg *service.Config) (client auth.ClientI, err error) {
// connect to the local auth server by default:
cfg.Auth.Enabled = true
if len(cfg.AuthServers) == 0 {
cfg.AuthServers = []utils.NetAddr{
*defaults.AuthConnectAddr(),
}
}
// read the host SSH keys and use them to open an SSH connection to the auth service
i, err := auth.ReadLocalIdentity(filepath.Join(cfg.DataDir, teleport.ComponentProcess), auth.IdentityID{Role: teleport.RoleAdmin, HostUUID: cfg.HostUUID})
if err != nil {
// the "admin" identity is not present? this means the tctl is running NOT on the auth server.
if trace.IsNotFound(err) {
return nil, trace.AccessDenied("tctl must be used on the auth server")
}
return nil, trace.Wrap(err)
}
tlsConfig, err := i.TLSConfig(cfg.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
client, err = auth.NewTLSClient(auth.ClientConfig{Addrs: cfg.AuthServers, TLS: tlsConfig})
if err != nil {
return nil, trace.Wrap(err)
}
// Check connectivity by calling something on the client.
_, err = client.GetClusterName()
if err != nil {
utils.Consolef(os.Stderr, teleport.ComponentClient,
"Cannot connect to the auth server: %v.\nIs the auth server running on %v?",
err, cfg.AuthServers[0].Addr)
os.Exit(1)
}
return client, nil
} | go | func connectToAuthService(cfg *service.Config) (client auth.ClientI, err error) {
// connect to the local auth server by default:
cfg.Auth.Enabled = true
if len(cfg.AuthServers) == 0 {
cfg.AuthServers = []utils.NetAddr{
*defaults.AuthConnectAddr(),
}
}
// read the host SSH keys and use them to open an SSH connection to the auth service
i, err := auth.ReadLocalIdentity(filepath.Join(cfg.DataDir, teleport.ComponentProcess), auth.IdentityID{Role: teleport.RoleAdmin, HostUUID: cfg.HostUUID})
if err != nil {
// the "admin" identity is not present? this means the tctl is running NOT on the auth server.
if trace.IsNotFound(err) {
return nil, trace.AccessDenied("tctl must be used on the auth server")
}
return nil, trace.Wrap(err)
}
tlsConfig, err := i.TLSConfig(cfg.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
client, err = auth.NewTLSClient(auth.ClientConfig{Addrs: cfg.AuthServers, TLS: tlsConfig})
if err != nil {
return nil, trace.Wrap(err)
}
// Check connectivity by calling something on the client.
_, err = client.GetClusterName()
if err != nil {
utils.Consolef(os.Stderr, teleport.ComponentClient,
"Cannot connect to the auth server: %v.\nIs the auth server running on %v?",
err, cfg.AuthServers[0].Addr)
os.Exit(1)
}
return client, nil
} | [
"func",
"connectToAuthService",
"(",
"cfg",
"*",
"service",
".",
"Config",
")",
"(",
"client",
"auth",
".",
"ClientI",
",",
"err",
"error",
")",
"{",
"cfg",
".",
"Auth",
".",
"Enabled",
"=",
"true",
"\n",
"if",
"len",
"(",
"cfg",
".",
"AuthServers",
")",
"==",
"0",
"{",
"cfg",
".",
"AuthServers",
"=",
"[",
"]",
"utils",
".",
"NetAddr",
"{",
"*",
"defaults",
".",
"AuthConnectAddr",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"i",
",",
"err",
":=",
"auth",
".",
"ReadLocalIdentity",
"(",
"filepath",
".",
"Join",
"(",
"cfg",
".",
"DataDir",
",",
"teleport",
".",
"ComponentProcess",
")",
",",
"auth",
".",
"IdentityID",
"{",
"Role",
":",
"teleport",
".",
"RoleAdmin",
",",
"HostUUID",
":",
"cfg",
".",
"HostUUID",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"tctl must be used on the auth server\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tlsConfig",
",",
"err",
":=",
"i",
".",
"TLSConfig",
"(",
"cfg",
".",
"CipherSuites",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"client",
",",
"err",
"=",
"auth",
".",
"NewTLSClient",
"(",
"auth",
".",
"ClientConfig",
"{",
"Addrs",
":",
"cfg",
".",
"AuthServers",
",",
"TLS",
":",
"tlsConfig",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"client",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"Consolef",
"(",
"os",
".",
"Stderr",
",",
"teleport",
".",
"ComponentClient",
",",
"\"Cannot connect to the auth server: %v.\\nIs the auth server running on %v?\"",
",",
"\\n",
",",
"err",
")",
"\n",
"cfg",
".",
"AuthServers",
"[",
"0",
"]",
".",
"Addr",
"\n",
"}",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}"
] | // connectToAuthService creates a valid client connection to the auth service | [
"connectToAuthService",
"creates",
"a",
"valid",
"client",
"connection",
"to",
"the",
"auth",
"service"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/tctl.go#L128-L163 | train |
gravitational/teleport | tool/tctl/common/tctl.go | applyConfig | func applyConfig(ccf *GlobalCLIFlags, cfg *service.Config) error {
// load /etc/teleport.yaml and apply it's values:
fileConf, err := config.ReadConfigFile(ccf.ConfigFile)
if err != nil {
return trace.Wrap(err)
}
// if configuration is passed as an environment variable,
// try to decode it and override the config file
if ccf.ConfigString != "" {
fileConf, err = config.ReadFromString(ccf.ConfigString)
if err != nil {
return trace.Wrap(err)
}
}
if err = config.ApplyFileConfig(fileConf, cfg); err != nil {
return trace.Wrap(err)
}
// --debug flag
if ccf.Debug {
cfg.Debug = ccf.Debug
utils.InitLogger(utils.LoggingForCLI, logrus.DebugLevel)
logrus.Debugf("DEBUG logging enabled")
}
// read a host UUID for this node
cfg.HostUUID, err = utils.ReadHostUUID(cfg.DataDir)
if err != nil {
utils.FatalError(err)
}
return nil
} | go | func applyConfig(ccf *GlobalCLIFlags, cfg *service.Config) error {
// load /etc/teleport.yaml and apply it's values:
fileConf, err := config.ReadConfigFile(ccf.ConfigFile)
if err != nil {
return trace.Wrap(err)
}
// if configuration is passed as an environment variable,
// try to decode it and override the config file
if ccf.ConfigString != "" {
fileConf, err = config.ReadFromString(ccf.ConfigString)
if err != nil {
return trace.Wrap(err)
}
}
if err = config.ApplyFileConfig(fileConf, cfg); err != nil {
return trace.Wrap(err)
}
// --debug flag
if ccf.Debug {
cfg.Debug = ccf.Debug
utils.InitLogger(utils.LoggingForCLI, logrus.DebugLevel)
logrus.Debugf("DEBUG logging enabled")
}
// read a host UUID for this node
cfg.HostUUID, err = utils.ReadHostUUID(cfg.DataDir)
if err != nil {
utils.FatalError(err)
}
return nil
} | [
"func",
"applyConfig",
"(",
"ccf",
"*",
"GlobalCLIFlags",
",",
"cfg",
"*",
"service",
".",
"Config",
")",
"error",
"{",
"fileConf",
",",
"err",
":=",
"config",
".",
"ReadConfigFile",
"(",
"ccf",
".",
"ConfigFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ccf",
".",
"ConfigString",
"!=",
"\"\"",
"{",
"fileConf",
",",
"err",
"=",
"config",
".",
"ReadFromString",
"(",
"ccf",
".",
"ConfigString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"=",
"config",
".",
"ApplyFileConfig",
"(",
"fileConf",
",",
"cfg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"ccf",
".",
"Debug",
"{",
"cfg",
".",
"Debug",
"=",
"ccf",
".",
"Debug",
"\n",
"utils",
".",
"InitLogger",
"(",
"utils",
".",
"LoggingForCLI",
",",
"logrus",
".",
"DebugLevel",
")",
"\n",
"logrus",
".",
"Debugf",
"(",
"\"DEBUG logging enabled\"",
")",
"\n",
"}",
"\n",
"cfg",
".",
"HostUUID",
",",
"err",
"=",
"utils",
".",
"ReadHostUUID",
"(",
"cfg",
".",
"DataDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"utils",
".",
"FatalError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // applyConfig takes configuration values from the config file and applies
// them to 'service.Config' object | [
"applyConfig",
"takes",
"configuration",
"values",
"from",
"the",
"config",
"file",
"and",
"applies",
"them",
"to",
"service",
".",
"Config",
"object"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/tool/tctl/common/tctl.go#L167-L197 | train |
gravitational/teleport | lib/limiter/limiter.go | SetEnv | func (l *LimiterConfig) SetEnv(v string) error {
if err := json.Unmarshal([]byte(v), l); err != nil {
return trace.Wrap(err, "expected JSON encoded remote certificate")
}
return nil
} | go | func (l *LimiterConfig) SetEnv(v string) error {
if err := json.Unmarshal([]byte(v), l); err != nil {
return trace.Wrap(err, "expected JSON encoded remote certificate")
}
return nil
} | [
"func",
"(",
"l",
"*",
"LimiterConfig",
")",
"SetEnv",
"(",
"v",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"v",
")",
",",
"l",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
",",
"\"expected JSON encoded remote certificate\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetEnv reads LimiterConfig from JSON string | [
"SetEnv",
"reads",
"LimiterConfig",
"from",
"JSON",
"string"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/limiter.go#L49-L54 | train |
gravitational/teleport | lib/limiter/limiter.go | NewLimiter | func NewLimiter(config LimiterConfig) (*Limiter, error) {
var err error
limiter := Limiter{}
limiter.ConnectionsLimiter, err = NewConnectionsLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
limiter.rateLimiter, err = NewRateLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
} | go | func NewLimiter(config LimiterConfig) (*Limiter, error) {
var err error
limiter := Limiter{}
limiter.ConnectionsLimiter, err = NewConnectionsLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
limiter.rateLimiter, err = NewRateLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
} | [
"func",
"NewLimiter",
"(",
"config",
"LimiterConfig",
")",
"(",
"*",
"Limiter",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"limiter",
":=",
"Limiter",
"{",
"}",
"\n",
"limiter",
".",
"ConnectionsLimiter",
",",
"err",
"=",
"NewConnectionsLimiter",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"limiter",
".",
"rateLimiter",
",",
"err",
"=",
"NewRateLimiter",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"limiter",
",",
"nil",
"\n",
"}"
] | // NewLimiter returns new rate and connection limiter | [
"NewLimiter",
"returns",
"new",
"rate",
"and",
"connection",
"limiter"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/limiter.go#L57-L72 | train |
gravitational/teleport | lib/limiter/limiter.go | WrapHandle | func (l *Limiter) WrapHandle(h http.Handler) {
l.rateLimiter.Wrap(h)
l.ConnLimiter.Wrap(l.rateLimiter)
} | go | func (l *Limiter) WrapHandle(h http.Handler) {
l.rateLimiter.Wrap(h)
l.ConnLimiter.Wrap(l.rateLimiter)
} | [
"func",
"(",
"l",
"*",
"Limiter",
")",
"WrapHandle",
"(",
"h",
"http",
".",
"Handler",
")",
"{",
"l",
".",
"rateLimiter",
".",
"Wrap",
"(",
"h",
")",
"\n",
"l",
".",
"ConnLimiter",
".",
"Wrap",
"(",
"l",
".",
"rateLimiter",
")",
"\n",
"}"
] | // Add limiter to the handle | [
"Add",
"limiter",
"to",
"the",
"handle"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/limiter.go#L79-L82 | train |
gravitational/teleport | lib/web/apiserver.go | SetSessionStreamPollPeriod | func SetSessionStreamPollPeriod(period time.Duration) HandlerOption {
return func(h *Handler) error {
if period < 0 {
return trace.BadParameter("period should be non zero")
}
h.sessionStreamPollPeriod = period
return nil
}
} | go | func SetSessionStreamPollPeriod(period time.Duration) HandlerOption {
return func(h *Handler) error {
if period < 0 {
return trace.BadParameter("period should be non zero")
}
h.sessionStreamPollPeriod = period
return nil
}
} | [
"func",
"SetSessionStreamPollPeriod",
"(",
"period",
"time",
".",
"Duration",
")",
"HandlerOption",
"{",
"return",
"func",
"(",
"h",
"*",
"Handler",
")",
"error",
"{",
"if",
"period",
"<",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"period should be non zero\"",
")",
"\n",
"}",
"\n",
"h",
".",
"sessionStreamPollPeriod",
"=",
"period",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // SetSessionStreamPollPeriod sets polling period for session streams | [
"SetSessionStreamPollPeriod",
"sets",
"polling",
"period",
"for",
"session",
"streams"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L79-L87 | train |
gravitational/teleport | lib/web/apiserver.go | getWebConfig | func (h *Handler) getWebConfig(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
httplib.SetWebConfigHeaders(w.Header())
authProviders := []ui.WebConfigAuthProvider{}
secondFactor := teleport.OFF
// get all OIDC connectors
oidcConnectors, err := h.cfg.ProxyClient.GetOIDCConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve OIDC connectors: %v.", err)
}
for _, item := range oidcConnectors {
authProviders = append(authProviders, ui.WebConfigAuthProvider{
Type: ui.WebConfigAuthProviderOIDCType,
WebAPIURL: ui.WebConfigAuthProviderOIDCURL,
Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get all SAML connectors
samlConnectors, err := h.cfg.ProxyClient.GetSAMLConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve SAML connectors: %v.", err)
}
for _, item := range samlConnectors {
authProviders = append(authProviders, ui.WebConfigAuthProvider{
Type: ui.WebConfigAuthProviderSAMLType,
WebAPIURL: ui.WebConfigAuthProviderSAMLURL,
Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get all Github connectors
githubConnectors, err := h.cfg.ProxyClient.GetGithubConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve Github connectors: %v.", err)
}
for _, item := range githubConnectors {
authProviders = append(authProviders, ui.WebConfigAuthProvider{
Type: ui.WebConfigAuthProviderGitHubType,
WebAPIURL: ui.WebConfigAuthProviderGitHubURL,
Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get second factor type
cap, err := h.cfg.ProxyClient.GetAuthPreference()
if err != nil {
log.Errorf("Cannot retrieve AuthPreferences: %v.", err)
} else {
secondFactor = cap.GetSecondFactor()
}
// disable joining sessions if proxy session recording is enabled
var canJoinSessions = true
clsCfg, err := h.cfg.ProxyClient.GetClusterConfig()
if err != nil {
log.Errorf("Cannot retrieve ClusterConfig: %v.", err)
} else {
canJoinSessions = clsCfg.GetSessionRecording() != services.RecordAtProxy
}
authSettings := ui.WebConfigAuthSettings{
Providers: authProviders,
SecondFactor: secondFactor,
}
webCfg := ui.WebConfig{
Auth: authSettings,
CanJoinSessions: canJoinSessions,
}
out, err := json.Marshal(webCfg)
if err != nil {
return nil, trace.Wrap(err)
}
fmt.Fprintf(w, "var GRV_CONFIG = %v;", string(out))
return nil, nil
} | go | func (h *Handler) getWebConfig(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
httplib.SetWebConfigHeaders(w.Header())
authProviders := []ui.WebConfigAuthProvider{}
secondFactor := teleport.OFF
// get all OIDC connectors
oidcConnectors, err := h.cfg.ProxyClient.GetOIDCConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve OIDC connectors: %v.", err)
}
for _, item := range oidcConnectors {
authProviders = append(authProviders, ui.WebConfigAuthProvider{
Type: ui.WebConfigAuthProviderOIDCType,
WebAPIURL: ui.WebConfigAuthProviderOIDCURL,
Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get all SAML connectors
samlConnectors, err := h.cfg.ProxyClient.GetSAMLConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve SAML connectors: %v.", err)
}
for _, item := range samlConnectors {
authProviders = append(authProviders, ui.WebConfigAuthProvider{
Type: ui.WebConfigAuthProviderSAMLType,
WebAPIURL: ui.WebConfigAuthProviderSAMLURL,
Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get all Github connectors
githubConnectors, err := h.cfg.ProxyClient.GetGithubConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve Github connectors: %v.", err)
}
for _, item := range githubConnectors {
authProviders = append(authProviders, ui.WebConfigAuthProvider{
Type: ui.WebConfigAuthProviderGitHubType,
WebAPIURL: ui.WebConfigAuthProviderGitHubURL,
Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get second factor type
cap, err := h.cfg.ProxyClient.GetAuthPreference()
if err != nil {
log.Errorf("Cannot retrieve AuthPreferences: %v.", err)
} else {
secondFactor = cap.GetSecondFactor()
}
// disable joining sessions if proxy session recording is enabled
var canJoinSessions = true
clsCfg, err := h.cfg.ProxyClient.GetClusterConfig()
if err != nil {
log.Errorf("Cannot retrieve ClusterConfig: %v.", err)
} else {
canJoinSessions = clsCfg.GetSessionRecording() != services.RecordAtProxy
}
authSettings := ui.WebConfigAuthSettings{
Providers: authProviders,
SecondFactor: secondFactor,
}
webCfg := ui.WebConfig{
Auth: authSettings,
CanJoinSessions: canJoinSessions,
}
out, err := json.Marshal(webCfg)
if err != nil {
return nil, trace.Wrap(err)
}
fmt.Fprintf(w, "var GRV_CONFIG = %v;", string(out))
return nil, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"getWebConfig",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"httplib",
".",
"SetWebConfigHeaders",
"(",
"w",
".",
"Header",
"(",
")",
")",
"\n",
"authProviders",
":=",
"[",
"]",
"ui",
".",
"WebConfigAuthProvider",
"{",
"}",
"\n",
"secondFactor",
":=",
"teleport",
".",
"OFF",
"\n",
"oidcConnectors",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
".",
"GetOIDCConnectors",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Cannot retrieve OIDC connectors: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"oidcConnectors",
"{",
"authProviders",
"=",
"append",
"(",
"authProviders",
",",
"ui",
".",
"WebConfigAuthProvider",
"{",
"Type",
":",
"ui",
".",
"WebConfigAuthProviderOIDCType",
",",
"WebAPIURL",
":",
"ui",
".",
"WebConfigAuthProviderOIDCURL",
",",
"Name",
":",
"item",
".",
"GetName",
"(",
")",
",",
"DisplayName",
":",
"item",
".",
"GetDisplay",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"samlConnectors",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
".",
"GetSAMLConnectors",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Cannot retrieve SAML connectors: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"samlConnectors",
"{",
"authProviders",
"=",
"append",
"(",
"authProviders",
",",
"ui",
".",
"WebConfigAuthProvider",
"{",
"Type",
":",
"ui",
".",
"WebConfigAuthProviderSAMLType",
",",
"WebAPIURL",
":",
"ui",
".",
"WebConfigAuthProviderSAMLURL",
",",
"Name",
":",
"item",
".",
"GetName",
"(",
")",
",",
"DisplayName",
":",
"item",
".",
"GetDisplay",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"githubConnectors",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
".",
"GetGithubConnectors",
"(",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Cannot retrieve Github connectors: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"githubConnectors",
"{",
"authProviders",
"=",
"append",
"(",
"authProviders",
",",
"ui",
".",
"WebConfigAuthProvider",
"{",
"Type",
":",
"ui",
".",
"WebConfigAuthProviderGitHubType",
",",
"WebAPIURL",
":",
"ui",
".",
"WebConfigAuthProviderGitHubURL",
",",
"Name",
":",
"item",
".",
"GetName",
"(",
")",
",",
"DisplayName",
":",
"item",
".",
"GetDisplay",
"(",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"cap",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
".",
"GetAuthPreference",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Cannot retrieve AuthPreferences: %v.\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"secondFactor",
"=",
"cap",
".",
"GetSecondFactor",
"(",
")",
"\n",
"}",
"\n",
"var",
"canJoinSessions",
"=",
"true",
"\n",
"clsCfg",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
".",
"GetClusterConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Cannot retrieve ClusterConfig: %v.\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"canJoinSessions",
"=",
"clsCfg",
".",
"GetSessionRecording",
"(",
")",
"!=",
"services",
".",
"RecordAtProxy",
"\n",
"}",
"\n",
"authSettings",
":=",
"ui",
".",
"WebConfigAuthSettings",
"{",
"Providers",
":",
"authProviders",
",",
"SecondFactor",
":",
"secondFactor",
",",
"}",
"\n",
"webCfg",
":=",
"ui",
".",
"WebConfig",
"{",
"Auth",
":",
"authSettings",
",",
"CanJoinSessions",
":",
"canJoinSessions",
",",
"}",
"\n",
"out",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"webCfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"var GRV_CONFIG = %v;\"",
",",
"string",
"(",
"out",
")",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // getWebConfig returns configuration for the web application. | [
"getWebConfig",
"returns",
"configuration",
"for",
"the",
"web",
"application",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L577-L659 | train |
gravitational/teleport | lib/web/apiserver.go | ConstructSSHResponse | func ConstructSSHResponse(response AuthParams) (*url.URL, error) {
u, err := url.Parse(response.ClientRedirectURL)
if err != nil {
return nil, trace.Wrap(err)
}
consoleResponse := auth.SSHLoginResponse{
Username: response.Username,
Cert: response.Cert,
TLSCert: response.TLSCert,
HostSigners: auth.AuthoritiesToTrustedCerts(response.HostSigners),
}
out, err := json.Marshal(consoleResponse)
if err != nil {
return nil, trace.Wrap(err)
}
// Extract secret out of the request. Look for both "secret" which is the
// old format and "secret_key" which is the new fomat. If this is not done,
// then users would have to update their callback URL in their identity
// provider.
values := u.Query()
secretV1 := values.Get("secret")
secretV2 := values.Get("secret_key")
values.Set("secret", "")
values.Set("secret_key", "")
var ciphertext []byte
switch {
// AES-GCM based symmetric cipher.
case secretV2 != "":
key, err := secret.ParseKey([]byte(secretV2))
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err = key.Seal(out)
if err != nil {
return nil, trace.Wrap(err)
}
// NaCl based symmetric cipher (legacy).
case secretV1 != "":
secretKeyBytes, err := lemma_secret.EncodedStringToKey(secretV1)
if err != nil {
return nil, trace.BadParameter("bad secret")
}
encryptor, err := lemma_secret.New(&lemma_secret.Config{KeyBytes: secretKeyBytes})
if err != nil {
return nil, trace.Wrap(err)
}
sealedBytes, err := encryptor.Seal(out)
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err = json.Marshal(sealedBytes)
if err != nil {
return nil, trace.Wrap(err)
}
default:
return nil, trace.BadParameter("missing secret")
}
// Place ciphertext into the response body.
values.Set("response", string(ciphertext))
u.RawQuery = values.Encode()
return u, nil
} | go | func ConstructSSHResponse(response AuthParams) (*url.URL, error) {
u, err := url.Parse(response.ClientRedirectURL)
if err != nil {
return nil, trace.Wrap(err)
}
consoleResponse := auth.SSHLoginResponse{
Username: response.Username,
Cert: response.Cert,
TLSCert: response.TLSCert,
HostSigners: auth.AuthoritiesToTrustedCerts(response.HostSigners),
}
out, err := json.Marshal(consoleResponse)
if err != nil {
return nil, trace.Wrap(err)
}
// Extract secret out of the request. Look for both "secret" which is the
// old format and "secret_key" which is the new fomat. If this is not done,
// then users would have to update their callback URL in their identity
// provider.
values := u.Query()
secretV1 := values.Get("secret")
secretV2 := values.Get("secret_key")
values.Set("secret", "")
values.Set("secret_key", "")
var ciphertext []byte
switch {
// AES-GCM based symmetric cipher.
case secretV2 != "":
key, err := secret.ParseKey([]byte(secretV2))
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err = key.Seal(out)
if err != nil {
return nil, trace.Wrap(err)
}
// NaCl based symmetric cipher (legacy).
case secretV1 != "":
secretKeyBytes, err := lemma_secret.EncodedStringToKey(secretV1)
if err != nil {
return nil, trace.BadParameter("bad secret")
}
encryptor, err := lemma_secret.New(&lemma_secret.Config{KeyBytes: secretKeyBytes})
if err != nil {
return nil, trace.Wrap(err)
}
sealedBytes, err := encryptor.Seal(out)
if err != nil {
return nil, trace.Wrap(err)
}
ciphertext, err = json.Marshal(sealedBytes)
if err != nil {
return nil, trace.Wrap(err)
}
default:
return nil, trace.BadParameter("missing secret")
}
// Place ciphertext into the response body.
values.Set("response", string(ciphertext))
u.RawQuery = values.Encode()
return u, nil
} | [
"func",
"ConstructSSHResponse",
"(",
"response",
"AuthParams",
")",
"(",
"*",
"url",
".",
"URL",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"response",
".",
"ClientRedirectURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"consoleResponse",
":=",
"auth",
".",
"SSHLoginResponse",
"{",
"Username",
":",
"response",
".",
"Username",
",",
"Cert",
":",
"response",
".",
"Cert",
",",
"TLSCert",
":",
"response",
".",
"TLSCert",
",",
"HostSigners",
":",
"auth",
".",
"AuthoritiesToTrustedCerts",
"(",
"response",
".",
"HostSigners",
")",
",",
"}",
"\n",
"out",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"consoleResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"values",
":=",
"u",
".",
"Query",
"(",
")",
"\n",
"secretV1",
":=",
"values",
".",
"Get",
"(",
"\"secret\"",
")",
"\n",
"secretV2",
":=",
"values",
".",
"Get",
"(",
"\"secret_key\"",
")",
"\n",
"values",
".",
"Set",
"(",
"\"secret\"",
",",
"\"\"",
")",
"\n",
"values",
".",
"Set",
"(",
"\"secret_key\"",
",",
"\"\"",
")",
"\n",
"var",
"ciphertext",
"[",
"]",
"byte",
"\n",
"switch",
"{",
"case",
"secretV2",
"!=",
"\"\"",
":",
"key",
",",
"err",
":=",
"secret",
".",
"ParseKey",
"(",
"[",
"]",
"byte",
"(",
"secretV2",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ciphertext",
",",
"err",
"=",
"key",
".",
"Seal",
"(",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"case",
"secretV1",
"!=",
"\"\"",
":",
"secretKeyBytes",
",",
"err",
":=",
"lemma_secret",
".",
"EncodedStringToKey",
"(",
"secretV1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"bad secret\"",
")",
"\n",
"}",
"\n",
"encryptor",
",",
"err",
":=",
"lemma_secret",
".",
"New",
"(",
"&",
"lemma_secret",
".",
"Config",
"{",
"KeyBytes",
":",
"secretKeyBytes",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sealedBytes",
",",
"err",
":=",
"encryptor",
".",
"Seal",
"(",
"out",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"ciphertext",
",",
"err",
"=",
"json",
".",
"Marshal",
"(",
"sealedBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing secret\"",
")",
"\n",
"}",
"\n",
"values",
".",
"Set",
"(",
"\"response\"",
",",
"string",
"(",
"ciphertext",
")",
")",
"\n",
"u",
".",
"RawQuery",
"=",
"values",
".",
"Encode",
"(",
")",
"\n",
"return",
"u",
",",
"nil",
"\n",
"}"
] | // ConstructSSHResponse creates a special SSH response for SSH login method
// that encodes everything using the client's secret key | [
"ConstructSSHResponse",
"creates",
"a",
"special",
"SSH",
"response",
"for",
"SSH",
"login",
"method",
"that",
"encodes",
"everything",
"using",
"the",
"client",
"s",
"secret",
"key"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L901-L967 | train |
gravitational/teleport | lib/web/apiserver.go | queryTime | func queryTime(query url.Values, name string, def time.Time) (time.Time, error) {
str := query.Get(name)
if str == "" {
return def, nil
}
parsed, err := time.Parse(time.RFC3339, str)
if err != nil {
return time.Time{}, trace.BadParameter("failed to parse %v as RFC3339 time: %v", name, str)
}
return parsed, nil
} | go | func queryTime(query url.Values, name string, def time.Time) (time.Time, error) {
str := query.Get(name)
if str == "" {
return def, nil
}
parsed, err := time.Parse(time.RFC3339, str)
if err != nil {
return time.Time{}, trace.BadParameter("failed to parse %v as RFC3339 time: %v", name, str)
}
return parsed, nil
} | [
"func",
"queryTime",
"(",
"query",
"url",
".",
"Values",
",",
"name",
"string",
",",
"def",
"time",
".",
"Time",
")",
"(",
"time",
".",
"Time",
",",
"error",
")",
"{",
"str",
":=",
"query",
".",
"Get",
"(",
"name",
")",
"\n",
"if",
"str",
"==",
"\"\"",
"{",
"return",
"def",
",",
"nil",
"\n",
"}",
"\n",
"parsed",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339",
",",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse %v as RFC3339 time: %v\"",
",",
"name",
",",
"str",
")",
"\n",
"}",
"\n",
"return",
"parsed",
",",
"nil",
"\n",
"}"
] | // queryTime parses the query string parameter with the specified name as a
// RFC3339 time and returns it.
//
// If there's no such parameter, specified default value is returned. | [
"queryTime",
"parses",
"the",
"query",
"string",
"parameter",
"with",
"the",
"specified",
"name",
"as",
"a",
"RFC3339",
"time",
"and",
"returns",
"it",
".",
"If",
"there",
"s",
"no",
"such",
"parameter",
"specified",
"default",
"value",
"is",
"returned",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L1643-L1653 | train |
gravitational/teleport | lib/web/apiserver.go | queryLimit | func queryLimit(query url.Values, name string, def int) (int, error) {
str := query.Get(name)
if str == "" {
return def, nil
}
limit, err := strconv.Atoi(str)
if err != nil {
return 0, trace.BadParameter("failed to parse %v as limit: %v", name, str)
}
return limit, nil
} | go | func queryLimit(query url.Values, name string, def int) (int, error) {
str := query.Get(name)
if str == "" {
return def, nil
}
limit, err := strconv.Atoi(str)
if err != nil {
return 0, trace.BadParameter("failed to parse %v as limit: %v", name, str)
}
return limit, nil
} | [
"func",
"queryLimit",
"(",
"query",
"url",
".",
"Values",
",",
"name",
"string",
",",
"def",
"int",
")",
"(",
"int",
",",
"error",
")",
"{",
"str",
":=",
"query",
".",
"Get",
"(",
"name",
")",
"\n",
"if",
"str",
"==",
"\"\"",
"{",
"return",
"def",
",",
"nil",
"\n",
"}",
"\n",
"limit",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to parse %v as limit: %v\"",
",",
"name",
",",
"str",
")",
"\n",
"}",
"\n",
"return",
"limit",
",",
"nil",
"\n",
"}"
] | // queryLimit returns the limit parameter with the specified name from the
// query string.
//
// If there's no such parameter, specified default limit is returned. | [
"queryLimit",
"returns",
"the",
"limit",
"parameter",
"with",
"the",
"specified",
"name",
"from",
"the",
"query",
"string",
".",
"If",
"there",
"s",
"no",
"such",
"parameter",
"specified",
"default",
"limit",
"is",
"returned",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L1659-L1669 | train |
gravitational/teleport | lib/web/apiserver.go | hostCredentials | func (h *Handler) hostCredentials(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
var req auth.RegisterUsingTokenRequest
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
authClient := h.cfg.ProxyClient
packedKeys, err := authClient.RegisterUsingToken(req)
if err != nil {
return nil, trace.Wrap(err)
}
return packedKeys, nil
} | go | func (h *Handler) hostCredentials(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
var req auth.RegisterUsingTokenRequest
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
authClient := h.cfg.ProxyClient
packedKeys, err := authClient.RegisterUsingToken(req)
if err != nil {
return nil, trace.Wrap(err)
}
return packedKeys, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"hostCredentials",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"auth",
".",
"RegisterUsingTokenRequest",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authClient",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
"\n",
"packedKeys",
",",
"err",
":=",
"authClient",
".",
"RegisterUsingToken",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"packedKeys",
",",
"nil",
"\n",
"}"
] | // hostCredentials sends a registration token and metadata to the Auth Server
// and gets back SSH and TLS certificates. | [
"hostCredentials",
"sends",
"a",
"registration",
"token",
"and",
"metadata",
"to",
"the",
"Auth",
"Server",
"and",
"gets",
"back",
"SSH",
"and",
"TLS",
"certificates",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L1832-L1845 | train |
gravitational/teleport | lib/web/apiserver.go | WithClusterAuth | func (h *Handler) WithClusterAuth(fn ClusterHandler) httprouter.Handle {
return httplib.MakeHandler(func(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
ctx, err := h.AuthenticateRequest(w, r, true)
if err != nil {
log.Info(err)
// clear session just in case if the authentication request is not valid
ClearSession(w)
return nil, trace.Wrap(err)
}
siteName := p.ByName("site")
if siteName == currentSiteShortcut {
res, err := h.cfg.ProxyClient.GetClusterName()
if err != nil {
log.Warn(err)
return nil, trace.Wrap(err)
}
siteName = res.GetClusterName()
}
site, err := h.cfg.Proxy.GetSite(siteName)
if err != nil {
log.Warn(err)
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx, site)
})
} | go | func (h *Handler) WithClusterAuth(fn ClusterHandler) httprouter.Handle {
return httplib.MakeHandler(func(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
ctx, err := h.AuthenticateRequest(w, r, true)
if err != nil {
log.Info(err)
// clear session just in case if the authentication request is not valid
ClearSession(w)
return nil, trace.Wrap(err)
}
siteName := p.ByName("site")
if siteName == currentSiteShortcut {
res, err := h.cfg.ProxyClient.GetClusterName()
if err != nil {
log.Warn(err)
return nil, trace.Wrap(err)
}
siteName = res.GetClusterName()
}
site, err := h.cfg.Proxy.GetSite(siteName)
if err != nil {
log.Warn(err)
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx, site)
})
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"WithClusterAuth",
"(",
"fn",
"ClusterHandler",
")",
"httprouter",
".",
"Handle",
"{",
"return",
"httplib",
".",
"MakeHandler",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ctx",
",",
"err",
":=",
"h",
".",
"AuthenticateRequest",
"(",
"w",
",",
"r",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Info",
"(",
"err",
")",
"\n",
"ClearSession",
"(",
"w",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"siteName",
":=",
"p",
".",
"ByName",
"(",
"\"site\"",
")",
"\n",
"if",
"siteName",
"==",
"currentSiteShortcut",
"{",
"res",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"ProxyClient",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warn",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"siteName",
"=",
"res",
".",
"GetClusterName",
"(",
")",
"\n",
"}",
"\n",
"site",
",",
"err",
":=",
"h",
".",
"cfg",
".",
"Proxy",
".",
"GetSite",
"(",
"siteName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warn",
"(",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"fn",
"(",
"w",
",",
"r",
",",
"p",
",",
"ctx",
",",
"site",
")",
"\n",
"}",
")",
"\n",
"}"
] | // WithClusterAuth ensures that request is authenticated and is issued for existing cluster | [
"WithClusterAuth",
"ensures",
"that",
"request",
"is",
"authenticated",
"and",
"is",
"issued",
"for",
"existing",
"cluster"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L1976-L2003 | train |
gravitational/teleport | lib/web/apiserver.go | WithAuth | func (h *Handler) WithAuth(fn ContextHandler) httprouter.Handle {
return httplib.MakeHandler(func(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
ctx, err := h.AuthenticateRequest(w, r, true)
if err != nil {
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx)
})
} | go | func (h *Handler) WithAuth(fn ContextHandler) httprouter.Handle {
return httplib.MakeHandler(func(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
ctx, err := h.AuthenticateRequest(w, r, true)
if err != nil {
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx)
})
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"WithAuth",
"(",
"fn",
"ContextHandler",
")",
"httprouter",
".",
"Handle",
"{",
"return",
"httplib",
".",
"MakeHandler",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ctx",
",",
"err",
":=",
"h",
".",
"AuthenticateRequest",
"(",
"w",
",",
"r",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"fn",
"(",
"w",
",",
"r",
",",
"p",
",",
"ctx",
")",
"\n",
"}",
")",
"\n",
"}"
] | // WithAuth ensures that request is authenticated | [
"WithAuth",
"ensures",
"that",
"request",
"is",
"authenticated"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L2006-L2014 | train |
gravitational/teleport | lib/web/apiserver.go | AuthenticateRequest | func (h *Handler) AuthenticateRequest(w http.ResponseWriter, r *http.Request, checkBearerToken bool) (*SessionContext, error) {
const missingCookieMsg = "missing session cookie"
logger := log.WithFields(log.Fields{
"request": fmt.Sprintf("%v %v", r.Method, r.URL.Path),
})
cookie, err := r.Cookie("session")
if err != nil || (cookie != nil && cookie.Value == "") {
if err != nil {
logger.Warn(err)
}
return nil, trace.AccessDenied(missingCookieMsg)
}
d, err := DecodeCookie(cookie.Value)
if err != nil {
logger.Warningf("failed to decode cookie: %v", err)
return nil, trace.AccessDenied("failed to decode cookie")
}
ctx, err := h.auth.ValidateSession(d.User, d.SID)
if err != nil {
logger.Warningf("invalid session: %v", err)
ClearSession(w)
return nil, trace.AccessDenied("need auth")
}
if checkBearerToken {
creds, err := roundtrip.ParseAuthHeaders(r)
if err != nil {
logger.Warningf("no auth headers %v", err)
return nil, trace.AccessDenied("need auth")
}
if subtle.ConstantTimeCompare([]byte(creds.Password), []byte(ctx.GetWebSession().GetBearerToken())) != 1 {
logger.Warningf("Request failed: bad bearer token.")
return nil, trace.AccessDenied("bad bearer token")
}
}
return ctx, nil
} | go | func (h *Handler) AuthenticateRequest(w http.ResponseWriter, r *http.Request, checkBearerToken bool) (*SessionContext, error) {
const missingCookieMsg = "missing session cookie"
logger := log.WithFields(log.Fields{
"request": fmt.Sprintf("%v %v", r.Method, r.URL.Path),
})
cookie, err := r.Cookie("session")
if err != nil || (cookie != nil && cookie.Value == "") {
if err != nil {
logger.Warn(err)
}
return nil, trace.AccessDenied(missingCookieMsg)
}
d, err := DecodeCookie(cookie.Value)
if err != nil {
logger.Warningf("failed to decode cookie: %v", err)
return nil, trace.AccessDenied("failed to decode cookie")
}
ctx, err := h.auth.ValidateSession(d.User, d.SID)
if err != nil {
logger.Warningf("invalid session: %v", err)
ClearSession(w)
return nil, trace.AccessDenied("need auth")
}
if checkBearerToken {
creds, err := roundtrip.ParseAuthHeaders(r)
if err != nil {
logger.Warningf("no auth headers %v", err)
return nil, trace.AccessDenied("need auth")
}
if subtle.ConstantTimeCompare([]byte(creds.Password), []byte(ctx.GetWebSession().GetBearerToken())) != 1 {
logger.Warningf("Request failed: bad bearer token.")
return nil, trace.AccessDenied("bad bearer token")
}
}
return ctx, nil
} | [
"func",
"(",
"h",
"*",
"Handler",
")",
"AuthenticateRequest",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"checkBearerToken",
"bool",
")",
"(",
"*",
"SessionContext",
",",
"error",
")",
"{",
"const",
"missingCookieMsg",
"=",
"\"missing session cookie\"",
"\n",
"logger",
":=",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"request\"",
":",
"fmt",
".",
"Sprintf",
"(",
"\"%v %v\"",
",",
"r",
".",
"Method",
",",
"r",
".",
"URL",
".",
"Path",
")",
",",
"}",
")",
"\n",
"cookie",
",",
"err",
":=",
"r",
".",
"Cookie",
"(",
"\"session\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"(",
"cookie",
"!=",
"nil",
"&&",
"cookie",
".",
"Value",
"==",
"\"\"",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"missingCookieMsg",
")",
"\n",
"}",
"\n",
"d",
",",
"err",
":=",
"DecodeCookie",
"(",
"cookie",
".",
"Value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warningf",
"(",
"\"failed to decode cookie: %v\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"failed to decode cookie\"",
")",
"\n",
"}",
"\n",
"ctx",
",",
"err",
":=",
"h",
".",
"auth",
".",
"ValidateSession",
"(",
"d",
".",
"User",
",",
"d",
".",
"SID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warningf",
"(",
"\"invalid session: %v\"",
",",
"err",
")",
"\n",
"ClearSession",
"(",
"w",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"need auth\"",
")",
"\n",
"}",
"\n",
"if",
"checkBearerToken",
"{",
"creds",
",",
"err",
":=",
"roundtrip",
".",
"ParseAuthHeaders",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logger",
".",
"Warningf",
"(",
"\"no auth headers %v\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"need auth\"",
")",
"\n",
"}",
"\n",
"if",
"subtle",
".",
"ConstantTimeCompare",
"(",
"[",
"]",
"byte",
"(",
"creds",
".",
"Password",
")",
",",
"[",
"]",
"byte",
"(",
"ctx",
".",
"GetWebSession",
"(",
")",
".",
"GetBearerToken",
"(",
")",
")",
")",
"!=",
"1",
"{",
"logger",
".",
"Warningf",
"(",
"\"Request failed: bad bearer token.\"",
")",
"\n",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"bad bearer token\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ctx",
",",
"nil",
"\n",
"}"
] | // AuthenticateRequest authenticates request using combination of a session cookie
// and bearer token | [
"AuthenticateRequest",
"authenticates",
"request",
"using",
"combination",
"of",
"a",
"session",
"cookie",
"and",
"bearer",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L2018-L2054 | train |
gravitational/teleport | lib/web/apiserver.go | CreateSignupLink | func CreateSignupLink(client auth.ClientI, token string) (string, string) {
proxyHost := "<proxyhost>:3080"
proxies, err := client.GetProxies()
if err != nil {
log.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHost = fmt.Sprintf("%v:%v", proxies[0].GetHostname(), defaults.HTTPListenPort)
log.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
u := &url.URL{
Scheme: "https",
Host: proxyHost,
Path: "web/newuser/" + token,
}
return u.String(), proxyHost
} | go | func CreateSignupLink(client auth.ClientI, token string) (string, string) {
proxyHost := "<proxyhost>:3080"
proxies, err := client.GetProxies()
if err != nil {
log.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHost = fmt.Sprintf("%v:%v", proxies[0].GetHostname(), defaults.HTTPListenPort)
log.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
u := &url.URL{
Scheme: "https",
Host: proxyHost,
Path: "web/newuser/" + token,
}
return u.String(), proxyHost
} | [
"func",
"CreateSignupLink",
"(",
"client",
"auth",
".",
"ClientI",
",",
"token",
"string",
")",
"(",
"string",
",",
"string",
")",
"{",
"proxyHost",
":=",
"\"<proxyhost>:3080\"",
"\n",
"proxies",
",",
"err",
":=",
"client",
".",
"GetProxies",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Errorf",
"(",
"\"Unable to retrieve proxy list: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"proxies",
")",
">",
"0",
"{",
"proxyHost",
"=",
"proxies",
"[",
"0",
"]",
".",
"GetPublicAddr",
"(",
")",
"\n",
"if",
"proxyHost",
"==",
"\"\"",
"{",
"proxyHost",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%v:%v\"",
",",
"proxies",
"[",
"0",
"]",
".",
"GetHostname",
"(",
")",
",",
"defaults",
".",
"HTTPListenPort",
")",
"\n",
"log",
".",
"Debugf",
"(",
"\"public_address not set for proxy, returning proxyHost: %q\"",
",",
"proxyHost",
")",
"\n",
"}",
"\n",
"}",
"\n",
"u",
":=",
"&",
"url",
".",
"URL",
"{",
"Scheme",
":",
"\"https\"",
",",
"Host",
":",
"proxyHost",
",",
"Path",
":",
"\"web/newuser/\"",
"+",
"token",
",",
"}",
"\n",
"return",
"u",
".",
"String",
"(",
")",
",",
"proxyHost",
"\n",
"}"
] | // CreateSignupLink generates and returns a URL which is given to a new
// user to complete registration with Teleport via Web UI | [
"CreateSignupLink",
"generates",
"and",
"returns",
"a",
"URL",
"which",
"is",
"given",
"to",
"a",
"new",
"user",
"to",
"complete",
"registration",
"with",
"Teleport",
"via",
"Web",
"UI"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L2080-L2102 | train |
gravitational/teleport | lib/web/apiserver.go | makeTeleportClientConfig | func makeTeleportClientConfig(ctx *SessionContext) (*client.Config, error) {
agent, cert, err := ctx.GetAgent()
if err != nil {
return nil, trace.BadParameter("failed to get user credentials: %v", err)
}
signers, err := agent.Signers()
if err != nil {
return nil, trace.BadParameter("failed to get user credentials: %v", err)
}
tlsConfig, err := ctx.ClientTLSConfig()
if err != nil {
return nil, trace.BadParameter("failed to get client TLS config: %v", err)
}
config := &client.Config{
Username: ctx.user,
Agent: agent,
SkipLocalAuth: true,
TLS: tlsConfig,
AuthMethods: []ssh.AuthMethod{ssh.PublicKeys(signers...)},
DefaultPrincipal: cert.ValidPrincipals[0],
HostKeyCallback: func(string, net.Addr, ssh.PublicKey) error { return nil },
}
return config, nil
} | go | func makeTeleportClientConfig(ctx *SessionContext) (*client.Config, error) {
agent, cert, err := ctx.GetAgent()
if err != nil {
return nil, trace.BadParameter("failed to get user credentials: %v", err)
}
signers, err := agent.Signers()
if err != nil {
return nil, trace.BadParameter("failed to get user credentials: %v", err)
}
tlsConfig, err := ctx.ClientTLSConfig()
if err != nil {
return nil, trace.BadParameter("failed to get client TLS config: %v", err)
}
config := &client.Config{
Username: ctx.user,
Agent: agent,
SkipLocalAuth: true,
TLS: tlsConfig,
AuthMethods: []ssh.AuthMethod{ssh.PublicKeys(signers...)},
DefaultPrincipal: cert.ValidPrincipals[0],
HostKeyCallback: func(string, net.Addr, ssh.PublicKey) error { return nil },
}
return config, nil
} | [
"func",
"makeTeleportClientConfig",
"(",
"ctx",
"*",
"SessionContext",
")",
"(",
"*",
"client",
".",
"Config",
",",
"error",
")",
"{",
"agent",
",",
"cert",
",",
"err",
":=",
"ctx",
".",
"GetAgent",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to get user credentials: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"signers",
",",
"err",
":=",
"agent",
".",
"Signers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to get user credentials: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"tlsConfig",
",",
"err",
":=",
"ctx",
".",
"ClientTLSConfig",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"failed to get client TLS config: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"config",
":=",
"&",
"client",
".",
"Config",
"{",
"Username",
":",
"ctx",
".",
"user",
",",
"Agent",
":",
"agent",
",",
"SkipLocalAuth",
":",
"true",
",",
"TLS",
":",
"tlsConfig",
",",
"AuthMethods",
":",
"[",
"]",
"ssh",
".",
"AuthMethod",
"{",
"ssh",
".",
"PublicKeys",
"(",
"signers",
"...",
")",
"}",
",",
"DefaultPrincipal",
":",
"cert",
".",
"ValidPrincipals",
"[",
"0",
"]",
",",
"HostKeyCallback",
":",
"func",
"(",
"string",
",",
"net",
".",
"Addr",
",",
"ssh",
".",
"PublicKey",
")",
"error",
"{",
"return",
"nil",
"}",
",",
"}",
"\n",
"return",
"config",
",",
"nil",
"\n",
"}"
] | // makeTeleportClientConfig creates default teleport client configuration
// that is used to initiate an SSH terminal session or SCP file transfer | [
"makeTeleportClientConfig",
"creates",
"default",
"teleport",
"client",
"configuration",
"that",
"is",
"used",
"to",
"initiate",
"an",
"SSH",
"terminal",
"session",
"or",
"SCP",
"file",
"transfer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/web/apiserver.go#L2114-L2141 | train |
gravitational/teleport | lib/client/keyagent.go | LoadKey | func (a *LocalKeyAgent) LoadKey(key Key) (*agent.AddedKey, error) {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// convert keys into a format understood by the ssh agent
agentKeys, err := key.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
// remove any keys that the user may already have loaded
err = a.UnloadKey()
if err != nil {
return nil, trace.Wrap(err)
}
// iterate over all teleport and system agent and load key
for i, _ := range agents {
for _, agentKey := range agentKeys {
err = agents[i].Add(*agentKey)
if err != nil {
a.log.Warnf("Unable to communicate with agent and add key: %v", err)
}
}
}
// return the first key because it has the embedded private key in it.
// see docs for AsAgentKeys for more details.
return agentKeys[0], nil
} | go | func (a *LocalKeyAgent) LoadKey(key Key) (*agent.AddedKey, error) {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// convert keys into a format understood by the ssh agent
agentKeys, err := key.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
// remove any keys that the user may already have loaded
err = a.UnloadKey()
if err != nil {
return nil, trace.Wrap(err)
}
// iterate over all teleport and system agent and load key
for i, _ := range agents {
for _, agentKey := range agentKeys {
err = agents[i].Add(*agentKey)
if err != nil {
a.log.Warnf("Unable to communicate with agent and add key: %v", err)
}
}
}
// return the first key because it has the embedded private key in it.
// see docs for AsAgentKeys for more details.
return agentKeys[0], nil
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"LoadKey",
"(",
"key",
"Key",
")",
"(",
"*",
"agent",
".",
"AddedKey",
",",
"error",
")",
"{",
"agents",
":=",
"[",
"]",
"agent",
".",
"Agent",
"{",
"a",
".",
"Agent",
"}",
"\n",
"if",
"a",
".",
"sshAgent",
"!=",
"nil",
"{",
"agents",
"=",
"append",
"(",
"agents",
",",
"a",
".",
"sshAgent",
")",
"\n",
"}",
"\n",
"agentKeys",
",",
"err",
":=",
"key",
".",
"AsAgentKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"a",
".",
"UnloadKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"_",
":=",
"range",
"agents",
"{",
"for",
"_",
",",
"agentKey",
":=",
"range",
"agentKeys",
"{",
"err",
"=",
"agents",
"[",
"i",
"]",
".",
"Add",
"(",
"*",
"agentKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to communicate with agent and add key: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"agentKeys",
"[",
"0",
"]",
",",
"nil",
"\n",
"}"
] | // LoadKey adds a key into the Teleport ssh agent as well as the system ssh
// agent. | [
"LoadKey",
"adds",
"a",
"key",
"into",
"the",
"Teleport",
"ssh",
"agent",
"as",
"well",
"as",
"the",
"system",
"ssh",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L123-L154 | train |
gravitational/teleport | lib/client/keyagent.go | UnloadKey | func (a *LocalKeyAgent) UnloadKey() error {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// iterate over all agents we have and unload keys for this user
for i, _ := range agents {
// get a list of all keys in the agent
keyList, err := agents[i].List()
if err != nil {
a.log.Warnf("Unable to communicate with agent and list keys: %v", err)
}
// remove any teleport keys we currently have loaded in the agent for this user
for _, key := range keyList {
if key.Comment == fmt.Sprintf("teleport:%v", a.username) {
err = agents[i].Remove(key)
if err != nil {
a.log.Warnf("Unable to communicate with agent and remove key: %v", err)
}
}
}
}
return nil
} | go | func (a *LocalKeyAgent) UnloadKey() error {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// iterate over all agents we have and unload keys for this user
for i, _ := range agents {
// get a list of all keys in the agent
keyList, err := agents[i].List()
if err != nil {
a.log.Warnf("Unable to communicate with agent and list keys: %v", err)
}
// remove any teleport keys we currently have loaded in the agent for this user
for _, key := range keyList {
if key.Comment == fmt.Sprintf("teleport:%v", a.username) {
err = agents[i].Remove(key)
if err != nil {
a.log.Warnf("Unable to communicate with agent and remove key: %v", err)
}
}
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"UnloadKey",
"(",
")",
"error",
"{",
"agents",
":=",
"[",
"]",
"agent",
".",
"Agent",
"{",
"a",
".",
"Agent",
"}",
"\n",
"if",
"a",
".",
"sshAgent",
"!=",
"nil",
"{",
"agents",
"=",
"append",
"(",
"agents",
",",
"a",
".",
"sshAgent",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"_",
":=",
"range",
"agents",
"{",
"keyList",
",",
"err",
":=",
"agents",
"[",
"i",
"]",
".",
"List",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to communicate with agent and list keys: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keyList",
"{",
"if",
"key",
".",
"Comment",
"==",
"fmt",
".",
"Sprintf",
"(",
"\"teleport:%v\"",
",",
"a",
".",
"username",
")",
"{",
"err",
"=",
"agents",
"[",
"i",
"]",
".",
"Remove",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to communicate with agent and remove key: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnloadKey will unload key for user from the teleport ssh agent as well as
// the system agent. | [
"UnloadKey",
"will",
"unload",
"key",
"for",
"user",
"from",
"the",
"teleport",
"ssh",
"agent",
"as",
"well",
"as",
"the",
"system",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L158-L184 | train |
gravitational/teleport | lib/client/keyagent.go | UnloadKeys | func (a *LocalKeyAgent) UnloadKeys() error {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// iterate over all agents we have
for i, _ := range agents {
// get a list of all keys in the agent
keyList, err := agents[i].List()
if err != nil {
a.log.Warnf("Unable to communicate with agent and list keys: %v", err)
}
// remove any teleport keys we currently have loaded in the agent
for _, key := range keyList {
if strings.HasPrefix(key.Comment, "teleport:") {
err = agents[i].Remove(key)
if err != nil {
a.log.Warnf("Unable to communicate with agent and remove key: %v", err)
}
}
}
}
return nil
} | go | func (a *LocalKeyAgent) UnloadKeys() error {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// iterate over all agents we have
for i, _ := range agents {
// get a list of all keys in the agent
keyList, err := agents[i].List()
if err != nil {
a.log.Warnf("Unable to communicate with agent and list keys: %v", err)
}
// remove any teleport keys we currently have loaded in the agent
for _, key := range keyList {
if strings.HasPrefix(key.Comment, "teleport:") {
err = agents[i].Remove(key)
if err != nil {
a.log.Warnf("Unable to communicate with agent and remove key: %v", err)
}
}
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"UnloadKeys",
"(",
")",
"error",
"{",
"agents",
":=",
"[",
"]",
"agent",
".",
"Agent",
"{",
"a",
".",
"Agent",
"}",
"\n",
"if",
"a",
".",
"sshAgent",
"!=",
"nil",
"{",
"agents",
"=",
"append",
"(",
"agents",
",",
"a",
".",
"sshAgent",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"_",
":=",
"range",
"agents",
"{",
"keyList",
",",
"err",
":=",
"agents",
"[",
"i",
"]",
".",
"List",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to communicate with agent and list keys: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keyList",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"key",
".",
"Comment",
",",
"\"teleport:\"",
")",
"{",
"err",
"=",
"agents",
"[",
"i",
"]",
".",
"Remove",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Warnf",
"(",
"\"Unable to communicate with agent and remove key: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnloadKeys will unload all Teleport keys from the teleport agent as well as
// the system agent. | [
"UnloadKeys",
"will",
"unload",
"all",
"Teleport",
"keys",
"from",
"the",
"teleport",
"agent",
"as",
"well",
"as",
"the",
"system",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L188-L214 | train |
gravitational/teleport | lib/client/keyagent.go | AddHostSignersToCache | func (a *LocalKeyAgent) AddHostSignersToCache(certAuthorities []auth.TrustedCerts) error {
for _, ca := range certAuthorities {
publicKeys, err := ca.SSHCertPublicKeys()
if err != nil {
a.log.Error(err)
return trace.Wrap(err)
}
a.log.Debugf("Adding CA key for %s", ca.ClusterName)
err = a.keyStore.AddKnownHostKeys(ca.ClusterName, publicKeys)
if err != nil {
return trace.Wrap(err)
}
}
return nil
} | go | func (a *LocalKeyAgent) AddHostSignersToCache(certAuthorities []auth.TrustedCerts) error {
for _, ca := range certAuthorities {
publicKeys, err := ca.SSHCertPublicKeys()
if err != nil {
a.log.Error(err)
return trace.Wrap(err)
}
a.log.Debugf("Adding CA key for %s", ca.ClusterName)
err = a.keyStore.AddKnownHostKeys(ca.ClusterName, publicKeys)
if err != nil {
return trace.Wrap(err)
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"AddHostSignersToCache",
"(",
"certAuthorities",
"[",
"]",
"auth",
".",
"TrustedCerts",
")",
"error",
"{",
"for",
"_",
",",
"ca",
":=",
"range",
"certAuthorities",
"{",
"publicKeys",
",",
"err",
":=",
"ca",
".",
"SSHCertPublicKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"log",
".",
"Debugf",
"(",
"\"Adding CA key for %s\"",
",",
"ca",
".",
"ClusterName",
")",
"\n",
"err",
"=",
"a",
".",
"keyStore",
".",
"AddKnownHostKeys",
"(",
"ca",
".",
"ClusterName",
",",
"publicKeys",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddHostSignersToCache takes a list of CAs whom we trust. This list is added to a database
// of "seen" CAs.
//
// Every time we connect to a new host, we'll request its certificaate to be signed by one
// of these trusted CAs.
//
// Why do we trust these CAs? Because we received them from a trusted Teleport Proxy.
// Why do we trust the proxy? Because we've connected to it via HTTPS + username + Password + HOTP. | [
"AddHostSignersToCache",
"takes",
"a",
"list",
"of",
"CAs",
"whom",
"we",
"trust",
".",
"This",
"list",
"is",
"added",
"to",
"a",
"database",
"of",
"seen",
"CAs",
".",
"Every",
"time",
"we",
"connect",
"to",
"a",
"new",
"host",
"we",
"ll",
"request",
"its",
"certificaate",
"to",
"be",
"signed",
"by",
"one",
"of",
"these",
"trusted",
"CAs",
".",
"Why",
"do",
"we",
"trust",
"these",
"CAs?",
"Because",
"we",
"received",
"them",
"from",
"a",
"trusted",
"Teleport",
"Proxy",
".",
"Why",
"do",
"we",
"trust",
"the",
"proxy?",
"Because",
"we",
"ve",
"connected",
"to",
"it",
"via",
"HTTPS",
"+",
"username",
"+",
"Password",
"+",
"HOTP",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L230-L244 | train |
gravitational/teleport | lib/client/keyagent.go | AddKey | func (a *LocalKeyAgent) AddKey(key *Key) (*agent.AddedKey, error) {
// save it to disk (usually into ~/.tsh)
err := a.keyStore.AddKey(a.proxyHost, a.username, key)
if err != nil {
return nil, trace.Wrap(err)
}
// load key into the teleport agent and system agent
return a.LoadKey(*key)
} | go | func (a *LocalKeyAgent) AddKey(key *Key) (*agent.AddedKey, error) {
// save it to disk (usually into ~/.tsh)
err := a.keyStore.AddKey(a.proxyHost, a.username, key)
if err != nil {
return nil, trace.Wrap(err)
}
// load key into the teleport agent and system agent
return a.LoadKey(*key)
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"AddKey",
"(",
"key",
"*",
"Key",
")",
"(",
"*",
"agent",
".",
"AddedKey",
",",
"error",
")",
"{",
"err",
":=",
"a",
".",
"keyStore",
".",
"AddKey",
"(",
"a",
".",
"proxyHost",
",",
"a",
".",
"username",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"a",
".",
"LoadKey",
"(",
"*",
"key",
")",
"\n",
"}"
] | // AddKey activates a new signed session key by adding it into the keystore and also
// by loading it into the SSH agent | [
"AddKey",
"activates",
"a",
"new",
"signed",
"session",
"key",
"by",
"adding",
"it",
"into",
"the",
"keystore",
"and",
"also",
"by",
"loading",
"it",
"into",
"the",
"SSH",
"agent"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L370-L379 | train |
gravitational/teleport | lib/client/keyagent.go | DeleteKey | func (a *LocalKeyAgent) DeleteKey() error {
// remove key from key store
err := a.keyStore.DeleteKey(a.proxyHost, a.username)
if err != nil {
return trace.Wrap(err)
}
// remove any keys that are loaded for this user from the teleport and
// system agents
err = a.UnloadKey()
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (a *LocalKeyAgent) DeleteKey() error {
// remove key from key store
err := a.keyStore.DeleteKey(a.proxyHost, a.username)
if err != nil {
return trace.Wrap(err)
}
// remove any keys that are loaded for this user from the teleport and
// system agents
err = a.UnloadKey()
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"DeleteKey",
"(",
")",
"error",
"{",
"err",
":=",
"a",
".",
"keyStore",
".",
"DeleteKey",
"(",
"a",
".",
"proxyHost",
",",
"a",
".",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"a",
".",
"UnloadKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteKey removes the key from the key store as well as unloading the key
// from the agent. | [
"DeleteKey",
"removes",
"the",
"key",
"from",
"the",
"key",
"store",
"as",
"well",
"as",
"unloading",
"the",
"key",
"from",
"the",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L383-L398 | train |
gravitational/teleport | lib/client/keyagent.go | DeleteKeys | func (a *LocalKeyAgent) DeleteKeys() error {
// Remove keys from the filesystem.
err := a.keyStore.DeleteKeys()
if err != nil {
return trace.Wrap(err)
}
// Remove all keys from the Teleport and system agents.
err = a.UnloadKeys()
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (a *LocalKeyAgent) DeleteKeys() error {
// Remove keys from the filesystem.
err := a.keyStore.DeleteKeys()
if err != nil {
return trace.Wrap(err)
}
// Remove all keys from the Teleport and system agents.
err = a.UnloadKeys()
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"a",
"*",
"LocalKeyAgent",
")",
"DeleteKeys",
"(",
")",
"error",
"{",
"err",
":=",
"a",
".",
"keyStore",
".",
"DeleteKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"a",
".",
"UnloadKeys",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteKeys removes all keys from the keystore as well as unloads keys
// from the agent. | [
"DeleteKeys",
"removes",
"all",
"keys",
"from",
"the",
"keystore",
"as",
"well",
"as",
"unloads",
"keys",
"from",
"the",
"agent",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/client/keyagent.go#L402-L416 | train |
gravitational/teleport | lib/utils/fs_unix.go | FSWriteLock | func FSWriteLock(f *os.File) error {
if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | func FSWriteLock(f *os.File) error {
if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"FSWriteLock",
"(",
"f",
"*",
"os",
".",
"File",
")",
"error",
"{",
"if",
"err",
":=",
"syscall",
".",
"Flock",
"(",
"int",
"(",
"f",
".",
"Fd",
"(",
")",
")",
",",
"syscall",
".",
"LOCK_EX",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // FSWriteLock grabs Flock-style filesystem lock on an open file
// in exclusive mode. | [
"FSWriteLock",
"grabs",
"Flock",
"-",
"style",
"filesystem",
"lock",
"on",
"an",
"open",
"file",
"in",
"exclusive",
"mode",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/fs_unix.go#L30-L35 | train |
gravitational/teleport | lib/utils/fs_unix.go | FSTryWriteLock | func FSTryWriteLock(f *os.File) error {
err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
if err != nil {
if err == syscall.EWOULDBLOCK {
return trace.CompareFailed("lock %v is acquired by another process", f.Name())
}
return trace.ConvertSystemError(err)
}
return nil
} | go | func FSTryWriteLock(f *os.File) error {
err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
if err != nil {
if err == syscall.EWOULDBLOCK {
return trace.CompareFailed("lock %v is acquired by another process", f.Name())
}
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"FSTryWriteLock",
"(",
"f",
"*",
"os",
".",
"File",
")",
"error",
"{",
"err",
":=",
"syscall",
".",
"Flock",
"(",
"int",
"(",
"f",
".",
"Fd",
"(",
")",
")",
",",
"syscall",
".",
"LOCK_EX",
"|",
"syscall",
".",
"LOCK_NB",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"syscall",
".",
"EWOULDBLOCK",
"{",
"return",
"trace",
".",
"CompareFailed",
"(",
"\"lock %v is acquired by another process\"",
",",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // FSTryWriteLock tries to grab write lock, returns CompareFailed
// if lock is already grabbed | [
"FSTryWriteLock",
"tries",
"to",
"grab",
"write",
"lock",
"returns",
"CompareFailed",
"if",
"lock",
"is",
"already",
"grabbed"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/fs_unix.go#L39-L48 | train |
gravitational/teleport | lib/utils/fs_unix.go | FSUnlock | func FSUnlock(f *os.File) error {
if err := syscall.Flock(int(f.Fd()), syscall.LOCK_UN); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | func FSUnlock(f *os.File) error {
if err := syscall.Flock(int(f.Fd()), syscall.LOCK_UN); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | [
"func",
"FSUnlock",
"(",
"f",
"*",
"os",
".",
"File",
")",
"error",
"{",
"if",
"err",
":=",
"syscall",
".",
"Flock",
"(",
"int",
"(",
"f",
".",
"Fd",
"(",
")",
")",
",",
"syscall",
".",
"LOCK_UN",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"ConvertSystemError",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // FSUnlock unlcocks Flock-style filesystem lock | [
"FSUnlock",
"unlcocks",
"Flock",
"-",
"style",
"filesystem",
"lock"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/fs_unix.go#L60-L65 | train |
gravitational/teleport | lib/limiter/ratelimiter.go | NewRateLimiter | func NewRateLimiter(config LimiterConfig) (*RateLimiter, error) {
limiter := RateLimiter{
Mutex: &sync.Mutex{},
}
ipExtractor, err := utils.NewExtractor("client.ip")
if err != nil {
return nil, trace.Wrap(err)
}
limiter.rates = ratelimit.NewRateSet()
for _, rate := range config.Rates {
err := limiter.rates.Add(rate.Period, rate.Average, rate.Burst)
if err != nil {
return nil, trace.Wrap(err)
}
}
if len(config.Rates) == 0 {
err := limiter.rates.Add(time.Second, DefaultRate, DefaultRate)
if err != nil {
return nil, trace.Wrap(err)
}
}
if config.Clock == nil {
config.Clock = &timetools.RealTime{}
}
limiter.clock = config.Clock
limiter.TokenLimiter, err = ratelimit.New(nil, ipExtractor,
limiter.rates, ratelimit.Clock(config.Clock))
if err != nil {
return nil, trace.Wrap(err)
}
maxNumberOfUsers := config.MaxNumberOfUsers
if maxNumberOfUsers <= 0 {
maxNumberOfUsers = DefaultMaxNumberOfUsers
}
limiter.rateLimits, err = ttlmap.NewMap(
maxNumberOfUsers, ttlmap.Clock(config.Clock))
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
} | go | func NewRateLimiter(config LimiterConfig) (*RateLimiter, error) {
limiter := RateLimiter{
Mutex: &sync.Mutex{},
}
ipExtractor, err := utils.NewExtractor("client.ip")
if err != nil {
return nil, trace.Wrap(err)
}
limiter.rates = ratelimit.NewRateSet()
for _, rate := range config.Rates {
err := limiter.rates.Add(rate.Period, rate.Average, rate.Burst)
if err != nil {
return nil, trace.Wrap(err)
}
}
if len(config.Rates) == 0 {
err := limiter.rates.Add(time.Second, DefaultRate, DefaultRate)
if err != nil {
return nil, trace.Wrap(err)
}
}
if config.Clock == nil {
config.Clock = &timetools.RealTime{}
}
limiter.clock = config.Clock
limiter.TokenLimiter, err = ratelimit.New(nil, ipExtractor,
limiter.rates, ratelimit.Clock(config.Clock))
if err != nil {
return nil, trace.Wrap(err)
}
maxNumberOfUsers := config.MaxNumberOfUsers
if maxNumberOfUsers <= 0 {
maxNumberOfUsers = DefaultMaxNumberOfUsers
}
limiter.rateLimits, err = ttlmap.NewMap(
maxNumberOfUsers, ttlmap.Clock(config.Clock))
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
} | [
"func",
"NewRateLimiter",
"(",
"config",
"LimiterConfig",
")",
"(",
"*",
"RateLimiter",
",",
"error",
")",
"{",
"limiter",
":=",
"RateLimiter",
"{",
"Mutex",
":",
"&",
"sync",
".",
"Mutex",
"{",
"}",
",",
"}",
"\n",
"ipExtractor",
",",
"err",
":=",
"utils",
".",
"NewExtractor",
"(",
"\"client.ip\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"limiter",
".",
"rates",
"=",
"ratelimit",
".",
"NewRateSet",
"(",
")",
"\n",
"for",
"_",
",",
"rate",
":=",
"range",
"config",
".",
"Rates",
"{",
"err",
":=",
"limiter",
".",
"rates",
".",
"Add",
"(",
"rate",
".",
"Period",
",",
"rate",
".",
"Average",
",",
"rate",
".",
"Burst",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"config",
".",
"Rates",
")",
"==",
"0",
"{",
"err",
":=",
"limiter",
".",
"rates",
".",
"Add",
"(",
"time",
".",
"Second",
",",
"DefaultRate",
",",
"DefaultRate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"config",
".",
"Clock",
"==",
"nil",
"{",
"config",
".",
"Clock",
"=",
"&",
"timetools",
".",
"RealTime",
"{",
"}",
"\n",
"}",
"\n",
"limiter",
".",
"clock",
"=",
"config",
".",
"Clock",
"\n",
"limiter",
".",
"TokenLimiter",
",",
"err",
"=",
"ratelimit",
".",
"New",
"(",
"nil",
",",
"ipExtractor",
",",
"limiter",
".",
"rates",
",",
"ratelimit",
".",
"Clock",
"(",
"config",
".",
"Clock",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"maxNumberOfUsers",
":=",
"config",
".",
"MaxNumberOfUsers",
"\n",
"if",
"maxNumberOfUsers",
"<=",
"0",
"{",
"maxNumberOfUsers",
"=",
"DefaultMaxNumberOfUsers",
"\n",
"}",
"\n",
"limiter",
".",
"rateLimits",
",",
"err",
"=",
"ttlmap",
".",
"NewMap",
"(",
"maxNumberOfUsers",
",",
"ttlmap",
".",
"Clock",
"(",
"config",
".",
"Clock",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"limiter",
",",
"nil",
"\n",
"}"
] | // NewRateLimiter returns new request rate controller | [
"NewRateLimiter",
"returns",
"new",
"request",
"rate",
"controller"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/ratelimiter.go#L50-L96 | train |
gravitational/teleport | lib/limiter/ratelimiter.go | RegisterRequest | func (l *RateLimiter) RegisterRequest(token string) error {
l.Lock()
defer l.Unlock()
bucketSetI, exists := l.rateLimits.Get(token)
var bucketSet *ratelimit.TokenBucketSet
if exists {
bucketSet = bucketSetI.(*ratelimit.TokenBucketSet)
bucketSet.Update(l.rates)
} else {
bucketSet = ratelimit.NewTokenBucketSet(l.rates, l.clock)
// We set ttl as 10 times rate period. E.g. if rate is 100 requests/second per client ip
// the counters for this ip will expire after 10 seconds of inactivity
err := l.rateLimits.Set(token, bucketSet, int(bucketSet.GetMaxPeriod()/time.Second)*10+1)
if err != nil {
return trace.Wrap(err)
}
}
delay, err := bucketSet.Consume(1)
if err != nil {
return err
}
if delay > 0 {
return &ratelimit.MaxRateError{}
}
return nil
} | go | func (l *RateLimiter) RegisterRequest(token string) error {
l.Lock()
defer l.Unlock()
bucketSetI, exists := l.rateLimits.Get(token)
var bucketSet *ratelimit.TokenBucketSet
if exists {
bucketSet = bucketSetI.(*ratelimit.TokenBucketSet)
bucketSet.Update(l.rates)
} else {
bucketSet = ratelimit.NewTokenBucketSet(l.rates, l.clock)
// We set ttl as 10 times rate period. E.g. if rate is 100 requests/second per client ip
// the counters for this ip will expire after 10 seconds of inactivity
err := l.rateLimits.Set(token, bucketSet, int(bucketSet.GetMaxPeriod()/time.Second)*10+1)
if err != nil {
return trace.Wrap(err)
}
}
delay, err := bucketSet.Consume(1)
if err != nil {
return err
}
if delay > 0 {
return &ratelimit.MaxRateError{}
}
return nil
} | [
"func",
"(",
"l",
"*",
"RateLimiter",
")",
"RegisterRequest",
"(",
"token",
"string",
")",
"error",
"{",
"l",
".",
"Lock",
"(",
")",
"\n",
"defer",
"l",
".",
"Unlock",
"(",
")",
"\n",
"bucketSetI",
",",
"exists",
":=",
"l",
".",
"rateLimits",
".",
"Get",
"(",
"token",
")",
"\n",
"var",
"bucketSet",
"*",
"ratelimit",
".",
"TokenBucketSet",
"\n",
"if",
"exists",
"{",
"bucketSet",
"=",
"bucketSetI",
".",
"(",
"*",
"ratelimit",
".",
"TokenBucketSet",
")",
"\n",
"bucketSet",
".",
"Update",
"(",
"l",
".",
"rates",
")",
"\n",
"}",
"else",
"{",
"bucketSet",
"=",
"ratelimit",
".",
"NewTokenBucketSet",
"(",
"l",
".",
"rates",
",",
"l",
".",
"clock",
")",
"\n",
"err",
":=",
"l",
".",
"rateLimits",
".",
"Set",
"(",
"token",
",",
"bucketSet",
",",
"int",
"(",
"bucketSet",
".",
"GetMaxPeriod",
"(",
")",
"/",
"time",
".",
"Second",
")",
"*",
"10",
"+",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"delay",
",",
"err",
":=",
"bucketSet",
".",
"Consume",
"(",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"delay",
">",
"0",
"{",
"return",
"&",
"ratelimit",
".",
"MaxRateError",
"{",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // RegisterRequest increases number of requests for the provided token
// Returns error if there are too many requests with the provided token | [
"RegisterRequest",
"increases",
"number",
"of",
"requests",
"for",
"the",
"provided",
"token",
"Returns",
"error",
"if",
"there",
"are",
"too",
"many",
"requests",
"with",
"the",
"provided",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/ratelimiter.go#L100-L127 | train |
gravitational/teleport | lib/limiter/ratelimiter.go | WrapHandle | func (l *RateLimiter) WrapHandle(h http.Handler) {
l.TokenLimiter.Wrap(h)
} | go | func (l *RateLimiter) WrapHandle(h http.Handler) {
l.TokenLimiter.Wrap(h)
} | [
"func",
"(",
"l",
"*",
"RateLimiter",
")",
"WrapHandle",
"(",
"h",
"http",
".",
"Handler",
")",
"{",
"l",
".",
"TokenLimiter",
".",
"Wrap",
"(",
"h",
")",
"\n",
"}"
] | // Add rate limiter to the handle | [
"Add",
"rate",
"limiter",
"to",
"the",
"handle"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/limiter/ratelimiter.go#L130-L132 | train |
gravitational/teleport | lib/auth/clt.go | EncodeClusterName | func EncodeClusterName(clusterName string) string {
// hex is used to hide "." that will prevent wildcard *. entry to match
return fmt.Sprintf("%v.%v", hex.EncodeToString([]byte(clusterName)), teleport.APIDomain)
} | go | func EncodeClusterName(clusterName string) string {
// hex is used to hide "." that will prevent wildcard *. entry to match
return fmt.Sprintf("%v.%v", hex.EncodeToString([]byte(clusterName)), teleport.APIDomain)
} | [
"func",
"EncodeClusterName",
"(",
"clusterName",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"%v.%v\"",
",",
"hex",
".",
"EncodeToString",
"(",
"[",
"]",
"byte",
"(",
"clusterName",
")",
")",
",",
"teleport",
".",
"APIDomain",
")",
"\n",
"}"
] | // EncodeClusterName encodes cluster name in the SNI hostname | [
"EncodeClusterName",
"encodes",
"cluster",
"name",
"in",
"the",
"SNI",
"hostname"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L97-L100 | train |
gravitational/teleport | lib/auth/clt.go | NewAddrDialer | func NewAddrDialer(addrs []utils.NetAddr) DialContext {
dialer := net.Dialer{
Timeout: defaults.DefaultDialTimeout,
KeepAlive: defaults.ReverseTunnelAgentHeartbeatPeriod,
}
return func(in context.Context, network, _ string) (net.Conn, error) {
var err error
var conn net.Conn
for _, addr := range addrs {
conn, err = dialer.DialContext(in, network, addr.Addr)
if err == nil {
return conn, nil
}
log.Errorf("Failed to dial auth server %v: %v.", addr.Addr, err)
}
// not wrapping on purpose to preserve the original error
return nil, err
}
} | go | func NewAddrDialer(addrs []utils.NetAddr) DialContext {
dialer := net.Dialer{
Timeout: defaults.DefaultDialTimeout,
KeepAlive: defaults.ReverseTunnelAgentHeartbeatPeriod,
}
return func(in context.Context, network, _ string) (net.Conn, error) {
var err error
var conn net.Conn
for _, addr := range addrs {
conn, err = dialer.DialContext(in, network, addr.Addr)
if err == nil {
return conn, nil
}
log.Errorf("Failed to dial auth server %v: %v.", addr.Addr, err)
}
// not wrapping on purpose to preserve the original error
return nil, err
}
} | [
"func",
"NewAddrDialer",
"(",
"addrs",
"[",
"]",
"utils",
".",
"NetAddr",
")",
"DialContext",
"{",
"dialer",
":=",
"net",
".",
"Dialer",
"{",
"Timeout",
":",
"defaults",
".",
"DefaultDialTimeout",
",",
"KeepAlive",
":",
"defaults",
".",
"ReverseTunnelAgentHeartbeatPeriod",
",",
"}",
"\n",
"return",
"func",
"(",
"in",
"context",
".",
"Context",
",",
"network",
",",
"_",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"conn",
"net",
".",
"Conn",
"\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"conn",
",",
"err",
"=",
"dialer",
".",
"DialContext",
"(",
"in",
",",
"network",
",",
"addr",
".",
"Addr",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"conn",
",",
"nil",
"\n",
"}",
"\n",
"log",
".",
"Errorf",
"(",
"\"Failed to dial auth server %v: %v.\"",
",",
"addr",
".",
"Addr",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] | // NewAddrDialer returns new dialer from a list of addresses | [
"NewAddrDialer",
"returns",
"new",
"dialer",
"from",
"a",
"list",
"of",
"addresses"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L124-L142 | train |
gravitational/teleport | lib/auth/clt.go | ClientTimeout | func ClientTimeout(timeout time.Duration) roundtrip.ClientParam {
return func(c *roundtrip.Client) error {
transport, ok := (c.HTTPClient().Transport).(*http.Transport)
if !ok {
return nil
}
transport.IdleConnTimeout = timeout
transport.ResponseHeaderTimeout = timeout
return nil
}
} | go | func ClientTimeout(timeout time.Duration) roundtrip.ClientParam {
return func(c *roundtrip.Client) error {
transport, ok := (c.HTTPClient().Transport).(*http.Transport)
if !ok {
return nil
}
transport.IdleConnTimeout = timeout
transport.ResponseHeaderTimeout = timeout
return nil
}
} | [
"func",
"ClientTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"roundtrip",
".",
"ClientParam",
"{",
"return",
"func",
"(",
"c",
"*",
"roundtrip",
".",
"Client",
")",
"error",
"{",
"transport",
",",
"ok",
":=",
"(",
"c",
".",
"HTTPClient",
"(",
")",
".",
"Transport",
")",
".",
"(",
"*",
"http",
".",
"Transport",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"transport",
".",
"IdleConnTimeout",
"=",
"timeout",
"\n",
"transport",
".",
"ResponseHeaderTimeout",
"=",
"timeout",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // ClientTimeout sets idle and dial timeouts of the HTTP transport
// used by the client. | [
"ClientTimeout",
"sets",
"idle",
"and",
"dial",
"timeouts",
"of",
"the",
"HTTP",
"transport",
"used",
"by",
"the",
"client",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L146-L156 | train |
gravitational/teleport | lib/auth/clt.go | CheckAndSetDefaults | func (c *ClientConfig) CheckAndSetDefaults() error {
if len(c.Addrs) == 0 && c.DialContext == nil {
return trace.BadParameter("set parameter Addrs or DialContext")
}
if c.TLS == nil {
return trace.BadParameter("missing parameter TLS")
}
if c.KeepAlivePeriod == 0 {
c.KeepAlivePeriod = defaults.ServerKeepAliveTTL
}
if c.KeepAliveCount == 0 {
c.KeepAliveCount = defaults.KeepAliveCountMax
}
if c.DialContext == nil {
c.DialContext = NewAddrDialer(c.Addrs)
}
if c.TLS.ServerName == "" {
c.TLS.ServerName = teleport.APIDomain
}
// this logic is necessary to force client to always send certificate
// regardless of the server setting, otherwise client may pick
// not to send the client certificate by looking at certificate request
if len(c.TLS.Certificates) != 0 {
cert := c.TLS.Certificates[0]
c.TLS.Certificates = nil
c.TLS.GetClientCertificate = func(_ *tls.CertificateRequestInfo) (*tls.Certificate, error) {
return &cert, nil
}
}
return nil
} | go | func (c *ClientConfig) CheckAndSetDefaults() error {
if len(c.Addrs) == 0 && c.DialContext == nil {
return trace.BadParameter("set parameter Addrs or DialContext")
}
if c.TLS == nil {
return trace.BadParameter("missing parameter TLS")
}
if c.KeepAlivePeriod == 0 {
c.KeepAlivePeriod = defaults.ServerKeepAliveTTL
}
if c.KeepAliveCount == 0 {
c.KeepAliveCount = defaults.KeepAliveCountMax
}
if c.DialContext == nil {
c.DialContext = NewAddrDialer(c.Addrs)
}
if c.TLS.ServerName == "" {
c.TLS.ServerName = teleport.APIDomain
}
// this logic is necessary to force client to always send certificate
// regardless of the server setting, otherwise client may pick
// not to send the client certificate by looking at certificate request
if len(c.TLS.Certificates) != 0 {
cert := c.TLS.Certificates[0]
c.TLS.Certificates = nil
c.TLS.GetClientCertificate = func(_ *tls.CertificateRequestInfo) (*tls.Certificate, error) {
return &cert, nil
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"ClientConfig",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"c",
".",
"Addrs",
")",
"==",
"0",
"&&",
"c",
".",
"DialContext",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"set parameter Addrs or DialContext\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"TLS",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter TLS\"",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"KeepAlivePeriod",
"==",
"0",
"{",
"c",
".",
"KeepAlivePeriod",
"=",
"defaults",
".",
"ServerKeepAliveTTL",
"\n",
"}",
"\n",
"if",
"c",
".",
"KeepAliveCount",
"==",
"0",
"{",
"c",
".",
"KeepAliveCount",
"=",
"defaults",
".",
"KeepAliveCountMax",
"\n",
"}",
"\n",
"if",
"c",
".",
"DialContext",
"==",
"nil",
"{",
"c",
".",
"DialContext",
"=",
"NewAddrDialer",
"(",
"c",
".",
"Addrs",
")",
"\n",
"}",
"\n",
"if",
"c",
".",
"TLS",
".",
"ServerName",
"==",
"\"\"",
"{",
"c",
".",
"TLS",
".",
"ServerName",
"=",
"teleport",
".",
"APIDomain",
"\n",
"}",
"\n",
"if",
"len",
"(",
"c",
".",
"TLS",
".",
"Certificates",
")",
"!=",
"0",
"{",
"cert",
":=",
"c",
".",
"TLS",
".",
"Certificates",
"[",
"0",
"]",
"\n",
"c",
".",
"TLS",
".",
"Certificates",
"=",
"nil",
"\n",
"c",
".",
"TLS",
".",
"GetClientCertificate",
"=",
"func",
"(",
"_",
"*",
"tls",
".",
"CertificateRequestInfo",
")",
"(",
"*",
"tls",
".",
"Certificate",
",",
"error",
")",
"{",
"return",
"&",
"cert",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets default config values | [
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"config",
"values"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L175-L206 | train |
gravitational/teleport | lib/auth/clt.go | NewTLSClient | func NewTLSClient(cfg ClientConfig, params ...roundtrip.ClientParam) (*Client, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
transport := &http.Transport{
// notice that below roundtrip.Client is passed
// teleport.APIEndpoint as an address for the API server, this is
// to make sure client verifies the DNS name of the API server
// custom DialContext overrides this DNS name to the real address
// in addition this dialer tries multiple adresses if provided
DialContext: cfg.DialContext,
ResponseHeaderTimeout: defaults.DefaultDialTimeout,
TLSClientConfig: cfg.TLS,
// Increase the size of the connection pool. This substantially improves the
// performance of Teleport under load as it reduces the number of TLS
// handshakes performed.
MaxIdleConns: defaults.HTTPMaxIdleConns,
MaxIdleConnsPerHost: defaults.HTTPMaxIdleConnsPerHost,
// IdleConnTimeout defines the maximum amount of time before idle connections
// are closed. Leaving this unset will lead to connections open forever and
// will cause memory leaks in a long running process.
IdleConnTimeout: defaults.HTTPIdleTimeout,
}
clientParams := append(
[]roundtrip.ClientParam{
roundtrip.HTTPClient(&http.Client{Transport: transport}),
roundtrip.SanitizerEnabled(true),
},
params...,
)
roundtripClient, err := roundtrip.NewClient("https://"+teleport.APIDomain, CurrentVersion, clientParams...)
if err != nil {
return nil, trace.Wrap(err)
}
return &Client{
ClientConfig: cfg,
Client: *roundtripClient,
transport: transport,
}, nil
} | go | func NewTLSClient(cfg ClientConfig, params ...roundtrip.ClientParam) (*Client, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
transport := &http.Transport{
// notice that below roundtrip.Client is passed
// teleport.APIEndpoint as an address for the API server, this is
// to make sure client verifies the DNS name of the API server
// custom DialContext overrides this DNS name to the real address
// in addition this dialer tries multiple adresses if provided
DialContext: cfg.DialContext,
ResponseHeaderTimeout: defaults.DefaultDialTimeout,
TLSClientConfig: cfg.TLS,
// Increase the size of the connection pool. This substantially improves the
// performance of Teleport under load as it reduces the number of TLS
// handshakes performed.
MaxIdleConns: defaults.HTTPMaxIdleConns,
MaxIdleConnsPerHost: defaults.HTTPMaxIdleConnsPerHost,
// IdleConnTimeout defines the maximum amount of time before idle connections
// are closed. Leaving this unset will lead to connections open forever and
// will cause memory leaks in a long running process.
IdleConnTimeout: defaults.HTTPIdleTimeout,
}
clientParams := append(
[]roundtrip.ClientParam{
roundtrip.HTTPClient(&http.Client{Transport: transport}),
roundtrip.SanitizerEnabled(true),
},
params...,
)
roundtripClient, err := roundtrip.NewClient("https://"+teleport.APIDomain, CurrentVersion, clientParams...)
if err != nil {
return nil, trace.Wrap(err)
}
return &Client{
ClientConfig: cfg,
Client: *roundtripClient,
transport: transport,
}, nil
} | [
"func",
"NewTLSClient",
"(",
"cfg",
"ClientConfig",
",",
"params",
"...",
"roundtrip",
".",
"ClientParam",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"transport",
":=",
"&",
"http",
".",
"Transport",
"{",
"DialContext",
":",
"cfg",
".",
"DialContext",
",",
"ResponseHeaderTimeout",
":",
"defaults",
".",
"DefaultDialTimeout",
",",
"TLSClientConfig",
":",
"cfg",
".",
"TLS",
",",
"MaxIdleConns",
":",
"defaults",
".",
"HTTPMaxIdleConns",
",",
"MaxIdleConnsPerHost",
":",
"defaults",
".",
"HTTPMaxIdleConnsPerHost",
",",
"IdleConnTimeout",
":",
"defaults",
".",
"HTTPIdleTimeout",
",",
"}",
"\n",
"clientParams",
":=",
"append",
"(",
"[",
"]",
"roundtrip",
".",
"ClientParam",
"{",
"roundtrip",
".",
"HTTPClient",
"(",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"transport",
"}",
")",
",",
"roundtrip",
".",
"SanitizerEnabled",
"(",
"true",
")",
",",
"}",
",",
"params",
"...",
",",
")",
"\n",
"roundtripClient",
",",
"err",
":=",
"roundtrip",
".",
"NewClient",
"(",
"\"https://\"",
"+",
"teleport",
".",
"APIDomain",
",",
"CurrentVersion",
",",
"clientParams",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"Client",
"{",
"ClientConfig",
":",
"cfg",
",",
"Client",
":",
"*",
"roundtripClient",
",",
"transport",
":",
"transport",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewTLSClient returns a new TLS client that uses mutual TLS authentication
// and dials the remote server using dialer | [
"NewTLSClient",
"returns",
"a",
"new",
"TLS",
"client",
"that",
"uses",
"mutual",
"TLS",
"authentication",
"and",
"dials",
"the",
"remote",
"server",
"using",
"dialer"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L210-L252 | train |
gravitational/teleport | lib/auth/clt.go | grpc | func (c *Client) grpc() (proto.AuthServiceClient, error) {
// it's ok to lock here, because Dial below is not locking
c.Lock()
defer c.Unlock()
if c.grpcClient != nil {
return c.grpcClient, nil
}
dialer := grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
if c.isClosed() {
return nil, trace.ConnectionProblem(nil, "client is closed")
}
c, err := c.DialContext(context.TODO(), "tcp", addr)
if err != nil {
log.Debugf("Dial to addr %v failed: %v.", addr, err)
}
return c, err
})
tlsConfig := c.TLS.Clone()
tlsConfig.NextProtos = []string{http2.NextProtoTLS}
log.Debugf("GRPC(): keep alive %v count: %v.", c.KeepAlivePeriod, c.KeepAliveCount)
conn, err := grpc.Dial(teleport.APIDomain,
dialer,
grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
grpc.WithKeepaliveParams(keepalive.ClientParameters{
Time: c.KeepAlivePeriod,
Timeout: c.KeepAlivePeriod * time.Duration(c.KeepAliveCount),
}),
)
if err != nil {
return nil, trail.FromGRPC(err)
}
c.conn = conn
c.grpcClient = proto.NewAuthServiceClient(c.conn)
return c.grpcClient, nil
} | go | func (c *Client) grpc() (proto.AuthServiceClient, error) {
// it's ok to lock here, because Dial below is not locking
c.Lock()
defer c.Unlock()
if c.grpcClient != nil {
return c.grpcClient, nil
}
dialer := grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
if c.isClosed() {
return nil, trace.ConnectionProblem(nil, "client is closed")
}
c, err := c.DialContext(context.TODO(), "tcp", addr)
if err != nil {
log.Debugf("Dial to addr %v failed: %v.", addr, err)
}
return c, err
})
tlsConfig := c.TLS.Clone()
tlsConfig.NextProtos = []string{http2.NextProtoTLS}
log.Debugf("GRPC(): keep alive %v count: %v.", c.KeepAlivePeriod, c.KeepAliveCount)
conn, err := grpc.Dial(teleport.APIDomain,
dialer,
grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
grpc.WithKeepaliveParams(keepalive.ClientParameters{
Time: c.KeepAlivePeriod,
Timeout: c.KeepAlivePeriod * time.Duration(c.KeepAliveCount),
}),
)
if err != nil {
return nil, trail.FromGRPC(err)
}
c.conn = conn
c.grpcClient = proto.NewAuthServiceClient(c.conn)
return c.grpcClient, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"grpc",
"(",
")",
"(",
"proto",
".",
"AuthServiceClient",
",",
"error",
")",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"if",
"c",
".",
"grpcClient",
"!=",
"nil",
"{",
"return",
"c",
".",
"grpcClient",
",",
"nil",
"\n",
"}",
"\n",
"dialer",
":=",
"grpc",
".",
"WithDialer",
"(",
"func",
"(",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"if",
"c",
".",
"isClosed",
"(",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"ConnectionProblem",
"(",
"nil",
",",
"\"client is closed\"",
")",
"\n",
"}",
"\n",
"c",
",",
"err",
":=",
"c",
".",
"DialContext",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"\"tcp\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"Dial to addr %v failed: %v.\"",
",",
"addr",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
",",
"err",
"\n",
"}",
")",
"\n",
"tlsConfig",
":=",
"c",
".",
"TLS",
".",
"Clone",
"(",
")",
"\n",
"tlsConfig",
".",
"NextProtos",
"=",
"[",
"]",
"string",
"{",
"http2",
".",
"NextProtoTLS",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"GRPC(): keep alive %v count: %v.\"",
",",
"c",
".",
"KeepAlivePeriod",
",",
"c",
".",
"KeepAliveCount",
")",
"\n",
"conn",
",",
"err",
":=",
"grpc",
".",
"Dial",
"(",
"teleport",
".",
"APIDomain",
",",
"dialer",
",",
"grpc",
".",
"WithTransportCredentials",
"(",
"credentials",
".",
"NewTLS",
"(",
"tlsConfig",
")",
")",
",",
"grpc",
".",
"WithKeepaliveParams",
"(",
"keepalive",
".",
"ClientParameters",
"{",
"Time",
":",
"c",
".",
"KeepAlivePeriod",
",",
"Timeout",
":",
"c",
".",
"KeepAlivePeriod",
"*",
"time",
".",
"Duration",
"(",
"c",
".",
"KeepAliveCount",
")",
",",
"}",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trail",
".",
"FromGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"c",
".",
"conn",
"=",
"conn",
"\n",
"c",
".",
"grpcClient",
"=",
"proto",
".",
"NewAuthServiceClient",
"(",
"c",
".",
"conn",
")",
"\n",
"return",
"c",
".",
"grpcClient",
",",
"nil",
"\n",
"}"
] | // grpc returns grpc client | [
"grpc",
"returns",
"grpc",
"client"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L263-L299 | train |
gravitational/teleport | lib/auth/clt.go | PutJSON | func (c *Client) PutJSON(
endpoint string, val interface{}) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.PutJSON(context.TODO(), endpoint, val))
} | go | func (c *Client) PutJSON(
endpoint string, val interface{}) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.PutJSON(context.TODO(), endpoint, val))
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PutJSON",
"(",
"endpoint",
"string",
",",
"val",
"interface",
"{",
"}",
")",
"(",
"*",
"roundtrip",
".",
"Response",
",",
"error",
")",
"{",
"return",
"httplib",
".",
"ConvertResponse",
"(",
"c",
".",
"Client",
".",
"PutJSON",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"endpoint",
",",
"val",
")",
")",
"\n",
"}"
] | // PutJSON is a generic method that issues http PUT request to the server | [
"PutJSON",
"is",
"a",
"generic",
"method",
"that",
"issues",
"http",
"PUT",
"request",
"to",
"the",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L312-L315 | train |
gravitational/teleport | lib/auth/clt.go | PostForm | func (c *Client) PostForm(
endpoint string,
vals url.Values,
files ...roundtrip.File) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.PostForm(context.TODO(), endpoint, vals, files...))
} | go | func (c *Client) PostForm(
endpoint string,
vals url.Values,
files ...roundtrip.File) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.PostForm(context.TODO(), endpoint, vals, files...))
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PostForm",
"(",
"endpoint",
"string",
",",
"vals",
"url",
".",
"Values",
",",
"files",
"...",
"roundtrip",
".",
"File",
")",
"(",
"*",
"roundtrip",
".",
"Response",
",",
"error",
")",
"{",
"return",
"httplib",
".",
"ConvertResponse",
"(",
"c",
".",
"Client",
".",
"PostForm",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"endpoint",
",",
"vals",
",",
"files",
"...",
")",
")",
"\n",
"}"
] | // PostForm is a generic method that issues http POST request to the server | [
"PostForm",
"is",
"a",
"generic",
"method",
"that",
"issues",
"http",
"POST",
"request",
"to",
"the",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L318-L323 | train |
gravitational/teleport | lib/auth/clt.go | Get | func (c *Client) Get(u string, params url.Values) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.Get(context.TODO(), u, params))
} | go | func (c *Client) Get(u string, params url.Values) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.Get(context.TODO(), u, params))
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Get",
"(",
"u",
"string",
",",
"params",
"url",
".",
"Values",
")",
"(",
"*",
"roundtrip",
".",
"Response",
",",
"error",
")",
"{",
"return",
"httplib",
".",
"ConvertResponse",
"(",
"c",
".",
"Client",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"u",
",",
"params",
")",
")",
"\n",
"}"
] | // Get issues http GET request to the server | [
"Get",
"issues",
"http",
"GET",
"request",
"to",
"the",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L326-L328 | train |
gravitational/teleport | lib/auth/clt.go | Delete | func (c *Client) Delete(u string) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.Delete(context.TODO(), u))
} | go | func (c *Client) Delete(u string) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.Delete(context.TODO(), u))
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Delete",
"(",
"u",
"string",
")",
"(",
"*",
"roundtrip",
".",
"Response",
",",
"error",
")",
"{",
"return",
"httplib",
".",
"ConvertResponse",
"(",
"c",
".",
"Client",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"u",
")",
")",
"\n",
"}"
] | // Delete issues http Delete Request to the server | [
"Delete",
"issues",
"http",
"Delete",
"Request",
"to",
"the",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L331-L333 | train |
gravitational/teleport | lib/auth/clt.go | GetSessions | func (c *Client) GetSessions(namespace string) ([]session.Session, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "sessions"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var sessions []session.Session
if err := json.Unmarshal(out.Bytes(), &sessions); err != nil {
return nil, err
}
return sessions, nil
} | go | func (c *Client) GetSessions(namespace string) ([]session.Session, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "sessions"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var sessions []session.Session
if err := json.Unmarshal(out.Bytes(), &sessions); err != nil {
return nil, err
}
return sessions, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetSessions",
"(",
"namespace",
"string",
")",
"(",
"[",
"]",
"session",
".",
"Session",
",",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"namespace",
",",
"\"sessions\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"sessions",
"[",
"]",
"session",
".",
"Session",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"sessions",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"sessions",
",",
"nil",
"\n",
"}"
] | // GetSessions returns a list of active sessions in the cluster
// as reported by auth server | [
"GetSessions",
"returns",
"a",
"list",
"of",
"active",
"sessions",
"in",
"the",
"cluster",
"as",
"reported",
"by",
"auth",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L354-L367 | train |
gravitational/teleport | lib/auth/clt.go | GetSession | func (c *Client) GetSession(namespace string, id session.ID) (*session.Session, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
// saving extra round-trip
if err := id.Check(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "sessions", string(id)), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var sess *session.Session
if err := json.Unmarshal(out.Bytes(), &sess); err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | go | func (c *Client) GetSession(namespace string, id session.ID) (*session.Session, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
// saving extra round-trip
if err := id.Check(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "sessions", string(id)), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var sess *session.Session
if err := json.Unmarshal(out.Bytes(), &sess); err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetSession",
"(",
"namespace",
"string",
",",
"id",
"session",
".",
"ID",
")",
"(",
"*",
"session",
".",
"Session",
",",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"id",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"namespace",
",",
"\"sessions\"",
",",
"string",
"(",
"id",
")",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"sess",
"*",
"session",
".",
"Session",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] | // GetSession returns a session by ID | [
"GetSession",
"returns",
"a",
"session",
"by",
"ID"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L370-L387 | train |
gravitational/teleport | lib/auth/clt.go | DeleteSession | func (c *Client) DeleteSession(namespace, id string) error {
if namespace == "" {
return trace.BadParameter(MissingNamespaceError)
}
_, err := c.Delete(c.Endpoint("namespaces", namespace, "sessions", id))
return trace.Wrap(err)
} | go | func (c *Client) DeleteSession(namespace, id string) error {
if namespace == "" {
return trace.BadParameter(MissingNamespaceError)
}
_, err := c.Delete(c.Endpoint("namespaces", namespace, "sessions", id))
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteSession",
"(",
"namespace",
",",
"id",
"string",
")",
"error",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"namespace",
",",
"\"sessions\"",
",",
"id",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteSession deletes a session by ID | [
"DeleteSession",
"deletes",
"a",
"session",
"by",
"ID"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L390-L396 | train |
gravitational/teleport | lib/auth/clt.go | CreateSession | func (c *Client) CreateSession(sess session.Session) error {
if sess.Namespace == "" {
return trace.BadParameter(MissingNamespaceError)
}
_, err := c.PostJSON(c.Endpoint("namespaces", sess.Namespace, "sessions"), createSessionReq{Session: sess})
return trace.Wrap(err)
} | go | func (c *Client) CreateSession(sess session.Session) error {
if sess.Namespace == "" {
return trace.BadParameter(MissingNamespaceError)
}
_, err := c.PostJSON(c.Endpoint("namespaces", sess.Namespace, "sessions"), createSessionReq{Session: sess})
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateSession",
"(",
"sess",
"session",
".",
"Session",
")",
"error",
"{",
"if",
"sess",
".",
"Namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"sess",
".",
"Namespace",
",",
"\"sessions\"",
")",
",",
"createSessionReq",
"{",
"Session",
":",
"sess",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // CreateSession creates new session | [
"CreateSession",
"creates",
"new",
"session"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L399-L405 | train |
gravitational/teleport | lib/auth/clt.go | UpdateSession | func (c *Client) UpdateSession(req session.UpdateRequest) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
_, err := c.PutJSON(c.Endpoint("namespaces", req.Namespace, "sessions", string(req.ID)), updateSessionReq{Update: req})
return trace.Wrap(err)
} | go | func (c *Client) UpdateSession(req session.UpdateRequest) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
_, err := c.PutJSON(c.Endpoint("namespaces", req.Namespace, "sessions", string(req.ID)), updateSessionReq{Update: req})
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpdateSession",
"(",
"req",
"session",
".",
"UpdateRequest",
")",
"error",
"{",
"if",
"err",
":=",
"req",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"PutJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"req",
".",
"Namespace",
",",
"\"sessions\"",
",",
"string",
"(",
"req",
".",
"ID",
")",
")",
",",
"updateSessionReq",
"{",
"Update",
":",
"req",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpdateSession updates existing session | [
"UpdateSession",
"updates",
"existing",
"session"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L408-L414 | train |
gravitational/teleport | lib/auth/clt.go | GetDomainName | func (c *Client) GetDomainName() (string, error) {
out, err := c.Get(c.Endpoint("domain"), url.Values{})
if err != nil {
return "", trace.Wrap(err)
}
var domain string
if err := json.Unmarshal(out.Bytes(), &domain); err != nil {
return "", trace.Wrap(err)
}
return domain, nil
} | go | func (c *Client) GetDomainName() (string, error) {
out, err := c.Get(c.Endpoint("domain"), url.Values{})
if err != nil {
return "", trace.Wrap(err)
}
var domain string
if err := json.Unmarshal(out.Bytes(), &domain); err != nil {
return "", trace.Wrap(err)
}
return domain, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetDomainName",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"domain\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"domain",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"domain",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"domain",
",",
"nil",
"\n",
"}"
] | // GetDomainName returns local auth domain of the current auth server | [
"GetDomainName",
"returns",
"local",
"auth",
"domain",
"of",
"the",
"current",
"auth",
"server"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L417-L427 | train |
gravitational/teleport | lib/auth/clt.go | RotateExternalCertAuthority | func (c *Client) RotateExternalCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
data, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("authorities", string(ca.GetType()), "rotate", "external"),
&rotateExternalCertAuthorityRawReq{CA: data})
return trace.Wrap(err)
} | go | func (c *Client) RotateExternalCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
data, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("authorities", string(ca.GetType()), "rotate", "external"),
&rotateExternalCertAuthorityRawReq{CA: data})
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RotateExternalCertAuthority",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"err",
":=",
"ca",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"data",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"MarshalCertAuthority",
"(",
"ca",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"authorities\"",
",",
"string",
"(",
"ca",
".",
"GetType",
"(",
")",
")",
",",
"\"rotate\"",
",",
"\"external\"",
")",
",",
"&",
"rotateExternalCertAuthorityRawReq",
"{",
"CA",
":",
"data",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // RotateExternalCertAuthority rotates external certificate authority,
// this method is used to update only public keys and certificates of the
// the certificate authorities of trusted clusters. | [
"RotateExternalCertAuthority",
"rotates",
"external",
"certificate",
"authority",
"this",
"method",
"is",
"used",
"to",
"update",
"only",
"public",
"keys",
"and",
"certificates",
"of",
"the",
"the",
"certificate",
"authorities",
"of",
"trusted",
"clusters",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L479-L490 | train |
gravitational/teleport | lib/auth/clt.go | GetCertAuthorities | func (c *Client) GetCertAuthorities(caType services.CertAuthType, loadKeys bool, opts ...services.MarshalOption) ([]services.CertAuthority, error) {
if err := caType.Check(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("authorities", string(caType)), url.Values{
"load_keys": []string{fmt.Sprintf("%t", loadKeys)},
})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, err
}
re := make([]services.CertAuthority, len(items))
for i, raw := range items {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = ca
}
return re, nil
} | go | func (c *Client) GetCertAuthorities(caType services.CertAuthType, loadKeys bool, opts ...services.MarshalOption) ([]services.CertAuthority, error) {
if err := caType.Check(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("authorities", string(caType)), url.Values{
"load_keys": []string{fmt.Sprintf("%t", loadKeys)},
})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, err
}
re := make([]services.CertAuthority, len(items))
for i, raw := range items {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = ca
}
return re, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetCertAuthorities",
"(",
"caType",
"services",
".",
"CertAuthType",
",",
"loadKeys",
"bool",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
",",
"error",
")",
"{",
"if",
"err",
":=",
"caType",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"authorities\"",
",",
"string",
"(",
"caType",
")",
")",
",",
"url",
".",
"Values",
"{",
"\"load_keys\"",
":",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%t\"",
",",
"loadKeys",
")",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"re",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"CertAuthority",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"items",
"{",
"ca",
",",
"err",
":=",
"services",
".",
"GetCertAuthorityMarshaler",
"(",
")",
".",
"UnmarshalCertAuthority",
"(",
"raw",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"re",
"[",
"i",
"]",
"=",
"ca",
"\n",
"}",
"\n",
"return",
"re",
",",
"nil",
"\n",
"}"
] | // GetCertAuthorities returns a list of certificate authorities | [
"GetCertAuthorities",
"returns",
"a",
"list",
"of",
"certificate",
"authorities"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L513-L536 | train |
gravitational/teleport | lib/auth/clt.go | DeleteCertAuthority | func (c *Client) DeleteCertAuthority(id services.CertAuthID) error {
if err := id.Check(); err != nil {
return trace.Wrap(err)
}
_, err := c.Delete(c.Endpoint("authorities", string(id.Type), id.DomainName))
return trace.Wrap(err)
} | go | func (c *Client) DeleteCertAuthority(id services.CertAuthID) error {
if err := id.Check(); err != nil {
return trace.Wrap(err)
}
_, err := c.Delete(c.Endpoint("authorities", string(id.Type), id.DomainName))
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteCertAuthority",
"(",
"id",
"services",
".",
"CertAuthID",
")",
"error",
"{",
"if",
"err",
":=",
"id",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"authorities\"",
",",
"string",
"(",
"id",
".",
"Type",
")",
",",
"id",
".",
"DomainName",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteCertAuthority deletes cert authority by ID | [
"DeleteCertAuthority",
"deletes",
"cert",
"authority",
"by",
"ID"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L555-L561 | train |
gravitational/teleport | lib/auth/clt.go | GenerateToken | func (c *Client) GenerateToken(req GenerateTokenRequest) (string, error) {
out, err := c.PostJSON(c.Endpoint("tokens"), req)
if err != nil {
return "", trace.Wrap(err)
}
var token string
if err := json.Unmarshal(out.Bytes(), &token); err != nil {
return "", trace.Wrap(err)
}
return token, nil
} | go | func (c *Client) GenerateToken(req GenerateTokenRequest) (string, error) {
out, err := c.PostJSON(c.Endpoint("tokens"), req)
if err != nil {
return "", trace.Wrap(err)
}
var token string
if err := json.Unmarshal(out.Bytes(), &token); err != nil {
return "", trace.Wrap(err)
}
return token, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GenerateToken",
"(",
"req",
"GenerateTokenRequest",
")",
"(",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"tokens\"",
")",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"token",
"string",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"token",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"token",
",",
"nil",
"\n",
"}"
] | // GenerateToken creates a special provisioning token for a new SSH server
// that is valid for ttl period seconds.
//
// This token is used by SSH server to authenticate with Auth server
// and get signed certificate and private key from the auth server.
//
// If token is not supplied, it will be auto generated and returned.
// If TTL is not supplied, token will be valid until removed. | [
"GenerateToken",
"creates",
"a",
"special",
"provisioning",
"token",
"for",
"a",
"new",
"SSH",
"server",
"that",
"is",
"valid",
"for",
"ttl",
"period",
"seconds",
".",
"This",
"token",
"is",
"used",
"by",
"SSH",
"server",
"to",
"authenticate",
"with",
"Auth",
"server",
"and",
"get",
"signed",
"certificate",
"and",
"private",
"key",
"from",
"the",
"auth",
"server",
".",
"If",
"token",
"is",
"not",
"supplied",
"it",
"will",
"be",
"auto",
"generated",
"and",
"returned",
".",
"If",
"TTL",
"is",
"not",
"supplied",
"token",
"will",
"be",
"valid",
"until",
"removed",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L583-L593 | train |
gravitational/teleport | lib/auth/clt.go | RegisterUsingToken | func (c *Client) RegisterUsingToken(req RegisterUsingTokenRequest) (*PackedKeys, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.PostJSON(c.Endpoint("tokens", "register"), req)
if err != nil {
return nil, trace.Wrap(err)
}
var keys PackedKeys
if err := json.Unmarshal(out.Bytes(), &keys); err != nil {
return nil, trace.Wrap(err)
}
return &keys, nil
} | go | func (c *Client) RegisterUsingToken(req RegisterUsingTokenRequest) (*PackedKeys, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.PostJSON(c.Endpoint("tokens", "register"), req)
if err != nil {
return nil, trace.Wrap(err)
}
var keys PackedKeys
if err := json.Unmarshal(out.Bytes(), &keys); err != nil {
return nil, trace.Wrap(err)
}
return &keys, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RegisterUsingToken",
"(",
"req",
"RegisterUsingTokenRequest",
")",
"(",
"*",
"PackedKeys",
",",
"error",
")",
"{",
"if",
"err",
":=",
"req",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"tokens\"",
",",
"\"register\"",
")",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"keys",
"PackedKeys",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"keys",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"keys",
",",
"nil",
"\n",
"}"
] | // RegisterUsingToken calls the auth service API to register a new node using a registration token
// which was previously issued via GenerateToken. | [
"RegisterUsingToken",
"calls",
"the",
"auth",
"service",
"API",
"to",
"register",
"a",
"new",
"node",
"using",
"a",
"registration",
"token",
"which",
"was",
"previously",
"issued",
"via",
"GenerateToken",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L597-L610 | train |
gravitational/teleport | lib/auth/clt.go | GetTokens | func (c *Client) GetTokens(opts ...services.MarshalOption) ([]services.ProvisionToken, error) {
out, err := c.Get(c.Endpoint("tokens"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var tokens []services.ProvisionTokenV1
if err := json.Unmarshal(out.Bytes(), &tokens); err != nil {
return nil, trace.Wrap(err)
}
return services.ProvisionTokensFromV1(tokens), nil
} | go | func (c *Client) GetTokens(opts ...services.MarshalOption) ([]services.ProvisionToken, error) {
out, err := c.Get(c.Endpoint("tokens"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var tokens []services.ProvisionTokenV1
if err := json.Unmarshal(out.Bytes(), &tokens); err != nil {
return nil, trace.Wrap(err)
}
return services.ProvisionTokensFromV1(tokens), nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetTokens",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"ProvisionToken",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"tokens\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"tokens",
"[",
"]",
"services",
".",
"ProvisionTokenV1",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"tokens",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"ProvisionTokensFromV1",
"(",
"tokens",
")",
",",
"nil",
"\n",
"}"
] | // GetTokens returns a list of active invitation tokens for nodes and users | [
"GetTokens",
"returns",
"a",
"list",
"of",
"active",
"invitation",
"tokens",
"for",
"nodes",
"and",
"users"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L644-L654 | train |
gravitational/teleport | lib/auth/clt.go | GetToken | func (c *Client) GetToken(token string) (services.ProvisionToken, error) {
out, err := c.Get(c.Endpoint("tokens", token), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.UnmarshalProvisionToken(out.Bytes(), services.SkipValidation())
} | go | func (c *Client) GetToken(token string) (services.ProvisionToken, error) {
out, err := c.Get(c.Endpoint("tokens", token), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.UnmarshalProvisionToken(out.Bytes(), services.SkipValidation())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetToken",
"(",
"token",
"string",
")",
"(",
"services",
".",
"ProvisionToken",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"tokens\"",
",",
"token",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"UnmarshalProvisionToken",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"}"
] | // GetToken returns provisioning token | [
"GetToken",
"returns",
"provisioning",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L657-L663 | train |
gravitational/teleport | lib/auth/clt.go | RegisterNewAuthServer | func (c *Client) RegisterNewAuthServer(token string) error {
_, err := c.PostJSON(c.Endpoint("tokens", "register", "auth"), registerNewAuthServerReq{
Token: token,
})
return trace.Wrap(err)
} | go | func (c *Client) RegisterNewAuthServer(token string) error {
_, err := c.PostJSON(c.Endpoint("tokens", "register", "auth"), registerNewAuthServerReq{
Token: token,
})
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RegisterNewAuthServer",
"(",
"token",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"tokens\"",
",",
"\"register\"",
",",
"\"auth\"",
")",
",",
"registerNewAuthServerReq",
"{",
"Token",
":",
"token",
",",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // RegisterNewAuthServer is used to register new auth server with token | [
"RegisterNewAuthServer",
"is",
"used",
"to",
"register",
"new",
"auth",
"server",
"with",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L673-L678 | train |
gravitational/teleport | lib/auth/clt.go | UpsertNode | func (c *Client) UpsertNode(s services.Server) (*services.KeepAlive, error) {
if s.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
protoServer, ok := s.(*services.ServerV2)
if !ok {
return nil, trace.BadParameter("unsupported client")
}
clt, err := c.grpc()
if err != nil {
return nil, trace.Wrap(err)
}
keepAlive, err := clt.UpsertNode(context.TODO(), protoServer)
if err != nil {
return nil, trail.FromGRPC(err)
}
return keepAlive, nil
} | go | func (c *Client) UpsertNode(s services.Server) (*services.KeepAlive, error) {
if s.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
protoServer, ok := s.(*services.ServerV2)
if !ok {
return nil, trace.BadParameter("unsupported client")
}
clt, err := c.grpc()
if err != nil {
return nil, trace.Wrap(err)
}
keepAlive, err := clt.UpsertNode(context.TODO(), protoServer)
if err != nil {
return nil, trail.FromGRPC(err)
}
return keepAlive, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertNode",
"(",
"s",
"services",
".",
"Server",
")",
"(",
"*",
"services",
".",
"KeepAlive",
",",
"error",
")",
"{",
"if",
"s",
".",
"GetNamespace",
"(",
")",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing node namespace\"",
")",
"\n",
"}",
"\n",
"protoServer",
",",
"ok",
":=",
"s",
".",
"(",
"*",
"services",
".",
"ServerV2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unsupported client\"",
")",
"\n",
"}",
"\n",
"clt",
",",
"err",
":=",
"c",
".",
"grpc",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"keepAlive",
",",
"err",
":=",
"clt",
".",
"UpsertNode",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"protoServer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trail",
".",
"FromGRPC",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"keepAlive",
",",
"nil",
"\n",
"}"
] | // UpsertNode is used by SSH servers to reprt their presence
// to the auth servers in form of hearbeat expiring after ttl period. | [
"UpsertNode",
"is",
"used",
"by",
"SSH",
"servers",
"to",
"reprt",
"their",
"presence",
"to",
"the",
"auth",
"servers",
"in",
"form",
"of",
"hearbeat",
"expiring",
"after",
"ttl",
"period",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L682-L699 | train |
gravitational/teleport | lib/auth/clt.go | KeepAliveNode | func (c *Client) KeepAliveNode(ctx context.Context, keepAlive services.KeepAlive) error {
return trace.BadParameter("not implemented, use StreamKeepAlives instead")
} | go | func (c *Client) KeepAliveNode(ctx context.Context, keepAlive services.KeepAlive) error {
return trace.BadParameter("not implemented, use StreamKeepAlives instead")
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"KeepAliveNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"keepAlive",
"services",
".",
"KeepAlive",
")",
"error",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"not implemented, use StreamKeepAlives instead\"",
")",
"\n",
"}"
] | // KeepAliveNode updates node keep alive information | [
"KeepAliveNode",
"updates",
"node",
"keep",
"alive",
"information"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L702-L704 | train |
gravitational/teleport | lib/auth/clt.go | recv | func (k *streamKeepAliver) recv() {
err := k.stream.RecvMsg(&empty.Empty{})
k.closeWithError(trail.FromGRPC(err))
} | go | func (k *streamKeepAliver) recv() {
err := k.stream.RecvMsg(&empty.Empty{})
k.closeWithError(trail.FromGRPC(err))
} | [
"func",
"(",
"k",
"*",
"streamKeepAliver",
")",
"recv",
"(",
")",
"{",
"err",
":=",
"k",
".",
"stream",
".",
"RecvMsg",
"(",
"&",
"empty",
".",
"Empty",
"{",
"}",
")",
"\n",
"k",
".",
"closeWithError",
"(",
"trail",
".",
"FromGRPC",
"(",
"err",
")",
")",
"\n",
"}"
] | // recv is necessary to receive errors from the
// server, otherwise no errors will be propagated | [
"recv",
"is",
"necessary",
"to",
"receive",
"errors",
"from",
"the",
"server",
"otherwise",
"no",
"errors",
"will",
"be",
"propagated"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L769-L772 | train |
gravitational/teleport | lib/auth/clt.go | UpsertNodes | func (c *Client) UpsertNodes(namespace string, servers []services.Server) error {
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
bytes, err := services.GetServerMarshaler().MarshalServers(servers)
if err != nil {
return trace.Wrap(err)
}
args := &upsertNodesReq{
Namespace: namespace,
Nodes: bytes,
}
_, err = c.PutJSON(c.Endpoint("namespaces", namespace, "nodes"), args)
return trace.Wrap(err)
} | go | func (c *Client) UpsertNodes(namespace string, servers []services.Server) error {
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
bytes, err := services.GetServerMarshaler().MarshalServers(servers)
if err != nil {
return trace.Wrap(err)
}
args := &upsertNodesReq{
Namespace: namespace,
Nodes: bytes,
}
_, err = c.PutJSON(c.Endpoint("namespaces", namespace, "nodes"), args)
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertNodes",
"(",
"namespace",
"string",
",",
"servers",
"[",
"]",
"services",
".",
"Server",
")",
"error",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing node namespace\"",
")",
"\n",
"}",
"\n",
"bytes",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"MarshalServers",
"(",
"servers",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"args",
":=",
"&",
"upsertNodesReq",
"{",
"Namespace",
":",
"namespace",
",",
"Nodes",
":",
"bytes",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PutJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"namespace",
",",
"\"nodes\"",
")",
",",
"args",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertNodes bulk inserts nodes. | [
"UpsertNodes",
"bulk",
"inserts",
"nodes",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L873-L888 | train |
gravitational/teleport | lib/auth/clt.go | DeleteNode | func (c *Client) DeleteNode(namespace string, name string) error {
if namespace == "" {
return trace.BadParameter("missing parameter namespace")
}
if name == "" {
return trace.BadParameter("missing parameter name")
}
_, err := c.Delete(c.Endpoint("namespaces", namespace, "nodes", name))
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) DeleteNode(namespace string, name string) error {
if namespace == "" {
return trace.BadParameter("missing parameter namespace")
}
if name == "" {
return trace.BadParameter("missing parameter name")
}
_, err := c.Delete(c.Endpoint("namespaces", namespace, "nodes", name))
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteNode",
"(",
"namespace",
"string",
",",
"name",
"string",
")",
"error",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter namespace\"",
")",
"\n",
"}",
"\n",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter name\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"namespace",
",",
"\"nodes\"",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteNode deletes node in the namespace by name | [
"DeleteNode",
"deletes",
"node",
"in",
"the",
"namespace",
"by",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L900-L912 | train |
gravitational/teleport | lib/auth/clt.go | GetNodes | func (c *Client) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
cfg, err := services.CollectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "nodes"), url.Values{
"skip_validation": []string{fmt.Sprintf("%t", cfg.SkipValidation)},
})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
re := make([]services.Server, len(items))
for i, raw := range items {
s, err := services.GetServerMarshaler().UnmarshalServer(
raw,
services.KindNode,
services.AddOptions(opts, services.SkipValidation())...)
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = s
}
return re, nil
} | go | func (c *Client) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
cfg, err := services.CollectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "nodes"), url.Values{
"skip_validation": []string{fmt.Sprintf("%t", cfg.SkipValidation)},
})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
re := make([]services.Server, len(items))
for i, raw := range items {
s, err := services.GetServerMarshaler().UnmarshalServer(
raw,
services.KindNode,
services.AddOptions(opts, services.SkipValidation())...)
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = s
}
return re, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetNodes",
"(",
"namespace",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"MissingNamespaceError",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"services",
".",
"CollectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"namespaces\"",
",",
"namespace",
",",
"\"nodes\"",
")",
",",
"url",
".",
"Values",
"{",
"\"skip_validation\"",
":",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"%t\"",
",",
"cfg",
".",
"SkipValidation",
")",
"}",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"re",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"items",
"{",
"s",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServer",
"(",
"raw",
",",
"services",
".",
"KindNode",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"re",
"[",
"i",
"]",
"=",
"s",
"\n",
"}",
"\n",
"return",
"re",
",",
"nil",
"\n",
"}"
] | // GetNodes returns the list of servers registered in the cluster. | [
"GetNodes",
"returns",
"the",
"list",
"of",
"servers",
"registered",
"in",
"the",
"cluster",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L915-L948 | train |
gravitational/teleport | lib/auth/clt.go | UpsertReverseTunnel | func (c *Client) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
args := &upsertReverseTunnelRawReq{
ReverseTunnel: data,
}
_, err = c.PostJSON(c.Endpoint("reversetunnels"), args)
return trace.Wrap(err)
} | go | func (c *Client) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
args := &upsertReverseTunnelRawReq{
ReverseTunnel: data,
}
_, err = c.PostJSON(c.Endpoint("reversetunnels"), args)
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertReverseTunnel",
"(",
"tunnel",
"services",
".",
"ReverseTunnel",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"MarshalReverseTunnel",
"(",
"tunnel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"args",
":=",
"&",
"upsertReverseTunnelRawReq",
"{",
"ReverseTunnel",
":",
"data",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"reversetunnels\"",
")",
",",
"args",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertReverseTunnel is used by admins to create a new reverse tunnel
// to the remote proxy to bypass firewall restrictions | [
"UpsertReverseTunnel",
"is",
"used",
"by",
"admins",
"to",
"create",
"a",
"new",
"reverse",
"tunnel",
"to",
"the",
"remote",
"proxy",
"to",
"bypass",
"firewall",
"restrictions"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L952-L962 | train |
gravitational/teleport | lib/auth/clt.go | GetReverseTunnels | func (c *Client) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
out, err := c.Get(c.Endpoint("reversetunnels"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(items))
for i, raw := range items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
return tunnels, nil
} | go | func (c *Client) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
out, err := c.Get(c.Endpoint("reversetunnels"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(items))
for i, raw := range items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tunnel
}
return tunnels, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetReverseTunnels",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"ReverseTunnel",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"reversetunnels\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tunnels",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"ReverseTunnel",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"items",
"{",
"tunnel",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"UnmarshalReverseTunnel",
"(",
"raw",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tunnels",
"[",
"i",
"]",
"=",
"tunnel",
"\n",
"}",
"\n",
"return",
"tunnels",
",",
"nil",
"\n",
"}"
] | // GetReverseTunnels returns the list of created reverse tunnels | [
"GetReverseTunnels",
"returns",
"the",
"list",
"of",
"created",
"reverse",
"tunnels"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L970-L988 | train |
gravitational/teleport | lib/auth/clt.go | DeleteReverseTunnel | func (c *Client) DeleteReverseTunnel(domainName string) error {
// this is to avoid confusing error in case if domain empty for example
// HTTP route will fail producing generic not found error
// instead we catch the error here
if strings.TrimSpace(domainName) == "" {
return trace.BadParameter("empty domain name")
}
_, err := c.Delete(c.Endpoint("reversetunnels", domainName))
return trace.Wrap(err)
} | go | func (c *Client) DeleteReverseTunnel(domainName string) error {
// this is to avoid confusing error in case if domain empty for example
// HTTP route will fail producing generic not found error
// instead we catch the error here
if strings.TrimSpace(domainName) == "" {
return trace.BadParameter("empty domain name")
}
_, err := c.Delete(c.Endpoint("reversetunnels", domainName))
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DeleteReverseTunnel",
"(",
"domainName",
"string",
")",
"error",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"domainName",
")",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"empty domain name\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"Delete",
"(",
"c",
".",
"Endpoint",
"(",
"\"reversetunnels\"",
",",
"domainName",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // DeleteReverseTunnel deletes reverse tunnel by domain name | [
"DeleteReverseTunnel",
"deletes",
"reverse",
"tunnel",
"by",
"domain",
"name"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L991-L1000 | train |
gravitational/teleport | lib/auth/clt.go | UpsertTunnelConnection | func (c *Client) UpsertTunnelConnection(conn services.TunnelConnection) error {
data, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
args := &upsertTunnelConnectionRawReq{
TunnelConnection: data,
}
_, err = c.PostJSON(c.Endpoint("tunnelconnections"), args)
return trace.Wrap(err)
} | go | func (c *Client) UpsertTunnelConnection(conn services.TunnelConnection) error {
data, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
args := &upsertTunnelConnectionRawReq{
TunnelConnection: data,
}
_, err = c.PostJSON(c.Endpoint("tunnelconnections"), args)
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertTunnelConnection",
"(",
"conn",
"services",
".",
"TunnelConnection",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"MarshalTunnelConnection",
"(",
"conn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"args",
":=",
"&",
"upsertTunnelConnectionRawReq",
"{",
"TunnelConnection",
":",
"data",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"tunnelconnections\"",
")",
",",
"args",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertTunnelConnection upserts tunnel connection | [
"UpsertTunnelConnection",
"upserts",
"tunnel",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1003-L1013 | train |
gravitational/teleport | lib/auth/clt.go | CreateRemoteCluster | func (c *Client) CreateRemoteCluster(rc services.RemoteCluster) error {
data, err := services.MarshalRemoteCluster(rc)
if err != nil {
return trace.Wrap(err)
}
args := &createRemoteClusterRawReq{
RemoteCluster: data,
}
_, err = c.PostJSON(c.Endpoint("remoteclusters"), args)
return trace.Wrap(err)
} | go | func (c *Client) CreateRemoteCluster(rc services.RemoteCluster) error {
data, err := services.MarshalRemoteCluster(rc)
if err != nil {
return trace.Wrap(err)
}
args := &createRemoteClusterRawReq{
RemoteCluster: data,
}
_, err = c.PostJSON(c.Endpoint("remoteclusters"), args)
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CreateRemoteCluster",
"(",
"rc",
"services",
".",
"RemoteCluster",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"MarshalRemoteCluster",
"(",
"rc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"args",
":=",
"&",
"createRemoteClusterRawReq",
"{",
"RemoteCluster",
":",
"data",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"remoteclusters\"",
")",
",",
"args",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // CreateRemoteCluster creates remote cluster resource | [
"CreateRemoteCluster",
"creates",
"remote",
"cluster",
"resource"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1151-L1161 | train |
gravitational/teleport | lib/auth/clt.go | GetAuthServers | func (c *Client) GetAuthServers() ([]services.Server, error) {
out, err := c.Get(c.Endpoint("authservers"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
re := make([]services.Server, len(items))
for i, raw := range items {
server, err := services.GetServerMarshaler().UnmarshalServer(raw, services.KindAuthServer, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = server
}
return re, nil
} | go | func (c *Client) GetAuthServers() ([]services.Server, error) {
out, err := c.Get(c.Endpoint("authservers"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
re := make([]services.Server, len(items))
for i, raw := range items {
server, err := services.GetServerMarshaler().UnmarshalServer(raw, services.KindAuthServer, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = server
}
return re, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetAuthServers",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"authservers\"",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"items",
"[",
"]",
"json",
".",
"RawMessage",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"items",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"re",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"len",
"(",
"items",
")",
")",
"\n",
"for",
"i",
",",
"raw",
":=",
"range",
"items",
"{",
"server",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServer",
"(",
"raw",
",",
"services",
".",
"KindAuthServer",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"re",
"[",
"i",
"]",
"=",
"server",
"\n",
"}",
"\n",
"return",
"re",
",",
"nil",
"\n",
"}"
] | // GetAuthServers returns the list of auth servers registered in the cluster. | [
"GetAuthServers",
"returns",
"the",
"list",
"of",
"auth",
"servers",
"registered",
"in",
"the",
"cluster",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1178-L1196 | train |
gravitational/teleport | lib/auth/clt.go | UpsertProxy | func (c *Client) UpsertProxy(s services.Server) error {
data, err := services.GetServerMarshaler().MarshalServer(s)
if err != nil {
return trace.Wrap(err)
}
args := &upsertServerRawReq{
Server: data,
}
_, err = c.PostJSON(c.Endpoint("proxies"), args)
return trace.Wrap(err)
} | go | func (c *Client) UpsertProxy(s services.Server) error {
data, err := services.GetServerMarshaler().MarshalServer(s)
if err != nil {
return trace.Wrap(err)
}
args := &upsertServerRawReq{
Server: data,
}
_, err = c.PostJSON(c.Endpoint("proxies"), args)
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertProxy",
"(",
"s",
"services",
".",
"Server",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"MarshalServer",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"args",
":=",
"&",
"upsertServerRawReq",
"{",
"Server",
":",
"data",
",",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"proxies\"",
")",
",",
"args",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertProxy is used by proxies to report their presence
// to other auth servers in form of hearbeat expiring after ttl period. | [
"UpsertProxy",
"is",
"used",
"by",
"proxies",
"to",
"report",
"their",
"presence",
"to",
"other",
"auth",
"servers",
"in",
"form",
"of",
"hearbeat",
"expiring",
"after",
"ttl",
"period",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1210-L1220 | train |
gravitational/teleport | lib/auth/clt.go | UpsertPassword | func (c *Client) UpsertPassword(user string, password []byte) error {
_, err := c.PostJSON(
c.Endpoint("users", user, "web", "password"),
upsertPasswordReq{
Password: string(password),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (c *Client) UpsertPassword(user string, password []byte) error {
_, err := c.PostJSON(
c.Endpoint("users", user, "web", "password"),
upsertPasswordReq{
Password: string(password),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertPassword",
"(",
"user",
"string",
",",
"password",
"[",
"]",
"byte",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"user",
",",
"\"web\"",
",",
"\"password\"",
")",
",",
"upsertPasswordReq",
"{",
"Password",
":",
"string",
"(",
"password",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UpsertPassword updates web access password for the user | [
"UpsertPassword",
"updates",
"web",
"access",
"password",
"for",
"the",
"user"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1278-L1289 | train |
gravitational/teleport | lib/auth/clt.go | UpsertUser | func (c *Client) UpsertUser(user services.User) error {
data, err := services.GetUserMarshaler().MarshalUser(user)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("users"), &upsertUserRawReq{User: data})
return trace.Wrap(err)
} | go | func (c *Client) UpsertUser(user services.User) error {
data, err := services.GetUserMarshaler().MarshalUser(user)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("users"), &upsertUserRawReq{User: data})
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UpsertUser",
"(",
"user",
"services",
".",
"User",
")",
"error",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetUserMarshaler",
"(",
")",
".",
"MarshalUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
")",
",",
"&",
"upsertUserRawReq",
"{",
"User",
":",
"data",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // UpsertUser user updates or inserts user entry | [
"UpsertUser",
"user",
"updates",
"or",
"inserts",
"user",
"entry"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1292-L1299 | train |
gravitational/teleport | lib/auth/clt.go | ChangePassword | func (c *Client) ChangePassword(req services.ChangePasswordReq) error {
_, err := c.PutJSON(c.Endpoint("users", req.User, "web", "password"), req)
return trace.Wrap(err)
} | go | func (c *Client) ChangePassword(req services.ChangePasswordReq) error {
_, err := c.PutJSON(c.Endpoint("users", req.User, "web", "password"), req)
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ChangePassword",
"(",
"req",
"services",
".",
"ChangePasswordReq",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"PutJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"req",
".",
"User",
",",
"\"web\"",
",",
"\"password\"",
")",
",",
"req",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // ChangePassword changes user password | [
"ChangePassword",
"changes",
"user",
"password"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1302-L1305 | train |
gravitational/teleport | lib/auth/clt.go | CheckPassword | func (c *Client) CheckPassword(user string, password []byte, otpToken string) error {
_, err := c.PostJSON(
c.Endpoint("users", user, "web", "password", "check"),
checkPasswordReq{
Password: string(password),
OTPToken: otpToken,
})
return trace.Wrap(err)
} | go | func (c *Client) CheckPassword(user string, password []byte, otpToken string) error {
_, err := c.PostJSON(
c.Endpoint("users", user, "web", "password", "check"),
checkPasswordReq{
Password: string(password),
OTPToken: otpToken,
})
return trace.Wrap(err)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"CheckPassword",
"(",
"user",
"string",
",",
"password",
"[",
"]",
"byte",
",",
"otpToken",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"user",
",",
"\"web\"",
",",
"\"password\"",
",",
"\"check\"",
")",
",",
"checkPasswordReq",
"{",
"Password",
":",
"string",
"(",
"password",
")",
",",
"OTPToken",
":",
"otpToken",
",",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] | // CheckPassword checks if the suplied web access password is valid. | [
"CheckPassword",
"checks",
"if",
"the",
"suplied",
"web",
"access",
"password",
"is",
"valid",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1308-L1316 | train |
gravitational/teleport | lib/auth/clt.go | GetU2FSignRequest | func (c *Client) GetU2FSignRequest(user string, password []byte) (*u2f.SignRequest, error) {
out, err := c.PostJSON(
c.Endpoint("u2f", "users", user, "sign"),
signInReq{
Password: string(password),
},
)
if err != nil {
return nil, trace.Wrap(err)
}
var signRequest *u2f.SignRequest
if err := json.Unmarshal(out.Bytes(), &signRequest); err != nil {
return nil, err
}
return signRequest, nil
} | go | func (c *Client) GetU2FSignRequest(user string, password []byte) (*u2f.SignRequest, error) {
out, err := c.PostJSON(
c.Endpoint("u2f", "users", user, "sign"),
signInReq{
Password: string(password),
},
)
if err != nil {
return nil, trace.Wrap(err)
}
var signRequest *u2f.SignRequest
if err := json.Unmarshal(out.Bytes(), &signRequest); err != nil {
return nil, err
}
return signRequest, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetU2FSignRequest",
"(",
"user",
"string",
",",
"password",
"[",
"]",
"byte",
")",
"(",
"*",
"u2f",
".",
"SignRequest",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"u2f\"",
",",
"\"users\"",
",",
"user",
",",
"\"sign\"",
")",
",",
"signInReq",
"{",
"Password",
":",
"string",
"(",
"password",
")",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"signRequest",
"*",
"u2f",
".",
"SignRequest",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"out",
".",
"Bytes",
"(",
")",
",",
"&",
"signRequest",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"signRequest",
",",
"nil",
"\n",
"}"
] | // GetU2FSignRequest generates request for user trying to authenticate with U2F token | [
"GetU2FSignRequest",
"generates",
"request",
"for",
"user",
"trying",
"to",
"authenticate",
"with",
"U2F",
"token"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1319-L1334 | train |
gravitational/teleport | lib/auth/clt.go | ExtendWebSession | func (c *Client) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
out, err := c.PostJSON(
c.Endpoint("users", user, "web", "sessions"),
createWebSessionReq{
PrevSessionID: prevSessionID,
},
)
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | go | func (c *Client) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
out, err := c.PostJSON(
c.Endpoint("users", user, "web", "sessions"),
createWebSessionReq{
PrevSessionID: prevSessionID,
},
)
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ExtendWebSession",
"(",
"user",
"string",
",",
"prevSessionID",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"PostJSON",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"user",
",",
"\"web\"",
",",
"\"sessions\"",
")",
",",
"createWebSessionReq",
"{",
"PrevSessionID",
":",
"prevSessionID",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"out",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // ExtendWebSession creates a new web session for a user based on another
// valid web session | [
"ExtendWebSession",
"creates",
"a",
"new",
"web",
"session",
"for",
"a",
"user",
"based",
"on",
"another",
"valid",
"web",
"session"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1338-L1349 | train |
gravitational/teleport | lib/auth/clt.go | GetWebSessionInfo | func (c *Client) GetWebSessionInfo(user string, sid string) (services.WebSession, error) {
out, err := c.Get(
c.Endpoint("users", user, "web", "sessions", sid), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | go | func (c *Client) GetWebSessionInfo(user string, sid string) (services.WebSession, error) {
out, err := c.Get(
c.Endpoint("users", user, "web", "sessions", sid), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetWebSessionInfo",
"(",
"user",
"string",
",",
"sid",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"c",
".",
"Get",
"(",
"c",
".",
"Endpoint",
"(",
"\"users\"",
",",
"user",
",",
"\"web\"",
",",
"\"sessions\"",
",",
"sid",
")",
",",
"url",
".",
"Values",
"{",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"UnmarshalWebSession",
"(",
"out",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // GetWebSessionInfo checks if a web sesion is valid, returns session id in case if
// it is valid, or error otherwise. | [
"GetWebSessionInfo",
"checks",
"if",
"a",
"web",
"sesion",
"is",
"valid",
"returns",
"session",
"id",
"in",
"case",
"if",
"it",
"is",
"valid",
"or",
"error",
"otherwise",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/clt.go#L1395-L1402 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.