id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23100 |
for _, conn := range tracker {
conn.Close()
}
delete(l.connections, backend)
} | |
c23101 | append(l.backends, b)
l.Debugf("backends %v", l.backends)
} | |
c23102 |
l.backends = append(l.backends[:i], l.backends[i+1:]...)
l.dropConnections(b)
return
}
}
} | |
c23103 | := l.Listen(); err != nil {
return trace.Wrap(err)
}
return l.Serve()
} | |
c23104 | return trace.ConvertSystemError(err)
}
l.Debugf("created listening socket")
return nil
} | |
c23105 | if l.isClosed() {
return trace.ConnectionProblem(nil, "listener is closed")
}
select {
case <-backoffTimer.C:
l.Debugf("backoff on network error")
case <-l.ctx.Done():
return trace.ConnectionProblem(nil, "context is closing")
}
}
go l.forwardConnection(conn)
}
} | |
c23106 | 0640)
if err != nil {
return nil, trace.Wrap(err)
}
sessionLogger := &DiskSessionLogger{
DiskSessionLoggerConfig: cfg,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentAuditLog,
trace.ComponentFields: log.Fields{
"sid": cfg.SessionID,
},
}),
sessionDir: sessionDir,
... | |
c23107 | defer sl.Unlock()
return sl.finalize()
} | |
c23108 | nil {
err = sl.chunksFile.Flush()
}
if sl.eventsFile != nil {
err2 = sl.eventsFile.Flush()
}
return trace.NewAggregate(err, err2)
} | |
c23109 | filepath.Join(dataDir, fmt.Sprintf("%v-%v.events.gz", sessionID.String(), eventIndex))
} | |
c23110 | filepath.Join(dataDir, fmt.Sprintf("%v-%v.chunks.gz", sessionID.String(), offset))
} | |
c23111 | := sl.writeChunk(slice.SessionID, slice.Chunks[i])
if err != nil {
return trace.Wrap(err)
}
}
return sl.flush()
} | |
c23112 |
fields[EventIndex] = chunk.EventIndex
fields[EventTime] = eventStart
fields[EventType] = chunk.EventType
if fields[EventID] == "" {
fields[EventID] = uuid.New()
}
return fields, nil
} | |
c23113 | errors = append(errors, f.file.Close())
f.file = nil
}
return trace.NewAggregate(errors...)
} | |
c23114 | f.ReadCloser = nil
}
if f.file != nil {
errors = append(errors, f.file.Close())
f.file = nil
}
return trace.NewAggregate(errors...)
} | |
c23115 | return "Auth"
default:
return fmt.Sprintf("<unknown: %v>", int(h))
}
} | |
c23116 | Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component(cfg.Component, "beat"),
}),
checkTicker: time.NewTicker(cfg.CheckPeriod),
announceC: make(chan struct{}, 1),
sendC: make(chan struct{}, 1),
}
h.Debugf("Starting %v heartbeat with announce period: %v, keep-alive period %v, poll p... | |
c23117 | case <-h.checkTicker.C:
case <-h.sendC:
h.Debugf("Asked check out of cycle")
case <-h.cancelCtx.Done():
h.Debugf("Heartbeat exited.")
return nil
}
}
} | |
c23118 | 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
}
} | |
c23119 | // Stay in keep alive state in case
// if there are no changes
case HeartbeatStateKeepAliveWait:
// time to send a new keep alive
if h.Clock.Now().UTC().After(h.nextKeepAlive) {
h.setState(HeartbeatStateKeepAlive)
return nil
}
result := services.CompareServers(h.current, server)
// server update ha... | |
c23120 | if err := h.announce(); err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23121 | return nil
case <-timeoutC:
return trace.ConnectionProblem(nil, "timeout waiting for announce to be sent")
}
} | |
c23122 | if len(requests) == 0 {
return nil
}
req, _ := b.svc.BatchWriteItemRequest(&dynamodb.BatchWriteItemInput{
RequestItems: map[string][]*dynamodb.WriteRequest{
b.Tablename: requests,
},
})
err = req.Send()
err = convertError(err)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23123 | logrus.WithFields(logrus.Fields{trace.Component: "Events"}),
backend: b,
}
} | |
c23124 | nil, trace.NotFound("failed parsing %v", string(key))
}
return parts[len(parts)-offset-1], nil
} | |
c23125 | "", "", trace.NotFound("failed parsing %v", string(key))
}
return string(parts[len(parts)-2]), string(parts[len(parts)-1]), nil
} | |
c23126 | writer,
ReadAccessPoint: cache,
}
} | |
c23127 | {
return w.Write.UpsertNode(s)
} | |
c23128 | w.Write.UpsertAuthServer(s)
} | |
c23129 | error {
return w.Write.UpsertProxy(s)
} | |
c23130 | w.Write.UpsertTunnelConnection(conn)
} | |
c23131 | return w.Write.DeleteTunnelConnection(clusterName, connName)
} | |
c23132 | s.shutdownPollPeriod = period
return nil
}
} | |
c23133 | case <-s.closeContext.Done():
case <-ctx.Done():
}
} | |
c23134 |
}
if time.Now().Sub(lastReport) > 10*s.shutdownPollPeriod {
s.Infof("Shutdown: waiting for %v connections to finish.", activeConnections)
lastReport = time.Now()
}
case <-ctx.Done():
s.Infof("Context cancelled wait, returning.")
return trace.ConnectionProblem(err, "context cancelled")
}
}
} | |
c23135 |
certChecker := utils.CertChecker{}
err := certChecker.CheckCert(cert.ValidPrincipals[0], cert)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23136 |
b := ssh.Marshal(bk)
return (len(a) == len(b) && subtle.ConstantTimeCompare(a, b) == 1)
} | |
c23137 | string(bytes.Join(w.Prefixes, []byte(", "))))
} | |
c23138 | return ""
}
s, _ := v.(string)
return s
} | |
c23139 | + 1
end = end[:i+1]
return end
}
}
// next key does not exist (e.g., 0xffff);
return noEnd
} | |
c23140 | time.Second {
return time.Second
}
return ttl
} | |
c23141 |
sort.Sort(earliest(times))
return times[0]
} | |
c23142 | return time.Time{}
}
return clock.Now().UTC().Add(ttl)
} | |
c23143 | return nil, trace.Wrap(err)
}
return conn, nil
} | |
c23144 | Version: V2,
Metadata: Metadata{
Name: MetaNameClusterAuthPreference,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
} | |
c23145 | == nil {
return nil, trace.NotFound("U2F configuration not found")
}
return c.Spec.U2F, nil
} | |
c23146 |
}
// make sure second factor makes sense
switch c.Spec.SecondFactor {
case teleport.OFF, teleport.OTP, teleport.U2F:
default:
return trace.BadParameter("second factor type %q not supported", c.Spec.SecondFactor)
}
return nil
} | |
c23147 | ndFactor=%q)", c.Spec.Type, c.Spec.SecondFactor)
} | |
c23148 | fmt.Sprintf(AuthPreferenceSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, authPreferenceSchema, DefaultDefinitions)
} | |
c23149 | io.Copy(ch, conn)
}()
go func() {
var err error
defer func() {
t.close(err)
}()
defer conn.Close()
_, err = io.Copy(conn, srv.NewTrackingReader(ctx, ch))
}()
return nil
} | |
c23150 | nil {
return nil, trace.Wrap(err)
}
return tls.Listen("tcp", address, tlsConfig)
} | |
c23151 | true
config.MinVersion = tls.VersionTLS12
config.SessionTicketsDisabled = false
config.ClientSessionCache = tls.NewLRUClientSessionCache(
DefaultLRUCapacity)
return config
} | |
c23152 | by '%v'", certFile)
}
if _, err := os.Stat(keyFile); err != nil {
return nil, trace.BadParameter("certificate is not accessible by '%v'", certFile)
}
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return nil, trace.Wrap(err)
}
config.Certificates = []tls.Certificate{cert}
return conf... | |
c23153 | and add them to the cert. template:
template.DNSNames = append(hostNames, "localhost.local")
ips, _ := net.LookupIP("localhost")
if ips != nil {
template.IPAddresses = ips
}
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
if err != nil {
return nil, trace.Wra... | |
c23154 | nil, trace.BadParameter("cipher suite not supported: %v", cs)
}
out = append(out, c)
}
return out, nil
} | |
c23155 | out what mode the cluster is in and
// return the correct terminal.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy {
return newRemoteTerminal(ctx)
}
return newLocalTerminal(ctx)
} | |
c23156 | 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
} | |
c23157 | cmd.SysProcAttr.Setctty = true
cmd.SysProcAttr.Setsid = true
err = cmd.Start()
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23158 | 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
} | |
c23159 | != "os: process already finished" {
return trace.Wrap(err)
}
}
}
return nil
} | |
c23160 | := t.tty.Close(); e != nil {
err = e
}
}
go t.closePTY()
return trace.Wrap(err)
} | |
c23161 | }
ws, err := term.GetWinsize(t.pty.Fd())
if err != nil {
return nil, trace.Wrap(err)
}
return ws, nil
} | |
c23162 |
if err := term.SetWinsize(t.pty.Fd(), params.Winsize()); err != nil {
return trace.Wrap(err)
}
t.params = params
return nil
} | |
c23163 | defer t.mu.Unlock()
return t.params
} | |
c23164 | term = defaultTerm
}
t.termType = term
} | |
c23165 | 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
} | |
c23166 | 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)
}
}
} | |
c23167 | 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: ... | |
c23168 | defer a.lock.Unlock()
a.cache = clt
} | |
c23169 | return &a.AuthServices
}
return a.cache
} | |
c23170 |
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 updat... | |
c23171 | defer a.lock.Unlock()
a.clock = clock
} | |
c23172 | return a.GetCache().GetClusterConfig(opts...)
} | |
c23173 | return a.GetCache().GetClusterName(opts...)
} | |
c23174 | return "", trace.Wrap(err)
}
return clusterName.GetClusterName(), nil
} | |
c23175 | roles: checker,
ttl: ttl,
compatibility: compatibility,
publicKey: key,
})
if err != nil {
return nil, nil, trace.Wrap(err)
}
return certs.ssh, certs.tls, nil
} | |
c23176 | 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(st... | |
c23177 | sess); err != nil {
return nil, trace.Wrap(err)
}
return sess.WithoutSecrets(), nil
} | |
c23178 |
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()... | |
c23179 | }
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | |
c23180 |
if req.Token == "" {
token, err := utils.CryptoRandomHex(TokenLenBytes)
if err != nil {
return trace.Wrap(err)
}
req.Token = token
}
return nil
} | |
c23181 | := 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
} | |
c23182 | suffix) {
return "", trace.BadParameter("expected suffix %q in %q", suffix, hostName)
}
return strings.TrimSuffix(hostName, suffix), nil
} | |
c23183 | 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
} | |
c23184 |
log.Warnf("Unable to delete token from backend: %v.", err)
}
}
return false
}
return true
} | |
c23185 | HostID")
}
if r.Token == "" {
return trace.BadParameter("missing parameter Token")
}
if err := r.Role.Check(); err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23186 | return a.GetCache().NewWatcher(ctx, watch)
} | |
c23187 | defer k.RUnlock()
return k.err
} | |
c23188 | != len(b.Scope) {
return false
}
for i := range a.Scope {
if a.Scope[i] != b.Scope[i] {
return false
}
}
return true
} | |
c23189 | 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
} | |
c23190 | return trace.BadParameter("expected scheme https, got %q", earl.Scheme)
}
return nil
} | |
c23191 | Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | |
c23192 | 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.BadPa... | |
c23193 | 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
... | |
c23194 | o.Spec.RedirectURL,
Display: o.Spec.Display,
Scope: o.Spec.Scope,
ClaimsToRoles: o.Spec.ClaimsToRoles,
}
} | |
c23195 | append(out, mapping.Claim)
}
return utils.Deduplicate(out)
} | |
c23196 | %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 ... | |
c23197 | out = append(out, claim)
}
return out
} | |
c23198 | o.ClientID,
ClientSecret: o.ClientSecret,
RedirectURL: o.RedirectURL,
Display: o.Display,
Scope: o.Scope,
ClaimsToRoles: o.ClaimsToRoles,
},
}
} | |
c23199 | c.CertChecker.Authenticate(conn, key)
if err != nil {
return nil, trace.Wrap(err)
}
return perms, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.