_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23400 | GetNewKeyPairFromPool | train | func (k *Keygen) GetNewKeyPairFromPool() ([]byte, []byte, error) {
select {
case key := <-k.keysCh:
return key.privPem, key.pubBytes, nil
default:
return GenerateKeyPair("")
}
} | go | {
"resource": ""
} |
q23401 | precomputeKeys | train | func (k *Keygen) precomputeKeys() {
for {
privPem, pubBytes, err := GenerateKeyPair("")
if err != nil {
log.Errorf("Unable to generate key pair: %v.", err)
continue
}
key := keyPair{
privPem: privPem,
pubBytes: pubBytes,
}
select {
case <-k.ctx.Done():
log.Infof("Stopping key precomputat... | go | {
"resource": ""
} |
q23402 | GenerateHostCert | train | func (k *Keygen) GenerateHostCert(c services.HostCertParams) ([]byte, error) {
if err := c.Check(); err != nil {
return nil, trace.Wrap(err)
}
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(c.PublicHostKey)
if err != nil {
return nil, trace.Wrap(err)
}
signer, err := ssh.ParsePrivateKey(c.PrivateCASigningKe... | go | {
"resource": ""
} |
q23403 | GenerateUserCert | train | func (k *Keygen) GenerateUserCert(c services.UserCertParams) ([]byte, error) {
if c.TTL < defaults.MinCertDuration {
return nil, trace.BadParameter("wrong certificate TTL")
}
if len(c.AllowedLogins) == 0 {
return nil, trace.BadParameter("allowedLogins: need allowed OS logins")
}
pubKey, _, _, _, err := ssh.Par... | go | {
"resource": ""
} |
q23404 | NewHandler | train | func NewHandler(cfg Config) (*Handler, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
h := &Handler{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component(teleport.SchemeS3),
}),
Config: cfg,
uploader: s3manager.NewUploader(cfg.Session),
... | go | {
"resource": ""
} |
q23405 | Upload | train | func (l *Handler) Upload(ctx context.Context, sessionID session.ID, reader io.Reader) (string, error) {
path := l.path(sessionID)
_, err := l.uploader.UploadWithContext(ctx, &s3manager.UploadInput{
Bucket: aws.String(l.Bucket),
Key: aws.String(path),
Body: reader,
... | go | {
"resource": ""
} |
q23406 | Download | train | func (l *Handler) Download(ctx context.Context, sessionID session.ID, writer io.WriterAt) error {
written, err := l.downloader.DownloadWithContext(ctx, writer, &s3.GetObjectInput{
Bucket: aws.String(l.Bucket),
Key: aws.String(l.path(sessionID)),
})
if err != nil {
return ConvertS3Error(err)
}
if written =... | go | {
"resource": ""
} |
q23407 | deleteBucket | train | func (h *Handler) deleteBucket() error {
// first, list and delete all the objects in the bucket
out, err := h.client.ListObjectVersions(&s3.ListObjectVersionsInput{
Bucket: aws.String(h.Bucket),
})
if err != nil {
return ConvertS3Error(err)
}
for _, ver := range out.Versions {
_, err := h.client.DeleteObje... | go | {
"resource": ""
} |
q23408 | ensureBucket | train | func (h *Handler) ensureBucket() error {
_, err := h.client.HeadBucket(&s3.HeadBucketInput{
Bucket: aws.String(h.Bucket),
})
err = ConvertS3Error(err)
// assumes that bucket is administered by other entity
if err == nil {
return nil
}
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
input := &s3.Crea... | go | {
"resource": ""
} |
q23409 | ConvertS3Error | train | func ConvertS3Error(err error, args ...interface{}) error {
if err == nil {
return nil
}
if aerr, ok := err.(awserr.Error); ok {
switch aerr.Code() {
case s3.ErrCodeNoSuchKey, s3.ErrCodeNoSuchBucket, s3.ErrCodeNoSuchUpload, "NotFound":
return trace.NotFound(aerr.Error(), args...)
case s3.ErrCodeBucketAlre... | go | {
"resource": ""
} |
q23410 | NewRoles | train | func NewRoles(in []string) (Roles, error) {
var roles Roles
for _, val := range in {
role := Role(val)
if err := role.Check(); err != nil {
return nil, trace.Wrap(err)
}
roles = append(roles, role)
}
return roles, nil
} | go | {
"resource": ""
} |
q23411 | ParseRoles | train | func ParseRoles(str string) (roles Roles, err error) {
for _, s := range strings.Split(str, ",") {
r := Role(strings.Title(strings.ToLower(strings.TrimSpace(s))))
if err = r.Check(); err != nil {
return nil, trace.Wrap(err)
}
roles = append(roles, r)
}
return roles, nil
} | go | {
"resource": ""
} |
q23412 | Include | train | func (roles Roles) Include(role Role) bool {
for _, r := range roles {
if r == role {
return true
}
}
return false
} | go | {
"resource": ""
} |
q23413 | StringSlice | train | func (roles Roles) StringSlice() []string {
s := make([]string, 0)
for _, r := range roles {
s = append(s, r.String())
}
return s
} | go | {
"resource": ""
} |
q23414 | Equals | train | func (roles Roles) Equals(other Roles) bool {
if len(roles) != len(other) {
return false
}
for _, r := range roles {
if !other.Include(r) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q23415 | Set | train | func (r *Role) Set(v string) error {
val := Role(strings.Title(v))
if err := val.Check(); err != nil {
return trace.Wrap(err)
}
*r = val
return nil
} | go | {
"resource": ""
} |
q23416 | String | train | func (r *Role) String() string {
switch string(*r) {
case string(RoleSignup):
return "User signup"
case string(RoleTrustedCluster), string(LegacyClusterTokenType):
return "trusted_cluster"
default:
return fmt.Sprintf("%v", string(*r))
}
} | go | {
"resource": ""
} |
q23417 | Check | train | func (r *Role) Check() error {
switch *r {
case RoleAuth, RoleWeb, RoleNode,
RoleAdmin, RoleProvisionToken,
RoleTrustedCluster, LegacyClusterTokenType,
RoleSignup, RoleProxy, RoleNop:
return nil
}
return trace.BadParameter("role %v is not registered", *r)
} | go | {
"resource": ""
} |
q23418 | CheckAndSetDefaults | train | func (cfg *Config) CheckAndSetDefaults() error {
if cfg.Path == "" && !cfg.Memory {
return trace.BadParameter("specify directory path to the database using 'path' parameter")
}
if cfg.BufferSize == 0 {
cfg.BufferSize = backend.DefaultBufferSize
}
if cfg.PollStreamPeriod == 0 {
cfg.PollStreamPeriod = backend.... | go | {
"resource": ""
} |
q23419 | New | train | func New(ctx context.Context, params backend.Params) (*LiteBackend, error) {
var cfg *Config
err := utils.ObjectToStruct(params, &cfg)
if err != nil {
return nil, trace.BadParameter("SQLite configuration is invalid: %v", err)
}
return NewWithConfig(ctx, *cfg)
} | go | {
"resource": ""
} |
q23420 | NewWithConfig | train | func NewWithConfig(ctx context.Context, cfg Config) (*LiteBackend, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
var connectorURL string
if !cfg.Memory {
// Ensure that the path to the root directory exists.
err := os.MkdirAll(cfg.Path, defaultDirMode)
if err != ni... | go | {
"resource": ""
} |
q23421 | showPragmas | train | func (l *LiteBackend) showPragmas() error {
return l.inTransaction(l.ctx, func(tx *sql.Tx) error {
row := tx.QueryRowContext(l.ctx, "PRAGMA synchronous;")
var syncValue string
if err := row.Scan(&syncValue); err != nil {
return trace.Wrap(err)
}
var timeoutValue string
row = tx.QueryRowContext(l.ctx, "P... | go | {
"resource": ""
} |
q23422 | Imported | train | func (l *LiteBackend) Imported(ctx context.Context) (imported bool, err error) {
err = l.inTransaction(ctx, func(tx *sql.Tx) error {
q, err := tx.PrepareContext(ctx,
"SELECT imported from meta LIMIT 1")
if err != nil {
return trace.Wrap(err)
}
row := q.QueryRowContext(ctx)
if err := row.Scan(&imported)... | go | {
"resource": ""
} |
q23423 | Import | train | func (l *LiteBackend) Import(ctx context.Context, items []backend.Item) error {
for i := range items {
if items[i].Key == nil {
return trace.BadParameter("missing parameter key in item %v", i)
}
}
err := l.inTransaction(ctx, func(tx *sql.Tx) error {
q, err := tx.PrepareContext(ctx,
"SELECT imported from ... | go | {
"resource": ""
} |
q23424 | getInTransaction | train | func (l *LiteBackend) getInTransaction(ctx context.Context, key []byte, tx *sql.Tx, item *backend.Item) error {
now := l.clock.Now().UTC()
q, err := tx.PrepareContext(ctx,
"SELECT key, value, expires, modified FROM kv WHERE key = ? AND (expires IS NULL OR expires > ?) LIMIT 1")
if err != nil {
return trace.Wrap(... | go | {
"resource": ""
} |
q23425 | PrintVersion | train | func (p *defaultModules) PrintVersion() {
var buf bytes.Buffer
buf.WriteString(fmt.Sprintf("Teleport v%s ", teleport.Version))
buf.WriteString(fmt.Sprintf("git:%s ", teleport.Gitref))
buf.WriteString(runtime.Version())
fmt.Println(buf.String())
} | go | {
"resource": ""
} |
q23426 | TraitsFromLogins | train | func (p *defaultModules) TraitsFromLogins(logins []string, kubeGroups []string) map[string][]string {
return map[string][]string{
teleport.TraitLogins: logins,
teleport.TraitKubeGroups: kubeGroups,
}
} | go | {
"resource": ""
} |
q23427 | NewGithubConnector | train | func NewGithubConnector(name string, spec GithubConnectorSpecV3) GithubConnector {
return &GithubConnectorV3{
Kind: KindGithubConnector,
Version: V3,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | go | {
"resource": ""
} |
q23428 | SetExpiry | train | func (c *GithubConnectorV3) SetExpiry(expires time.Time) {
c.Metadata.SetExpiry(expires)
} | go | {
"resource": ""
} |
q23429 | SetTTL | train | func (c *GithubConnectorV3) SetTTL(clock clockwork.Clock, ttl time.Duration) {
c.Metadata.SetTTL(clock, ttl)
} | go | {
"resource": ""
} |
q23430 | MapClaims | train | func (c *GithubConnectorV3) MapClaims(claims GithubClaims) ([]string, []string) {
var logins, kubeGroups []string
for _, mapping := range c.GetTeamsToLogins() {
teams, ok := claims.OrganizationToTeams[mapping.Organization]
if !ok {
// the user does not belong to this organization
continue
}
for _, team ... | go | {
"resource": ""
} |
q23431 | Unmarshal | train | func (*TeleportGithubConnectorMarshaler) Unmarshal(bytes []byte) (GithubConnector, error) {
var h ResourceHeader
if err := json.Unmarshal(bytes, &h); err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case V3:
var c GithubConnectorV3
if err := utils.UnmarshalWithSchema(GetGithubConnectorSchema(), ... | go | {
"resource": ""
} |
q23432 | Marshal | train | func (*TeleportGithubConnectorMarshaler) Marshal(c GithubConnector, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *GithubConnectorV3:
if !cfg.PreserveResourceID {
// avoid modifying the original obje... | go | {
"resource": ""
} |
q23433 | DeleteAllTokens | train | func (s *ProvisioningService) DeleteAllTokens() error {
startKey := backend.Key(tokensPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | {
"resource": ""
} |
q23434 | NewClusterConfig | train | func NewClusterConfig(spec ClusterConfigSpecV3) (ClusterConfig, error) {
cc := ClusterConfigV3{
Kind: KindClusterConfig,
Version: V3,
Metadata: Metadata{
Name: MetaNameClusterConfig,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := cc.CheckAndSetDefaults(); err != nil {
return nil,... | go | {
"resource": ""
} |
q23435 | AuditConfigFromObject | train | func AuditConfigFromObject(in interface{}) (*AuditConfig, error) {
var cfg AuditConfig
if in == nil {
return &cfg, nil
}
if err := utils.ObjectToStruct(in, &cfg); err != nil {
return nil, trace.Wrap(err)
}
return &cfg, nil
} | go | {
"resource": ""
} |
q23436 | SetClientIdleTimeout | train | func (c *ClusterConfigV3) SetClientIdleTimeout(d time.Duration) {
c.Spec.ClientIdleTimeout = Duration(d)
} | go | {
"resource": ""
} |
q23437 | SetDisconnectExpiredCert | train | func (c *ClusterConfigV3) SetDisconnectExpiredCert(b bool) {
c.Spec.DisconnectExpiredCert = NewBool(b)
} | go | {
"resource": ""
} |
q23438 | SetKeepAliveInterval | train | func (c *ClusterConfigV3) SetKeepAliveInterval(t time.Duration) {
c.Spec.KeepAliveInterval = Duration(t)
} | go | {
"resource": ""
} |
q23439 | String | train | func (c *ClusterConfigV3) String() string {
return fmt.Sprintf("ClusterConfig(SessionRecording=%v, ClusterID=%v, ProxyChecksHostKeys=%v)",
c.Spec.SessionRecording, c.Spec.ClusterID, c.Spec.ProxyChecksHostKeys)
} | go | {
"resource": ""
} |
q23440 | GetClusterConfigSchema | train | func GetClusterConfigSchema(extensionSchema string) string {
var clusterConfigSchema string
if clusterConfigSchema == "" {
clusterConfigSchema = fmt.Sprintf(ClusterConfigSpecSchemaTemplate, "")
} else {
clusterConfigSchema = fmt.Sprintf(ClusterConfigSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf... | go | {
"resource": ""
} |
q23441 | Unmarshal | train | func (t *TeleportClusterConfigMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (ClusterConfig, error) {
var clusterConfig ClusterConfigV3
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
i... | go | {
"resource": ""
} |
q23442 | Marshal | train | func (t *TeleportClusterConfigMarshaler) Marshal(c ClusterConfig, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *ClusterConfigV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
... | go | {
"resource": ""
} |
q23443 | CheckVersions | train | func CheckVersions(clientVersion string, minClientVersion string) error {
clientSemver, err := semver.NewVersion(clientVersion)
if err != nil {
return trace.Wrap(err,
"unsupported version format, need semver format: %q, e.g 1.0.0", clientVersion)
}
minClientSemver, err := semver.NewVersion(minClientVersion)
... | go | {
"resource": ""
} |
q23444 | NewExecRequest | train | func NewExecRequest(ctx *ServerContext, command string) (Exec, error) {
// It doesn't matter what mode the cluster is in, if this is a Teleport node
// return a local *localExec.
if ctx.srv.Component() == teleport.ComponentNode {
return &localExec{
Ctx: ctx,
Command: command,
}, nil
}
// When in rec... | go | {
"resource": ""
} |
q23445 | Wait | train | func (e *localExec) Wait() (*ExecResult, error) {
if e.Cmd.Process == nil {
e.Ctx.Errorf("no process")
}
// wait for the command to complete, then figure out if the command
// successfully exited or if it exited in failure
execResult, err := collectLocalStatus(e.Cmd, e.Cmd.Wait())
// emit the result of execut... | go | {
"resource": ""
} |
q23446 | Wait | train | func (r *remoteExec) Wait() (*ExecResult, error) {
// block until the command is finished and then figure out if the command
// successfully exited or if it exited in failure
execResult, err := r.collectRemoteStatus(r.session.Wait())
// emit the result of execution to the audit log
emitExecAuditEvent(r.ctx, r.com... | go | {
"resource": ""
} |
q23447 | parseSecureCopy | train | func parseSecureCopy(path string) (string, string, bool, error) {
parts := strings.Fields(path)
if len(parts) == 0 {
return "", "", false, trace.BadParameter("no executable found")
}
// Look for the -t flag, it indicates that an upload occurred. The other
// flags do no matter for now.
action := events.SCPActi... | go | {
"resource": ""
} |
q23448 | MakeIdentityFile | train | func MakeIdentityFile(filePath string, key *Key, format IdentityFileFormat, certAuthorities []services.CertAuthority) (err error) {
const (
// the files and the dir will be created with these permissions:
fileMode = 0600
dirMode = 0700
)
if filePath == "" {
return trace.BadParameter("identity location is n... | go | {
"resource": ""
} |
q23449 | CheckAndSetDefaults | train | func (s *Config) CheckAndSetDefaults() error {
if s.Directory == "" {
return trace.BadParameter("missing parameter Directory")
}
if !utils.IsDir(s.Directory) {
return trace.BadParameter("path %q does not exist or is not a directory", s.Directory)
}
return nil
} | go | {
"resource": ""
} |
q23450 | NewHandler | train | func NewHandler(cfg Config) (*Handler, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
h := &Handler{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Component(teleport.SchemeFile),
}),
Config: cfg,
}
return h, nil
} | go | {
"resource": ""
} |
q23451 | Download | train | func (l *Handler) Download(ctx context.Context, sessionID session.ID, writer io.WriterAt) error {
path := l.path(sessionID)
_, err := os.Stat(filepath.Dir(path))
f, err := os.Open(path)
if err != nil {
return trace.ConvertSystemError(err)
}
defer f.Close()
_, err = io.Copy(writer.(io.Writer), f)
if err != nil... | go | {
"resource": ""
} |
q23452 | Upload | train | func (l *Handler) Upload(ctx context.Context, sessionID session.ID, reader io.Reader) (string, error) {
path := l.path(sessionID)
f, err := os.Create(path)
if err != nil {
return "", trace.ConvertSystemError(err)
}
defer f.Close()
_, err = io.Copy(f, reader)
if err != nil {
return "", trace.Wrap(err)
}
ret... | go | {
"resource": ""
} |
q23453 | List | train | func (c *TokenCommand) List(client auth.ClientI) error {
tokens, err := client.GetTokens()
if err != nil {
return trace.Wrap(err)
}
if len(tokens) == 0 {
fmt.Println("No active tokens found.")
return nil
}
// Sort by expire time.
sort.Slice(tokens, func(i, j int) bool { return tokens[i].Expiry().Unix() < ... | go | {
"resource": ""
} |
q23454 | calculateCAPin | train | func calculateCAPin(client auth.ClientI) (string, error) {
localCA, err := client.GetClusterCACert()
if err != nil {
return "", trace.Wrap(err)
}
tlsCA, err := tlsca.ParseCertificatePEM(localCA.TLSCA)
if err != nil {
return "", trace.Wrap(err)
}
return utils.CalculateSPKI(tlsCA), nil
} | go | {
"resource": ""
} |
q23455 | isKeySafe | train | func isKeySafe(s []byte) bool {
return whitelistPattern.Match(s) && !blacklistPattern.Match(s)
} | go | {
"resource": ""
} |
q23456 | Check | train | func (r SSOLoginConsoleReq) Check() error {
if r.RedirectURL == "" {
return trace.BadParameter("missing RedirectURL")
}
if len(r.PublicKey) == 0 {
return trace.BadParameter("missing PublicKey")
}
if r.ConnectorID == "" {
return trace.BadParameter("missing ConnectorID")
}
return nil
} | go | {
"resource": ""
} |
q23457 | NewCredentialsClient | train | func NewCredentialsClient(proxyAddr string, insecure bool, pool *x509.CertPool) (*CredentialsClient, error) {
log := logrus.WithFields(logrus.Fields{
trace.Component: teleport.ComponentClient,
})
log.Debugf("HTTPS client init(proxyAddr=%v, insecure=%v)", proxyAddr, insecure)
// validate proxyAddr:
host, port, e... | go | {
"resource": ""
} |
q23458 | SSHAgentLogin | train | func (c *CredentialsClient) SSHAgentLogin(ctx context.Context, user string, password string, otpToken string, pubKey []byte, ttl time.Duration, compatibility string) (*auth.SSHLoginResponse, error) {
re, err := c.clt.PostJSON(ctx, c.clt.Endpoint("webapi", "ssh", "certs"), CreateSSHCertReq{
User: user,
Pas... | go | {
"resource": ""
} |
q23459 | HostCredentials | train | func (c *CredentialsClient) HostCredentials(ctx context.Context, req auth.RegisterUsingTokenRequest) (*auth.PackedKeys, error) {
resp, err := c.clt.PostJSON(ctx, c.clt.Endpoint("webapi", "host", "credentials"), req)
if err != nil {
return nil, trace.Wrap(err)
}
var packedKeys *auth.PackedKeys
err = json.Unmarsh... | go | {
"resource": ""
} |
q23460 | DeleteAllRoles | train | func (s *AccessService) DeleteAllRoles() error {
return s.DeleteRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)))
} | go | {
"resource": ""
} |
q23461 | GetRoles | train | func (s *AccessService) GetRoles() ([]services.Role, error) {
result, err := s.GetRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.Role, 0, len(result.Items))
for _, item := range resu... | go | {
"resource": ""
} |
q23462 | CreateRole | train | func (s *AccessService) CreateRole(role services.Role) error {
value, err := services.GetRoleMarshaler().MarshalRole(role)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(rolesPrefix, role.GetName(), paramsPrefix),
Value: value,
Expires: role.Expiry(),
}
_, err = s.... | go | {
"resource": ""
} |
q23463 | GetRole | train | func (s *AccessService) GetRole(name string) (services.Role, error) {
if name == "" {
return nil, trace.BadParameter("missing role name")
}
item, err := s.Get(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("role %v is not fo... | go | {
"resource": ""
} |
q23464 | DeleteRole | train | func (s *AccessService) DeleteRole(name string) error {
if name == "" {
return trace.BadParameter("missing role name")
}
err := s.Delete(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("role %q is not found", name)
}
}
return ... | go | {
"resource": ""
} |
q23465 | hasRemoteBuiltinRole | train | func (a *AuthWithRoles) hasRemoteBuiltinRole(name string) bool {
if _, ok := a.checker.(RemoteBuiltinRoleSet); !ok {
return false
}
if !a.checker.HasRole(name) {
return false
}
return true
} | go | {
"resource": ""
} |
q23466 | RotateExternalCertAuthority | train | func (a *AuthWithRoles) RotateExternalCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
ctx := &services.Context{User: a.user, Resource: ca}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbRo... | go | {
"resource": ""
} |
q23467 | UpsertCertAuthority | train | func (a *AuthWithRoles) UpsertCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
ctx := &services.Context{User: a.user, Resource: ca}
if err := a.actionWithContext(ctx, defaults.Namespace, services.KindCertAuthority, services.VerbCreate); e... | go | {
"resource": ""
} |
q23468 | UpsertNodes | train | func (a *AuthWithRoles) UpsertNodes(namespace string, servers []services.Server) error {
if err := a.action(namespace, services.KindNode, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(namespace, services.KindNode, services.VerbUpdate); err != nil {
return trace.Wrap(err)
}
retu... | go | {
"resource": ""
} |
q23469 | filterNodes | train | func (a *AuthWithRoles) filterNodes(nodes []services.Server) ([]services.Server, error) {
// For certain built-in roles, continue to allow full access and return
// the full set of nodes to not break existing clusters during migration.
//
// In addition, allow proxy (and remote proxy) to access all nodes for it's
... | go | {
"resource": ""
} |
q23470 | DeleteProxy | train | func (a *AuthWithRoles) DeleteProxy(name string) error {
if err := a.action(defaults.Namespace, services.KindProxy, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteProxy(name)
} | go | {
"resource": ""
} |
q23471 | DeleteNamespace | train | func (a *AuthWithRoles) DeleteNamespace(name string) error {
if err := a.action(defaults.Namespace, services.KindNamespace, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteNamespace(name)
} | go | {
"resource": ""
} |
q23472 | DeleteRole | train | func (a *AuthWithRoles) DeleteRole(name string) error {
if err := a.action(defaults.Namespace, services.KindRole, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteRole(name)
} | go | {
"resource": ""
} |
q23473 | GetClusterConfig | train | func (a *AuthWithRoles) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbRead); err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterConfig(opts...)
} | go | {
"resource": ""
} |
q23474 | DeleteClusterConfig | train | func (a *AuthWithRoles) DeleteClusterConfig() error {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterConfig()
} | go | {
"resource": ""
} |
q23475 | DeleteClusterName | train | func (a *AuthWithRoles) DeleteClusterName() error {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbDelete); err != nil {
return trace.Wrap(err)
}
return a.authServer.DeleteClusterName()
} | go | {
"resource": ""
} |
q23476 | SetClusterConfig | train | func (a *AuthWithRoles) SetClusterConfig(c services.ClusterConfig) error {
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterConfig, services.VerbUpdate); err != nil {
return tr... | go | {
"resource": ""
} |
q23477 | GetClusterName | train | func (a *AuthWithRoles) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbRead); err != nil {
return nil, trace.Wrap(err)
}
return a.authServer.GetClusterName()
} | go | {
"resource": ""
} |
q23478 | SetClusterName | train | func (a *AuthWithRoles) SetClusterName(c services.ClusterName) error {
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbCreate); err != nil {
return trace.Wrap(err)
}
if err := a.action(defaults.Namespace, services.KindClusterName, services.VerbUpdate); err != nil {
return trace.Wrap... | go | {
"resource": ""
} |
q23479 | NewAdminAuthServer | train | func NewAdminAuthServer(authServer *AuthServer, sessions session.Service, alog events.IAuditLog) (ClientI, error) {
ctx, err := NewAdminContext()
if err != nil {
return nil, trace.Wrap(err)
}
return &AuthWithRoles{
authServer: authServer,
checker: ctx.Checker,
user: ctx.User,
alog: alog,
... | go | {
"resource": ""
} |
q23480 | NewAuthWithRoles | train | func NewAuthWithRoles(authServer *AuthServer,
checker services.AccessChecker,
user services.User,
sessions session.Service,
alog events.IAuditLog) *AuthWithRoles {
return &AuthWithRoles{
authServer: authServer,
checker: checker,
sessions: sessions,
user: user,
alog: alog,
}
} | go | {
"resource": ""
} |
q23481 | SetChmod | train | func (l *localFileSystem) SetChmod(path string, mode int) error {
chmode := os.FileMode(mode & int(os.ModePerm))
if err := os.Chmod(path, chmode); err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23482 | MkDir | train | func (l *localFileSystem) MkDir(path string, mode int) error {
fileMode := os.FileMode(mode & int(os.ModePerm))
err := os.MkdirAll(path, fileMode)
if err != nil && !os.IsExist(err) {
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23483 | OpenFile | train | func (l *localFileSystem) OpenFile(filePath string) (io.ReadCloser, error) {
f, err := os.Open(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | go | {
"resource": ""
} |
q23484 | GetFileInfo | train | func (l *localFileSystem) GetFileInfo(filePath string) (FileInfo, error) {
info, err := makeFileInfo(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return info, nil
} | go | {
"resource": ""
} |
q23485 | CreateFile | train | func (l *localFileSystem) CreateFile(filePath string, length uint64) (io.WriteCloser, error) {
f, err := os.Create(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
return f, nil
} | go | {
"resource": ""
} |
q23486 | ReadDir | train | func (l *localFileInfo) ReadDir() ([]FileInfo, error) {
f, err := os.Open(l.filePath)
if err != nil {
return nil, trace.Wrap(err)
}
fis, err := f.Readdir(0)
if err != nil {
return nil, trace.Wrap(err)
}
infos := make([]FileInfo, len(fis))
for i := range fis {
fi := fis[i]
info, err := makeFileInfo(fil... | go | {
"resource": ""
} |
q23487 | GetModePerm | train | func (l *localFileInfo) GetModePerm() os.FileMode {
return l.fileInfo.Mode() & os.ModePerm
} | go | {
"resource": ""
} |
q23488 | Close | train | func (s *remoteSite) Close() error {
s.Lock()
defer s.Unlock()
s.cancel()
for i := range s.connections {
s.connections[i].Close()
}
s.connections = []*remoteConn{}
return nil
} | go | {
"resource": ""
} |
q23489 | nextConn | train | func (s *remoteSite) nextConn() (*remoteConn, error) {
s.Lock()
defer s.Unlock()
s.removeInvalidConns()
for i := 0; i < len(s.connections); i++ {
s.lastUsed = (s.lastUsed + 1) % len(s.connections)
remoteConn := s.connections[s.lastUsed]
// connection could have been initated, but agent
// on the other sid... | go | {
"resource": ""
} |
q23490 | removeInvalidConns | train | func (s *remoteSite) removeInvalidConns() {
// for first pass, do nothing if no connections are marked
count := 0
for _, conn := range s.connections {
if conn.isInvalid() {
count++
}
}
if count == 0 {
return
}
s.lastUsed = 0
conns := make([]*remoteConn, 0, len(s.connections)-count)
for i := range s.co... | go | {
"resource": ""
} |
q23491 | addConn | train | func (s *remoteSite) addConn(conn net.Conn, sconn ssh.Conn) (*remoteConn, error) {
s.Lock()
defer s.Unlock()
cn, err := s.localAccessPoint.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
rconn := newRemoteConn(&connConfig{
conn: conn,
sconn: sconn,
accessPoint: s.localAccessP... | go | {
"resource": ""
} |
q23492 | deleteConnectionRecord | train | func (s *remoteSite) deleteConnectionRecord() {
s.localAccessPoint.DeleteTunnelConnection(s.connInfo.GetClusterName(), s.connInfo.GetName())
} | go | {
"resource": ""
} |
q23493 | handleHeartbeat | train | func (s *remoteSite) handleHeartbeat(conn *remoteConn, ch ssh.Channel, reqC <-chan *ssh.Request) {
defer func() {
s.Infof("Cluster connection closed.")
conn.Close()
}()
for {
select {
case <-s.ctx.Done():
s.Infof("closing")
return
case req := <-reqC:
if req == nil {
s.Infof("Cluster agent disc... | go | {
"resource": ""
} |
q23494 | updateCertAuthorities | train | func (s *remoteSite) updateCertAuthorities() error {
// update main cluster cert authorities on the remote side
// remote side makes sure that only relevant fields
// are updated
hostCA, err := s.localClient.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: s.srv.ClusterName,
}, fa... | go | {
"resource": ""
} |
q23495 | CheckAndSetDefaults | train | func (r *ReporterConfig) CheckAndSetDefaults() error {
if r.Backend == nil {
return trace.BadParameter("missing parameter Backend")
}
if r.Component == "" {
r.Component = teleport.ComponentBackend
}
return nil
} | go | {
"resource": ""
} |
q23496 | NewReporter | train | func NewReporter(cfg ReporterConfig) (*Reporter, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
r := &Reporter{
ReporterConfig: cfg,
}
return r, nil
} | go | {
"resource": ""
} |
q23497 | trackRequest | train | func (s *Reporter) trackRequest(opType OpType, key []byte, endKey []byte) {
if !s.TrackTopRequests {
return
}
if len(key) == 0 {
return
}
// take just the first two parts, otherwise too many distinct requests
// can end up in the map
parts := bytes.Split(key, []byte{Separator})
if len(parts) > 3 {
parts =... | go | {
"resource": ""
} |
q23498 | NewReporterWatcher | train | func NewReporterWatcher(ctx context.Context, component string, w Watcher) *ReporterWatcher {
rw := &ReporterWatcher{
Watcher: w,
Component: component,
}
go rw.watch(ctx)
return rw
} | go | {
"resource": ""
} |
q23499 | MakeTable | train | func MakeTable(headers []string) Table {
t := MakeHeadlessTable(len(headers))
for i := range t.columns {
t.columns[i].title = headers[i]
t.columns[i].width = len(headers[i])
}
return t
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.