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/utils/tls.go
|
CipherSuiteMapping
|
func CipherSuiteMapping(cipherSuites []string) ([]uint16, error) {
out := make([]uint16, 0, len(cipherSuites))
for _, cs := range cipherSuites {
c, ok := cipherSuiteMapping[cs]
if !ok {
return nil, trace.BadParameter("cipher suite not supported: %v", cs)
}
out = append(out, c)
}
return out, nil
}
|
go
|
func CipherSuiteMapping(cipherSuites []string) ([]uint16, error) {
out := make([]uint16, 0, len(cipherSuites))
for _, cs := range cipherSuites {
c, ok := cipherSuiteMapping[cs]
if !ok {
return nil, trace.BadParameter("cipher suite not supported: %v", cs)
}
out = append(out, c)
}
return out, nil
}
|
[
"func",
"CipherSuiteMapping",
"(",
"cipherSuites",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"uint16",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"uint16",
",",
"0",
",",
"len",
"(",
"cipherSuites",
")",
")",
"\n",
"for",
"_",
",",
"cs",
":=",
"range",
"cipherSuites",
"{",
"c",
",",
"ok",
":=",
"cipherSuiteMapping",
"[",
"cs",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"cipher suite not supported: %v\"",
",",
"cs",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"c",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// CipherSuiteMapping transforms Teleport formatted cipher suites strings
// into uint16 IDs.
|
[
"CipherSuiteMapping",
"transforms",
"Teleport",
"formatted",
"cipher",
"suites",
"strings",
"into",
"uint16",
"IDs",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/tls.go#L157-L170
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
NewTerminal
|
func NewTerminal(ctx *ServerContext) (Terminal, error) {
// It doesn't matter what mode the cluster is in, if this is a Teleport node
// return a local terminal.
if ctx.srv.Component() == teleport.ComponentNode {
return newLocalTerminal(ctx)
}
// If this is not a Teleport node, find out what mode the cluster is in and
// return the correct terminal.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy {
return newRemoteTerminal(ctx)
}
return newLocalTerminal(ctx)
}
|
go
|
func NewTerminal(ctx *ServerContext) (Terminal, error) {
// It doesn't matter what mode the cluster is in, if this is a Teleport node
// return a local terminal.
if ctx.srv.Component() == teleport.ComponentNode {
return newLocalTerminal(ctx)
}
// If this is not a Teleport node, find out what mode the cluster is in and
// return the correct terminal.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy {
return newRemoteTerminal(ctx)
}
return newLocalTerminal(ctx)
}
|
[
"func",
"NewTerminal",
"(",
"ctx",
"*",
"ServerContext",
")",
"(",
"Terminal",
",",
"error",
")",
"{",
"if",
"ctx",
".",
"srv",
".",
"Component",
"(",
")",
"==",
"teleport",
".",
"ComponentNode",
"{",
"return",
"newLocalTerminal",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"if",
"ctx",
".",
"ClusterConfig",
".",
"GetSessionRecording",
"(",
")",
"==",
"services",
".",
"RecordAtProxy",
"{",
"return",
"newRemoteTerminal",
"(",
"ctx",
")",
"\n",
"}",
"\n",
"return",
"newLocalTerminal",
"(",
"ctx",
")",
"\n",
"}"
] |
// NewTerminal returns a new terminal. Terminal can be local or remote
// depending on cluster configuration.
|
[
"NewTerminal",
"returns",
"a",
"new",
"terminal",
".",
"Terminal",
"can",
"be",
"local",
"or",
"remote",
"depending",
"on",
"cluster",
"configuration",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L95-L108
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
newLocalTerminal
|
func newLocalTerminal(ctx *ServerContext) (*terminal, error) {
var err error
t := &terminal{
log: log.WithFields(log.Fields{
trace.Component: teleport.ComponentLocalTerm,
}),
ctx: ctx,
}
// Open PTY and corresponding TTY.
t.pty, t.tty, err = pty.Open()
if err != nil {
log.Warnf("Could not start PTY %v", err)
return nil, err
}
// Set the TTY owner. Failure is not fatal, for example Teleport is running
// on a read-only filesystem, but logging is useful for diagnostic purposes.
err = t.setOwner()
if err != nil {
log.Debugf("Unable to set TTY owner: %v.\n", err)
}
return t, nil
}
|
go
|
func newLocalTerminal(ctx *ServerContext) (*terminal, error) {
var err error
t := &terminal{
log: log.WithFields(log.Fields{
trace.Component: teleport.ComponentLocalTerm,
}),
ctx: ctx,
}
// Open PTY and corresponding TTY.
t.pty, t.tty, err = pty.Open()
if err != nil {
log.Warnf("Could not start PTY %v", err)
return nil, err
}
// Set the TTY owner. Failure is not fatal, for example Teleport is running
// on a read-only filesystem, but logging is useful for diagnostic purposes.
err = t.setOwner()
if err != nil {
log.Debugf("Unable to set TTY owner: %v.\n", err)
}
return t, nil
}
|
[
"func",
"newLocalTerminal",
"(",
"ctx",
"*",
"ServerContext",
")",
"(",
"*",
"terminal",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"t",
":=",
"&",
"terminal",
"{",
"log",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"teleport",
".",
"ComponentLocalTerm",
",",
"}",
")",
",",
"ctx",
":",
"ctx",
",",
"}",
"\n",
"t",
".",
"pty",
",",
"t",
".",
"tty",
",",
"err",
"=",
"pty",
".",
"Open",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warnf",
"(",
"\"Could not start PTY %v\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"t",
".",
"setOwner",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Debugf",
"(",
"\"Unable to set TTY owner: %v.\\n\"",
",",
"\\n",
")",
"\n",
"}",
"\n",
"err",
"\n",
"}"
] |
// NewLocalTerminal creates and returns a local PTY.
|
[
"NewLocalTerminal",
"creates",
"and",
"returns",
"a",
"local",
"PTY",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L128-L153
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
Run
|
func (t *terminal) Run() error {
defer t.closeTTY()
cmd, err := prepareInteractiveCommand(t.ctx)
if err != nil {
return trace.Wrap(err)
}
t.cmd = cmd
cmd.Stdout = t.tty
cmd.Stdin = t.tty
cmd.Stderr = t.tty
cmd.SysProcAttr.Setctty = true
cmd.SysProcAttr.Setsid = true
err = cmd.Start()
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (t *terminal) Run() error {
defer t.closeTTY()
cmd, err := prepareInteractiveCommand(t.ctx)
if err != nil {
return trace.Wrap(err)
}
t.cmd = cmd
cmd.Stdout = t.tty
cmd.Stdin = t.tty
cmd.Stderr = t.tty
cmd.SysProcAttr.Setctty = true
cmd.SysProcAttr.Setsid = true
err = cmd.Start()
if err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"Run",
"(",
")",
"error",
"{",
"defer",
"t",
".",
"closeTTY",
"(",
")",
"\n",
"cmd",
",",
"err",
":=",
"prepareInteractiveCommand",
"(",
"t",
".",
"ctx",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"t",
".",
"cmd",
"=",
"cmd",
"\n",
"cmd",
".",
"Stdout",
"=",
"t",
".",
"tty",
"\n",
"cmd",
".",
"Stdin",
"=",
"t",
".",
"tty",
"\n",
"cmd",
".",
"Stderr",
"=",
"t",
".",
"tty",
"\n",
"cmd",
".",
"SysProcAttr",
".",
"Setctty",
"=",
"true",
"\n",
"cmd",
".",
"SysProcAttr",
".",
"Setsid",
"=",
"true",
"\n",
"err",
"=",
"cmd",
".",
"Start",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Run will run the terminal.
|
[
"Run",
"will",
"run",
"the",
"terminal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L162-L183
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
Wait
|
func (t *terminal) Wait() (*ExecResult, error) {
err := t.cmd.Wait()
if err != nil {
if exitErr, ok := err.(*exec.ExitError); ok {
status := exitErr.Sys().(syscall.WaitStatus)
return &ExecResult{Code: status.ExitStatus(), Command: t.cmd.Path}, nil
}
return nil, err
}
status, ok := t.cmd.ProcessState.Sys().(syscall.WaitStatus)
if !ok {
return nil, trace.Errorf("unknown exit status: %T(%v)", t.cmd.ProcessState.Sys(), t.cmd.ProcessState.Sys())
}
return &ExecResult{
Code: status.ExitStatus(),
Command: t.cmd.Path,
}, nil
}
|
go
|
func (t *terminal) Wait() (*ExecResult, error) {
err := t.cmd.Wait()
if err != nil {
if exitErr, ok := err.(*exec.ExitError); ok {
status := exitErr.Sys().(syscall.WaitStatus)
return &ExecResult{Code: status.ExitStatus(), Command: t.cmd.Path}, nil
}
return nil, err
}
status, ok := t.cmd.ProcessState.Sys().(syscall.WaitStatus)
if !ok {
return nil, trace.Errorf("unknown exit status: %T(%v)", t.cmd.ProcessState.Sys(), t.cmd.ProcessState.Sys())
}
return &ExecResult{
Code: status.ExitStatus(),
Command: t.cmd.Path,
}, nil
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"Wait",
"(",
")",
"(",
"*",
"ExecResult",
",",
"error",
")",
"{",
"err",
":=",
"t",
".",
"cmd",
".",
"Wait",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"exitErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"exec",
".",
"ExitError",
")",
";",
"ok",
"{",
"status",
":=",
"exitErr",
".",
"Sys",
"(",
")",
".",
"(",
"syscall",
".",
"WaitStatus",
")",
"\n",
"return",
"&",
"ExecResult",
"{",
"Code",
":",
"status",
".",
"ExitStatus",
"(",
")",
",",
"Command",
":",
"t",
".",
"cmd",
".",
"Path",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"status",
",",
"ok",
":=",
"t",
".",
"cmd",
".",
"ProcessState",
".",
"Sys",
"(",
")",
".",
"(",
"syscall",
".",
"WaitStatus",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"Errorf",
"(",
"\"unknown exit status: %T(%v)\"",
",",
"t",
".",
"cmd",
".",
"ProcessState",
".",
"Sys",
"(",
")",
",",
"t",
".",
"cmd",
".",
"ProcessState",
".",
"Sys",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"&",
"ExecResult",
"{",
"Code",
":",
"status",
".",
"ExitStatus",
"(",
")",
",",
"Command",
":",
"t",
".",
"cmd",
".",
"Path",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Wait will block until the terminal is complete.
|
[
"Wait",
"will",
"block",
"until",
"the",
"terminal",
"is",
"complete",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L186-L205
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
Kill
|
func (t *terminal) Kill() error {
if t.cmd.Process != nil {
if err := t.cmd.Process.Kill(); err != nil {
if err.Error() != "os: process already finished" {
return trace.Wrap(err)
}
}
}
return nil
}
|
go
|
func (t *terminal) Kill() error {
if t.cmd.Process != nil {
if err := t.cmd.Process.Kill(); err != nil {
if err.Error() != "os: process already finished" {
return trace.Wrap(err)
}
}
}
return nil
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"Kill",
"(",
")",
"error",
"{",
"if",
"t",
".",
"cmd",
".",
"Process",
"!=",
"nil",
"{",
"if",
"err",
":=",
"t",
".",
"cmd",
".",
"Process",
".",
"Kill",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
".",
"Error",
"(",
")",
"!=",
"\"os: process already finished\"",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Kill will force kill the terminal.
|
[
"Kill",
"will",
"force",
"kill",
"the",
"terminal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L208-L218
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
Close
|
func (t *terminal) Close() error {
var err error
// note, pty is closed in the copying goroutine,
// not here to avoid data races
if t.tty != nil {
if e := t.tty.Close(); e != nil {
err = e
}
}
go t.closePTY()
return trace.Wrap(err)
}
|
go
|
func (t *terminal) Close() error {
var err error
// note, pty is closed in the copying goroutine,
// not here to avoid data races
if t.tty != nil {
if e := t.tty.Close(); e != nil {
err = e
}
}
go t.closePTY()
return trace.Wrap(err)
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"Close",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"t",
".",
"tty",
"!=",
"nil",
"{",
"if",
"e",
":=",
"t",
".",
"tty",
".",
"Close",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"err",
"=",
"e",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"t",
".",
"closePTY",
"(",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// Close will free resources associated with the terminal.
|
[
"Close",
"will",
"free",
"resources",
"associated",
"with",
"the",
"terminal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L231-L242
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
GetWinSize
|
func (t *terminal) GetWinSize() (*term.Winsize, error) {
t.mu.Lock()
defer t.mu.Unlock()
if t.pty == nil {
return nil, trace.NotFound("no pty")
}
ws, err := term.GetWinsize(t.pty.Fd())
if err != nil {
return nil, trace.Wrap(err)
}
return ws, nil
}
|
go
|
func (t *terminal) GetWinSize() (*term.Winsize, error) {
t.mu.Lock()
defer t.mu.Unlock()
if t.pty == nil {
return nil, trace.NotFound("no pty")
}
ws, err := term.GetWinsize(t.pty.Fd())
if err != nil {
return nil, trace.Wrap(err)
}
return ws, nil
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"GetWinSize",
"(",
")",
"(",
"*",
"term",
".",
"Winsize",
",",
"error",
")",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"t",
".",
"pty",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"no pty\"",
")",
"\n",
"}",
"\n",
"ws",
",",
"err",
":=",
"term",
".",
"GetWinsize",
"(",
"t",
".",
"pty",
".",
"Fd",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ws",
",",
"nil",
"\n",
"}"
] |
// GetWinSize returns the window size of the terminal.
|
[
"GetWinSize",
"returns",
"the",
"window",
"size",
"of",
"the",
"terminal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L264-L275
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
SetWinSize
|
func (t *terminal) SetWinSize(params rsession.TerminalParams) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.pty == nil {
return trace.NotFound("no pty")
}
if err := term.SetWinsize(t.pty.Fd(), params.Winsize()); err != nil {
return trace.Wrap(err)
}
t.params = params
return nil
}
|
go
|
func (t *terminal) SetWinSize(params rsession.TerminalParams) error {
t.mu.Lock()
defer t.mu.Unlock()
if t.pty == nil {
return trace.NotFound("no pty")
}
if err := term.SetWinsize(t.pty.Fd(), params.Winsize()); err != nil {
return trace.Wrap(err)
}
t.params = params
return nil
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"SetWinSize",
"(",
"params",
"rsession",
".",
"TerminalParams",
")",
"error",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"t",
".",
"pty",
"==",
"nil",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"no pty\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"term",
".",
"SetWinsize",
"(",
"t",
".",
"pty",
".",
"Fd",
"(",
")",
",",
"params",
".",
"Winsize",
"(",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"t",
".",
"params",
"=",
"params",
"\n",
"return",
"nil",
"\n",
"}"
] |
// SetWinSize sets the window size of the terminal.
|
[
"SetWinSize",
"sets",
"the",
"window",
"size",
"of",
"the",
"terminal",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L278-L289
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
GetTerminalParams
|
func (t *terminal) GetTerminalParams() rsession.TerminalParams {
t.mu.Lock()
defer t.mu.Unlock()
return t.params
}
|
go
|
func (t *terminal) GetTerminalParams() rsession.TerminalParams {
t.mu.Lock()
defer t.mu.Unlock()
return t.params
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"GetTerminalParams",
"(",
")",
"rsession",
".",
"TerminalParams",
"{",
"t",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"t",
".",
"params",
"\n",
"}"
] |
// GetTerminalParams is a fast call to get cached terminal parameters
// and avoid extra system call.
|
[
"GetTerminalParams",
"is",
"a",
"fast",
"call",
"to",
"get",
"cached",
"terminal",
"parameters",
"and",
"avoid",
"extra",
"system",
"call",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L293-L297
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
SetTermType
|
func (t *terminal) SetTermType(term string) {
if term == "" {
term = defaultTerm
}
t.termType = term
}
|
go
|
func (t *terminal) SetTermType(term string) {
if term == "" {
term = defaultTerm
}
t.termType = term
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"SetTermType",
"(",
"term",
"string",
")",
"{",
"if",
"term",
"==",
"\"\"",
"{",
"term",
"=",
"defaultTerm",
"\n",
"}",
"\n",
"t",
".",
"termType",
"=",
"term",
"\n",
"}"
] |
// SetTermType sets the terminal type from "req-pty" request.
|
[
"SetTermType",
"sets",
"the",
"terminal",
"type",
"from",
"req",
"-",
"pty",
"request",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L305-L310
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
setOwner
|
func (t *terminal) setOwner() error {
uid, gid, mode, err := getOwner(t.ctx.Identity.Login, user.Lookup, user.LookupGroup)
if err != nil {
return trace.Wrap(err)
}
err = os.Chown(t.tty.Name(), uid, gid)
if err != nil {
return trace.Wrap(err)
}
err = os.Chmod(t.tty.Name(), mode)
if err != nil {
return trace.Wrap(err)
}
log.Debugf("Set permissions on %v to %v:%v with mode %v.", t.tty.Name(), uid, gid, mode)
return nil
}
|
go
|
func (t *terminal) setOwner() error {
uid, gid, mode, err := getOwner(t.ctx.Identity.Login, user.Lookup, user.LookupGroup)
if err != nil {
return trace.Wrap(err)
}
err = os.Chown(t.tty.Name(), uid, gid)
if err != nil {
return trace.Wrap(err)
}
err = os.Chmod(t.tty.Name(), mode)
if err != nil {
return trace.Wrap(err)
}
log.Debugf("Set permissions on %v to %v:%v with mode %v.", t.tty.Name(), uid, gid, mode)
return nil
}
|
[
"func",
"(",
"t",
"*",
"terminal",
")",
"setOwner",
"(",
")",
"error",
"{",
"uid",
",",
"gid",
",",
"mode",
",",
"err",
":=",
"getOwner",
"(",
"t",
".",
"ctx",
".",
"Identity",
".",
"Login",
",",
"user",
".",
"Lookup",
",",
"user",
".",
"LookupGroup",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"Chown",
"(",
"t",
".",
"tty",
".",
"Name",
"(",
")",
",",
"uid",
",",
"gid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"Chmod",
"(",
"t",
".",
"tty",
".",
"Name",
"(",
")",
",",
"mode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"Debugf",
"(",
"\"Set permissions on %v to %v:%v with mode %v.\"",
",",
"t",
".",
"tty",
".",
"Name",
"(",
")",
",",
"uid",
",",
"gid",
",",
"mode",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// setOwner changes the owner and mode of the TTY.
|
[
"setOwner",
"changes",
"the",
"owner",
"and",
"mode",
"of",
"the",
"TTY",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L355-L373
|
train
|
gravitational/teleport
|
lib/srv/term.go
|
prepareRemoteSession
|
func (t *remoteTerminal) prepareRemoteSession(session *ssh.Session, ctx *ServerContext) {
envs := map[string]string{
teleport.SSHTeleportUser: ctx.Identity.TeleportUser,
teleport.SSHSessionWebproxyAddr: ctx.ProxyPublicAddress(),
teleport.SSHTeleportHostUUID: ctx.srv.ID(),
teleport.SSHTeleportClusterName: ctx.ClusterName,
teleport.SSHSessionID: string(ctx.session.id),
}
for k, v := range envs {
if err := session.Setenv(k, v); err != nil {
t.log.Debugf("Unable to set environment variable: %v: %v", k, v)
}
}
}
|
go
|
func (t *remoteTerminal) prepareRemoteSession(session *ssh.Session, ctx *ServerContext) {
envs := map[string]string{
teleport.SSHTeleportUser: ctx.Identity.TeleportUser,
teleport.SSHSessionWebproxyAddr: ctx.ProxyPublicAddress(),
teleport.SSHTeleportHostUUID: ctx.srv.ID(),
teleport.SSHTeleportClusterName: ctx.ClusterName,
teleport.SSHSessionID: string(ctx.session.id),
}
for k, v := range envs {
if err := session.Setenv(k, v); err != nil {
t.log.Debugf("Unable to set environment variable: %v: %v", k, v)
}
}
}
|
[
"func",
"(",
"t",
"*",
"remoteTerminal",
")",
"prepareRemoteSession",
"(",
"session",
"*",
"ssh",
".",
"Session",
",",
"ctx",
"*",
"ServerContext",
")",
"{",
"envs",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"teleport",
".",
"SSHTeleportUser",
":",
"ctx",
".",
"Identity",
".",
"TeleportUser",
",",
"teleport",
".",
"SSHSessionWebproxyAddr",
":",
"ctx",
".",
"ProxyPublicAddress",
"(",
")",
",",
"teleport",
".",
"SSHTeleportHostUUID",
":",
"ctx",
".",
"srv",
".",
"ID",
"(",
")",
",",
"teleport",
".",
"SSHTeleportClusterName",
":",
"ctx",
".",
"ClusterName",
",",
"teleport",
".",
"SSHSessionID",
":",
"string",
"(",
"ctx",
".",
"session",
".",
"id",
")",
",",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"envs",
"{",
"if",
"err",
":=",
"session",
".",
"Setenv",
"(",
"k",
",",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"t",
".",
"log",
".",
"Debugf",
"(",
"\"Unable to set environment variable: %v: %v\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// prepareRemoteSession prepares the more session for execution.
|
[
"prepareRemoteSession",
"prepares",
"the",
"more",
"session",
"for",
"execution",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/srv/term.go#L586-L600
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
NewAuthServer
|
func NewAuthServer(cfg *InitConfig, opts ...AuthServerOption) (*AuthServer, error) {
if cfg.Trust == nil {
cfg.Trust = local.NewCAService(cfg.Backend)
}
if cfg.Presence == nil {
cfg.Presence = local.NewPresenceService(cfg.Backend)
}
if cfg.Provisioner == nil {
cfg.Provisioner = local.NewProvisioningService(cfg.Backend)
}
if cfg.Identity == nil {
cfg.Identity = local.NewIdentityService(cfg.Backend)
}
if cfg.Access == nil {
cfg.Access = local.NewAccessService(cfg.Backend)
}
if cfg.ClusterConfiguration == nil {
cfg.ClusterConfiguration = local.NewClusterConfigurationService(cfg.Backend)
}
if cfg.Events == nil {
cfg.Events = local.NewEventsService(cfg.Backend)
}
if cfg.AuditLog == nil {
cfg.AuditLog = events.NewDiscardAuditLog()
}
limiter, err := limiter.NewConnectionsLimiter(limiter.LimiterConfig{
MaxConnections: defaults.LimiterMaxConcurrentSignatures,
})
if err != nil {
return nil, trace.Wrap(err)
}
closeCtx, cancelFunc := context.WithCancel(context.TODO())
as := AuthServer{
bk: cfg.Backend,
limiter: limiter,
Authority: cfg.Authority,
AuthServiceName: cfg.AuthServiceName,
oidcClients: make(map[string]*oidcClient),
samlProviders: make(map[string]*samlProvider),
githubClients: make(map[string]*githubClient),
cancelFunc: cancelFunc,
closeCtx: closeCtx,
AuthServices: AuthServices{
Trust: cfg.Trust,
Presence: cfg.Presence,
Provisioner: cfg.Provisioner,
Identity: cfg.Identity,
Access: cfg.Access,
ClusterConfiguration: cfg.ClusterConfiguration,
IAuditLog: cfg.AuditLog,
Events: cfg.Events,
},
}
for _, o := range opts {
o(&as)
}
if as.clock == nil {
as.clock = clockwork.NewRealClock()
}
return &as, nil
}
|
go
|
func NewAuthServer(cfg *InitConfig, opts ...AuthServerOption) (*AuthServer, error) {
if cfg.Trust == nil {
cfg.Trust = local.NewCAService(cfg.Backend)
}
if cfg.Presence == nil {
cfg.Presence = local.NewPresenceService(cfg.Backend)
}
if cfg.Provisioner == nil {
cfg.Provisioner = local.NewProvisioningService(cfg.Backend)
}
if cfg.Identity == nil {
cfg.Identity = local.NewIdentityService(cfg.Backend)
}
if cfg.Access == nil {
cfg.Access = local.NewAccessService(cfg.Backend)
}
if cfg.ClusterConfiguration == nil {
cfg.ClusterConfiguration = local.NewClusterConfigurationService(cfg.Backend)
}
if cfg.Events == nil {
cfg.Events = local.NewEventsService(cfg.Backend)
}
if cfg.AuditLog == nil {
cfg.AuditLog = events.NewDiscardAuditLog()
}
limiter, err := limiter.NewConnectionsLimiter(limiter.LimiterConfig{
MaxConnections: defaults.LimiterMaxConcurrentSignatures,
})
if err != nil {
return nil, trace.Wrap(err)
}
closeCtx, cancelFunc := context.WithCancel(context.TODO())
as := AuthServer{
bk: cfg.Backend,
limiter: limiter,
Authority: cfg.Authority,
AuthServiceName: cfg.AuthServiceName,
oidcClients: make(map[string]*oidcClient),
samlProviders: make(map[string]*samlProvider),
githubClients: make(map[string]*githubClient),
cancelFunc: cancelFunc,
closeCtx: closeCtx,
AuthServices: AuthServices{
Trust: cfg.Trust,
Presence: cfg.Presence,
Provisioner: cfg.Provisioner,
Identity: cfg.Identity,
Access: cfg.Access,
ClusterConfiguration: cfg.ClusterConfiguration,
IAuditLog: cfg.AuditLog,
Events: cfg.Events,
},
}
for _, o := range opts {
o(&as)
}
if as.clock == nil {
as.clock = clockwork.NewRealClock()
}
return &as, nil
}
|
[
"func",
"NewAuthServer",
"(",
"cfg",
"*",
"InitConfig",
",",
"opts",
"...",
"AuthServerOption",
")",
"(",
"*",
"AuthServer",
",",
"error",
")",
"{",
"if",
"cfg",
".",
"Trust",
"==",
"nil",
"{",
"cfg",
".",
"Trust",
"=",
"local",
".",
"NewCAService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Presence",
"==",
"nil",
"{",
"cfg",
".",
"Presence",
"=",
"local",
".",
"NewPresenceService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Provisioner",
"==",
"nil",
"{",
"cfg",
".",
"Provisioner",
"=",
"local",
".",
"NewProvisioningService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Identity",
"==",
"nil",
"{",
"cfg",
".",
"Identity",
"=",
"local",
".",
"NewIdentityService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Access",
"==",
"nil",
"{",
"cfg",
".",
"Access",
"=",
"local",
".",
"NewAccessService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ClusterConfiguration",
"==",
"nil",
"{",
"cfg",
".",
"ClusterConfiguration",
"=",
"local",
".",
"NewClusterConfigurationService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"Events",
"==",
"nil",
"{",
"cfg",
".",
"Events",
"=",
"local",
".",
"NewEventsService",
"(",
"cfg",
".",
"Backend",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"AuditLog",
"==",
"nil",
"{",
"cfg",
".",
"AuditLog",
"=",
"events",
".",
"NewDiscardAuditLog",
"(",
")",
"\n",
"}",
"\n",
"limiter",
",",
"err",
":=",
"limiter",
".",
"NewConnectionsLimiter",
"(",
"limiter",
".",
"LimiterConfig",
"{",
"MaxConnections",
":",
"defaults",
".",
"LimiterMaxConcurrentSignatures",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"closeCtx",
",",
"cancelFunc",
":=",
"context",
".",
"WithCancel",
"(",
"context",
".",
"TODO",
"(",
")",
")",
"\n",
"as",
":=",
"AuthServer",
"{",
"bk",
":",
"cfg",
".",
"Backend",
",",
"limiter",
":",
"limiter",
",",
"Authority",
":",
"cfg",
".",
"Authority",
",",
"AuthServiceName",
":",
"cfg",
".",
"AuthServiceName",
",",
"oidcClients",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"oidcClient",
")",
",",
"samlProviders",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"samlProvider",
")",
",",
"githubClients",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"githubClient",
")",
",",
"cancelFunc",
":",
"cancelFunc",
",",
"closeCtx",
":",
"closeCtx",
",",
"AuthServices",
":",
"AuthServices",
"{",
"Trust",
":",
"cfg",
".",
"Trust",
",",
"Presence",
":",
"cfg",
".",
"Presence",
",",
"Provisioner",
":",
"cfg",
".",
"Provisioner",
",",
"Identity",
":",
"cfg",
".",
"Identity",
",",
"Access",
":",
"cfg",
".",
"Access",
",",
"ClusterConfiguration",
":",
"cfg",
".",
"ClusterConfiguration",
",",
"IAuditLog",
":",
"cfg",
".",
"AuditLog",
",",
"Events",
":",
"cfg",
".",
"Events",
",",
"}",
",",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"o",
"(",
"&",
"as",
")",
"\n",
"}",
"\n",
"if",
"as",
".",
"clock",
"==",
"nil",
"{",
"as",
".",
"clock",
"=",
"clockwork",
".",
"NewRealClock",
"(",
")",
"\n",
"}",
"\n",
"return",
"&",
"as",
",",
"nil",
"\n",
"}"
] |
// NewAuthServer creates and configures a new AuthServer instance
|
[
"NewAuthServer",
"creates",
"and",
"configures",
"a",
"new",
"AuthServer",
"instance"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L62-L125
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
SetCache
|
func (a *AuthServer) SetCache(clt AuthCache) {
a.lock.Lock()
defer a.lock.Unlock()
a.cache = clt
}
|
go
|
func (a *AuthServer) SetCache(clt AuthCache) {
a.lock.Lock()
defer a.lock.Unlock()
a.cache = clt
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"SetCache",
"(",
"clt",
"AuthCache",
")",
"{",
"a",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"a",
".",
"cache",
"=",
"clt",
"\n",
"}"
] |
// SetCache sets cache used by auth server
|
[
"SetCache",
"sets",
"cache",
"used",
"by",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L212-L216
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
GetCache
|
func (a *AuthServer) GetCache() AuthCache {
a.lock.RLock()
defer a.lock.RUnlock()
if a.cache == nil {
return &a.AuthServices
}
return a.cache
}
|
go
|
func (a *AuthServer) GetCache() AuthCache {
a.lock.RLock()
defer a.lock.RUnlock()
if a.cache == nil {
return &a.AuthServices
}
return a.cache
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"GetCache",
"(",
")",
"AuthCache",
"{",
"a",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"a",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"a",
".",
"cache",
"==",
"nil",
"{",
"return",
"&",
"a",
".",
"AuthServices",
"\n",
"}",
"\n",
"return",
"a",
".",
"cache",
"\n",
"}"
] |
// GetCache returns cache used by auth server
|
[
"GetCache",
"returns",
"cache",
"used",
"by",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L219-L226
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
runPeriodicOperations
|
func (a *AuthServer) runPeriodicOperations() {
// run periodic functions with a semi-random period
// to avoid contention on the database in case if there are multiple
// auth servers running - so they don't compete trying
// to update the same resources.
r := rand.New(rand.NewSource(a.GetClock().Now().UnixNano()))
period := defaults.HighResPollingPeriod + time.Duration(r.Intn(int(defaults.HighResPollingPeriod/time.Second)))*time.Second
log.Debugf("Ticking with period: %v.", period)
ticker := time.NewTicker(period)
defer ticker.Stop()
for {
select {
case <-a.closeCtx.Done():
return
case <-ticker.C:
err := a.autoRotateCertAuthorities()
if err != nil {
if trace.IsCompareFailed(err) {
log.Debugf("Cert authority has been updated concurrently: %v.", err)
} else {
log.Errorf("Failed to perform cert rotation check: %v.", err)
}
}
}
}
}
|
go
|
func (a *AuthServer) runPeriodicOperations() {
// run periodic functions with a semi-random period
// to avoid contention on the database in case if there are multiple
// auth servers running - so they don't compete trying
// to update the same resources.
r := rand.New(rand.NewSource(a.GetClock().Now().UnixNano()))
period := defaults.HighResPollingPeriod + time.Duration(r.Intn(int(defaults.HighResPollingPeriod/time.Second)))*time.Second
log.Debugf("Ticking with period: %v.", period)
ticker := time.NewTicker(period)
defer ticker.Stop()
for {
select {
case <-a.closeCtx.Done():
return
case <-ticker.C:
err := a.autoRotateCertAuthorities()
if err != nil {
if trace.IsCompareFailed(err) {
log.Debugf("Cert authority has been updated concurrently: %v.", err)
} else {
log.Errorf("Failed to perform cert rotation check: %v.", err)
}
}
}
}
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"runPeriodicOperations",
"(",
")",
"{",
"r",
":=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"a",
".",
"GetClock",
"(",
")",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
"period",
":=",
"defaults",
".",
"HighResPollingPeriod",
"+",
"time",
".",
"Duration",
"(",
"r",
".",
"Intn",
"(",
"int",
"(",
"defaults",
".",
"HighResPollingPeriod",
"/",
"time",
".",
"Second",
")",
")",
")",
"*",
"time",
".",
"Second",
"\n",
"log",
".",
"Debugf",
"(",
"\"Ticking with period: %v.\"",
",",
"period",
")",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"period",
")",
"\n",
"defer",
"ticker",
".",
"Stop",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"a",
".",
"closeCtx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"case",
"<-",
"ticker",
".",
"C",
":",
"err",
":=",
"a",
".",
"autoRotateCertAuthorities",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsCompareFailed",
"(",
"err",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"Cert authority has been updated concurrently: %v.\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Errorf",
"(",
"\"Failed to perform cert rotation check: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// runPeriodicOperations runs some periodic bookkeeping operations
// performed by auth server
|
[
"runPeriodicOperations",
"runs",
"some",
"periodic",
"bookkeeping",
"operations",
"performed",
"by",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L230-L255
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
SetClock
|
func (a *AuthServer) SetClock(clock clockwork.Clock) {
a.lock.Lock()
defer a.lock.Unlock()
a.clock = clock
}
|
go
|
func (a *AuthServer) SetClock(clock clockwork.Clock) {
a.lock.Lock()
defer a.lock.Unlock()
a.clock = clock
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"SetClock",
"(",
"clock",
"clockwork",
".",
"Clock",
")",
"{",
"a",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"a",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"a",
".",
"clock",
"=",
"clock",
"\n",
"}"
] |
// SetClock sets clock, used in tests
|
[
"SetClock",
"sets",
"clock",
"used",
"in",
"tests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L272-L276
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
GetClusterConfig
|
func (a *AuthServer) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
return a.GetCache().GetClusterConfig(opts...)
}
|
go
|
func (a *AuthServer) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
return a.GetCache().GetClusterConfig(opts...)
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"GetClusterConfig",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"ClusterConfig",
",",
"error",
")",
"{",
"return",
"a",
".",
"GetCache",
"(",
")",
".",
"GetClusterConfig",
"(",
"opts",
"...",
")",
"\n",
"}"
] |
// GetClusterConfig gets ClusterConfig from the backend.
|
[
"GetClusterConfig",
"gets",
"ClusterConfig",
"from",
"the",
"backend",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L284-L286
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
GetClusterName
|
func (a *AuthServer) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
return a.GetCache().GetClusterName(opts...)
}
|
go
|
func (a *AuthServer) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
return a.GetCache().GetClusterName(opts...)
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"GetClusterName",
"(",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"services",
".",
"ClusterName",
",",
"error",
")",
"{",
"return",
"a",
".",
"GetCache",
"(",
")",
".",
"GetClusterName",
"(",
"opts",
"...",
")",
"\n",
"}"
] |
// GetClusterName returns the domain name that identifies this authority server.
// Also known as "cluster name"
|
[
"GetClusterName",
"returns",
"the",
"domain",
"name",
"that",
"identifies",
"this",
"authority",
"server",
".",
"Also",
"known",
"as",
"cluster",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L290-L292
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
GetDomainName
|
func (a *AuthServer) GetDomainName() (string, error) {
clusterName, err := a.GetClusterName()
if err != nil {
return "", trace.Wrap(err)
}
return clusterName.GetClusterName(), nil
}
|
go
|
func (a *AuthServer) GetDomainName() (string, error) {
clusterName, err := a.GetClusterName()
if err != nil {
return "", trace.Wrap(err)
}
return clusterName.GetClusterName(), nil
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"GetDomainName",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"clusterName",
",",
"err",
":=",
"a",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"clusterName",
".",
"GetClusterName",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// GetDomainName returns the domain name that identifies this authority server.
// Also known as "cluster name"
|
[
"GetDomainName",
"returns",
"the",
"domain",
"name",
"that",
"identifies",
"this",
"authority",
"server",
".",
"Also",
"known",
"as",
"cluster",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L296-L302
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
GenerateUserCerts
|
func (a *AuthServer) GenerateUserCerts(key []byte, username string, ttl time.Duration, compatibility string) ([]byte, []byte, error) {
user, err := a.Identity.GetUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
checker, err := services.FetchRoles(user.GetRoles(), a.Access, user.GetTraits())
if err != nil {
return nil, nil, trace.Wrap(err)
}
certs, err := a.generateUserCert(certRequest{
user: user,
roles: checker,
ttl: ttl,
compatibility: compatibility,
publicKey: key,
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return certs.ssh, certs.tls, nil
}
|
go
|
func (a *AuthServer) GenerateUserCerts(key []byte, username string, ttl time.Duration, compatibility string) ([]byte, []byte, error) {
user, err := a.Identity.GetUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
checker, err := services.FetchRoles(user.GetRoles(), a.Access, user.GetTraits())
if err != nil {
return nil, nil, trace.Wrap(err)
}
certs, err := a.generateUserCert(certRequest{
user: user,
roles: checker,
ttl: ttl,
compatibility: compatibility,
publicKey: key,
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return certs.ssh, certs.tls, nil
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"GenerateUserCerts",
"(",
"key",
"[",
"]",
"byte",
",",
"username",
"string",
",",
"ttl",
"time",
".",
"Duration",
",",
"compatibility",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"user",
",",
"err",
":=",
"a",
".",
"Identity",
".",
"GetUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"checker",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"user",
".",
"GetRoles",
"(",
")",
",",
"a",
".",
"Access",
",",
"user",
".",
"GetTraits",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certs",
",",
"err",
":=",
"a",
".",
"generateUserCert",
"(",
"certRequest",
"{",
"user",
":",
"user",
",",
"roles",
":",
"checker",
",",
"ttl",
":",
"ttl",
",",
"compatibility",
":",
"compatibility",
",",
"publicKey",
":",
"key",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"certs",
".",
"ssh",
",",
"certs",
".",
"tls",
",",
"nil",
"\n",
"}"
] |
// GenerateUserCerts is used to generate user certificate, used internally for tests
|
[
"GenerateUserCerts",
"is",
"used",
"to",
"generate",
"user",
"certificate",
"used",
"internally",
"for",
"tests"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L407-L427
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
WithUserLock
|
func (s *AuthServer) WithUserLock(username string, authenticateFn func() error) error {
user, err := s.Identity.GetUser(username)
if err != nil {
return trace.Wrap(err)
}
status := user.GetStatus()
if status.IsLocked && status.LockExpires.After(s.clock.Now().UTC()) {
return trace.AccessDenied("%v exceeds %v failed login attempts, locked until %v",
user.GetName(), defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
}
fnErr := authenticateFn()
if fnErr == nil {
// upon successful login, reset the failed attempt counter
err = s.DeleteUserLoginAttempts(username)
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
return nil
}
// do not lock user in case if DB is flaky or down
if trace.IsConnectionProblem(err) {
return trace.Wrap(fnErr)
}
// log failed attempt and possibly lock user
attempt := services.LoginAttempt{Time: s.clock.Now().UTC(), Success: false}
err = s.AddUserLoginAttempt(username, attempt, defaults.AttemptTTL)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
loginAttempts, err := s.Identity.GetUserLoginAttempts(username)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
if !services.LastFailed(defaults.MaxLoginAttempts, loginAttempts) {
log.Debugf("%v user has less than %v failed login attempts", username, defaults.MaxLoginAttempts)
return trace.Wrap(fnErr)
}
lockUntil := s.clock.Now().UTC().Add(defaults.AccountLockInterval)
message := fmt.Sprintf("%v exceeds %v failed login attempts, locked until %v",
username, defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
log.Debug(message)
user.SetLocked(lockUntil, "user has exceeded maximum failed login attempts")
err = s.Identity.UpsertUser(user)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
return trace.AccessDenied(message)
}
|
go
|
func (s *AuthServer) WithUserLock(username string, authenticateFn func() error) error {
user, err := s.Identity.GetUser(username)
if err != nil {
return trace.Wrap(err)
}
status := user.GetStatus()
if status.IsLocked && status.LockExpires.After(s.clock.Now().UTC()) {
return trace.AccessDenied("%v exceeds %v failed login attempts, locked until %v",
user.GetName(), defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
}
fnErr := authenticateFn()
if fnErr == nil {
// upon successful login, reset the failed attempt counter
err = s.DeleteUserLoginAttempts(username)
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
return nil
}
// do not lock user in case if DB is flaky or down
if trace.IsConnectionProblem(err) {
return trace.Wrap(fnErr)
}
// log failed attempt and possibly lock user
attempt := services.LoginAttempt{Time: s.clock.Now().UTC(), Success: false}
err = s.AddUserLoginAttempt(username, attempt, defaults.AttemptTTL)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
loginAttempts, err := s.Identity.GetUserLoginAttempts(username)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
if !services.LastFailed(defaults.MaxLoginAttempts, loginAttempts) {
log.Debugf("%v user has less than %v failed login attempts", username, defaults.MaxLoginAttempts)
return trace.Wrap(fnErr)
}
lockUntil := s.clock.Now().UTC().Add(defaults.AccountLockInterval)
message := fmt.Sprintf("%v exceeds %v failed login attempts, locked until %v",
username, defaults.MaxLoginAttempts, utils.HumanTimeFormat(status.LockExpires))
log.Debug(message)
user.SetLocked(lockUntil, "user has exceeded maximum failed login attempts")
err = s.Identity.UpsertUser(user)
if err != nil {
log.Error(trace.DebugReport(err))
return trace.Wrap(fnErr)
}
return trace.AccessDenied(message)
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"WithUserLock",
"(",
"username",
"string",
",",
"authenticateFn",
"func",
"(",
")",
"error",
")",
"error",
"{",
"user",
",",
"err",
":=",
"s",
".",
"Identity",
".",
"GetUser",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"status",
":=",
"user",
".",
"GetStatus",
"(",
")",
"\n",
"if",
"status",
".",
"IsLocked",
"&&",
"status",
".",
"LockExpires",
".",
"After",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
")",
"{",
"return",
"trace",
".",
"AccessDenied",
"(",
"\"%v exceeds %v failed login attempts, locked until %v\"",
",",
"user",
".",
"GetName",
"(",
")",
",",
"defaults",
".",
"MaxLoginAttempts",
",",
"utils",
".",
"HumanTimeFormat",
"(",
"status",
".",
"LockExpires",
")",
")",
"\n",
"}",
"\n",
"fnErr",
":=",
"authenticateFn",
"(",
")",
"\n",
"if",
"fnErr",
"==",
"nil",
"{",
"err",
"=",
"s",
".",
"DeleteUserLoginAttempts",
"(",
"username",
")",
"\n",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"trace",
".",
"IsConnectionProblem",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"attempt",
":=",
"services",
".",
"LoginAttempt",
"{",
"Time",
":",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"Success",
":",
"false",
"}",
"\n",
"err",
"=",
"s",
".",
"AddUserLoginAttempt",
"(",
"username",
",",
"attempt",
",",
"defaults",
".",
"AttemptTTL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"loginAttempts",
",",
"err",
":=",
"s",
".",
"Identity",
".",
"GetUserLoginAttempts",
"(",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"if",
"!",
"services",
".",
"LastFailed",
"(",
"defaults",
".",
"MaxLoginAttempts",
",",
"loginAttempts",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"%v user has less than %v failed login attempts\"",
",",
"username",
",",
"defaults",
".",
"MaxLoginAttempts",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"lockUntil",
":=",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"defaults",
".",
"AccountLockInterval",
")",
"\n",
"message",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%v exceeds %v failed login attempts, locked until %v\"",
",",
"username",
",",
"defaults",
".",
"MaxLoginAttempts",
",",
"utils",
".",
"HumanTimeFormat",
"(",
"status",
".",
"LockExpires",
")",
")",
"\n",
"log",
".",
"Debug",
"(",
"message",
")",
"\n",
"user",
".",
"SetLocked",
"(",
"lockUntil",
",",
"\"user has exceeded maximum failed login attempts\"",
")",
"\n",
"err",
"=",
"s",
".",
"Identity",
".",
"UpsertUser",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Error",
"(",
"trace",
".",
"DebugReport",
"(",
"err",
")",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"fnErr",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"AccessDenied",
"(",
"message",
")",
"\n",
"}"
] |
// WithUserLock executes function authenticateFn that performs user authentication
// if authenticateFn returns non nil error, the login attempt will be logged in as failed.
// The only exception to this rule is ConnectionProblemError, in case if it occurs
// access will be denied, but login attempt will not be recorded
// this is done to avoid potential user lockouts due to backend failures
// In case if user exceeds defaults.MaxLoginAttempts
// the user account will be locked for defaults.AccountLockInterval
|
[
"WithUserLock",
"executes",
"function",
"authenticateFn",
"that",
"performs",
"user",
"authentication",
"if",
"authenticateFn",
"returns",
"non",
"nil",
"error",
"the",
"login",
"attempt",
"will",
"be",
"logged",
"in",
"as",
"failed",
".",
"The",
"only",
"exception",
"to",
"this",
"rule",
"is",
"ConnectionProblemError",
"in",
"case",
"if",
"it",
"occurs",
"access",
"will",
"be",
"denied",
"but",
"login",
"attempt",
"will",
"not",
"be",
"recorded",
"this",
"is",
"done",
"to",
"avoid",
"potential",
"user",
"lockouts",
"due",
"to",
"backend",
"failures",
"In",
"case",
"if",
"user",
"exceeds",
"defaults",
".",
"MaxLoginAttempts",
"the",
"user",
"account",
"will",
"be",
"locked",
"for",
"defaults",
".",
"AccountLockInterval"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L543-L594
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
PreAuthenticatedSignIn
|
func (s *AuthServer) PreAuthenticatedSignIn(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
return sess.WithoutSecrets(), nil
}
|
go
|
func (s *AuthServer) PreAuthenticatedSignIn(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
return sess.WithoutSecrets(), nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"PreAuthenticatedSignIn",
"(",
"user",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"user",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
".",
"WithoutSecrets",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// PreAuthenticatedSignIn is for 2-way authentication methods like U2F where the password is
// already checked before issuing the second factor challenge
|
[
"PreAuthenticatedSignIn",
"is",
"for",
"2",
"-",
"way",
"authentication",
"methods",
"like",
"U2F",
"where",
"the",
"password",
"is",
"already",
"checked",
"before",
"issuing",
"the",
"second",
"factor",
"challenge"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L598-L607
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
ExtendWebSession
|
func (s *AuthServer) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
prevSession, err := s.GetWebSession(user, prevSessionID)
if err != nil {
return nil, trace.Wrap(err)
}
// consider absolute expiry time that may be set for this session
// by some external identity serivce, so we can not renew this session
// any more without extra logic for renewal with external OIDC provider
expiresAt := prevSession.GetExpiryTime()
if !expiresAt.IsZero() && expiresAt.Before(s.clock.Now().UTC()) {
return nil, trace.NotFound("web session has expired")
}
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
sess.SetExpiryTime(expiresAt)
bearerTokenTTL := utils.MinTTL(utils.ToTTL(s.clock, expiresAt), BearerTokenTTL)
sess.SetBearerTokenExpiryTime(s.clock.Now().UTC().Add(bearerTokenTTL))
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().ExtendWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
}
|
go
|
func (s *AuthServer) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
prevSession, err := s.GetWebSession(user, prevSessionID)
if err != nil {
return nil, trace.Wrap(err)
}
// consider absolute expiry time that may be set for this session
// by some external identity serivce, so we can not renew this session
// any more without extra logic for renewal with external OIDC provider
expiresAt := prevSession.GetExpiryTime()
if !expiresAt.IsZero() && expiresAt.Before(s.clock.Now().UTC()) {
return nil, trace.NotFound("web session has expired")
}
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
sess.SetExpiryTime(expiresAt)
bearerTokenTTL := utils.MinTTL(utils.ToTTL(s.clock, expiresAt), BearerTokenTTL)
sess.SetBearerTokenExpiryTime(s.clock.Now().UTC().Add(bearerTokenTTL))
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().ExtendWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"ExtendWebSession",
"(",
"user",
"string",
",",
"prevSessionID",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"prevSession",
",",
"err",
":=",
"s",
".",
"GetWebSession",
"(",
"user",
",",
"prevSessionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"expiresAt",
":=",
"prevSession",
".",
"GetExpiryTime",
"(",
")",
"\n",
"if",
"!",
"expiresAt",
".",
"IsZero",
"(",
")",
"&&",
"expiresAt",
".",
"Before",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"web session has expired\"",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
".",
"SetExpiryTime",
"(",
"expiresAt",
")",
"\n",
"bearerTokenTTL",
":=",
"utils",
".",
"MinTTL",
"(",
"utils",
".",
"ToTTL",
"(",
"s",
".",
"clock",
",",
"expiresAt",
")",
",",
"BearerTokenTTL",
")",
"\n",
"sess",
".",
"SetBearerTokenExpiryTime",
"(",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"bearerTokenTTL",
")",
")",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"user",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
"=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"ExtendWebSession",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] |
// ExtendWebSession creates a new web session for a user based on a valid previous sessionID,
// method is used to renew the web session for a user
|
[
"ExtendWebSession",
"creates",
"a",
"new",
"web",
"session",
"for",
"a",
"user",
"based",
"on",
"a",
"valid",
"previous",
"sessionID",
"method",
"is",
"used",
"to",
"renew",
"the",
"web",
"session",
"for",
"a",
"user"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L686-L715
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
CreateWebSession
|
func (s *AuthServer) CreateWebSession(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
}
|
go
|
func (s *AuthServer) CreateWebSession(user string) (services.WebSession, error) {
sess, err := s.NewWebSession(user)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(user, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"CreateWebSession",
"(",
"user",
"string",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"user",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"user",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
"=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"GenerateWebSession",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] |
// CreateWebSession creates a new web session for user without any
// checks, is used by admins
|
[
"CreateWebSession",
"creates",
"a",
"new",
"web",
"session",
"for",
"user",
"without",
"any",
"checks",
"is",
"used",
"by",
"admins"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L719-L732
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
CheckAndSetDefaults
|
func (req *GenerateTokenRequest) CheckAndSetDefaults() error {
for _, role := range req.Roles {
if err := role.Check(); err != nil {
return trace.Wrap(err)
}
}
if req.TTL == 0 {
req.TTL = defaults.ProvisioningTokenTTL
}
if req.Token == "" {
token, err := utils.CryptoRandomHex(TokenLenBytes)
if err != nil {
return trace.Wrap(err)
}
req.Token = token
}
return nil
}
|
go
|
func (req *GenerateTokenRequest) CheckAndSetDefaults() error {
for _, role := range req.Roles {
if err := role.Check(); err != nil {
return trace.Wrap(err)
}
}
if req.TTL == 0 {
req.TTL = defaults.ProvisioningTokenTTL
}
if req.Token == "" {
token, err := utils.CryptoRandomHex(TokenLenBytes)
if err != nil {
return trace.Wrap(err)
}
req.Token = token
}
return nil
}
|
[
"func",
"(",
"req",
"*",
"GenerateTokenRequest",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"for",
"_",
",",
"role",
":=",
"range",
"req",
".",
"Roles",
"{",
"if",
"err",
":=",
"role",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"req",
".",
"TTL",
"==",
"0",
"{",
"req",
".",
"TTL",
"=",
"defaults",
".",
"ProvisioningTokenTTL",
"\n",
"}",
"\n",
"if",
"req",
".",
"Token",
"==",
"\"\"",
"{",
"token",
",",
"err",
":=",
"utils",
".",
"CryptoRandomHex",
"(",
"TokenLenBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"req",
".",
"Token",
"=",
"token",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckAndSetDefaults checks and sets default values of request
|
[
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"values",
"of",
"request"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L745-L762
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
GenerateToken
|
func (s *AuthServer) GenerateToken(req GenerateTokenRequest) (string, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return "", trace.Wrap(err)
}
token, err := services.NewProvisionToken(req.Token, req.Roles, s.clock.Now().UTC().Add(req.TTL))
if err != nil {
return "", trace.Wrap(err)
}
if err := s.Provisioner.UpsertToken(token); err != nil {
return "", trace.Wrap(err)
}
return req.Token, nil
}
|
go
|
func (s *AuthServer) GenerateToken(req GenerateTokenRequest) (string, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return "", trace.Wrap(err)
}
token, err := services.NewProvisionToken(req.Token, req.Roles, s.clock.Now().UTC().Add(req.TTL))
if err != nil {
return "", trace.Wrap(err)
}
if err := s.Provisioner.UpsertToken(token); err != nil {
return "", trace.Wrap(err)
}
return req.Token, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"GenerateToken",
"(",
"req",
"GenerateTokenRequest",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"req",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"token",
",",
"err",
":=",
"services",
".",
"NewProvisionToken",
"(",
"req",
".",
"Token",
",",
"req",
".",
"Roles",
",",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"req",
".",
"TTL",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"Provisioner",
".",
"UpsertToken",
"(",
"token",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"req",
".",
"Token",
",",
"nil",
"\n",
"}"
] |
// GenerateToken generates multi-purpose authentication token
|
[
"GenerateToken",
"generates",
"multi",
"-",
"purpose",
"authentication",
"token"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L765-L777
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
ExtractHostID
|
func ExtractHostID(hostName string, clusterName string) (string, error) {
suffix := "." + clusterName
if !strings.HasSuffix(hostName, suffix) {
return "", trace.BadParameter("expected suffix %q in %q", suffix, hostName)
}
return strings.TrimSuffix(hostName, suffix), nil
}
|
go
|
func ExtractHostID(hostName string, clusterName string) (string, error) {
suffix := "." + clusterName
if !strings.HasSuffix(hostName, suffix) {
return "", trace.BadParameter("expected suffix %q in %q", suffix, hostName)
}
return strings.TrimSuffix(hostName, suffix), nil
}
|
[
"func",
"ExtractHostID",
"(",
"hostName",
"string",
",",
"clusterName",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"suffix",
":=",
"\".\"",
"+",
"clusterName",
"\n",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"hostName",
",",
"suffix",
")",
"{",
"return",
"\"\"",
",",
"trace",
".",
"BadParameter",
"(",
"\"expected suffix %q in %q\"",
",",
"suffix",
",",
"hostName",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimSuffix",
"(",
"hostName",
",",
"suffix",
")",
",",
"nil",
"\n",
"}"
] |
// ExtractHostID returns host id based on the hostname
|
[
"ExtractHostID",
"returns",
"host",
"id",
"based",
"on",
"the",
"hostname"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L780-L786
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
ValidateToken
|
func (s *AuthServer) ValidateToken(token string) (roles teleport.Roles, e error) {
tkns, err := s.GetCache().GetStaticTokens()
if err != nil {
return nil, trace.Wrap(err)
}
// First check if the token is a static token. If it is, return right away.
// Static tokens have no expiration.
for _, st := range tkns.GetStaticTokens() {
if st.GetName() == token {
return st.GetRoles(), nil
}
}
// If it's not a static token, check if it's a ephemeral token in the backend.
// If a ephemeral token is found, make sure it's still valid.
tok, err := s.GetCache().GetToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
if !s.checkTokenTTL(tok) {
return nil, trace.AccessDenied("token expired")
}
return tok.GetRoles(), nil
}
|
go
|
func (s *AuthServer) ValidateToken(token string) (roles teleport.Roles, e error) {
tkns, err := s.GetCache().GetStaticTokens()
if err != nil {
return nil, trace.Wrap(err)
}
// First check if the token is a static token. If it is, return right away.
// Static tokens have no expiration.
for _, st := range tkns.GetStaticTokens() {
if st.GetName() == token {
return st.GetRoles(), nil
}
}
// If it's not a static token, check if it's a ephemeral token in the backend.
// If a ephemeral token is found, make sure it's still valid.
tok, err := s.GetCache().GetToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
if !s.checkTokenTTL(tok) {
return nil, trace.AccessDenied("token expired")
}
return tok.GetRoles(), nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"ValidateToken",
"(",
"token",
"string",
")",
"(",
"roles",
"teleport",
".",
"Roles",
",",
"e",
"error",
")",
"{",
"tkns",
",",
"err",
":=",
"s",
".",
"GetCache",
"(",
")",
".",
"GetStaticTokens",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"st",
":=",
"range",
"tkns",
".",
"GetStaticTokens",
"(",
")",
"{",
"if",
"st",
".",
"GetName",
"(",
")",
"==",
"token",
"{",
"return",
"st",
".",
"GetRoles",
"(",
")",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"tok",
",",
"err",
":=",
"s",
".",
"GetCache",
"(",
")",
".",
"GetToken",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"s",
".",
"checkTokenTTL",
"(",
"tok",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"token expired\"",
")",
"\n",
"}",
"\n",
"return",
"tok",
".",
"GetRoles",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// ValidateToken takes a provisioning token value and finds if it's valid. Returns
// a list of roles this token allows its owner to assume, or an error if the token
// cannot be found.
|
[
"ValidateToken",
"takes",
"a",
"provisioning",
"token",
"value",
"and",
"finds",
"if",
"it",
"s",
"valid",
".",
"Returns",
"a",
"list",
"of",
"roles",
"this",
"token",
"allows",
"its",
"owner",
"to",
"assume",
"or",
"an",
"error",
"if",
"the",
"token",
"cannot",
"be",
"found",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L993-L1018
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
checkTokenTTL
|
func (s *AuthServer) checkTokenTTL(tok services.ProvisionToken) bool {
now := s.clock.Now().UTC()
if tok.Expiry().Before(now) {
err := s.DeleteToken(tok.GetName())
if err != nil {
if !trace.IsNotFound(err) {
log.Warnf("Unable to delete token from backend: %v.", err)
}
}
return false
}
return true
}
|
go
|
func (s *AuthServer) checkTokenTTL(tok services.ProvisionToken) bool {
now := s.clock.Now().UTC()
if tok.Expiry().Before(now) {
err := s.DeleteToken(tok.GetName())
if err != nil {
if !trace.IsNotFound(err) {
log.Warnf("Unable to delete token from backend: %v.", err)
}
}
return false
}
return true
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"checkTokenTTL",
"(",
"tok",
"services",
".",
"ProvisionToken",
")",
"bool",
"{",
"now",
":=",
"s",
".",
"clock",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"if",
"tok",
".",
"Expiry",
"(",
")",
".",
"Before",
"(",
"now",
")",
"{",
"err",
":=",
"s",
".",
"DeleteToken",
"(",
"tok",
".",
"GetName",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"log",
".",
"Warnf",
"(",
"\"Unable to delete token from backend: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// checkTokenTTL checks if the token is still valid. If it is not, the token
// is removed from the backend and returns false. Otherwise returns true.
|
[
"checkTokenTTL",
"checks",
"if",
"the",
"token",
"is",
"still",
"valid",
".",
"If",
"it",
"is",
"not",
"the",
"token",
"is",
"removed",
"from",
"the",
"backend",
"and",
"returns",
"false",
".",
"Otherwise",
"returns",
"true",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1022-L1034
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
CheckAndSetDefaults
|
func (r *RegisterUsingTokenRequest) CheckAndSetDefaults() error {
if r.HostID == "" {
return trace.BadParameter("missing parameter HostID")
}
if r.Token == "" {
return trace.BadParameter("missing parameter Token")
}
if err := r.Role.Check(); err != nil {
return trace.Wrap(err)
}
return nil
}
|
go
|
func (r *RegisterUsingTokenRequest) CheckAndSetDefaults() error {
if r.HostID == "" {
return trace.BadParameter("missing parameter HostID")
}
if r.Token == "" {
return trace.BadParameter("missing parameter Token")
}
if err := r.Role.Check(); err != nil {
return trace.Wrap(err)
}
return nil
}
|
[
"func",
"(",
"r",
"*",
"RegisterUsingTokenRequest",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"r",
".",
"HostID",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter HostID\"",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Token",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter Token\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"Role",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckAndSetDefaults checks for errors and sets defaults
|
[
"CheckAndSetDefaults",
"checks",
"for",
"errors",
"and",
"sets",
"defaults"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1064-L1075
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
NewWatcher
|
func (a *AuthServer) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return a.GetCache().NewWatcher(ctx, watch)
}
|
go
|
func (a *AuthServer) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return a.GetCache().NewWatcher(ctx, watch)
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"NewWatcher",
"(",
"ctx",
"context",
".",
"Context",
",",
"watch",
"services",
".",
"Watch",
")",
"(",
"services",
".",
"Watcher",
",",
"error",
")",
"{",
"return",
"a",
".",
"GetCache",
"(",
")",
".",
"NewWatcher",
"(",
"ctx",
",",
"watch",
")",
"\n",
"}"
] |
// NewWatcher returns a new event watcher. In case of an auth server
// this watcher will return events as seen by the auth server's
// in memory cache, not the backend.
|
[
"NewWatcher",
"returns",
"a",
"new",
"event",
"watcher",
".",
"In",
"case",
"of",
"an",
"auth",
"server",
"this",
"watcher",
"will",
"return",
"events",
"as",
"seen",
"by",
"the",
"auth",
"server",
"s",
"in",
"memory",
"cache",
"not",
"the",
"backend",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1274-L1276
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
Error
|
func (k *authKeepAliver) Error() error {
k.RLock()
defer k.RUnlock()
return k.err
}
|
go
|
func (k *authKeepAliver) Error() error {
k.RLock()
defer k.RUnlock()
return k.err
}
|
[
"func",
"(",
"k",
"*",
"authKeepAliver",
")",
"Error",
"(",
")",
"error",
"{",
"k",
".",
"RLock",
"(",
")",
"\n",
"defer",
"k",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"k",
".",
"err",
"\n",
"}"
] |
// Error returns the error if keep aliver
// has been closed
|
[
"Error",
"returns",
"the",
"error",
"if",
"keep",
"aliver",
"has",
"been",
"closed"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1443-L1447
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
oidcConfigsEqual
|
func oidcConfigsEqual(a, b oidc.ClientConfig) bool {
if a.RedirectURL != b.RedirectURL {
return false
}
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
return true
}
|
go
|
func oidcConfigsEqual(a, b oidc.ClientConfig) bool {
if a.RedirectURL != b.RedirectURL {
return false
}
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
return true
}
|
[
"func",
"oidcConfigsEqual",
"(",
"a",
",",
"b",
"oidc",
".",
"ClientConfig",
")",
"bool",
"{",
"if",
"a",
".",
"RedirectURL",
"!=",
"b",
".",
"RedirectURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"Credentials",
".",
"ID",
"!=",
"b",
".",
"Credentials",
".",
"ID",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"Credentials",
".",
"Secret",
"!=",
"b",
".",
"Credentials",
".",
"Secret",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
".",
"Scope",
")",
"!=",
"len",
"(",
"b",
".",
"Scope",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"a",
".",
"Scope",
"{",
"if",
"a",
".",
"Scope",
"[",
"i",
"]",
"!=",
"b",
".",
"Scope",
"[",
"i",
"]",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// oidcConfigsEqual returns true if the provided OIDC configs are equal
|
[
"oidcConfigsEqual",
"returns",
"true",
"if",
"the",
"provided",
"OIDC",
"configs",
"are",
"equal"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1488-L1507
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
oauth2ConfigsEqual
|
func oauth2ConfigsEqual(a, b oauth2.Config) bool {
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if a.RedirectURL != b.RedirectURL {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
if a.AuthURL != b.AuthURL {
return false
}
if a.TokenURL != b.TokenURL {
return false
}
if a.AuthMethod != b.AuthMethod {
return false
}
return true
}
|
go
|
func oauth2ConfigsEqual(a, b oauth2.Config) bool {
if a.Credentials.ID != b.Credentials.ID {
return false
}
if a.Credentials.Secret != b.Credentials.Secret {
return false
}
if a.RedirectURL != b.RedirectURL {
return false
}
if len(a.Scope) != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
if a.AuthURL != b.AuthURL {
return false
}
if a.TokenURL != b.TokenURL {
return false
}
if a.AuthMethod != b.AuthMethod {
return false
}
return true
}
|
[
"func",
"oauth2ConfigsEqual",
"(",
"a",
",",
"b",
"oauth2",
".",
"Config",
")",
"bool",
"{",
"if",
"a",
".",
"Credentials",
".",
"ID",
"!=",
"b",
".",
"Credentials",
".",
"ID",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"Credentials",
".",
"Secret",
"!=",
"b",
".",
"Credentials",
".",
"Secret",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"RedirectURL",
"!=",
"b",
".",
"RedirectURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
".",
"Scope",
")",
"!=",
"len",
"(",
"b",
".",
"Scope",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"a",
".",
"Scope",
"{",
"if",
"a",
".",
"Scope",
"[",
"i",
"]",
"!=",
"b",
".",
"Scope",
"[",
"i",
"]",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"a",
".",
"AuthURL",
"!=",
"b",
".",
"AuthURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"TokenURL",
"!=",
"b",
".",
"TokenURL",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"a",
".",
"AuthMethod",
"!=",
"b",
".",
"AuthMethod",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// oauth2ConfigsEqual returns true if the provided OAuth2 configs are equal
|
[
"oauth2ConfigsEqual",
"returns",
"true",
"if",
"the",
"provided",
"OAuth2",
"configs",
"are",
"equal"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1510-L1538
|
train
|
gravitational/teleport
|
lib/auth/auth.go
|
isHTTPS
|
func isHTTPS(u string) error {
earl, err := url.Parse(u)
if err != nil {
return trace.Wrap(err)
}
if earl.Scheme != "https" {
return trace.BadParameter("expected scheme https, got %q", earl.Scheme)
}
return nil
}
|
go
|
func isHTTPS(u string) error {
earl, err := url.Parse(u)
if err != nil {
return trace.Wrap(err)
}
if earl.Scheme != "https" {
return trace.BadParameter("expected scheme https, got %q", earl.Scheme)
}
return nil
}
|
[
"func",
"isHTTPS",
"(",
"u",
"string",
")",
"error",
"{",
"earl",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"u",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"earl",
".",
"Scheme",
"!=",
"\"https\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"expected scheme https, got %q\"",
",",
"earl",
".",
"Scheme",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// isHTTPS checks if the scheme for a URL is https or not.
|
[
"isHTTPS",
"checks",
"if",
"the",
"scheme",
"for",
"a",
"URL",
"is",
"https",
"or",
"not",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/auth.go#L1541-L1551
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
NewOIDCConnector
|
func NewOIDCConnector(name string, spec OIDCConnectorSpecV2) OIDCConnector {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
}
|
go
|
func NewOIDCConnector(name string, spec OIDCConnectorSpecV2) OIDCConnector {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
}
|
[
"func",
"NewOIDCConnector",
"(",
"name",
"string",
",",
"spec",
"OIDCConnectorSpecV2",
")",
"OIDCConnector",
"{",
"return",
"&",
"OIDCConnectorV2",
"{",
"Kind",
":",
"KindOIDCConnector",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"}"
] |
// NewOIDCConnector returns a new OIDCConnector based off a name and OIDCConnectorSpecV2.
|
[
"NewOIDCConnector",
"returns",
"a",
"new",
"OIDCConnector",
"based",
"off",
"a",
"name",
"and",
"OIDCConnectorSpecV2",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L92-L102
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
UnmarshalOIDCConnector
|
func (*TeleportOIDCConnectorMarshaler) UnmarshalOIDCConnector(bytes []byte, opts ...MarshalOption) (OIDCConnector, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var c OIDCConnectorV1
err := json.Unmarshal(bytes, &c)
if err != nil {
return nil, trace.Wrap(err)
}
return c.V2(), nil
case V2:
var c OIDCConnectorV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &c); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetOIDCConnectorSchema(), &c, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := c.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
c.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
c.SetExpiry(cfg.Expires)
}
return &c, nil
}
return nil, trace.BadParameter("OIDC connector resource version %v is not supported", h.Version)
}
|
go
|
func (*TeleportOIDCConnectorMarshaler) UnmarshalOIDCConnector(bytes []byte, opts ...MarshalOption) (OIDCConnector, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var c OIDCConnectorV1
err := json.Unmarshal(bytes, &c)
if err != nil {
return nil, trace.Wrap(err)
}
return c.V2(), nil
case V2:
var c OIDCConnectorV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &c); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetOIDCConnectorSchema(), &c, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := c.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
c.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
c.SetExpiry(cfg.Expires)
}
return &c, nil
}
return nil, trace.BadParameter("OIDC connector resource version %v is not supported", h.Version)
}
|
[
"func",
"(",
"*",
"TeleportOIDCConnectorMarshaler",
")",
"UnmarshalOIDCConnector",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"OIDCConnector",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"h",
"ResourceHeader",
"\n",
"err",
"=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"c",
"OIDCConnectorV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"c",
"OIDCConnectorV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetOIDCConnectorSchema",
"(",
")",
",",
"&",
"c",
",",
"bytes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"c",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"c",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"c",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"OIDC connector resource version %v is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] |
// UnmarshalOIDCConnector unmarshals connector from
|
[
"UnmarshalOIDCConnector",
"unmarshals",
"connector",
"from"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L137-L180
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
MarshalOIDCConnector
|
func (*TeleportOIDCConnectorMarshaler) MarshalOIDCConnector(c OIDCConnector, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type connv1 interface {
V1() *OIDCConnectorV1
}
type connv2 interface {
V2() *OIDCConnectorV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := c.(connv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := c.(connv2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
}
|
go
|
func (*TeleportOIDCConnectorMarshaler) MarshalOIDCConnector(c OIDCConnector, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type connv1 interface {
V1() *OIDCConnectorV1
}
type connv2 interface {
V2() *OIDCConnectorV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := c.(connv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := c.(connv2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
}
|
[
"func",
"(",
"*",
"TeleportOIDCConnectorMarshaler",
")",
"MarshalOIDCConnector",
"(",
"c",
"OIDCConnector",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"connv1",
"interface",
"{",
"V1",
"(",
")",
"*",
"OIDCConnectorV1",
"\n",
"}",
"\n",
"type",
"connv2",
"interface",
"{",
"V2",
"(",
")",
"*",
"OIDCConnectorV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"c",
".",
"(",
"connv1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"c",
".",
"(",
"connv2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"don't know how to marshal %v\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"version %v is not supported\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] |
// MarshalUser marshals OIDC connector into JSON
|
[
"MarshalUser",
"marshals",
"OIDC",
"connector",
"into",
"JSON"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L183-L220
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
V1
|
func (o *OIDCConnectorV2) V1() *OIDCConnectorV1 {
return &OIDCConnectorV1{
ID: o.Metadata.Name,
IssuerURL: o.Spec.IssuerURL,
ClientID: o.Spec.ClientID,
ClientSecret: o.Spec.ClientSecret,
RedirectURL: o.Spec.RedirectURL,
Display: o.Spec.Display,
Scope: o.Spec.Scope,
ClaimsToRoles: o.Spec.ClaimsToRoles,
}
}
|
go
|
func (o *OIDCConnectorV2) V1() *OIDCConnectorV1 {
return &OIDCConnectorV1{
ID: o.Metadata.Name,
IssuerURL: o.Spec.IssuerURL,
ClientID: o.Spec.ClientID,
ClientSecret: o.Spec.ClientSecret,
RedirectURL: o.Spec.RedirectURL,
Display: o.Spec.Display,
Scope: o.Spec.Scope,
ClaimsToRoles: o.Spec.ClaimsToRoles,
}
}
|
[
"func",
"(",
"o",
"*",
"OIDCConnectorV2",
")",
"V1",
"(",
")",
"*",
"OIDCConnectorV1",
"{",
"return",
"&",
"OIDCConnectorV1",
"{",
"ID",
":",
"o",
".",
"Metadata",
".",
"Name",
",",
"IssuerURL",
":",
"o",
".",
"Spec",
".",
"IssuerURL",
",",
"ClientID",
":",
"o",
".",
"Spec",
".",
"ClientID",
",",
"ClientSecret",
":",
"o",
".",
"Spec",
".",
"ClientSecret",
",",
"RedirectURL",
":",
"o",
".",
"Spec",
".",
"RedirectURL",
",",
"Display",
":",
"o",
".",
"Spec",
".",
"Display",
",",
"Scope",
":",
"o",
".",
"Spec",
".",
"Scope",
",",
"ClaimsToRoles",
":",
"o",
".",
"Spec",
".",
"ClaimsToRoles",
",",
"}",
"\n",
"}"
] |
// V1 converts OIDCConnectorV2 to OIDCConnectorV1 format
|
[
"V1",
"converts",
"OIDCConnectorV2",
"to",
"OIDCConnectorV1",
"format"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L272-L283
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
GetClaims
|
func (o *OIDCConnectorV2) GetClaims() []string {
var out []string
for _, mapping := range o.Spec.ClaimsToRoles {
out = append(out, mapping.Claim)
}
return utils.Deduplicate(out)
}
|
go
|
func (o *OIDCConnectorV2) GetClaims() []string {
var out []string
for _, mapping := range o.Spec.ClaimsToRoles {
out = append(out, mapping.Claim)
}
return utils.Deduplicate(out)
}
|
[
"func",
"(",
"o",
"*",
"OIDCConnectorV2",
")",
"GetClaims",
"(",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"mapping",
":=",
"range",
"o",
".",
"Spec",
".",
"ClaimsToRoles",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"mapping",
".",
"Claim",
")",
"\n",
"}",
"\n",
"return",
"utils",
".",
"Deduplicate",
"(",
"out",
")",
"\n",
"}"
] |
// GetClaims returns list of claims expected by mappings
|
[
"GetClaims",
"returns",
"list",
"of",
"claims",
"expected",
"by",
"mappings"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L412-L418
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
MapClaims
|
func (o *OIDCConnectorV2) MapClaims(claims jose.Claims) []string {
var roles []string
for _, mapping := range o.Spec.ClaimsToRoles {
for claimName := range claims {
if claimName != mapping.Claim {
continue
}
var claimValues []string
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
claimValues = []string{claimValue}
} else {
claimValues, _, _ = claims.StringsClaim(claimName)
}
claimLoop:
for _, claimValue := range claimValues {
for _, role := range mapping.Roles {
outRole, err := utils.ReplaceRegexp(mapping.Value, role, claimValue)
switch {
case err != nil:
if trace.IsNotFound(err) {
log.Debugf("Failed to match expression %v, replace with: %v input: %v, err: %v", mapping.Value, role, claimValue, err)
}
// this claim value clearly did not match, move on to another
continue claimLoop
// skip empty replacement or empty role
case outRole == "":
case outRole != "":
roles = append(roles, outRole)
}
}
}
}
}
return utils.Deduplicate(roles)
}
|
go
|
func (o *OIDCConnectorV2) MapClaims(claims jose.Claims) []string {
var roles []string
for _, mapping := range o.Spec.ClaimsToRoles {
for claimName := range claims {
if claimName != mapping.Claim {
continue
}
var claimValues []string
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
claimValues = []string{claimValue}
} else {
claimValues, _, _ = claims.StringsClaim(claimName)
}
claimLoop:
for _, claimValue := range claimValues {
for _, role := range mapping.Roles {
outRole, err := utils.ReplaceRegexp(mapping.Value, role, claimValue)
switch {
case err != nil:
if trace.IsNotFound(err) {
log.Debugf("Failed to match expression %v, replace with: %v input: %v, err: %v", mapping.Value, role, claimValue, err)
}
// this claim value clearly did not match, move on to another
continue claimLoop
// skip empty replacement or empty role
case outRole == "":
case outRole != "":
roles = append(roles, outRole)
}
}
}
}
}
return utils.Deduplicate(roles)
}
|
[
"func",
"(",
"o",
"*",
"OIDCConnectorV2",
")",
"MapClaims",
"(",
"claims",
"jose",
".",
"Claims",
")",
"[",
"]",
"string",
"{",
"var",
"roles",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"mapping",
":=",
"range",
"o",
".",
"Spec",
".",
"ClaimsToRoles",
"{",
"for",
"claimName",
":=",
"range",
"claims",
"{",
"if",
"claimName",
"!=",
"mapping",
".",
"Claim",
"{",
"continue",
"\n",
"}",
"\n",
"var",
"claimValues",
"[",
"]",
"string",
"\n",
"claimValue",
",",
"ok",
",",
"_",
":=",
"claims",
".",
"StringClaim",
"(",
"claimName",
")",
"\n",
"if",
"ok",
"{",
"claimValues",
"=",
"[",
"]",
"string",
"{",
"claimValue",
"}",
"\n",
"}",
"else",
"{",
"claimValues",
",",
"_",
",",
"_",
"=",
"claims",
".",
"StringsClaim",
"(",
"claimName",
")",
"\n",
"}",
"\n",
"claimLoop",
":",
"for",
"_",
",",
"claimValue",
":=",
"range",
"claimValues",
"{",
"for",
"_",
",",
"role",
":=",
"range",
"mapping",
".",
"Roles",
"{",
"outRole",
",",
"err",
":=",
"utils",
".",
"ReplaceRegexp",
"(",
"mapping",
".",
"Value",
",",
"role",
",",
"claimValue",
")",
"\n",
"switch",
"{",
"case",
"err",
"!=",
"nil",
":",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"log",
".",
"Debugf",
"(",
"\"Failed to match expression %v, replace with: %v input: %v, err: %v\"",
",",
"mapping",
".",
"Value",
",",
"role",
",",
"claimValue",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"claimLoop",
"\n",
"case",
"outRole",
"==",
"\"\"",
":",
"case",
"outRole",
"!=",
"\"\"",
":",
"roles",
"=",
"append",
"(",
"roles",
",",
"outRole",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"utils",
".",
"Deduplicate",
"(",
"roles",
")",
"\n",
"}"
] |
// MapClaims maps claims to roles
|
[
"MapClaims",
"maps",
"claims",
"to",
"roles"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L421-L456
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
GetClaimNames
|
func GetClaimNames(claims jose.Claims) []string {
var out []string
for claim := range claims {
out = append(out, claim)
}
return out
}
|
go
|
func GetClaimNames(claims jose.Claims) []string {
var out []string
for claim := range claims {
out = append(out, claim)
}
return out
}
|
[
"func",
"GetClaimNames",
"(",
"claims",
"jose",
".",
"Claims",
")",
"[",
"]",
"string",
"{",
"var",
"out",
"[",
"]",
"string",
"\n",
"for",
"claim",
":=",
"range",
"claims",
"{",
"out",
"=",
"append",
"(",
"out",
",",
"claim",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] |
// GetClaimNames returns a list of claim names from the claim values
|
[
"GetClaimNames",
"returns",
"a",
"list",
"of",
"claim",
"names",
"from",
"the",
"claim",
"values"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L613-L619
|
train
|
gravitational/teleport
|
lib/services/oidc.go
|
V2
|
func (o *OIDCConnectorV1) V2() *OIDCConnectorV2 {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: o.ID,
},
Spec: OIDCConnectorSpecV2{
IssuerURL: o.IssuerURL,
ClientID: o.ClientID,
ClientSecret: o.ClientSecret,
RedirectURL: o.RedirectURL,
Display: o.Display,
Scope: o.Scope,
ClaimsToRoles: o.ClaimsToRoles,
},
}
}
|
go
|
func (o *OIDCConnectorV1) V2() *OIDCConnectorV2 {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: o.ID,
},
Spec: OIDCConnectorSpecV2{
IssuerURL: o.IssuerURL,
ClientID: o.ClientID,
ClientSecret: o.ClientSecret,
RedirectURL: o.RedirectURL,
Display: o.Display,
Scope: o.Scope,
ClaimsToRoles: o.ClaimsToRoles,
},
}
}
|
[
"func",
"(",
"o",
"*",
"OIDCConnectorV1",
")",
"V2",
"(",
")",
"*",
"OIDCConnectorV2",
"{",
"return",
"&",
"OIDCConnectorV2",
"{",
"Kind",
":",
"KindOIDCConnector",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"o",
".",
"ID",
",",
"}",
",",
"Spec",
":",
"OIDCConnectorSpecV2",
"{",
"IssuerURL",
":",
"o",
".",
"IssuerURL",
",",
"ClientID",
":",
"o",
".",
"ClientID",
",",
"ClientSecret",
":",
"o",
".",
"ClientSecret",
",",
"RedirectURL",
":",
"o",
".",
"RedirectURL",
",",
"Display",
":",
"o",
".",
"Display",
",",
"Scope",
":",
"o",
".",
"Scope",
",",
"ClaimsToRoles",
":",
"o",
".",
"ClaimsToRoles",
",",
"}",
",",
"}",
"\n",
"}"
] |
// V2 returns V2 version of the connector
|
[
"V2",
"returns",
"V2",
"version",
"of",
"the",
"connector"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/oidc.go#L682-L699
|
train
|
gravitational/teleport
|
lib/utils/checker.go
|
Authenticate
|
func (c *CertChecker) Authenticate(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
err := validate(key)
if err != nil {
return nil, trace.Wrap(err)
}
perms, err := c.CertChecker.Authenticate(conn, key)
if err != nil {
return nil, trace.Wrap(err)
}
return perms, nil
}
|
go
|
func (c *CertChecker) Authenticate(conn ssh.ConnMetadata, key ssh.PublicKey) (*ssh.Permissions, error) {
err := validate(key)
if err != nil {
return nil, trace.Wrap(err)
}
perms, err := c.CertChecker.Authenticate(conn, key)
if err != nil {
return nil, trace.Wrap(err)
}
return perms, nil
}
|
[
"func",
"(",
"c",
"*",
"CertChecker",
")",
"Authenticate",
"(",
"conn",
"ssh",
".",
"ConnMetadata",
",",
"key",
"ssh",
".",
"PublicKey",
")",
"(",
"*",
"ssh",
".",
"Permissions",
",",
"error",
")",
"{",
"err",
":=",
"validate",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"perms",
",",
"err",
":=",
"c",
".",
"CertChecker",
".",
"Authenticate",
"(",
"conn",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"perms",
",",
"nil",
"\n",
"}"
] |
// Authenticate checks the validity of a user certificate.
// a value for ServerConfig.PublicKeyCallback.
|
[
"Authenticate",
"checks",
"the",
"validity",
"of",
"a",
"user",
"certificate",
".",
"a",
"value",
"for",
"ServerConfig",
".",
"PublicKeyCallback",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L43-L55
|
train
|
gravitational/teleport
|
lib/utils/checker.go
|
CheckCert
|
func (c *CertChecker) CheckCert(principal string, cert *ssh.Certificate) error {
err := validate(cert)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckCert(principal, cert)
}
|
go
|
func (c *CertChecker) CheckCert(principal string, cert *ssh.Certificate) error {
err := validate(cert)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckCert(principal, cert)
}
|
[
"func",
"(",
"c",
"*",
"CertChecker",
")",
"CheckCert",
"(",
"principal",
"string",
",",
"cert",
"*",
"ssh",
".",
"Certificate",
")",
"error",
"{",
"err",
":=",
"validate",
"(",
"cert",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"CertChecker",
".",
"CheckCert",
"(",
"principal",
",",
"cert",
")",
"\n",
"}"
] |
// CheckCert checks certificate metadata and signature.
|
[
"CheckCert",
"checks",
"certificate",
"metadata",
"and",
"signature",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L58-L65
|
train
|
gravitational/teleport
|
lib/utils/checker.go
|
CheckHostKey
|
func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key ssh.PublicKey) error {
err := validate(key)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckHostKey(addr, remote, key)
}
|
go
|
func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key ssh.PublicKey) error {
err := validate(key)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckHostKey(addr, remote, key)
}
|
[
"func",
"(",
"c",
"*",
"CertChecker",
")",
"CheckHostKey",
"(",
"addr",
"string",
",",
"remote",
"net",
".",
"Addr",
",",
"key",
"ssh",
".",
"PublicKey",
")",
"error",
"{",
"err",
":=",
"validate",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"CertChecker",
".",
"CheckHostKey",
"(",
"addr",
",",
"remote",
",",
"key",
")",
"\n",
"}"
] |
// CheckHostKey checks the validity of a host certificate.
|
[
"CheckHostKey",
"checks",
"the",
"validity",
"of",
"a",
"host",
"certificate",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L68-L75
|
train
|
gravitational/teleport
|
lib/utils/checker.go
|
CreateCertificate
|
func CreateCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create RSA key for CA and certificate to be signed by CA.
caKey, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
}
|
go
|
func CreateCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create RSA key for CA and certificate to be signed by CA.
caKey, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
}
|
[
"func",
"CreateCertificate",
"(",
"principal",
"string",
",",
"certType",
"uint32",
")",
"(",
"*",
"ssh",
".",
"Certificate",
",",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"caKey",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"teleport",
".",
"RSAKeySize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"key",
",",
"err",
":=",
"rsa",
".",
"GenerateKey",
"(",
"rand",
".",
"Reader",
",",
"teleport",
".",
"RSAKeySize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"certSigner",
",",
"err",
":=",
"createCertificate",
"(",
"principal",
",",
"certType",
",",
"caKey",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cert",
",",
"certSigner",
",",
"nil",
"\n",
"}"
] |
// CreateCertificate creates a valid 2048-bit RSA certificate.
|
[
"CreateCertificate",
"creates",
"a",
"valid",
"2048",
"-",
"bit",
"RSA",
"certificate",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L111-L128
|
train
|
gravitational/teleport
|
lib/utils/checker.go
|
CreateEllipticCertificate
|
func CreateEllipticCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create ECDSA key for CA and certificate to be signed by CA.
caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
}
|
go
|
func CreateEllipticCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create ECDSA key for CA and certificate to be signed by CA.
caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
cert, certSigner, err := createCertificate(principal, certType, caKey, key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
}
|
[
"func",
"CreateEllipticCertificate",
"(",
"principal",
"string",
",",
"certType",
"uint32",
")",
"(",
"*",
"ssh",
".",
"Certificate",
",",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"caKey",
",",
"err",
":=",
"ecdsa",
".",
"GenerateKey",
"(",
"elliptic",
".",
"P256",
"(",
")",
",",
"rand",
".",
"Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"key",
",",
"err",
":=",
"ecdsa",
".",
"GenerateKey",
"(",
"elliptic",
".",
"P256",
"(",
")",
",",
"rand",
".",
"Reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
",",
"certSigner",
",",
"err",
":=",
"createCertificate",
"(",
"principal",
",",
"certType",
",",
"caKey",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cert",
",",
"certSigner",
",",
"nil",
"\n",
"}"
] |
// CreateEllipticCertificate creates a valid, but not supported, ECDSA
// SSH certificate. This certificate is used to make sure Teleport rejects
// such certificates.
|
[
"CreateEllipticCertificate",
"creates",
"a",
"valid",
"but",
"not",
"supported",
"ECDSA",
"SSH",
"certificate",
".",
"This",
"certificate",
"is",
"used",
"to",
"make",
"sure",
"Teleport",
"rejects",
"such",
"certificates",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L133-L150
|
train
|
gravitational/teleport
|
lib/utils/checker.go
|
createCertificate
|
func createCertificate(principal string, certType uint32, caKey crypto.Signer, key crypto.Signer) (*ssh.Certificate, ssh.Signer, error) {
// Create CA.
caPublicKey, err := ssh.NewPublicKey(caKey.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
caSigner, err := ssh.NewSignerFromKey(caKey)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create key.
publicKey, err := ssh.NewPublicKey(key.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
keySigner, err := ssh.NewSignerFromKey(key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create certificate and signer.
cert := &ssh.Certificate{
KeyId: principal,
ValidPrincipals: []string{principal},
Key: publicKey,
SignatureKey: caPublicKey,
ValidAfter: uint64(time.Now().UTC().Add(-1 * time.Minute).Unix()),
ValidBefore: uint64(time.Now().UTC().Add(1 * time.Minute).Unix()),
CertType: certType,
}
err = cert.SignCert(rand.Reader, caSigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
certSigner, err := ssh.NewCertSigner(cert, keySigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
}
|
go
|
func createCertificate(principal string, certType uint32, caKey crypto.Signer, key crypto.Signer) (*ssh.Certificate, ssh.Signer, error) {
// Create CA.
caPublicKey, err := ssh.NewPublicKey(caKey.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
caSigner, err := ssh.NewSignerFromKey(caKey)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create key.
publicKey, err := ssh.NewPublicKey(key.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
keySigner, err := ssh.NewSignerFromKey(key)
if err != nil {
return nil, nil, trace.Wrap(err)
}
// Create certificate and signer.
cert := &ssh.Certificate{
KeyId: principal,
ValidPrincipals: []string{principal},
Key: publicKey,
SignatureKey: caPublicKey,
ValidAfter: uint64(time.Now().UTC().Add(-1 * time.Minute).Unix()),
ValidBefore: uint64(time.Now().UTC().Add(1 * time.Minute).Unix()),
CertType: certType,
}
err = cert.SignCert(rand.Reader, caSigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
certSigner, err := ssh.NewCertSigner(cert, keySigner)
if err != nil {
return nil, nil, trace.Wrap(err)
}
return cert, certSigner, nil
}
|
[
"func",
"createCertificate",
"(",
"principal",
"string",
",",
"certType",
"uint32",
",",
"caKey",
"crypto",
".",
"Signer",
",",
"key",
"crypto",
".",
"Signer",
")",
"(",
"*",
"ssh",
".",
"Certificate",
",",
"ssh",
".",
"Signer",
",",
"error",
")",
"{",
"caPublicKey",
",",
"err",
":=",
"ssh",
".",
"NewPublicKey",
"(",
"caKey",
".",
"Public",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"caSigner",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"caKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"publicKey",
",",
"err",
":=",
"ssh",
".",
"NewPublicKey",
"(",
"key",
".",
"Public",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"keySigner",
",",
"err",
":=",
"ssh",
".",
"NewSignerFromKey",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cert",
":=",
"&",
"ssh",
".",
"Certificate",
"{",
"KeyId",
":",
"principal",
",",
"ValidPrincipals",
":",
"[",
"]",
"string",
"{",
"principal",
"}",
",",
"Key",
":",
"publicKey",
",",
"SignatureKey",
":",
"caPublicKey",
",",
"ValidAfter",
":",
"uint64",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"-",
"1",
"*",
"time",
".",
"Minute",
")",
".",
"Unix",
"(",
")",
")",
",",
"ValidBefore",
":",
"uint64",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Add",
"(",
"1",
"*",
"time",
".",
"Minute",
")",
".",
"Unix",
"(",
")",
")",
",",
"CertType",
":",
"certType",
",",
"}",
"\n",
"err",
"=",
"cert",
".",
"SignCert",
"(",
"rand",
".",
"Reader",
",",
"caSigner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"certSigner",
",",
"err",
":=",
"ssh",
".",
"NewCertSigner",
"(",
"cert",
",",
"keySigner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"cert",
",",
"certSigner",
",",
"nil",
"\n",
"}"
] |
// createCertificate creates a SSH certificate for the given key signed by the
// given CA key. This function exists here to allow easy key generation for
// some of the more core packages like "sshutils".
|
[
"createCertificate",
"creates",
"a",
"SSH",
"certificate",
"for",
"the",
"given",
"key",
"signed",
"by",
"the",
"given",
"CA",
"key",
".",
"This",
"function",
"exists",
"here",
"to",
"allow",
"easy",
"key",
"generation",
"for",
"some",
"of",
"the",
"more",
"core",
"packages",
"like",
"sshutils",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/checker.go#L155-L196
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
upsertServer
|
func (s *APIServer) upsertServer(auth ClientI, role teleport.Role, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertServerRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
var kind string
switch role {
case teleport.RoleNode:
kind = services.KindNode
case teleport.RoleAuth:
kind = services.KindAuthServer
case teleport.RoleProxy:
kind = services.KindProxy
}
server, err := services.GetServerMarshaler().UnmarshalServer(req.Server, kind)
if err != nil {
return nil, trace.Wrap(err)
}
// if server sent "local" IP address to us, replace the ip/host part with the remote address we see
// on the socket, but keep the original port:
server.SetAddr(utils.ReplaceLocalhost(server.GetAddr(), r.RemoteAddr))
if req.TTL != 0 {
server.SetTTL(s, req.TTL)
}
switch role {
case teleport.RoleNode:
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
server.SetNamespace(namespace)
handle, err := auth.UpsertNode(server)
if err != nil {
return nil, trace.Wrap(err)
}
return handle, nil
case teleport.RoleAuth:
if err := auth.UpsertAuthServer(server); err != nil {
return nil, trace.Wrap(err)
}
case teleport.RoleProxy:
if err := auth.UpsertProxy(server); err != nil {
return nil, trace.Wrap(err)
}
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) upsertServer(auth ClientI, role teleport.Role, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertServerRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
var kind string
switch role {
case teleport.RoleNode:
kind = services.KindNode
case teleport.RoleAuth:
kind = services.KindAuthServer
case teleport.RoleProxy:
kind = services.KindProxy
}
server, err := services.GetServerMarshaler().UnmarshalServer(req.Server, kind)
if err != nil {
return nil, trace.Wrap(err)
}
// if server sent "local" IP address to us, replace the ip/host part with the remote address we see
// on the socket, but keep the original port:
server.SetAddr(utils.ReplaceLocalhost(server.GetAddr(), r.RemoteAddr))
if req.TTL != 0 {
server.SetTTL(s, req.TTL)
}
switch role {
case teleport.RoleNode:
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
server.SetNamespace(namespace)
handle, err := auth.UpsertNode(server)
if err != nil {
return nil, trace.Wrap(err)
}
return handle, nil
case teleport.RoleAuth:
if err := auth.UpsertAuthServer(server); err != nil {
return nil, trace.Wrap(err)
}
case teleport.RoleProxy:
if err := auth.UpsertProxy(server); err != nil {
return nil, trace.Wrap(err)
}
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertServer",
"(",
"auth",
"ClientI",
",",
"role",
"teleport",
".",
"Role",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertServerRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"kind",
"string",
"\n",
"switch",
"role",
"{",
"case",
"teleport",
".",
"RoleNode",
":",
"kind",
"=",
"services",
".",
"KindNode",
"\n",
"case",
"teleport",
".",
"RoleAuth",
":",
"kind",
"=",
"services",
".",
"KindAuthServer",
"\n",
"case",
"teleport",
".",
"RoleProxy",
":",
"kind",
"=",
"services",
".",
"KindProxy",
"\n",
"}",
"\n",
"server",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServer",
"(",
"req",
".",
"Server",
",",
"kind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"server",
".",
"SetAddr",
"(",
"utils",
".",
"ReplaceLocalhost",
"(",
"server",
".",
"GetAddr",
"(",
")",
",",
"r",
".",
"RemoteAddr",
")",
")",
"\n",
"if",
"req",
".",
"TTL",
"!=",
"0",
"{",
"server",
".",
"SetTTL",
"(",
"s",
",",
"req",
".",
"TTL",
")",
"\n",
"}",
"\n",
"switch",
"role",
"{",
"case",
"teleport",
".",
"RoleNode",
":",
"namespace",
":=",
"p",
".",
"ByName",
"(",
"\"namespace\"",
")",
"\n",
"if",
"!",
"services",
".",
"IsValidNamespace",
"(",
"namespace",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid namespace %q\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"server",
".",
"SetNamespace",
"(",
"namespace",
")",
"\n",
"handle",
",",
"err",
":=",
"auth",
".",
"UpsertNode",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"handle",
",",
"nil",
"\n",
"case",
"teleport",
".",
"RoleAuth",
":",
"if",
"err",
":=",
"auth",
".",
"UpsertAuthServer",
"(",
"server",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"case",
"teleport",
".",
"RoleProxy",
":",
"if",
"err",
":=",
"auth",
".",
"UpsertProxy",
"(",
"server",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// upsertServer is a common utility function
|
[
"upsertServer",
"is",
"a",
"common",
"utility",
"function"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L279-L325
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
keepAliveNode
|
func (s *APIServer) keepAliveNode(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var handle services.KeepAlive
if err := httplib.ReadJSON(r, &handle); err != nil {
return nil, trace.Wrap(err)
}
if err := auth.KeepAliveNode(r.Context(), handle); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) keepAliveNode(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var handle services.KeepAlive
if err := httplib.ReadJSON(r, &handle); err != nil {
return nil, trace.Wrap(err)
}
if err := auth.KeepAliveNode(r.Context(), handle); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"keepAliveNode",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"handle",
"services",
".",
"KeepAlive",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"KeepAliveNode",
"(",
"r",
".",
"Context",
"(",
")",
",",
"handle",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// keepAliveNode updates node TTL in the backend
|
[
"keepAliveNode",
"updates",
"node",
"TTL",
"in",
"the",
"backend"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L328-L337
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
upsertNodes
|
func (s *APIServer) upsertNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertNodesReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
if !services.IsValidNamespace(req.Namespace) {
return nil, trace.BadParameter("invalid namespace %q", req.Namespace)
}
nodes, err := services.GetServerMarshaler().UnmarshalServers(req.Nodes)
if err != nil {
return nil, trace.Wrap(err)
}
err = auth.UpsertNodes(req.Namespace, nodes)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) upsertNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertNodesReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
if !services.IsValidNamespace(req.Namespace) {
return nil, trace.BadParameter("invalid namespace %q", req.Namespace)
}
nodes, err := services.GetServerMarshaler().UnmarshalServers(req.Nodes)
if err != nil {
return nil, trace.Wrap(err)
}
err = auth.UpsertNodes(req.Namespace, nodes)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertNodes",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertNodesReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"!",
"services",
".",
"IsValidNamespace",
"(",
"req",
".",
"Namespace",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid namespace %q\"",
",",
"req",
".",
"Namespace",
")",
"\n",
"}",
"\n",
"nodes",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServers",
"(",
"req",
".",
"Nodes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"auth",
".",
"UpsertNodes",
"(",
"req",
".",
"Namespace",
",",
"nodes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// upsertNodes is used to bulk insert nodes into the backend.
|
[
"upsertNodes",
"is",
"used",
"to",
"bulk",
"insert",
"nodes",
"into",
"the",
"backend",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L345-L365
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getNodes
|
func (s *APIServer) getNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
skipValidation, _, err := httplib.ParseBool(r.URL.Query(), "skip_validation")
if err != nil {
return nil, trace.Wrap(err)
}
var opts []services.MarshalOption
if skipValidation {
opts = append(opts, services.SkipValidation())
}
servers, err := auth.GetNodes(namespace, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
}
|
go
|
func (s *APIServer) getNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
skipValidation, _, err := httplib.ParseBool(r.URL.Query(), "skip_validation")
if err != nil {
return nil, trace.Wrap(err)
}
var opts []services.MarshalOption
if skipValidation {
opts = append(opts, services.SkipValidation())
}
servers, err := auth.GetNodes(namespace, opts...)
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getNodes",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"namespace",
":=",
"p",
".",
"ByName",
"(",
"\"namespace\"",
")",
"\n",
"if",
"!",
"services",
".",
"IsValidNamespace",
"(",
"namespace",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"invalid namespace %q\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"skipValidation",
",",
"_",
",",
"err",
":=",
"httplib",
".",
"ParseBool",
"(",
"r",
".",
"URL",
".",
"Query",
"(",
")",
",",
"\"skip_validation\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"var",
"opts",
"[",
"]",
"services",
".",
"MarshalOption",
"\n",
"if",
"skipValidation",
"{",
"opts",
"=",
"append",
"(",
"opts",
",",
"services",
".",
"SkipValidation",
"(",
")",
")",
"\n",
"}",
"\n",
"servers",
",",
"err",
":=",
"auth",
".",
"GetNodes",
"(",
"namespace",
",",
"opts",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"marshalServers",
"(",
"servers",
",",
"version",
")",
"\n",
"}"
] |
// getNodes returns registered SSH nodes
|
[
"getNodes",
"returns",
"registered",
"SSH",
"nodes"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L373-L392
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
deleteProxy
|
func (s *APIServer) deleteProxy(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
name := p.ByName("name")
if name == "" {
return nil, trace.BadParameter("missing proxy name")
}
err := auth.DeleteProxy(name)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) deleteProxy(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
name := p.ByName("name")
if name == "" {
return nil, trace.BadParameter("missing proxy name")
}
err := auth.DeleteProxy(name)
if err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"deleteProxy",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"name",
":=",
"p",
".",
"ByName",
"(",
"\"name\"",
")",
"\n",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing proxy name\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"auth",
".",
"DeleteProxy",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// deleteProxy deletes proxy
|
[
"deleteProxy",
"deletes",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L448-L458
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
upsertAuthServer
|
func (s *APIServer) upsertAuthServer(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
return s.upsertServer(auth, teleport.RoleAuth, w, r, p, version)
}
|
go
|
func (s *APIServer) upsertAuthServer(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
return s.upsertServer(auth, teleport.RoleAuth, w, r, p, version)
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertAuthServer",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"s",
".",
"upsertServer",
"(",
"auth",
",",
"teleport",
".",
"RoleAuth",
",",
"w",
",",
"r",
",",
"p",
",",
"version",
")",
"\n",
"}"
] |
// upsertAuthServer is called by remote Auth servers when they ping back into the auth service
|
[
"upsertAuthServer",
"is",
"called",
"by",
"remote",
"Auth",
"servers",
"when",
"they",
"ping",
"back",
"into",
"the",
"auth",
"service"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L461-L463
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getAuthServers
|
func (s *APIServer) getAuthServers(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
servers, err := auth.GetAuthServers()
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
}
|
go
|
func (s *APIServer) getAuthServers(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
servers, err := auth.GetAuthServers()
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getAuthServers",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"servers",
",",
"err",
":=",
"auth",
".",
"GetAuthServers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"marshalServers",
"(",
"servers",
",",
"version",
")",
"\n",
"}"
] |
// getAuthServers returns registered auth servers
|
[
"getAuthServers",
"returns",
"registered",
"auth",
"servers"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L466-L472
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
upsertReverseTunnel
|
func (s *APIServer) upsertReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertReverseTunnelRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
tun, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(req.ReverseTunnel)
if err != nil {
return nil, trace.Wrap(err)
}
if req.TTL != 0 {
tun.SetTTL(s, req.TTL)
}
if err := auth.UpsertReverseTunnel(tun); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) upsertReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertReverseTunnelRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
tun, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(req.ReverseTunnel)
if err != nil {
return nil, trace.Wrap(err)
}
if req.TTL != 0 {
tun.SetTTL(s, req.TTL)
}
if err := auth.UpsertReverseTunnel(tun); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertReverseTunnel",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertReverseTunnelRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"tun",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"UnmarshalReverseTunnel",
"(",
"req",
".",
"ReverseTunnel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"req",
".",
"TTL",
"!=",
"0",
"{",
"tun",
".",
"SetTTL",
"(",
"s",
",",
"req",
".",
"TTL",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"UpsertReverseTunnel",
"(",
"tun",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// upsertReverseTunnel is called by admin to create a reverse tunnel to remote proxy
|
[
"upsertReverseTunnel",
"is",
"called",
"by",
"admin",
"to",
"create",
"a",
"reverse",
"tunnel",
"to",
"remote",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L492-L508
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getReverseTunnels
|
func (s *APIServer) getReverseTunnels(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
reverseTunnels, err := auth.GetReverseTunnels()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(reverseTunnels))
for i, tunnel := range reverseTunnels {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
}
|
go
|
func (s *APIServer) getReverseTunnels(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
reverseTunnels, err := auth.GetReverseTunnels()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(reverseTunnels))
for i, tunnel := range reverseTunnels {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getReverseTunnels",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"reverseTunnels",
",",
"err",
":=",
"auth",
".",
"GetReverseTunnels",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"json",
".",
"RawMessage",
",",
"len",
"(",
"reverseTunnels",
")",
")",
"\n",
"for",
"i",
",",
"tunnel",
":=",
"range",
"reverseTunnels",
"{",
"data",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"MarshalReverseTunnel",
"(",
"tunnel",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"data",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] |
// getReverseTunnels returns a list of reverse tunnels
|
[
"getReverseTunnels",
"returns",
"a",
"list",
"of",
"reverse",
"tunnels"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L511-L525
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
deleteReverseTunnel
|
func (s *APIServer) deleteReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
domainName := p.ByName("domain")
err := auth.DeleteReverseTunnel(domainName)
if err != nil {
return nil, trace.Wrap(err)
}
return message(fmt.Sprintf("reverse tunnel %v deleted", domainName)), nil
}
|
go
|
func (s *APIServer) deleteReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
domainName := p.ByName("domain")
err := auth.DeleteReverseTunnel(domainName)
if err != nil {
return nil, trace.Wrap(err)
}
return message(fmt.Sprintf("reverse tunnel %v deleted", domainName)), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"deleteReverseTunnel",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"domainName",
":=",
"p",
".",
"ByName",
"(",
"\"domain\"",
")",
"\n",
"err",
":=",
"auth",
".",
"DeleteReverseTunnel",
"(",
"domainName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"reverse tunnel %v deleted\"",
",",
"domainName",
")",
")",
",",
"nil",
"\n",
"}"
] |
// deleteReverseTunnel deletes reverse tunnel
|
[
"deleteReverseTunnel",
"deletes",
"reverse",
"tunnel"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L528-L535
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getClusterCACert
|
func (s *APIServer) getClusterCACert(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
localCA, err := auth.GetClusterCACert()
if err != nil {
return nil, trace.Wrap(err)
}
return localCA, nil
}
|
go
|
func (s *APIServer) getClusterCACert(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
localCA, err := auth.GetClusterCACert()
if err != nil {
return nil, trace.Wrap(err)
}
return localCA, nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getClusterCACert",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"localCA",
",",
"err",
":=",
"auth",
".",
"GetClusterCACert",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"localCA",
",",
"nil",
"\n",
"}"
] |
// getClusterCACert returns the CAs for the local cluster without signing keys.
|
[
"getClusterCACert",
"returns",
"the",
"CAs",
"for",
"the",
"local",
"cluster",
"without",
"signing",
"keys",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L1075-L1082
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getU2FAppID
|
func (s *APIServer) getU2FAppID(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cap, err := auth.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
universalSecondFactor, err := cap.GetU2F()
if err != nil {
return nil, trace.Wrap(err)
}
w.Header().Set("Content-Type", "application/fido.trusted-apps+json")
return universalSecondFactor.AppID, nil
}
|
go
|
func (s *APIServer) getU2FAppID(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cap, err := auth.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
universalSecondFactor, err := cap.GetU2F()
if err != nil {
return nil, trace.Wrap(err)
}
w.Header().Set("Content-Type", "application/fido.trusted-apps+json")
return universalSecondFactor.AppID, nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getU2FAppID",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cap",
",",
"err",
":=",
"auth",
".",
"GetAuthPreference",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"universalSecondFactor",
",",
"err",
":=",
"cap",
".",
"GetU2F",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"\"application/fido.trusted-apps+json\"",
")",
"\n",
"return",
"universalSecondFactor",
".",
"AppID",
",",
"nil",
"\n",
"}"
] |
// getU2FAppID returns the U2F AppID in the auth configuration
|
[
"getU2FAppID",
"returns",
"the",
"U2F",
"AppID",
"in",
"the",
"auth",
"configuration"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L1085-L1098
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getSignupTokenData
|
func (s *APIServer) getSignupTokenData(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
token := p.ByName("token")
user, otpQRCode, err := auth.GetSignupTokenData(token)
if err != nil {
return nil, trace.Wrap(err)
}
return &getSignupTokenDataResponse{
User: user,
QRImg: otpQRCode,
}, nil
}
|
go
|
func (s *APIServer) getSignupTokenData(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
token := p.ByName("token")
user, otpQRCode, err := auth.GetSignupTokenData(token)
if err != nil {
return nil, trace.Wrap(err)
}
return &getSignupTokenDataResponse{
User: user,
QRImg: otpQRCode,
}, nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getSignupTokenData",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"token",
":=",
"p",
".",
"ByName",
"(",
"\"token\"",
")",
"\n",
"user",
",",
"otpQRCode",
",",
"err",
":=",
"auth",
".",
"GetSignupTokenData",
"(",
"token",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"getSignupTokenDataResponse",
"{",
"User",
":",
"user",
",",
"QRImg",
":",
"otpQRCode",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// getSignupTokenData returns the signup data for a token.
|
[
"getSignupTokenData",
"returns",
"the",
"signup",
"data",
"for",
"a",
"token",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L1185-L1197
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
upsertTunnelConnection
|
func (s *APIServer) upsertTunnelConnection(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertTunnelConnectionRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(req.TunnelConnection)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.UpsertTunnelConnection(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) upsertTunnelConnection(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertTunnelConnectionRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelConnection(req.TunnelConnection)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.UpsertTunnelConnection(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"upsertTunnelConnection",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"upsertTunnelConnectionRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalTunnelConnection",
"(",
"req",
".",
"TunnelConnection",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"UpsertTunnelConnection",
"(",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// upsertTunnelConnection updates or inserts tunnel connection
|
[
"upsertTunnelConnection",
"updates",
"or",
"inserts",
"tunnel",
"connection"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2259-L2272
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getTunnelConnections
|
func (s *APIServer) getTunnelConnections(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
conns, err := auth.GetTunnelConnections(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(conns))
for i, conn := range conns {
data, err := services.MarshalTunnelConnection(conn, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
}
|
go
|
func (s *APIServer) getTunnelConnections(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
conns, err := auth.GetTunnelConnections(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(conns))
for i, conn := range conns {
data, err := services.MarshalTunnelConnection(conn, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getTunnelConnections",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"conns",
",",
"err",
":=",
"auth",
".",
"GetTunnelConnections",
"(",
"p",
".",
"ByName",
"(",
"\"cluster\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"json",
".",
"RawMessage",
",",
"len",
"(",
"conns",
")",
")",
"\n",
"for",
"i",
",",
"conn",
":=",
"range",
"conns",
"{",
"data",
",",
"err",
":=",
"services",
".",
"MarshalTunnelConnection",
"(",
"conn",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"data",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] |
// getTunnelConnections returns a list of tunnel connections from a cluster
|
[
"getTunnelConnections",
"returns",
"a",
"list",
"of",
"tunnel",
"connections",
"from",
"a",
"cluster"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2275-L2289
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
createRemoteCluster
|
func (s *APIServer) createRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req createRemoteClusterRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalRemoteCluster(req.RemoteCluster)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.CreateRemoteCluster(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
go
|
func (s *APIServer) createRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req createRemoteClusterRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalRemoteCluster(req.RemoteCluster)
if err != nil {
return nil, trace.Wrap(err)
}
if err := auth.CreateRemoteCluster(conn); err != nil {
return nil, trace.Wrap(err)
}
return message("ok"), nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"createRemoteCluster",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"req",
"createRemoteClusterRawReq",
"\n",
"if",
"err",
":=",
"httplib",
".",
"ReadJSON",
"(",
"r",
",",
"&",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"services",
".",
"UnmarshalRemoteCluster",
"(",
"req",
".",
"RemoteCluster",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"auth",
".",
"CreateRemoteCluster",
"(",
"conn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"message",
"(",
"\"ok\"",
")",
",",
"nil",
"\n",
"}"
] |
// createRemoteCluster creates remote cluster
|
[
"createRemoteCluster",
"creates",
"remote",
"cluster"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2341-L2354
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getRemoteClusters
|
func (s *APIServer) getRemoteClusters(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
clusters, err := auth.GetRemoteClusters()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(clusters))
for i, cluster := range clusters {
data, err := services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
}
|
go
|
func (s *APIServer) getRemoteClusters(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
clusters, err := auth.GetRemoteClusters()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(clusters))
for i, cluster := range clusters {
data, err := services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID())
if err != nil {
return nil, trace.Wrap(err)
}
items[i] = data
}
return items, nil
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getRemoteClusters",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"clusters",
",",
"err",
":=",
"auth",
".",
"GetRemoteClusters",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"json",
".",
"RawMessage",
",",
"len",
"(",
"clusters",
")",
")",
"\n",
"for",
"i",
",",
"cluster",
":=",
"range",
"clusters",
"{",
"data",
",",
"err",
":=",
"services",
".",
"MarshalRemoteCluster",
"(",
"cluster",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"data",
"\n",
"}",
"\n",
"return",
"items",
",",
"nil",
"\n",
"}"
] |
// getRemoteClusters returns a list of remote clusters
|
[
"getRemoteClusters",
"returns",
"a",
"list",
"of",
"remote",
"clusters"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2357-L2371
|
train
|
gravitational/teleport
|
lib/auth/apiserver.go
|
getRemoteCluster
|
func (s *APIServer) getRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cluster, err := auth.GetRemoteCluster(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
return rawMessage(services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID()))
}
|
go
|
func (s *APIServer) getRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cluster, err := auth.GetRemoteCluster(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
return rawMessage(services.MarshalRemoteCluster(cluster, services.WithVersion(version), services.PreserveResourceID()))
}
|
[
"func",
"(",
"s",
"*",
"APIServer",
")",
"getRemoteCluster",
"(",
"auth",
"ClientI",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"p",
"httprouter",
".",
"Params",
",",
"version",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cluster",
",",
"err",
":=",
"auth",
".",
"GetRemoteCluster",
"(",
"p",
".",
"ByName",
"(",
"\"cluster\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"rawMessage",
"(",
"services",
".",
"MarshalRemoteCluster",
"(",
"cluster",
",",
"services",
".",
"WithVersion",
"(",
"version",
")",
",",
"services",
".",
"PreserveResourceID",
"(",
")",
")",
")",
"\n",
"}"
] |
// getRemoteCluster returns a remote cluster by name
|
[
"getRemoteCluster",
"returns",
"a",
"remote",
"cluster",
"by",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/apiserver.go#L2374-L2380
|
train
|
gravitational/teleport
|
lib/auth/saml.go
|
buildSAMLRoles
|
func (a *AuthServer) buildSAMLRoles(connector services.SAMLConnector, assertionInfo saml2.AssertionInfo) ([]string, error) {
roles := connector.MapAttributes(assertionInfo)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map attributes to role for connector: %v", connector.GetName())
}
return roles, nil
}
|
go
|
func (a *AuthServer) buildSAMLRoles(connector services.SAMLConnector, assertionInfo saml2.AssertionInfo) ([]string, error) {
roles := connector.MapAttributes(assertionInfo)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map attributes to role for connector: %v", connector.GetName())
}
return roles, nil
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"buildSAMLRoles",
"(",
"connector",
"services",
".",
"SAMLConnector",
",",
"assertionInfo",
"saml2",
".",
"AssertionInfo",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"roles",
":=",
"connector",
".",
"MapAttributes",
"(",
"assertionInfo",
")",
"\n",
"if",
"len",
"(",
"roles",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"unable to map attributes to role for connector: %v\"",
",",
"connector",
".",
"GetName",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"roles",
",",
"nil",
"\n",
"}"
] |
// buildSAMLRoles takes a connector and claims and returns a slice of roles.
|
[
"buildSAMLRoles",
"takes",
"a",
"connector",
"and",
"claims",
"and",
"returns",
"a",
"slice",
"of",
"roles",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/saml.go#L98-L105
|
train
|
gravitational/teleport
|
lib/auth/saml.go
|
assertionsToTraitMap
|
func assertionsToTraitMap(assertionInfo saml2.AssertionInfo) map[string][]string {
traits := make(map[string][]string)
for _, assr := range assertionInfo.Values {
var vals []string
for _, value := range assr.Values {
vals = append(vals, value.Value)
}
traits[assr.Name] = vals
}
return traits
}
|
go
|
func assertionsToTraitMap(assertionInfo saml2.AssertionInfo) map[string][]string {
traits := make(map[string][]string)
for _, assr := range assertionInfo.Values {
var vals []string
for _, value := range assr.Values {
vals = append(vals, value.Value)
}
traits[assr.Name] = vals
}
return traits
}
|
[
"func",
"assertionsToTraitMap",
"(",
"assertionInfo",
"saml2",
".",
"AssertionInfo",
")",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"traits",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
")",
"\n",
"for",
"_",
",",
"assr",
":=",
"range",
"assertionInfo",
".",
"Values",
"{",
"var",
"vals",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"assr",
".",
"Values",
"{",
"vals",
"=",
"append",
"(",
"vals",
",",
"value",
".",
"Value",
")",
"\n",
"}",
"\n",
"traits",
"[",
"assr",
".",
"Name",
"]",
"=",
"vals",
"\n",
"}",
"\n",
"return",
"traits",
"\n",
"}"
] |
// assertionsToTraitMap extracts all string assertions and creates a map of traits
// that can be used to populate role variables.
|
[
"assertionsToTraitMap",
"extracts",
"all",
"string",
"assertions",
"and",
"creates",
"a",
"map",
"of",
"traits",
"that",
"can",
"be",
"used",
"to",
"populate",
"role",
"variables",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/saml.go#L109-L121
|
train
|
gravitational/teleport
|
lib/auth/saml.go
|
ValidateSAMLResponse
|
func (a *AuthServer) ValidateSAMLResponse(samlResponse string) (*SAMLAuthResponse, error) {
re, err := a.validateSAMLResponse(samlResponse)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodSAML,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodSAML,
})
}
return re, err
}
|
go
|
func (a *AuthServer) ValidateSAMLResponse(samlResponse string) (*SAMLAuthResponse, error) {
re, err := a.validateSAMLResponse(samlResponse)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodSAML,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
a.EmitAuditEvent(events.UserSSOLogin, events.EventFields{
events.EventUser: re.Username,
events.AuthAttemptSuccess: true,
events.LoginMethod: events.LoginMethodSAML,
})
}
return re, err
}
|
[
"func",
"(",
"a",
"*",
"AuthServer",
")",
"ValidateSAMLResponse",
"(",
"samlResponse",
"string",
")",
"(",
"*",
"SAMLAuthResponse",
",",
"error",
")",
"{",
"re",
",",
"err",
":=",
"a",
".",
"validateSAMLResponse",
"(",
"samlResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodSAML",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"false",
",",
"events",
".",
"AuthAttemptErr",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"a",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserSSOLogin",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"re",
".",
"Username",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"true",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodSAML",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"re",
",",
"err",
"\n",
"}"
] |
// ValidateSAMLResponse consumes attribute statements from SAML identity provider
|
[
"ValidateSAMLResponse",
"consumes",
"attribute",
"statements",
"from",
"SAML",
"identity",
"provider"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/saml.go#L278-L294
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
ForAuth
|
func ForAuth(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: true},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindStaticTokens},
{Kind: services.KindToken},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.AuthQueueSize
return cfg
}
|
go
|
func ForAuth(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: true},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindStaticTokens},
{Kind: services.KindToken},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.AuthQueueSize
return cfg
}
|
[
"func",
"ForAuth",
"(",
"cfg",
"Config",
")",
"Config",
"{",
"cfg",
".",
"Watches",
"=",
"[",
"]",
"services",
".",
"WatchKind",
"{",
"{",
"Kind",
":",
"services",
".",
"KindCertAuthority",
",",
"LoadSecrets",
":",
"true",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindStaticTokens",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindToken",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindUser",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindRole",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNamespace",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNode",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindProxy",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindReverseTunnel",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindTunnelConnection",
"}",
",",
"}",
"\n",
"cfg",
".",
"QueueSize",
"=",
"defaults",
".",
"AuthQueueSize",
"\n",
"return",
"cfg",
"\n",
"}"
] |
// ForAuth sets up watch configuration for the auth server
|
[
"ForAuth",
"sets",
"up",
"watch",
"configuration",
"for",
"the",
"auth",
"server"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L37-L54
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
ForProxy
|
func ForProxy(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindAuthServer},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.ProxyQueueSize
return cfg
}
|
go
|
func ForProxy(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNode},
{Kind: services.KindProxy},
{Kind: services.KindAuthServer},
{Kind: services.KindReverseTunnel},
{Kind: services.KindTunnelConnection},
}
cfg.QueueSize = defaults.ProxyQueueSize
return cfg
}
|
[
"func",
"ForProxy",
"(",
"cfg",
"Config",
")",
"Config",
"{",
"cfg",
".",
"Watches",
"=",
"[",
"]",
"services",
".",
"WatchKind",
"{",
"{",
"Kind",
":",
"services",
".",
"KindCertAuthority",
",",
"LoadSecrets",
":",
"false",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindUser",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindRole",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNamespace",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNode",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindProxy",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindAuthServer",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindReverseTunnel",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindTunnelConnection",
"}",
",",
"}",
"\n",
"cfg",
".",
"QueueSize",
"=",
"defaults",
".",
"ProxyQueueSize",
"\n",
"return",
"cfg",
"\n",
"}"
] |
// ForProxy sets up watch configuration for proxy
|
[
"ForProxy",
"sets",
"up",
"watch",
"configuration",
"for",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L57-L73
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
ForNode
|
func ForNode(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
// Node only needs to "know" about default
// namespace events to avoid matching too much
// data about other namespaces or node events
{Kind: services.KindNamespace, Name: defaults.Namespace},
}
cfg.QueueSize = defaults.NodeQueueSize
return cfg
}
|
go
|
func ForNode(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
// Node only needs to "know" about default
// namespace events to avoid matching too much
// data about other namespaces or node events
{Kind: services.KindNamespace, Name: defaults.Namespace},
}
cfg.QueueSize = defaults.NodeQueueSize
return cfg
}
|
[
"func",
"ForNode",
"(",
"cfg",
"Config",
")",
"Config",
"{",
"cfg",
".",
"Watches",
"=",
"[",
"]",
"services",
".",
"WatchKind",
"{",
"{",
"Kind",
":",
"services",
".",
"KindCertAuthority",
",",
"LoadSecrets",
":",
"false",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindUser",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindRole",
"}",
",",
"{",
"Kind",
":",
"services",
".",
"KindNamespace",
",",
"Name",
":",
"defaults",
".",
"Namespace",
"}",
",",
"}",
"\n",
"cfg",
".",
"QueueSize",
"=",
"defaults",
".",
"NodeQueueSize",
"\n",
"return",
"cfg",
"\n",
"}"
] |
// ForNode sets up watch configuration for node
|
[
"ForNode",
"sets",
"up",
"watch",
"configuration",
"for",
"node"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L76-L90
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
New
|
func New(config Config) (*Cache, error) {
if err := config.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
wrapper := backend.NewWrapper(config.Backend)
ctx, cancel := context.WithCancel(config.Context)
cs := &Cache{
wrapper: wrapper,
ctx: ctx,
cancel: cancel,
Config: config,
trustCache: local.NewCAService(wrapper),
clusterConfigCache: local.NewClusterConfigurationService(wrapper),
provisionerCache: local.NewProvisioningService(wrapper),
usersCache: local.NewIdentityService(wrapper),
accessCache: local.NewAccessService(wrapper),
presenceCache: local.NewPresenceService(wrapper),
eventsCache: local.NewEventsService(config.Backend),
Entry: log.WithFields(log.Fields{
trace.Component: config.Component,
}),
}
collections, err := setupCollections(cs, config.Watches)
if err != nil {
return nil, trace.Wrap(err)
}
cs.collections = collections
err = cs.fetch()
if err != nil {
// "only recent" behavior does not tolerate
// stale data, so it has to initialize itself
// with recent data on startup or fail
if cs.OnlyRecent.Enabled {
return nil, trace.Wrap(err)
}
}
go cs.update()
return cs, nil
}
|
go
|
func New(config Config) (*Cache, error) {
if err := config.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
wrapper := backend.NewWrapper(config.Backend)
ctx, cancel := context.WithCancel(config.Context)
cs := &Cache{
wrapper: wrapper,
ctx: ctx,
cancel: cancel,
Config: config,
trustCache: local.NewCAService(wrapper),
clusterConfigCache: local.NewClusterConfigurationService(wrapper),
provisionerCache: local.NewProvisioningService(wrapper),
usersCache: local.NewIdentityService(wrapper),
accessCache: local.NewAccessService(wrapper),
presenceCache: local.NewPresenceService(wrapper),
eventsCache: local.NewEventsService(config.Backend),
Entry: log.WithFields(log.Fields{
trace.Component: config.Component,
}),
}
collections, err := setupCollections(cs, config.Watches)
if err != nil {
return nil, trace.Wrap(err)
}
cs.collections = collections
err = cs.fetch()
if err != nil {
// "only recent" behavior does not tolerate
// stale data, so it has to initialize itself
// with recent data on startup or fail
if cs.OnlyRecent.Enabled {
return nil, trace.Wrap(err)
}
}
go cs.update()
return cs, nil
}
|
[
"func",
"New",
"(",
"config",
"Config",
")",
"(",
"*",
"Cache",
",",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"wrapper",
":=",
"backend",
".",
"NewWrapper",
"(",
"config",
".",
"Backend",
")",
"\n",
"ctx",
",",
"cancel",
":=",
"context",
".",
"WithCancel",
"(",
"config",
".",
"Context",
")",
"\n",
"cs",
":=",
"&",
"Cache",
"{",
"wrapper",
":",
"wrapper",
",",
"ctx",
":",
"ctx",
",",
"cancel",
":",
"cancel",
",",
"Config",
":",
"config",
",",
"trustCache",
":",
"local",
".",
"NewCAService",
"(",
"wrapper",
")",
",",
"clusterConfigCache",
":",
"local",
".",
"NewClusterConfigurationService",
"(",
"wrapper",
")",
",",
"provisionerCache",
":",
"local",
".",
"NewProvisioningService",
"(",
"wrapper",
")",
",",
"usersCache",
":",
"local",
".",
"NewIdentityService",
"(",
"wrapper",
")",
",",
"accessCache",
":",
"local",
".",
"NewAccessService",
"(",
"wrapper",
")",
",",
"presenceCache",
":",
"local",
".",
"NewPresenceService",
"(",
"wrapper",
")",
",",
"eventsCache",
":",
"local",
".",
"NewEventsService",
"(",
"config",
".",
"Backend",
")",
",",
"Entry",
":",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"config",
".",
"Component",
",",
"}",
")",
",",
"}",
"\n",
"collections",
",",
"err",
":=",
"setupCollections",
"(",
"cs",
",",
"config",
".",
"Watches",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cs",
".",
"collections",
"=",
"collections",
"\n",
"err",
"=",
"cs",
".",
"fetch",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"cs",
".",
"OnlyRecent",
".",
"Enabled",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"go",
"cs",
".",
"update",
"(",
")",
"\n",
"return",
"cs",
",",
"nil",
"\n",
"}"
] |
// New creates a new instance of Cache
|
[
"New",
"creates",
"a",
"new",
"instance",
"of",
"Cache"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L261-L300
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
NewWatcher
|
func (c *Cache) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return c.eventsCache.NewWatcher(ctx, watch)
}
|
go
|
func (c *Cache) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return c.eventsCache.NewWatcher(ctx, watch)
}
|
[
"func",
"(",
"c",
"*",
"Cache",
")",
"NewWatcher",
"(",
"ctx",
"context",
".",
"Context",
",",
"watch",
"services",
".",
"Watch",
")",
"(",
"services",
".",
"Watcher",
",",
"error",
")",
"{",
"return",
"c",
".",
"eventsCache",
".",
"NewWatcher",
"(",
"ctx",
",",
"watch",
")",
"\n",
"}"
] |
// NewWatcher returns a new event watcher. In case of a cache
// this watcher will return events as seen by the cache,
// not the backend. This feature allows auth server
// to handle subscribers connected to the in-memory caches
// instead of reading from the backend.
|
[
"NewWatcher",
"returns",
"a",
"new",
"event",
"watcher",
".",
"In",
"case",
"of",
"a",
"cache",
"this",
"watcher",
"will",
"return",
"events",
"as",
"seen",
"by",
"the",
"cache",
"not",
"the",
"backend",
".",
"This",
"feature",
"allows",
"auth",
"server",
"to",
"handle",
"subscribers",
"connected",
"to",
"the",
"in",
"-",
"memory",
"caches",
"instead",
"of",
"reading",
"from",
"the",
"backend",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L307-L309
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
setCacheState
|
func (c *Cache) setCacheState(err error) error {
if !c.OnlyRecent.Enabled {
return err
}
if err := c.eraseAll(); err != nil {
if !c.isClosed() {
c.Warningf("Failed to erase the data: %v.", err)
}
}
c.wrapper.SetReadError(trace.ConnectionProblem(err, "cache is unavailable"))
return err
}
|
go
|
func (c *Cache) setCacheState(err error) error {
if !c.OnlyRecent.Enabled {
return err
}
if err := c.eraseAll(); err != nil {
if !c.isClosed() {
c.Warningf("Failed to erase the data: %v.", err)
}
}
c.wrapper.SetReadError(trace.ConnectionProblem(err, "cache is unavailable"))
return err
}
|
[
"func",
"(",
"c",
"*",
"Cache",
")",
"setCacheState",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"!",
"c",
".",
"OnlyRecent",
".",
"Enabled",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"eraseAll",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"!",
"c",
".",
"isClosed",
"(",
")",
"{",
"c",
".",
"Warningf",
"(",
"\"Failed to erase the data: %v.\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"c",
".",
"wrapper",
".",
"SetReadError",
"(",
"trace",
".",
"ConnectionProblem",
"(",
"err",
",",
"\"cache is unavailable\"",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// setCacheState for "only recent" cache behavior will erase
// the cache and set error mode to refuse to serve stale data,
// otherwise does nothing
|
[
"setCacheState",
"for",
"only",
"recent",
"cache",
"behavior",
"will",
"erase",
"the",
"cache",
"and",
"set",
"error",
"mode",
"to",
"refuse",
"to",
"serve",
"stale",
"data",
"otherwise",
"does",
"nothing"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L358-L369
|
train
|
gravitational/teleport
|
lib/cache/cache.go
|
eraseAll
|
func (c *Cache) eraseAll() error {
var errors []error
for _, collection := range c.collections {
errors = append(errors, collection.erase())
}
return trace.NewAggregate(errors...)
}
|
go
|
func (c *Cache) eraseAll() error {
var errors []error
for _, collection := range c.collections {
errors = append(errors, collection.erase())
}
return trace.NewAggregate(errors...)
}
|
[
"func",
"(",
"c",
"*",
"Cache",
")",
"eraseAll",
"(",
")",
"error",
"{",
"var",
"errors",
"[",
"]",
"error",
"\n",
"for",
"_",
",",
"collection",
":=",
"range",
"c",
".",
"collections",
"{",
"errors",
"=",
"append",
"(",
"errors",
",",
"collection",
".",
"erase",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"trace",
".",
"NewAggregate",
"(",
"errors",
"...",
")",
"\n",
"}"
] |
// eraseAll erases all the data from cache collections
|
[
"eraseAll",
"erases",
"all",
"the",
"data",
"from",
"cache",
"collections"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/cache/cache.go#L501-L507
|
train
|
gravitational/teleport
|
lib/reversetunnel/localsite.go
|
findMatchingConn
|
func (s *localSite) findMatchingConn(principals []string) (*remoteConn, bool) {
for _, principal := range principals {
rconn, err := s.getConn(principal)
if err == nil {
return rconn, true
}
}
return nil, false
}
|
go
|
func (s *localSite) findMatchingConn(principals []string) (*remoteConn, bool) {
for _, principal := range principals {
rconn, err := s.getConn(principal)
if err == nil {
return rconn, true
}
}
return nil, false
}
|
[
"func",
"(",
"s",
"*",
"localSite",
")",
"findMatchingConn",
"(",
"principals",
"[",
"]",
"string",
")",
"(",
"*",
"remoteConn",
",",
"bool",
")",
"{",
"for",
"_",
",",
"principal",
":=",
"range",
"principals",
"{",
"rconn",
",",
"err",
":=",
"s",
".",
"getConn",
"(",
"principal",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"rconn",
",",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}"
] |
// findMatchingConn iterates over passed in principals looking for matching
// remote connections.
|
[
"findMatchingConn",
"iterates",
"over",
"passed",
"in",
"principals",
"looking",
"for",
"matching",
"remote",
"connections",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/reversetunnel/localsite.go#L244-L252
|
train
|
gravitational/teleport
|
examples/go-client/main.go
|
setupClientTLS
|
func setupClientTLS() (*tls.Config, error) {
storage, err := auth.NewProcessStorage(filepath.Join("/var/lib/teleport", teleport.ComponentProcess))
if err != nil {
return nil, trace.Wrap(err)
}
defer storage.Close()
identity, err := storage.ReadIdentity(auth.IdentityCurrent, teleport.RoleAdmin)
if err != nil {
return nil, trace.Wrap(err)
}
return identity.TLSConfig(nil)
}
|
go
|
func setupClientTLS() (*tls.Config, error) {
storage, err := auth.NewProcessStorage(filepath.Join("/var/lib/teleport", teleport.ComponentProcess))
if err != nil {
return nil, trace.Wrap(err)
}
defer storage.Close()
identity, err := storage.ReadIdentity(auth.IdentityCurrent, teleport.RoleAdmin)
if err != nil {
return nil, trace.Wrap(err)
}
return identity.TLSConfig(nil)
}
|
[
"func",
"setupClientTLS",
"(",
")",
"(",
"*",
"tls",
".",
"Config",
",",
"error",
")",
"{",
"storage",
",",
"err",
":=",
"auth",
".",
"NewProcessStorage",
"(",
"filepath",
".",
"Join",
"(",
"\"/var/lib/teleport\"",
",",
"teleport",
".",
"ComponentProcess",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"storage",
".",
"Close",
"(",
")",
"\n",
"identity",
",",
"err",
":=",
"storage",
".",
"ReadIdentity",
"(",
"auth",
".",
"IdentityCurrent",
",",
"teleport",
".",
"RoleAdmin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"identity",
".",
"TLSConfig",
"(",
"nil",
")",
"\n",
"}"
] |
// setupClientTLS sets up client TLS authentiction between TLS client
// and Teleport Auth server. This function uses hardcoded certificate paths,
// assuming program runs alongside auth server, but it can be ran
// on a remote location, assuming client has all the client certificates.
|
[
"setupClientTLS",
"sets",
"up",
"client",
"TLS",
"authentiction",
"between",
"TLS",
"client",
"and",
"Teleport",
"Auth",
"server",
".",
"This",
"function",
"uses",
"hardcoded",
"certificate",
"paths",
"assuming",
"program",
"runs",
"alongside",
"auth",
"server",
"but",
"it",
"can",
"be",
"ran",
"on",
"a",
"remote",
"location",
"assuming",
"client",
"has",
"all",
"the",
"client",
"certificates",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/examples/go-client/main.go#L64-L77
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
NewPresenceService
|
func NewPresenceService(b backend.Backend) *PresenceService {
return &PresenceService{
log: logrus.WithFields(logrus.Fields{trace.Component: "Presence"}),
Backend: b,
}
}
|
go
|
func NewPresenceService(b backend.Backend) *PresenceService {
return &PresenceService{
log: logrus.WithFields(logrus.Fields{trace.Component: "Presence"}),
Backend: b,
}
}
|
[
"func",
"NewPresenceService",
"(",
"b",
"backend",
".",
"Backend",
")",
"*",
"PresenceService",
"{",
"return",
"&",
"PresenceService",
"{",
"log",
":",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"trace",
".",
"Component",
":",
"\"Presence\"",
"}",
")",
",",
"Backend",
":",
"b",
",",
"}",
"\n",
"}"
] |
// NewPresenceService returns new presence service instance
|
[
"NewPresenceService",
"returns",
"new",
"presence",
"service",
"instance"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L41-L46
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertLocalClusterName
|
func (s *PresenceService) UpsertLocalClusterName(name string) error {
_, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(localClusterPrefix, valPrefix),
Value: []byte(name),
})
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) UpsertLocalClusterName(name string) error {
_, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(localClusterPrefix, valPrefix),
Value: []byte(name),
})
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertLocalClusterName",
"(",
"name",
"string",
")",
"error",
"{",
"_",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"localClusterPrefix",
",",
"valPrefix",
")",
",",
"Value",
":",
"[",
"]",
"byte",
"(",
"name",
")",
",",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// UpsertLocalClusterName upserts local cluster name
|
[
"UpsertLocalClusterName",
"upserts",
"local",
"cluster",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L53-L59
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetLocalClusterName
|
func (s *PresenceService) GetLocalClusterName() (string, error) {
item, err := s.Get(context.TODO(), backend.Key(localClusterPrefix, valPrefix))
if err != nil {
return "", trace.Wrap(err)
}
return string(item.Value), nil
}
|
go
|
func (s *PresenceService) GetLocalClusterName() (string, error) {
item, err := s.Get(context.TODO(), backend.Key(localClusterPrefix, valPrefix))
if err != nil {
return "", trace.Wrap(err)
}
return string(item.Value), nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetLocalClusterName",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"localClusterPrefix",
",",
"valPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"item",
".",
"Value",
")",
",",
"nil",
"\n",
"}"
] |
// GetLocalClusterName upserts local domain
|
[
"GetLocalClusterName",
"upserts",
"local",
"domain"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L62-L68
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteAllNamespaces
|
func (s *PresenceService) DeleteAllNamespaces() error {
return s.DeleteRange(context.TODO(), backend.Key(namespacesPrefix), backend.RangeEnd(backend.Key(namespacesPrefix)))
}
|
go
|
func (s *PresenceService) DeleteAllNamespaces() error {
return s.DeleteRange(context.TODO(), backend.Key(namespacesPrefix), backend.RangeEnd(backend.Key(namespacesPrefix)))
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllNamespaces",
"(",
")",
"error",
"{",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
")",
",",
"backend",
".",
"RangeEnd",
"(",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
")",
")",
")",
"\n",
"}"
] |
// DeleteAllNamespaces deletes all namespaces
|
[
"DeleteAllNamespaces",
"deletes",
"all",
"namespaces"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L71-L73
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetNamespace
|
func (s *PresenceService) GetNamespace(name string) (*services.Namespace, error) {
if name == "" {
return nil, trace.BadParameter("missing namespace name")
}
item, err := s.Get(context.TODO(), backend.Key(namespacesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("namespace %q is not found", name)
}
return nil, trace.Wrap(err)
}
return services.UnmarshalNamespace(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
}
|
go
|
func (s *PresenceService) GetNamespace(name string) (*services.Namespace, error) {
if name == "" {
return nil, trace.BadParameter("missing namespace name")
}
item, err := s.Get(context.TODO(), backend.Key(namespacesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("namespace %q is not found", name)
}
return nil, trace.Wrap(err)
}
return services.UnmarshalNamespace(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetNamespace",
"(",
"name",
"string",
")",
"(",
"*",
"services",
".",
"Namespace",
",",
"error",
")",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing namespace name\"",
")",
"\n",
"}",
"\n",
"item",
",",
"err",
":=",
"s",
".",
"Get",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
",",
"name",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"trace",
".",
"NotFound",
"(",
"\"namespace %q is not found\"",
",",
"name",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"services",
".",
"UnmarshalNamespace",
"(",
"item",
".",
"Value",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"\n",
"}"
] |
// GetNamespace returns a namespace by name
|
[
"GetNamespace",
"returns",
"a",
"namespace",
"by",
"name"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L121-L134
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteNamespace
|
func (s *PresenceService) DeleteNamespace(namespace string) error {
if namespace == "" {
return trace.BadParameter("missing namespace name")
}
err := s.Delete(context.TODO(), backend.Key(namespacesPrefix, namespace, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("namespace %q is not found", namespace)
}
}
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) DeleteNamespace(namespace string) error {
if namespace == "" {
return trace.BadParameter("missing namespace name")
}
err := s.Delete(context.TODO(), backend.Key(namespacesPrefix, namespace, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("namespace %q is not found", namespace)
}
}
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteNamespace",
"(",
"namespace",
"string",
")",
"error",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing namespace name\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Key",
"(",
"namespacesPrefix",
",",
"namespace",
",",
"paramsPrefix",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"trace",
".",
"IsNotFound",
"(",
"err",
")",
"{",
"return",
"trace",
".",
"NotFound",
"(",
"\"namespace %q is not found\"",
",",
"namespace",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// DeleteNamespace deletes a namespace with all the keys from the backend
|
[
"DeleteNamespace",
"deletes",
"a",
"namespace",
"with",
"all",
"the",
"keys",
"from",
"the",
"backend"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L137-L148
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteAllNodes
|
func (s *PresenceService) DeleteAllNodes(namespace string) error {
startKey := backend.Key(nodesPrefix, namespace)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
}
|
go
|
func (s *PresenceService) DeleteAllNodes(namespace string) error {
startKey := backend.Key(nodesPrefix, namespace)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllNodes",
"(",
"namespace",
"string",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"namespace",
")",
"\n",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"}"
] |
// DeleteAllNodes deletes all nodes in a namespace
|
[
"DeleteAllNodes",
"deletes",
"all",
"nodes",
"in",
"a",
"namespace"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L188-L191
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteNode
|
func (s *PresenceService) DeleteNode(namespace string, name string) error {
key := backend.Key(nodesPrefix, namespace, name)
return s.Delete(context.TODO(), key)
}
|
go
|
func (s *PresenceService) DeleteNode(namespace string, name string) error {
key := backend.Key(nodesPrefix, namespace, name)
return s.Delete(context.TODO(), key)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteNode",
"(",
"namespace",
"string",
",",
"name",
"string",
")",
"error",
"{",
"key",
":=",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"namespace",
",",
"name",
")",
"\n",
"return",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"key",
")",
"\n",
"}"
] |
// DeleteNode deletes node
|
[
"DeleteNode",
"deletes",
"node"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L194-L197
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetNodes
|
func (s *PresenceService) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter("missing namespace value")
}
// Get all items in the bucket.
startKey := backend.Key(nodesPrefix, namespace)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
// Marshal values into a []services.Server slice.
servers := make([]services.Server, len(result.Items))
for i, item := range result.Items {
server, err := services.GetServerMarshaler().UnmarshalServer(
item.Value,
services.KindNode,
services.AddOptions(opts,
services.WithResourceID(item.ID),
services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
servers[i] = server
}
return servers, nil
}
|
go
|
func (s *PresenceService) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter("missing namespace value")
}
// Get all items in the bucket.
startKey := backend.Key(nodesPrefix, namespace)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
// Marshal values into a []services.Server slice.
servers := make([]services.Server, len(result.Items))
for i, item := range result.Items {
server, err := services.GetServerMarshaler().UnmarshalServer(
item.Value,
services.KindNode,
services.AddOptions(opts,
services.WithResourceID(item.ID),
services.WithExpires(item.Expires))...)
if err != nil {
return nil, trace.Wrap(err)
}
servers[i] = server
}
return servers, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetNodes",
"(",
"namespace",
"string",
",",
"opts",
"...",
"services",
".",
"MarshalOption",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing namespace value\"",
")",
"\n",
"}",
"\n",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"namespace",
")",
"\n",
"result",
",",
"err",
":=",
"s",
".",
"GetRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
",",
"backend",
".",
"NoLimit",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"servers",
":=",
"make",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"len",
"(",
"result",
".",
"Items",
")",
")",
"\n",
"for",
"i",
",",
"item",
":=",
"range",
"result",
".",
"Items",
"{",
"server",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"UnmarshalServer",
"(",
"item",
".",
"Value",
",",
"services",
".",
"KindNode",
",",
"services",
".",
"AddOptions",
"(",
"opts",
",",
"services",
".",
"WithResourceID",
"(",
"item",
".",
"ID",
")",
",",
"services",
".",
"WithExpires",
"(",
"item",
".",
"Expires",
")",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"servers",
"[",
"i",
"]",
"=",
"server",
"\n",
"}",
"\n",
"return",
"servers",
",",
"nil",
"\n",
"}"
] |
// GetNodes returns a list of registered servers
|
[
"GetNodes",
"returns",
"a",
"list",
"of",
"registered",
"servers"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L200-L227
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertNode
|
func (s *PresenceService) UpsertNode(server services.Server) (*services.KeepAlive, error) {
if server.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return nil, trace.Wrap(err)
}
lease, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
if server.Expiry().IsZero() {
return &services.KeepAlive{}, nil
}
return &services.KeepAlive{LeaseID: lease.ID, ServerName: server.GetName()}, nil
}
|
go
|
func (s *PresenceService) UpsertNode(server services.Server) (*services.KeepAlive, error) {
if server.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return nil, trace.Wrap(err)
}
lease, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
})
if err != nil {
return nil, trace.Wrap(err)
}
if server.Expiry().IsZero() {
return &services.KeepAlive{}, nil
}
return &services.KeepAlive{LeaseID: lease.ID, ServerName: server.GetName()}, nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertNode",
"(",
"server",
"services",
".",
"Server",
")",
"(",
"*",
"services",
".",
"KeepAlive",
",",
"error",
")",
"{",
"if",
"server",
".",
"GetNamespace",
"(",
")",
"==",
"\"\"",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing node namespace\"",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"MarshalServer",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"lease",
",",
"err",
":=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"server",
".",
"GetNamespace",
"(",
")",
",",
"server",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"server",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"server",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"server",
".",
"Expiry",
"(",
")",
".",
"IsZero",
"(",
")",
"{",
"return",
"&",
"services",
".",
"KeepAlive",
"{",
"}",
",",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"services",
".",
"KeepAlive",
"{",
"LeaseID",
":",
"lease",
".",
"ID",
",",
"ServerName",
":",
"server",
".",
"GetName",
"(",
")",
"}",
",",
"nil",
"\n",
"}"
] |
// UpsertNode registers node presence, permanently if TTL is 0 or for the
// specified duration with second resolution if it's >= 1 second.
|
[
"UpsertNode",
"registers",
"node",
"presence",
"permanently",
"if",
"TTL",
"is",
"0",
"or",
"for",
"the",
"specified",
"duration",
"with",
"second",
"resolution",
"if",
"it",
"s",
">",
"=",
"1",
"second",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L231-L252
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
KeepAliveNode
|
func (s *PresenceService) KeepAliveNode(ctx context.Context, h services.KeepAlive) error {
if err := h.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
err := s.KeepAlive(ctx, backend.Lease{
ID: h.LeaseID,
Key: backend.Key(nodesPrefix, h.Namespace, h.ServerName),
}, h.Expires)
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) KeepAliveNode(ctx context.Context, h services.KeepAlive) error {
if err := h.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
err := s.KeepAlive(ctx, backend.Lease{
ID: h.LeaseID,
Key: backend.Key(nodesPrefix, h.Namespace, h.ServerName),
}, h.Expires)
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"KeepAliveNode",
"(",
"ctx",
"context",
".",
"Context",
",",
"h",
"services",
".",
"KeepAlive",
")",
"error",
"{",
"if",
"err",
":=",
"h",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"err",
":=",
"s",
".",
"KeepAlive",
"(",
"ctx",
",",
"backend",
".",
"Lease",
"{",
"ID",
":",
"h",
".",
"LeaseID",
",",
"Key",
":",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"h",
".",
"Namespace",
",",
"h",
".",
"ServerName",
")",
",",
"}",
",",
"h",
".",
"Expires",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// KeepAliveNode updates node expiry
|
[
"KeepAliveNode",
"updates",
"node",
"expiry"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L255-L264
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertNodes
|
func (s *PresenceService) UpsertNodes(namespace string, servers []services.Server) error {
batch, ok := s.Backend.(backend.Batch)
if !ok {
return trace.BadParameter("backend does not support batch interface")
}
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
start := time.Now()
items := make([]backend.Item, len(servers))
for i, server := range servers {
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return trace.Wrap(err)
}
items[i] = backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
}
}
err := batch.PutRange(context.TODO(), items)
if err != nil {
return trace.Wrap(err)
}
s.log.Debugf("UpsertNodes(%v) in %v", len(servers), time.Now().Sub(start))
return nil
}
|
go
|
func (s *PresenceService) UpsertNodes(namespace string, servers []services.Server) error {
batch, ok := s.Backend.(backend.Batch)
if !ok {
return trace.BadParameter("backend does not support batch interface")
}
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
start := time.Now()
items := make([]backend.Item, len(servers))
for i, server := range servers {
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return trace.Wrap(err)
}
items[i] = backend.Item{
Key: backend.Key(nodesPrefix, server.GetNamespace(), server.GetName()),
Value: value,
Expires: server.Expiry(),
ID: server.GetResourceID(),
}
}
err := batch.PutRange(context.TODO(), items)
if err != nil {
return trace.Wrap(err)
}
s.log.Debugf("UpsertNodes(%v) in %v", len(servers), time.Now().Sub(start))
return nil
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertNodes",
"(",
"namespace",
"string",
",",
"servers",
"[",
"]",
"services",
".",
"Server",
")",
"error",
"{",
"batch",
",",
"ok",
":=",
"s",
".",
"Backend",
".",
"(",
"backend",
".",
"Batch",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"backend does not support batch interface\"",
")",
"\n",
"}",
"\n",
"if",
"namespace",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing node namespace\"",
")",
"\n",
"}",
"\n",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"items",
":=",
"make",
"(",
"[",
"]",
"backend",
".",
"Item",
",",
"len",
"(",
"servers",
")",
")",
"\n",
"for",
"i",
",",
"server",
":=",
"range",
"servers",
"{",
"value",
",",
"err",
":=",
"services",
".",
"GetServerMarshaler",
"(",
")",
".",
"MarshalServer",
"(",
"server",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"items",
"[",
"i",
"]",
"=",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"nodesPrefix",
",",
"server",
".",
"GetNamespace",
"(",
")",
",",
"server",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"server",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"server",
".",
"GetResourceID",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"err",
":=",
"batch",
".",
"PutRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"items",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"s",
".",
"log",
".",
"Debugf",
"(",
"\"UpsertNodes(%v) in %v\"",
",",
"len",
"(",
"servers",
")",
",",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"start",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UpsertNodes is used for bulk insertion of nodes. Schema validation is
// always skipped during bulk insertion.
|
[
"UpsertNodes",
"is",
"used",
"for",
"bulk",
"insertion",
"of",
"nodes",
".",
"Schema",
"validation",
"is",
"always",
"skipped",
"during",
"bulk",
"insertion",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L268-L302
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetAuthServers
|
func (s *PresenceService) GetAuthServers() ([]services.Server, error) {
return s.getServers(services.KindAuthServer, authServersPrefix)
}
|
go
|
func (s *PresenceService) GetAuthServers() ([]services.Server, error) {
return s.getServers(services.KindAuthServer, authServersPrefix)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetAuthServers",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"return",
"s",
".",
"getServers",
"(",
"services",
".",
"KindAuthServer",
",",
"authServersPrefix",
")",
"\n",
"}"
] |
// GetAuthServers returns a list of registered servers
|
[
"GetAuthServers",
"returns",
"a",
"list",
"of",
"registered",
"servers"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L305-L307
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertAuthServer
|
func (s *PresenceService) UpsertAuthServer(server services.Server) error {
return s.upsertServer(authServersPrefix, server)
}
|
go
|
func (s *PresenceService) UpsertAuthServer(server services.Server) error {
return s.upsertServer(authServersPrefix, server)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertAuthServer",
"(",
"server",
"services",
".",
"Server",
")",
"error",
"{",
"return",
"s",
".",
"upsertServer",
"(",
"authServersPrefix",
",",
"server",
")",
"\n",
"}"
] |
// UpsertAuthServer registers auth server presence, permanently if ttl is 0 or
// for the specified duration with second resolution if it's >= 1 second
|
[
"UpsertAuthServer",
"registers",
"auth",
"server",
"presence",
"permanently",
"if",
"ttl",
"is",
"0",
"or",
"for",
"the",
"specified",
"duration",
"with",
"second",
"resolution",
"if",
"it",
"s",
">",
"=",
"1",
"second"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L311-L313
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertProxy
|
func (s *PresenceService) UpsertProxy(server services.Server) error {
return s.upsertServer(proxiesPrefix, server)
}
|
go
|
func (s *PresenceService) UpsertProxy(server services.Server) error {
return s.upsertServer(proxiesPrefix, server)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertProxy",
"(",
"server",
"services",
".",
"Server",
")",
"error",
"{",
"return",
"s",
".",
"upsertServer",
"(",
"proxiesPrefix",
",",
"server",
")",
"\n",
"}"
] |
// UpsertProxy registers proxy server presence, permanently if ttl is 0 or
// for the specified duration with second resolution if it's >= 1 second
|
[
"UpsertProxy",
"registers",
"proxy",
"server",
"presence",
"permanently",
"if",
"ttl",
"is",
"0",
"or",
"for",
"the",
"specified",
"duration",
"with",
"second",
"resolution",
"if",
"it",
"s",
">",
"=",
"1",
"second"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L329-L331
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
GetProxies
|
func (s *PresenceService) GetProxies() ([]services.Server, error) {
return s.getServers(services.KindProxy, proxiesPrefix)
}
|
go
|
func (s *PresenceService) GetProxies() ([]services.Server, error) {
return s.getServers(services.KindProxy, proxiesPrefix)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"GetProxies",
"(",
")",
"(",
"[",
"]",
"services",
".",
"Server",
",",
"error",
")",
"{",
"return",
"s",
".",
"getServers",
"(",
"services",
".",
"KindProxy",
",",
"proxiesPrefix",
")",
"\n",
"}"
] |
// GetProxies returns a list of registered proxies
|
[
"GetProxies",
"returns",
"a",
"list",
"of",
"registered",
"proxies"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L334-L336
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteProxy
|
func (s *PresenceService) DeleteProxy(name string) error {
key := backend.Key(proxiesPrefix, name)
return s.Delete(context.TODO(), key)
}
|
go
|
func (s *PresenceService) DeleteProxy(name string) error {
key := backend.Key(proxiesPrefix, name)
return s.Delete(context.TODO(), key)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteProxy",
"(",
"name",
"string",
")",
"error",
"{",
"key",
":=",
"backend",
".",
"Key",
"(",
"proxiesPrefix",
",",
"name",
")",
"\n",
"return",
"s",
".",
"Delete",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"key",
")",
"\n",
"}"
] |
// DeleteProxy deletes proxy
|
[
"DeleteProxy",
"deletes",
"proxy"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L345-L348
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
DeleteAllReverseTunnels
|
func (s *PresenceService) DeleteAllReverseTunnels() error {
startKey := backend.Key(reverseTunnelsPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
}
|
go
|
func (s *PresenceService) DeleteAllReverseTunnels() error {
startKey := backend.Key(reverseTunnelsPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"DeleteAllReverseTunnels",
"(",
")",
"error",
"{",
"startKey",
":=",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
")",
"\n",
"return",
"s",
".",
"DeleteRange",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"startKey",
",",
"backend",
".",
"RangeEnd",
"(",
"startKey",
")",
")",
"\n",
"}"
] |
// DeleteAllReverseTunnels deletes all reverse tunnels
|
[
"DeleteAllReverseTunnels",
"deletes",
"all",
"reverse",
"tunnels"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L351-L354
|
train
|
gravitational/teleport
|
lib/services/local/presence.go
|
UpsertReverseTunnel
|
func (s *PresenceService) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
if err := tunnel.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(reverseTunnelsPrefix, tunnel.GetName()),
Value: value,
Expires: tunnel.Expiry(),
ID: tunnel.GetResourceID(),
})
return trace.Wrap(err)
}
|
go
|
func (s *PresenceService) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
if err := tunnel.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key: backend.Key(reverseTunnelsPrefix, tunnel.GetName()),
Value: value,
Expires: tunnel.Expiry(),
ID: tunnel.GetResourceID(),
})
return trace.Wrap(err)
}
|
[
"func",
"(",
"s",
"*",
"PresenceService",
")",
"UpsertReverseTunnel",
"(",
"tunnel",
"services",
".",
"ReverseTunnel",
")",
"error",
"{",
"if",
"err",
":=",
"tunnel",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"value",
",",
"err",
":=",
"services",
".",
"GetReverseTunnelMarshaler",
"(",
")",
".",
"MarshalReverseTunnel",
"(",
"tunnel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"s",
".",
"Put",
"(",
"context",
".",
"TODO",
"(",
")",
",",
"backend",
".",
"Item",
"{",
"Key",
":",
"backend",
".",
"Key",
"(",
"reverseTunnelsPrefix",
",",
"tunnel",
".",
"GetName",
"(",
")",
")",
",",
"Value",
":",
"value",
",",
"Expires",
":",
"tunnel",
".",
"Expiry",
"(",
")",
",",
"ID",
":",
"tunnel",
".",
"GetResourceID",
"(",
")",
",",
"}",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}"
] |
// UpsertReverseTunnel upserts reverse tunnel entry temporarily or permanently
|
[
"UpsertReverseTunnel",
"upserts",
"reverse",
"tunnel",
"entry",
"temporarily",
"or",
"permanently"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/local/presence.go#L357-L372
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.