_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23100 | dropConnections | train | func (l *LoadBalancer) dropConnections(backend NetAddr) {
tracker := l.connections[backend]
for _, conn := range tracker {
conn.Close()
}
delete(l.connections, backend)
} | go | {
"resource": ""
} |
q23101 | AddBackend | train | func (l *LoadBalancer) AddBackend(b NetAddr) {
l.Lock()
defer l.Unlock()
l.backends = append(l.backends, b)
l.Debugf("backends %v", l.backends)
} | go | {
"resource": ""
} |
q23102 | RemoveBackend | train | func (l *LoadBalancer) RemoveBackend(b NetAddr) {
l.Lock()
defer l.Unlock()
l.currentIndex = -1
for i := range l.backends {
if l.backends[i].Equals(b) {
l.backends = append(l.backends[:i], l.backends[i+1:]...)
l.dropConnections(b)
return
}
}
} | go | {
"resource": ""
} |
q23103 | ListenAndServe | train | func (l *LoadBalancer) ListenAndServe() error {
if err := l.Listen(); err != nil {
return trace.Wrap(err)
}
return l.Serve()
} | go | {
"resource": ""
} |
q23104 | Listen | train | func (l *LoadBalancer) Listen() error {
var err error
l.listener, err = net.Listen(l.frontend.AddrNetwork, l.frontend.Addr)
if err != nil {
return trace.ConvertSystemError(err)
}
l.Debugf("created listening socket")
return nil
} | go | {
"resource": ""
} |
q23105 | Serve | train | func (l *LoadBalancer) Serve() error {
defer l.waitCancel()
backoffTimer := time.NewTicker(5 * time.Second)
defer backoffTimer.Stop()
for {
conn, err := l.listener.Accept()
if err != nil {
if l.isClosed() {
return trace.ConnectionProblem(nil, "listener is closed")
}
select {
case <-backoffTimer.... | go | {
"resource": ""
} |
q23106 | NewDiskSessionLogger | train | func NewDiskSessionLogger(cfg DiskSessionLoggerConfig) (*DiskSessionLogger, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
var err error
sessionDir := filepath.Join(cfg.DataDir, cfg.ServerID, SessionLogsDir, cfg.Namespace)
indexFile, err := os.OpenFile(
filepath.Join(... | go | {
"resource": ""
} |
q23107 | Finalize | train | func (sl *DiskSessionLogger) Finalize() error {
sl.Lock()
defer sl.Unlock()
return sl.finalize()
} | go | {
"resource": ""
} |
q23108 | flush | train | func (sl *DiskSessionLogger) flush() error {
var err, err2 error
if sl.RecordSessions && sl.chunksFile != nil {
err = sl.chunksFile.Flush()
}
if sl.eventsFile != nil {
err2 = sl.eventsFile.Flush()
}
return trace.NewAggregate(err, err2)
} | go | {
"resource": ""
} |
q23109 | eventsFileName | train | func eventsFileName(dataDir string, sessionID session.ID, eventIndex int64) string {
return filepath.Join(dataDir, fmt.Sprintf("%v-%v.events.gz", sessionID.String(), eventIndex))
} | go | {
"resource": ""
} |
q23110 | chunksFileName | train | func chunksFileName(dataDir string, sessionID session.ID, offset int64) string {
return filepath.Join(dataDir, fmt.Sprintf("%v-%v.chunks.gz", sessionID.String(), offset))
} | go | {
"resource": ""
} |
q23111 | PostSessionSlice | train | func (sl *DiskSessionLogger) PostSessionSlice(slice SessionSlice) error {
sl.Lock()
defer sl.Unlock()
for i := range slice.Chunks {
_, err := sl.writeChunk(slice.SessionID, slice.Chunks[i])
if err != nil {
return trace.Wrap(err)
}
}
return sl.flush()
} | go | {
"resource": ""
} |
q23112 | EventFromChunk | train | func EventFromChunk(sessionID string, chunk *SessionChunk) (EventFields, error) {
var fields EventFields
eventStart := time.Unix(0, chunk.Time).In(time.UTC).Round(time.Millisecond)
err := json.Unmarshal(chunk.Data, &fields)
if err != nil {
return nil, trace.Wrap(err)
}
fields[SessionEventID] = sessionID
fields... | go | {
"resource": ""
} |
q23113 | Close | train | func (f *gzipWriter) Close() error {
var errors []error
if f.Writer != nil {
errors = append(errors, f.Writer.Close())
f.Writer.Reset(ioutil.Discard)
writerPool.Put(f.Writer)
f.Writer = nil
}
if f.file != nil {
errors = append(errors, f.file.Close())
f.file = nil
}
return trace.NewAggregate(errors...)... | go | {
"resource": ""
} |
q23114 | Close | train | func (f *gzipReader) Close() error {
var errors []error
if f.ReadCloser != nil {
errors = append(errors, f.ReadCloser.Close())
f.ReadCloser = nil
}
if f.file != nil {
errors = append(errors, f.file.Close())
f.file = nil
}
return trace.NewAggregate(errors...)
} | go | {
"resource": ""
} |
q23115 | String | train | func (h HeartbeatMode) String() string {
switch h {
case HeartbeatModeNode:
return "Node"
case HeartbeatModeProxy:
return "Proxy"
case HeartbeatModeAuth:
return "Auth"
default:
return fmt.Sprintf("<unknown: %v>", int(h))
}
} | go | {
"resource": ""
} |
q23116 | NewHeartbeat | train | func NewHeartbeat(cfg HeartbeatConfig) (*Heartbeat, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
h := &Heartbeat{
cancelCtx: ctx,
cancel: cancel,
HeartbeatConfig: cfg,
Entry: log.WithFields(log.Fields... | go | {
"resource": ""
} |
q23117 | Run | train | func (h *Heartbeat) Run() error {
defer func() {
h.reset(HeartbeatStateInit)
h.checkTicker.Stop()
}()
for {
if err := h.fetchAndAnnounce(); err != nil {
h.Warningf("Heartbeat failed %v.", err)
}
select {
case <-h.checkTicker.C:
case <-h.sendC:
h.Debugf("Asked check out of cycle")
case <-h.cance... | go | {
"resource": ""
} |
q23118 | reset | train | func (h *Heartbeat) reset(state KeepAliveState) {
h.setState(state)
h.nextAnnounce = time.Time{}
h.nextKeepAlive = time.Time{}
h.keepAlive = nil
if h.keepAliver != nil {
if err := h.keepAliver.Close(); err != nil {
h.Warningf("Failed to close keep aliver: %v", err)
}
h.keepAliver = nil
}
} | go | {
"resource": ""
} |
q23119 | fetch | train | func (h *Heartbeat) fetch() error {
// failed to fetch server info?
// reset to init state regardless of the current state
server, err := h.GetServerInfo()
if err != nil {
h.reset(HeartbeatStateInit)
return trace.Wrap(err)
}
switch h.state {
// in case of successfull state fetch, move to announce from init
... | go | {
"resource": ""
} |
q23120 | fetchAndAnnounce | train | func (h *Heartbeat) fetchAndAnnounce() error {
if err := h.fetch(); err != nil {
return trace.Wrap(err)
}
if err := h.announce(); err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23121 | ForceSend | train | func (h *Heartbeat) ForceSend(timeout time.Duration) error {
timeoutC := time.After(timeout)
select {
case h.sendC <- struct{}{}:
case <-timeoutC:
return trace.ConnectionProblem(nil, "timeout waiting for send")
}
select {
case <-h.announceC:
return nil
case <-timeoutC:
return trace.ConnectionProblem(nil, ... | go | {
"resource": ""
} |
q23122 | deleteAllItems | train | func (b *Log) deleteAllItems() error {
out, err := b.svc.Scan(&dynamodb.ScanInput{TableName: aws.String(b.Tablename)})
if err != nil {
return trace.Wrap(err)
}
var requests []*dynamodb.WriteRequest
for _, item := range out.Items {
requests = append(requests, &dynamodb.WriteRequest{
DeleteRequest: &dynamodb.... | go | {
"resource": ""
} |
q23123 | NewEventsService | train | func NewEventsService(b backend.Backend) *EventsService {
return &EventsService{
Entry: logrus.WithFields(logrus.Fields{trace.Component: "Events"}),
backend: b,
}
} | go | {
"resource": ""
} |
q23124 | base | train | func base(key []byte, offset int) ([]byte, error) {
parts := bytes.Split(key, []byte{backend.Separator})
if len(parts) < offset+1 {
return nil, trace.NotFound("failed parsing %v", string(key))
}
return parts[len(parts)-offset-1], nil
} | go | {
"resource": ""
} |
q23125 | baseTwoKeys | train | func baseTwoKeys(key []byte) (string, string, error) {
parts := bytes.Split(key, []byte{backend.Separator})
if len(parts) < 2 {
return "", "", trace.NotFound("failed parsing %v", string(key))
}
return string(parts[len(parts)-2]), string(parts[len(parts)-1]), nil
} | go | {
"resource": ""
} |
q23126 | NewWrapper | train | func NewWrapper(writer AccessPoint, cache ReadAccessPoint) AccessPoint {
return &Wrapper{
Write: writer,
ReadAccessPoint: cache,
}
} | go | {
"resource": ""
} |
q23127 | UpsertNode | train | func (w *Wrapper) UpsertNode(s services.Server) (*services.KeepAlive, error) {
return w.Write.UpsertNode(s)
} | go | {
"resource": ""
} |
q23128 | UpsertAuthServer | train | func (w *Wrapper) UpsertAuthServer(s services.Server) error {
return w.Write.UpsertAuthServer(s)
} | go | {
"resource": ""
} |
q23129 | UpsertProxy | train | func (w *Wrapper) UpsertProxy(s services.Server) error {
return w.Write.UpsertProxy(s)
} | go | {
"resource": ""
} |
q23130 | UpsertTunnelConnection | train | func (w *Wrapper) UpsertTunnelConnection(conn services.TunnelConnection) error {
return w.Write.UpsertTunnelConnection(conn)
} | go | {
"resource": ""
} |
q23131 | DeleteTunnelConnection | train | func (w *Wrapper) DeleteTunnelConnection(clusterName, connName string) error {
return w.Write.DeleteTunnelConnection(clusterName, connName)
} | go | {
"resource": ""
} |
q23132 | SetShutdownPollPeriod | train | func SetShutdownPollPeriod(period time.Duration) ServerOption {
return func(s *Server) error {
s.shutdownPollPeriod = period
return nil
}
} | go | {
"resource": ""
} |
q23133 | Wait | train | func (s *Server) Wait(ctx context.Context) {
select {
case <-s.closeContext.Done():
case <-ctx.Done():
}
} | go | {
"resource": ""
} |
q23134 | Shutdown | train | func (s *Server) Shutdown(ctx context.Context) error {
// close listener to stop receiving new connections
err := s.Close()
s.Wait(ctx)
activeConnections := s.trackConnections(0)
if activeConnections == 0 {
return err
}
s.Infof("Shutdown: waiting for %v connections to finish.", activeConnections)
lastReport :... | go | {
"resource": ""
} |
q23135 | validateHostSigner | train | func validateHostSigner(signer ssh.Signer) error {
cert, ok := signer.PublicKey().(*ssh.Certificate)
if !ok {
return trace.BadParameter("only host certificates supported")
}
if len(cert.ValidPrincipals) == 0 {
return trace.BadParameter("at least one valid principal is required in host certificate")
}
certChe... | go | {
"resource": ""
} |
q23136 | KeysEqual | train | func KeysEqual(ak, bk ssh.PublicKey) bool {
a := ssh.Marshal(ak)
b := ssh.Marshal(bk)
return (len(a) == len(b) && subtle.ConstantTimeCompare(a, b) == 1)
} | go | {
"resource": ""
} |
q23137 | String | train | func (w *Watch) String() string {
return fmt.Sprintf("Watcher(name=%v, prefixes=%v)", w.Name, string(bytes.Join(w.Prefixes, []byte(", "))))
} | go | {
"resource": ""
} |
q23138 | GetString | train | func (p Params) GetString(key string) string {
v, ok := p[key]
if !ok {
return ""
}
s, _ := v.(string)
return s
} | go | {
"resource": ""
} |
q23139 | RangeEnd | train | func RangeEnd(key []byte) []byte {
end := make([]byte, len(key))
copy(end, key)
for i := len(end) - 1; i >= 0; i-- {
if end[i] < 0xff {
end[i] = end[i] + 1
end = end[:i+1]
return end
}
}
// next key does not exist (e.g., 0xffff);
return noEnd
} | go | {
"resource": ""
} |
q23140 | TTL | train | func TTL(clock clockwork.Clock, expires time.Time) time.Duration {
ttl := expires.Sub(clock.Now())
if ttl < time.Second {
return time.Second
}
return ttl
} | go | {
"resource": ""
} |
q23141 | EarliestExpiry | train | func EarliestExpiry(times ...time.Time) time.Time {
if len(times) == 0 {
return time.Time{}
}
sort.Sort(earliest(times))
return times[0]
} | go | {
"resource": ""
} |
q23142 | Expiry | train | func Expiry(clock clockwork.Clock, ttl time.Duration) time.Time {
if ttl == 0 {
return time.Time{}
}
return clock.Now().UTC().Add(ttl)
} | go | {
"resource": ""
} |
q23143 | Dial | train | func Dial(socket string) (net.Conn, error) {
conn, err := net.Dial("unix", socket)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | go | {
"resource": ""
} |
q23144 | NewAuthPreference | train | func NewAuthPreference(spec AuthPreferenceSpecV2) (AuthPreference, error) {
return &AuthPreferenceV2{
Kind: KindClusterAuthPreference,
Version: V2,
Metadata: Metadata{
Name: MetaNameClusterAuthPreference,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
} | go | {
"resource": ""
} |
q23145 | GetU2F | train | func (c *AuthPreferenceV2) GetU2F() (*U2F, error) {
if c.Spec.U2F == nil {
return nil, trace.NotFound("U2F configuration not found")
}
return c.Spec.U2F, nil
} | go | {
"resource": ""
} |
q23146 | CheckAndSetDefaults | train | func (c *AuthPreferenceV2) CheckAndSetDefaults() error {
// if nothing is passed in, set defaults
if c.Spec.Type == "" {
c.Spec.Type = teleport.Local
}
if c.Spec.SecondFactor == "" {
c.Spec.SecondFactor = teleport.OTP
}
// make sure type makes sense
switch c.Spec.Type {
case teleport.Local, teleport.OIDC, ... | go | {
"resource": ""
} |
q23147 | String | train | func (c *AuthPreferenceV2) String() string {
return fmt.Sprintf("AuthPreference(Type=%q,SecondFactor=%q)", c.Spec.Type, c.Spec.SecondFactor)
} | go | {
"resource": ""
} |
q23148 | GetAuthPreferenceSchema | train | func GetAuthPreferenceSchema(extensionSchema string) string {
var authPreferenceSchema string
if authPreferenceSchema == "" {
authPreferenceSchema = fmt.Sprintf(AuthPreferenceSpecSchemaTemplate, "")
} else {
authPreferenceSchema = fmt.Sprintf(AuthPreferenceSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.... | go | {
"resource": ""
} |
q23149 | proxyToSite | train | func (t *proxySubsys) proxyToSite(
ctx *srv.ServerContext, site reversetunnel.RemoteSite, remoteAddr net.Addr, ch ssh.Channel) error {
conn, err := site.DialAuthServer()
if err != nil {
return trace.Wrap(err)
}
t.log.Infof("Connected to auth server: %v", conn.RemoteAddr())
go func() {
var err error
defer ... | go | {
"resource": ""
} |
q23150 | ListenTLS | train | func ListenTLS(address string, certFile, keyFile string, cipherSuites []uint16) (net.Listener, error) {
tlsConfig, err := CreateTLSConfiguration(certFile, keyFile, cipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
return tls.Listen("tcp", address, tlsConfig)
} | go | {
"resource": ""
} |
q23151 | TLSConfig | train | func TLSConfig(cipherSuites []uint16) *tls.Config {
config := &tls.Config{}
// If ciphers suites were passed in, use them. Otherwise use the the
// Go defaults.
if len(cipherSuites) > 0 {
config.CipherSuites = cipherSuites
}
// Pick the servers preferred ciphersuite, not the clients.
config.PreferServerCiphe... | go | {
"resource": ""
} |
q23152 | CreateTLSConfiguration | train | func CreateTLSConfiguration(certFile, keyFile string, cipherSuites []uint16) (*tls.Config, error) {
config := TLSConfig(cipherSuites)
if _, err := os.Stat(certFile); err != nil {
return nil, trace.BadParameter("certificate is not accessible by '%v'", certFile)
}
if _, err := os.Stat(keyFile); err != nil {
retu... | go | {
"resource": ""
} |
q23153 | GenerateSelfSignedCert | train | func GenerateSelfSignedCert(hostNames []string) (*TLSCredentials, error) {
priv, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, trace.Wrap(err)
}
notBefore := time.Now()
notAfter := notBefore.Add(time.Hour * 24 * 365 * 10) // 10 years
serialNumberLimit := new(big.Int).Lsh(... | go | {
"resource": ""
} |
q23154 | CipherSuiteMapping | train | 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 | {
"resource": ""
} |
q23155 | NewTerminal | train | 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... | go | {
"resource": ""
} |
q23156 | newLocalTerminal | train | 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 %... | go | {
"resource": ""
} |
q23157 | Run | train | 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 {
... | go | {
"resource": ""
} |
q23158 | Wait | train | 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.Sy... | go | {
"resource": ""
} |
q23159 | Kill | train | 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 | {
"resource": ""
} |
q23160 | Close | train | 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 | {
"resource": ""
} |
q23161 | GetWinSize | train | 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 | {
"resource": ""
} |
q23162 | SetWinSize | train | 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 | {
"resource": ""
} |
q23163 | GetTerminalParams | train | func (t *terminal) GetTerminalParams() rsession.TerminalParams {
t.mu.Lock()
defer t.mu.Unlock()
return t.params
} | go | {
"resource": ""
} |
q23164 | SetTermType | train | func (t *terminal) SetTermType(term string) {
if term == "" {
term = defaultTerm
}
t.termType = term
} | go | {
"resource": ""
} |
q23165 | setOwner | train | 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 tra... | go | {
"resource": ""
} |
q23166 | prepareRemoteSession | train | 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.SSHTeleportClusterN... | go | {
"resource": ""
} |
q23167 | NewAuthServer | train | 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(c... | go | {
"resource": ""
} |
q23168 | SetCache | train | func (a *AuthServer) SetCache(clt AuthCache) {
a.lock.Lock()
defer a.lock.Unlock()
a.cache = clt
} | go | {
"resource": ""
} |
q23169 | GetCache | train | func (a *AuthServer) GetCache() AuthCache {
a.lock.RLock()
defer a.lock.RUnlock()
if a.cache == nil {
return &a.AuthServices
}
return a.cache
} | go | {
"resource": ""
} |
q23170 | runPeriodicOperations | train | 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())... | go | {
"resource": ""
} |
q23171 | SetClock | train | func (a *AuthServer) SetClock(clock clockwork.Clock) {
a.lock.Lock()
defer a.lock.Unlock()
a.clock = clock
} | go | {
"resource": ""
} |
q23172 | GetClusterConfig | train | func (a *AuthServer) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
return a.GetCache().GetClusterConfig(opts...)
} | go | {
"resource": ""
} |
q23173 | GetClusterName | train | func (a *AuthServer) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
return a.GetCache().GetClusterName(opts...)
} | go | {
"resource": ""
} |
q23174 | GetDomainName | train | func (a *AuthServer) GetDomainName() (string, error) {
clusterName, err := a.GetClusterName()
if err != nil {
return "", trace.Wrap(err)
}
return clusterName.GetClusterName(), nil
} | go | {
"resource": ""
} |
q23175 | GenerateUserCerts | train | 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 e... | go | {
"resource": ""
} |
q23176 | WithUserLock | train | 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 fa... | go | {
"resource": ""
} |
q23177 | PreAuthenticatedSignIn | train | 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 | {
"resource": ""
} |
q23178 | ExtendWebSession | train | 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, s... | go | {
"resource": ""
} |
q23179 | CreateWebSession | train | 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().GenerateWebSessi... | go | {
"resource": ""
} |
q23180 | CheckAndSetDefaults | train | 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 != ... | go | {
"resource": ""
} |
q23181 | GenerateToken | train | 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 := ... | go | {
"resource": ""
} |
q23182 | ExtractHostID | train | 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 | {
"resource": ""
} |
q23183 | ValidateToken | train | 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.G... | go | {
"resource": ""
} |
q23184 | checkTokenTTL | train | 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 | {
"resource": ""
} |
q23185 | CheckAndSetDefaults | train | 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 | {
"resource": ""
} |
q23186 | NewWatcher | train | func (a *AuthServer) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return a.GetCache().NewWatcher(ctx, watch)
} | go | {
"resource": ""
} |
q23187 | Error | train | func (k *authKeepAliver) Error() error {
k.RLock()
defer k.RUnlock()
return k.err
} | go | {
"resource": ""
} |
q23188 | oidcConfigsEqual | train | 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 {
i... | go | {
"resource": ""
} |
q23189 | oauth2ConfigsEqual | train | 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 ... | go | {
"resource": ""
} |
q23190 | isHTTPS | train | 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 | {
"resource": ""
} |
q23191 | NewOIDCConnector | train | func NewOIDCConnector(name string, spec OIDCConnectorSpecV2) OIDCConnector {
return &OIDCConnectorV2{
Kind: KindOIDCConnector,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | go | {
"resource": ""
} |
q23192 | UnmarshalOIDCConnector | train | 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)
}
s... | go | {
"resource": ""
} |
q23193 | MarshalOIDCConnector | train | 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 := c... | go | {
"resource": ""
} |
q23194 | V1 | train | 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,
... | go | {
"resource": ""
} |
q23195 | GetClaims | train | func (o *OIDCConnectorV2) GetClaims() []string {
var out []string
for _, mapping := range o.Spec.ClaimsToRoles {
out = append(out, mapping.Claim)
}
return utils.Deduplicate(out)
} | go | {
"resource": ""
} |
q23196 | MapClaims | train | 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 {
c... | go | {
"resource": ""
} |
q23197 | GetClaimNames | train | func GetClaimNames(claims jose.Claims) []string {
var out []string
for claim := range claims {
out = append(out, claim)
}
return out
} | go | {
"resource": ""
} |
q23198 | V2 | train | 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,
... | go | {
"resource": ""
} |
q23199 | Authenticate | train | 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 | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.