id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23400 | key.privPem, key.pubBytes, nil
default:
return GenerateKeyPair("")
}
} | |
c23401 | continue
}
key := keyPair{
privPem: privPem,
pubBytes: pubBytes,
}
select {
case <-k.ctx.Done():
log.Infof("Stopping key precomputation routine.")
return
case k.keysCh <- key:
continue
}
}
} | |
c23402 | uint64(k.clock.Now().UTC().Add(-1 * time.Minute).Unix()),
ValidBefore: validBefore,
CertType: ssh.HostCert,
}
cert.Permissions.Extensions = make(map[string]string)
cert.Permissions.Extensions[utils.CertExtensionRole] = c.Roles.String()
cert.Permissions.Extensions[utils.CertExtensionAuthority] = st... | |
c23403 | 0 {
// only add roles to the certificate extensions if the standard format was
// requested. we allow the option to omit this to support older versions of
// OpenSSH due to a bug in <= OpenSSH 7.1
// https://bugzilla.mindrot.org/show_bug.cgi?id=2387
if c.CertificateFormat == teleport.CertificateFormatStandar... | |
c23404 |
h.Infof("Setting up bucket %q, sessions path %q in region %q.", h.Bucket, h.Path, h.Region)
if err := h.ensureBucket(); err != nil {
return nil, trace.Wrap(err)
}
h.WithFields(log.Fields{"duration": time.Now().Sub(start)}).Infof("Setup bucket %q completed.", h.Bucket)
return h, nil
} | |
c23405 |
Body: reader,
ServerSideEncryption: aws.String(s3.ServerSideEncryptionAwsKms),
})
if err != nil {
return "", ConvertS3Error(err)
}
return fmt.Sprintf("%v://%v/%v", teleport.SchemeS3, l.Bucket, path), nil
} | |
c23406 | {
return ConvertS3Error(err)
}
if written == 0 {
return trace.NotFound("recording for %v is not found", sessionID)
}
return nil
} | |
c23407 | VersionId: ver.VersionId,
})
if err != nil {
return ConvertS3Error(err)
}
}
_, err = h.client.DeleteBucket(&s3.DeleteBucketInput{
Bucket: aws.String(h.Bucket),
})
return ConvertS3Error(err)
} | |
c23408 | Bucket: aws.String(h.Bucket),
ServerSideEncryptionConfiguration: &s3.ServerSideEncryptionConfiguration{
Rules: []*s3.ServerSideEncryptionRule{&s3.ServerSideEncryptionRule{
ApplyServerSideEncryptionByDefault: &s3.ServerSideEncryptionByDefault{
SSEAlgorithm: aws.String(s3.ServerSideEncryptionAwsKms),
... | |
c23409 | case s3.ErrCodeBucketAlreadyExists, s3.ErrCodeBucketAlreadyOwnedByYou:
return trace.AlreadyExists(aerr.Error(), args...)
default:
return trace.BadParameter(aerr.Error(), args...)
}
}
return err
} | |
c23410 | Role(val)
if err := role.Check(); err != nil {
return nil, trace.Wrap(err)
}
roles = append(roles, role)
}
return roles, nil
} | |
c23411 | {
return nil, trace.Wrap(err)
}
roles = append(roles, r)
}
return roles, nil
} | |
c23412 | == role {
return true
}
}
return false
} | |
c23413 |
s = append(s, r.String())
}
return s
} | |
c23414 | !other.Include(r) {
return false
}
}
return true
} | |
c23415 |
return trace.Wrap(err)
}
*r = val
return nil
} | |
c23416 |
return "trusted_cluster"
default:
return fmt.Sprintf("%v", string(*r))
}
} | |
c23417 |
RoleTrustedCluster, LegacyClusterTokenType,
RoleSignup, RoleProxy, RoleNop:
return nil
}
return trace.BadParameter("role %v is not registered", *r)
} | |
c23418 | == nil {
cfg.Clock = clockwork.NewRealClock()
}
if cfg.Sync == "" {
cfg.Sync = syncOFF
}
if cfg.BusyTimeout == 0 {
cfg.BusyTimeout = busyTimeout
}
if cfg.MemoryName == "" {
cfg.MemoryName = defaultDBFile
}
return nil
} | |
c23419 | return nil, trace.BadParameter("SQLite configuration is invalid: %v", err)
}
return NewWithConfig(ctx, *cfg)
} | |
c23420 | db,
Entry: log.WithFields(log.Fields{trace.Component: BackendName}),
clock: cfg.Clock,
buf: buf,
ctx: closeCtx,
cancel: cancel,
watchStarted: watchStarted,
signalWatchStart: signalWatchStart,
}
l.Debugf("Connected to: %v, poll st... | |
c23421 | row = tx.QueryRowContext(l.ctx, "PRAGMA busy_timeout;")
if err := row.Scan(&timeoutValue); err != nil {
return trace.Wrap(err)
}
l.Debugf("Synchronous: %v, busy timeout: %v", syncValue, timeoutValue)
return nil
})
} | |
c23422 | }
row := q.QueryRowContext(ctx)
if err := row.Scan(&imported); err != nil {
if err != sql.ErrNoRows {
return trace.Wrap(err)
}
}
return nil
})
return imported, err
} | |
c23423 | := row.Scan(&imported); err != nil {
if err != sql.ErrNoRows {
return trace.Wrap(err)
}
}
if imported {
return trace.AlreadyExists("database has been already imported")
}
if err := l.putRangeInTransaction(ctx, tx, items, true); err != nil {
return trace.Wrap(err)
}
stmt, err := tx.Prepare... | |
c23424 | > ?) LIMIT 1")
if err != nil {
return trace.Wrap(err)
}
row := q.QueryRowContext(ctx, string(key), now)
var expires NullTime
if err := row.Scan(&item.Key, &item.Value, &expires, &item.ID); err != nil {
if err == sql.ErrNoRows {
return trace.NotFound("key %v is not found", string(key))
}
return trace.Wr... | |
c23425 | buf.WriteString(fmt.Sprintf("git:%s ", teleport.Gitref))
buf.WriteString(runtime.Version())
fmt.Println(buf.String())
} | |
c23426 |
teleport.TraitLogins: logins,
teleport.TraitKubeGroups: kubeGroups,
}
} | |
c23427 | Kind: KindGithubConnector,
Version: V3,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | |
c23428 | time.Time) {
c.Metadata.SetExpiry(expires)
} | |
c23429 | {
c.Metadata.SetTTL(clock, ttl)
} | |
c23430 | belongs to this team
if team == mapping.Team {
logins = append(logins, mapping.Logins...)
kubeGroups = append(kubeGroups, mapping.KubeGroups...)
}
}
}
return utils.Deduplicate(logins), utils.Deduplicate(kubeGroups)
} | |
c23431 | trace.Wrap(err)
}
if err := c.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &c, nil
}
return nil, trace.BadParameter(
"Github connector resource version %q is not supported", h.Version)
} | |
c23432 | *GithubConnectorV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c... | |
c23433 | backend.Key(tokensPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | |
c23434 | },
Spec: spec,
}
if err := cc.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &cc, nil
} | |
c23435 | nil {
return &cfg, nil
}
if err := utils.ObjectToStruct(in, &cfg); err != nil {
return nil, trace.Wrap(err)
}
return &cfg, nil
} | |
c23436 | time.Duration) {
c.Spec.ClientIdleTimeout = Duration(d)
} | |
c23437 | bool) {
c.Spec.DisconnectExpiredCert = NewBool(b)
} | |
c23438 | time.Duration) {
c.Spec.KeepAliveInterval = Duration(t)
} | |
c23439 | c.Spec.SessionRecording, c.Spec.ClusterID, c.Spec.ProxyChecksHostKeys)
} | |
c23440 | fmt.Sprintf(ClusterConfigSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, clusterConfigSchema, DefaultDefinitions)
} | |
c23441 | return nil, trace.BadParameter(err.Error())
}
}
err = clusterConfig.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
clusterConfig.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
clusterConfig.SetExpiry(cfg.Expires)
}
return &clusterConfig, nil
} | |
c23442 | *ClusterConfigV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
... | |
c23443 | fmt.Sprintf("minimum client version supported by the server "+
"is %v. Please upgrade the client, downgrade the server, or use the "+
"--skip-version-check flag to by-pass this check.", minClientVersion)
return trace.BadParameter(errorMessage)
}
return nil
} | |
c23444 | ctx,
command: command,
session: ctx.RemoteSession,
}, nil
}
// Otherwise return a *localExec which will execute locally on the server.
// used by the regular Teleport nodes.
return &localExec{
Ctx: ctx,
Command: command,
}, nil
} | |
c23445 | // emit the result of execution to the audit log
emitExecAuditEvent(e.Ctx, e.GetCommand(), execResult, err)
return execResult, trace.Wrap(err)
} | |
c23446 | it exited in failure
execResult, err := r.collectRemoteStatus(r.session.Wait())
// emit the result of execution to the audit log
emitExecAuditEvent(r.ctx, r.command, execResult, err)
return execResult, trace.Wrap(err)
} | |
c23447 | }
_, teleportBinary := filepath.Split(teleportPath)
// Extract the name of the executable that was run. The command was secure
// copy if the executable was "scp" or "teleport".
_, executable := filepath.Split(parts[0])
switch executable {
case teleport.SCP, teleportBinary:
return parts[len(parts)-1], action,... | |
c23448 |
}
if _, err = output.Write([]byte(data)); err != nil {
return trace.Wrap(err)
}
if _, err = output.Write([]byte("\n")); err != nil {
return trace.Wrap(err)
}
}
}
// dump user identity into separate files:
case IdentityFormatOpenSSH:
keyPath := filePath
certPath := keyPath + "-... | |
c23449 | return trace.BadParameter("path %q does not exist or is not a directory", s.Directory)
}
return nil
} | |
c23450 | Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component(teleport.SchemeFile),
}),
Config: cfg,
}
return h, nil
} | |
c23451 | defer f.Close()
_, err = io.Copy(writer.(io.Writer), f)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23452 | err = io.Copy(f, reader)
if err != nil {
return "", trace.Wrap(err)
}
return fmt.Sprintf("%v://%v", teleport.SchemeFile, path), nil
} | |
c23453 | if t.Expiry().Unix() > 0 {
expiry = t.Expiry().Format(time.RFC822)
}
table.AddRow([]string{t.GetName(), t.GetRoles().String(), expiry})
}
return table.AsBuffer().String()
}
fmt.Printf(tokensView())
} else {
data, err := json.MarshalIndent(tokens, "", " ")
if err != nil {
return trace.... | |
c23454 | := tlsca.ParseCertificatePEM(localCA.TLSCA)
if err != nil {
return "", trace.Wrap(err)
}
return utils.CalculateSPKI(tlsCA), nil
} | |
c23455 | whitelistPattern.Match(s) && !blacklistPattern.Match(s)
} | |
c23456 | }
if len(r.PublicKey) == 0 {
return trace.BadParameter("missing PublicKey")
}
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
return nil
} | |
c23457 | = "https://" + net.JoinHostPort(host, port)
u, err := url.Parse(proxyAddr)
if err != nil {
return nil, trace.BadParameter("'%v' is not a valid proxy address", proxyAddr)
}
var opts []roundtrip.ClientParam
if insecure {
// Skip https cert verification, print a warning that this is insecure.
fmt.Printf("WAR... | |
c23458 | User: user,
Password: password,
OTPToken: otpToken,
PubKey: pubKey,
TTL: ttl,
Compatibility: compatibility,
})
if err != nil {
return nil, trace.Wrap(err)
}
var out *auth.SSHLoginResponse
err = json.Unmarshal(re.Bytes(), &out)
if err != nil {
return nil, trace.W... | |
c23459 | var packedKeys *auth.PackedKeys
err = json.Unmarshal(resp.Bytes(), &packedKeys)
if err != nil {
return nil, trace.Wrap(err)
}
return packedKeys, nil
} | |
c23460 | backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)))
} | |
c23461 |
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, role)
}
sort.Sort(services.SortedRoles(out))
return out, nil
} | |
c23462 | Value: value,
Expires: role.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23463 |
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("role %v is not found", name)
}
return nil, trace.Wrap(err)
}
return services.GetRoleMarshaler().UnmarshalRole(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | |
c23464 |
if trace.IsNotFound(err) {
return trace.NotFound("role %q is not found", name)
}
}
return trace.Wrap(err)
} | |
c23465 | if !a.checker.HasRole(name) {
return false
}
return true
} | |
c23466 | a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbRotate); err != nil {
return trace.Wrap(err)
}
return a.authServer.RotateExternalCertAuthority(ca)
} | |
c23467 | a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.UpsertCertAuthority(ca)
} | |
c23468 | != nil {
return trace.Wrap(err)
}
if err := a.action(namespace, services.KindNode, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.UpsertNodes(namespace, servers)
} | |
c23469 | nodes, nil
}
// Fetch services.RoleSet for the identity of the logged in user.
roles, err := services.FetchRoles(a.user.GetRoles(), a.authServer, a.user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Extract all unique allowed logins across all roles.
allowedLogins := make(map[string]bool)
f... | |
c23470 | services.KindProxy, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteProxy(name)
} | |
c23471 | services.KindNamespace, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteNamespace(name)
} | |
c23472 | services.KindRole, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteRole(name)
} | |
c23473 | != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterConfig(opts...)
} | |
c23474 | services.KindClusterConfig, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterConfig()
} | |
c23475 | services.KindClusterName, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterName()
} | |
c23476 | != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.SetClusterConfig(c)
} | |
c23477 | err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterName()
} | |
c23478 | != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
return a.authServer.SetClusterName(c)
} | |
c23479 | authServer: authServer,
checker: ctx.Checker,
user: ctx.User,
alog: alog,
sessions: sessions,
}, nil
} | |
c23480 | authServer: authServer,
checker: checker,
sessions: sessions,
user: user,
alog: alog,
}
} | |
c23481 | & int(os.ModePerm))
if err := os.Chmod(path, chmode); err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23482 | nil && !os.IsExist(err) {
return trace.ConvertSystemError(err)
}
return nil
} | |
c23483 | != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | |
c23484 | != nil {
return nil, trace.Wrap(err)
}
return info, nil
} | |
c23485 | err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | |
c23486 | fis {
fi := fis[i]
info, err := makeFileInfo(filepath.Join(l.GetPath(), fi.Name()))
if err != nil {
return nil, trace.Wrap(err)
}
infos[i] = info
}
return infos, nil
} | |
c23487 | l.fileInfo.Mode() & os.ModePerm
} | |
c23488 | s.connections[i].Close()
}
s.connections = []*remoteConn{}
return nil
} | |
c23489 |
// had a chance to start handling connection requests,
// what could lead to proxy marking the connection
// as invalid without a good reason.
if remoteConn.isReady() {
return remoteConn, nil
}
}
return nil, trace.NotFound("%v is offline: no active tunnels to %v found", s.GetName(), s.srv.ClusterName)
... | |
c23490 | count == 0 {
return
}
s.lastUsed = 0
conns := make([]*remoteConn, 0, len(s.connections)-count)
for i := range s.connections {
if !s.connections[i].isInvalid() {
conns = append(conns, s.connections[i])
} else {
go s.connections[i].Close()
}
}
s.connections = conns
} | |
c23491 | string(services.ProxyTunnel),
proxyName: s.connInfo.GetProxyName(),
clusterName: s.domainName,
})
s.connections = append(s.connections, rconn)
s.lastUsed = 0
return rconn, nil
} | |
c23492 | connInfo.GetClusterName(), s.connInfo.GetName())
} | |
c23493 | s.WithFields(log.Fields{"latency": roundtrip}).Debugf("ping <- %v", conn.conn.RemoteAddr())
} else {
s.Debugf("Ping <- %v.", conn.conn.RemoteAddr())
}
tm := time.Now().UTC()
conn.setLastHeartbeat(tm)
go s.registerHeartbeat(tm)
// since we block on select, time.After is re-created everytime we pro... | |
c23494 | services.HostCA,
DomainName: s.domainName,
}, false)
if err != nil {
return trace.Wrap(err)
}
if remoteCA.GetClusterName() != s.domainName {
return trace.BadParameter(
"remote cluster sent different cluster name %v instead of expected one %v",
remoteCA.GetClusterName(), s.domainName)
}
err = s.l... | |
c23495 | parameter Backend")
}
if r.Component == "" {
r.Component = teleport.ComponentBackend
}
return nil
} | |
c23496 |
}
r := &Reporter{
ReporterConfig: cfg,
}
return r, nil
} | |
c23497 | = teleport.TagTrue
}
counter, err := requests.GetMetricWithLabelValues(s.Component, string(bytes.Join(parts, []byte{Separator})), rangeSuffix)
if err != nil {
log.Warningf("Failed to get counter: %v", err)
return
}
counter.Inc()
} | |
c23498 | w,
Component: component,
}
go rw.watch(ctx)
return rw
} | |
c23499 | t.columns[i].title = headers[i]
t.columns[i].width = len(headers[i])
}
return t
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.