_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23900 | NotifyWinChange | train | func (s *SessionRegistry) NotifyWinChange(params rsession.TerminalParams, ctx *ServerContext) error {
if ctx.session == nil {
s.log.Debugf("Unable to update window size, no session found in context.")
return nil
}
sid := ctx.session.id
// Build the resize event.
resizeEvent := events.EventFields{
events.Eve... | go | {
"resource": ""
} |
q23901 | newSession | train | func newSession(id rsession.ID, r *SessionRegistry, ctx *ServerContext) (*session, error) {
serverSessions.Inc()
rsess := rsession.Session{
ID: id,
TerminalParams: rsession.TerminalParams{
W: teleport.DefaultTerminalWidth,
H: teleport.DefaultTerminalHeight,
},
Login: ctx.Identity.Login,
Created: ... | go | {
"resource": ""
} |
q23902 | isLingering | train | func (s *session) isLingering() bool {
s.Lock()
defer s.Unlock()
return len(s.parties) == 0
} | go | {
"resource": ""
} |
q23903 | Close | train | func (s *session) Close() error {
serverSessions.Dec()
s.closeOnce.Do(func() {
// closing needs to happen asynchronously because the last client
// (session writer) will try to close this session, causing a deadlock
// because of closeOnce
go func() {
s.log.Infof("Closing session %v", s.id)
if s.term !=... | go | {
"resource": ""
} |
q23904 | removePartyMember | train | func (s *session) removePartyMember(party *party) {
s.Lock()
defer s.Unlock()
delete(s.parties, party.id)
} | go | {
"resource": ""
} |
q23905 | removeParty | train | func (s *session) removeParty(p *party) error {
p.ctx.Infof("Removing party %v from session %v", p, s.id)
// Removes participant from in-memory map of party members.
s.removePartyMember(p)
s.writer.deleteWriter(string(p.id))
return nil
} | go | {
"resource": ""
} |
q23906 | exportPartyMembers | train | func (s *session) exportPartyMembers() []rsession.Party {
s.Lock()
defer s.Unlock()
var partyList []rsession.Party
for _, p := range s.parties {
partyList = append(partyList, rsession.Party{
ID: p.id,
User: p.user,
ServerID: p.serverID,
RemoteAddr: p.site,
LastActive: p.getLastActi... | go | {
"resource": ""
} |
q23907 | heartbeat | train | func (s *session) heartbeat(ctx *ServerContext) {
// If sessions are being recorded at the proxy, an identical version of this
// goroutine is running in the proxy, which means it does not need to run here.
if ctx.ClusterConfig.GetSessionRecording() == services.RecordAtProxy &&
s.registry.srv.Component() == telepo... | go | {
"resource": ""
} |
q23908 | addPartyMember | train | func (s *session) addPartyMember(p *party) {
s.Lock()
defer s.Unlock()
s.parties[p.id] = p
} | go | {
"resource": ""
} |
q23909 | addParty | train | func (s *session) addParty(p *party) error {
if s.login != p.login {
return trace.AccessDenied(
"can't switch users from %v to %v for session %v",
s.login, p.login, s.id)
}
// Adds participant to in-memory map of party members.
s.addPartyMember(p)
// Write last chunk (so the newly joined parties won't st... | go | {
"resource": ""
} |
q23910 | Write | train | func (m *multiWriter) Write(p []byte) (n int, err error) {
// lock and make a local copy of available writers:
getWriters := func() (writers []writerWrapper) {
m.RLock()
defer m.RUnlock()
writers = make([]writerWrapper, 0, len(m.writers))
for _, w := range m.writers {
writers = append(writers, w)
}
//... | go | {
"resource": ""
} |
q23911 | String | train | func (e EventMapping) String() string {
return fmt.Sprintf("EventMapping(in=%v, out=%v)", e.In, e.Out)
} | go | {
"resource": ""
} |
q23912 | NewSupervisor | train | func NewSupervisor(id string) Supervisor {
closeContext, cancel := context.WithCancel(context.TODO())
exitContext, signalExit := context.WithCancel(context.TODO())
reloadContext, signalReload := context.WithCancel(context.TODO())
srv := &LocalSupervisor{
id: id,
services: []Service{},
wg: ... | go | {
"resource": ""
} |
q23913 | ServiceCount | train | func (s *LocalSupervisor) ServiceCount() int {
s.Lock()
defer s.Unlock()
return len(s.services)
} | go | {
"resource": ""
} |
q23914 | RegisterFunc | train | func (s *LocalSupervisor) RegisterFunc(name string, fn ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name})
} | go | {
"resource": ""
} |
q23915 | RegisterCriticalFunc | train | func (s *LocalSupervisor) RegisterCriticalFunc(name string, fn ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name, Critical: true})
} | go | {
"resource": ""
} |
q23916 | RemoveService | train | func (s *LocalSupervisor) RemoveService(srv Service) error {
l := logrus.WithFields(logrus.Fields{"service": srv.Name(), trace.Component: teleport.Component(teleport.ComponentProcess, s.id)})
s.Lock()
defer s.Unlock()
for i, el := range s.services {
if el == srv {
s.services = append(s.services[:i], s.services... | go | {
"resource": ""
} |
q23917 | BroadcastEvent | train | func (s *LocalSupervisor) BroadcastEvent(event Event) {
s.Lock()
defer s.Unlock()
switch event.Name {
case TeleportExitEvent:
s.signalExit()
case TeleportReloadEvent:
s.signalReload()
}
s.events[event.Name] = event
// Log all events other than recovered events to prevent the logs from
// being flooded.
... | go | {
"resource": ""
} |
q23918 | RegisterEventMapping | train | func (s *LocalSupervisor) RegisterEventMapping(m EventMapping) {
s.Lock()
defer s.Unlock()
s.eventMappings = append(s.eventMappings, m)
} | go | {
"resource": ""
} |
q23919 | WaitForEvent | train | func (s *LocalSupervisor) WaitForEvent(ctx context.Context, name string, eventC chan Event) {
s.Lock()
defer s.Unlock()
waiter := &waiter{eventC: eventC, context: ctx}
event, ok := s.events[name]
if ok {
go s.notifyWaiter(waiter, event)
return
}
s.eventWaiters[name] = append(s.eventWaiters[name], waiter)
} | go | {
"resource": ""
} |
q23920 | onPlay | train | func onPlay(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
if err := tc.Play(context.TODO(), cf.Namespace, cf.SessionID); err != nil {
utils.FatalError(err)
}
} | go | {
"resource": ""
} |
q23921 | onLogin | train | func onLogin(cf *CLIConf) {
var (
err error
tc *client.TeleportClient
key *client.Key
)
if cf.IdentityFileIn != "" {
utils.FatalError(trace.BadParameter("-i flag cannot be used here"))
}
if cf.IdentityFormat != client.IdentityFormatOpenSSH && cf.IdentityFormat != client.IdentityFormatFile {
utils.Fata... | go | {
"resource": ""
} |
q23922 | setupNoninteractiveClient | train | func setupNoninteractiveClient(tc *client.TeleportClient, key *client.Key) error {
certUsername, err := key.CertUsername()
if err != nil {
return trace.Wrap(err)
}
tc.Username = certUsername
// Extract and set the HostLogin to be the first principal. It doesn't
// matter what the value is, but some valid princ... | go | {
"resource": ""
} |
q23923 | onListNodes | train | func onListNodes(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
// Get list of all nodes in backend and sort by "Node Name".
var nodes []services.Server
err = client.RetryWithRelogin(cf.Context, tc, func() error {
nodes, err = tc.ListNodes(cf.Context)
return err
})
... | go | {
"resource": ""
} |
q23924 | chunkLabels | train | func chunkLabels(labels map[string]string, chunkSize int) [][]string {
// First sort labels so they always occur in the same order.
sorted := make([]string, 0, len(labels))
for k, v := range labels {
sorted = append(sorted, fmt.Sprintf("%v=%v", k, v))
}
sort.Slice(sorted, func(i, j int) bool { return sorted[i] <... | go | {
"resource": ""
} |
q23925 | onListClusters | train | func onListClusters(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
proxyClient, err := tc.ConnectToProxy(cf.Context)
if err != nil {
utils.FatalError(err)
}
defer proxyClient.Close()
var sites []services.Site
err = client.RetryWithRelogin(cf.Context, tc, func() erro... | go | {
"resource": ""
} |
q23926 | onSSH | train | func onSSH(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
tc.Stdin = os.Stdin
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.SSH(cf.Context, cf.RemoteCommand, cf.LocalExec)
})
if err != nil {
// exit with the same exit status as the failed c... | go | {
"resource": ""
} |
q23927 | onBenchmark | train | func onBenchmark(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
result, err := tc.Benchmark(cf.Context, client.Benchmark{
Command: cf.RemoteCommand,
Threads: cf.BenchThreads,
Duration: cf.BenchDuration,
Rate: cf.BenchRate,
})
if err != nil {
fmt.Fprintln(... | go | {
"resource": ""
} |
q23928 | onJoin | train | func onJoin(cf *CLIConf) {
tc, err := makeClient(cf, true)
if err != nil {
utils.FatalError(err)
}
sid, err := session.ParseID(cf.SessionID)
if err != nil {
utils.FatalError(fmt.Errorf("'%v' is not a valid session ID (must be GUID)", cf.SessionID))
}
err = client.RetryWithRelogin(cf.Context, tc, func() error... | go | {
"resource": ""
} |
q23929 | onSCP | train | func onSCP(cf *CLIConf) {
tc, err := makeClient(cf, false)
if err != nil {
utils.FatalError(err)
}
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.SCP(context.TODO(), cf.CopySpec, int(cf.NodePort), cf.RecursiveCopy, cf.Quiet)
})
if err != nil {
// exit with the same exit status as the... | go | {
"resource": ""
} |
q23930 | authFromIdentity | train | func authFromIdentity(k *client.Key) (ssh.AuthMethod, error) {
signer, err := sshutils.NewSigner(k.Priv, k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
return client.NewAuthMethodForCert(signer), nil
} | go | {
"resource": ""
} |
q23931 | printStatus | train | func printStatus(p *client.ProfileStatus, isActive bool) {
var prefix string
if isActive {
prefix = "> "
} else {
prefix = " "
}
duration := p.ValidUntil.Sub(time.Now())
humanDuration := "EXPIRED"
if duration.Nanoseconds() > 0 {
humanDuration = fmt.Sprintf("valid for %v", duration.Round(time.Minute))
}
... | go | {
"resource": ""
} |
q23932 | onStatus | train | func onStatus(cf *CLIConf) {
// Get the status of the active profile ~/.tsh/profile as well as the status
// of any other proxies the user is logged into.
profile, profiles, err := client.Status("", cf.Proxy)
if err != nil {
if trace.IsNotFound(err) {
fmt.Printf("Not logged in.\n")
return
}
utils.FatalE... | go | {
"resource": ""
} |
q23933 | NewUser | train | func NewUser(name string) (User, error) {
u := &UserV2{
Kind: KindUser,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | go | {
"resource": ""
} |
q23934 | String | train | func (c CreatedBy) String() string {
if c.User.Name == "" {
return "system"
}
if c.Connector != nil {
return fmt.Sprintf("%v connector %v for user %v at %v",
c.Connector.Type, c.Connector.ID, c.Connector.Identity, utils.HumanTimeFormat(c.Time))
}
return fmt.Sprintf("%v at %v", c.User.Name, c.Time)
} | go | {
"resource": ""
} |
q23935 | Check | train | func (la *LoginAttempt) Check() error {
if la.Time.IsZero() {
return trace.BadParameter("missing parameter time")
}
return nil
} | go | {
"resource": ""
} |
q23936 | WebSessionInfo | train | func (u *UserV2) WebSessionInfo(allowedLogins []string) interface{} {
out := u.V1()
out.AllowedLogins = allowedLogins
return *out
} | go | {
"resource": ""
} |
q23937 | SetTraits | train | func (u *UserV2) SetTraits(traits map[string][]string) {
u.Spec.Traits = traits
} | go | {
"resource": ""
} |
q23938 | V1 | train | func (u *UserV2) V1() *UserV1 {
return &UserV1{
Name: u.Metadata.Name,
OIDCIdentities: u.Spec.OIDCIdentities,
Status: u.Spec.Status,
Expires: u.Spec.Expires,
CreatedBy: u.Spec.CreatedBy,
}
} | go | {
"resource": ""
} |
q23939 | Equals | train | func (u *UserV2) Equals(other User) bool {
if u.Metadata.Name != other.GetName() {
return false
}
otherIdentities := other.GetOIDCIdentities()
if len(u.Spec.OIDCIdentities) != len(otherIdentities) {
return false
}
for i := range u.Spec.OIDCIdentities {
if !u.Spec.OIDCIdentities[i].Equals(&otherIdentities[i]... | go | {
"resource": ""
} |
q23940 | Expiry | train | func (u *UserV2) Expiry() time.Time {
if u.Metadata.Expires != nil && !u.Metadata.Expires.IsZero() {
return *u.Metadata.Expires
}
return u.Spec.Expires
} | go | {
"resource": ""
} |
q23941 | SetRoles | train | func (u *UserV2) SetRoles(roles []string) {
u.Spec.Roles = utils.Deduplicate(roles)
} | go | {
"resource": ""
} |
q23942 | AddRole | train | func (u *UserV2) AddRole(name string) {
for _, r := range u.Spec.Roles {
if r == name {
return
}
}
u.Spec.Roles = append(u.Spec.Roles, name)
} | go | {
"resource": ""
} |
q23943 | V2 | train | func (u *UserV1) V2() *UserV2 {
return &UserV2{
Kind: KindUser,
Version: V2,
Metadata: Metadata{
Name: u.Name,
Namespace: defaults.Namespace,
},
Spec: UserSpecV2{
OIDCIdentities: u.OIDCIdentities,
Status: u.Status,
Expires: u.Expires,
CreatedBy: u.CreatedBy,
R... | go | {
"resource": ""
} |
q23944 | GetUserSchema | train | func GetUserSchema(extensionSchema string) string {
var userSchema string
if extensionSchema == "" {
userSchema = fmt.Sprintf(UserSpecV2SchemaTemplate, ExternalIdentitySchema, ExternalIdentitySchema, ExternalIdentitySchema, LoginStatusSchema, CreatedBySchema, ``)
} else {
userSchema = fmt.Sprintf(UserSpecV2Schem... | go | {
"resource": ""
} |
q23945 | UnmarshalUser | train | func (*TeleportUserMarshaler) UnmarshalUser(bytes []byte, opts ...MarshalOption) (User, error) {
var h ResourceHeader
err := json.Unmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
... | go | {
"resource": ""
} |
q23946 | MarshalUser | train | func (*TeleportUserMarshaler) MarshalUser(u User, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type userv1 interface {
V1() *UserV1
}
type userv2 interface {
V2() *UserV2
}
version := cfg.GetVersion()
switch version {
case V1:
... | go | {
"resource": ""
} |
q23947 | GetReadError | train | func (s *Wrapper) GetReadError() error {
s.RLock()
defer s.RUnlock()
return s.readErr
} | go | {
"resource": ""
} |
q23948 | SetReadError | train | func (s *Wrapper) SetReadError(err error) {
s.Lock()
defer s.Unlock()
s.readErr = err
} | go | {
"resource": ""
} |
q23949 | DeleteAllUsers | train | func (s *IdentityService) DeleteAllUsers() error {
startKey := backend.Key(webPrefix, usersPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | {
"resource": ""
} |
q23950 | GetUsers | train | func (s *IdentityService) GetUsers() ([]services.User, error) {
startKey := backend.Key(webPrefix, usersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
var out []services.User
for _, item := range result.Items... | go | {
"resource": ""
} |
q23951 | CreateUser | train | func (s *IdentityService) CreateUser(user services.User) error {
if err := user.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetUserMarshaler().MarshalUser(user)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user.GetName(... | go | {
"resource": ""
} |
q23952 | GetUser | train | func (s *IdentityService) GetUser(user string) (services.User, error) {
if user == "" {
return nil, trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, paramsPrefix))
if err != nil {
return nil, trace.NotFound("user %q is not found", user)
}
u... | go | {
"resource": ""
} |
q23953 | GetUserByOIDCIdentity | train | func (s *IdentityService) GetUserByOIDCIdentity(id services.ExternalIdentity) (services.User, error) {
users, err := s.GetUsers()
if err != nil {
return nil, trace.Wrap(err)
}
for _, u := range users {
for _, uid := range u.GetOIDCIdentities() {
if uid.Equals(&id) {
return u, nil
}
}
}
return nil,... | go | {
"resource": ""
} |
q23954 | DeleteUser | train | func (s *IdentityService) DeleteUser(user string) error {
_, err := s.GetUser(user)
if err != nil {
return trace.Wrap(err)
}
startKey := backend.Key(webPrefix, usersPrefix, user)
err = s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23955 | UpsertPasswordHash | train | func (s *IdentityService) UpsertPasswordHash(username string, hash []byte) error {
userPrototype, err := services.NewUser(username)
if err != nil {
return trace.Wrap(err)
}
user, err := services.GetUserMarshaler().GenerateUser(userPrototype)
if err != nil {
return trace.Wrap(err)
}
err = s.CreateUser(user)
... | go | {
"resource": ""
} |
q23956 | UpsertTOTP | train | func (s *IdentityService) UpsertTOTP(user string, secretKey string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, totpPrefix),
Value: []byte(secretKey),
}
_, err := s.Put(context.TODO(), item)
if err != nil {... | go | {
"resource": ""
} |
q23957 | GetTOTP | train | func (s *IdentityService) GetTOTP(user string) (string, error) {
if user == "" {
return "", trace.BadParameter("missing user name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, totpPrefix))
if err != nil {
if trace.IsNotFound(err) {
return "", trace.NotFound("user %q is not... | go | {
"resource": ""
} |
q23958 | UpsertUsedTOTPToken | train | func (s *IdentityService) UpsertUsedTOTPToken(user string, otpToken string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix),
Value: []byte(otpToken),
Expires: s.Clock().Now().UTC().Add(usedTOTP... | go | {
"resource": ""
} |
q23959 | DeleteUsedTOTPToken | train | func (s *IdentityService) DeleteUsedTOTPToken(user string) error {
if user == "" {
return trace.BadParameter("missing user name")
}
return s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix))
} | go | {
"resource": ""
} |
q23960 | UpsertWebSession | train | func (s *IdentityService) UpsertWebSession(user, sid string, session services.WebSession) error {
session.SetUser(user)
session.SetName(sid)
value, err := services.GetWebSessionMarshaler().MarshalWebSession(session)
if err != nil {
return trace.Wrap(err)
}
sessionMetadata := session.GetMetadata()
item := backe... | go | {
"resource": ""
} |
q23961 | GetUserLoginAttempts | train | func (s *IdentityService) GetUserLoginAttempts(user string) ([]services.LoginAttempt, error) {
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out :... | go | {
"resource": ""
} |
q23962 | DeleteUserLoginAttempts | train | func (s *IdentityService) DeleteUserLoginAttempts(user string) error {
if user == "" {
return trace.BadParameter("missing username")
}
startKey := backend.Key(webPrefix, usersPrefix, user, attemptsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
if err != nil {
return trace.Wr... | go | {
"resource": ""
} |
q23963 | GetWebSession | train | func (s *IdentityService) GetWebSession(user, sid string) (services.WebSession, error) {
if user == "" {
return nil, trace.BadParameter("missing username")
}
if sid == "" {
return nil, trace.BadParameter("missing session id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessio... | go | {
"resource": ""
} |
q23964 | DeleteWebSession | train | func (s *IdentityService) DeleteWebSession(user, sid string) error {
if user == "" {
return trace.BadParameter("missing username")
}
if sid == "" {
return trace.BadParameter("missing session id")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
return trace.Wra... | go | {
"resource": ""
} |
q23965 | UpsertPassword | train | func (s *IdentityService) UpsertPassword(user string, password []byte) error {
if user == "" {
return trace.BadParameter("missing username")
}
err := services.VerifyPassword(password)
if err != nil {
return trace.Wrap(err)
}
hash, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
if err != nil... | go | {
"resource": ""
} |
q23966 | UpsertSignupToken | train | func (s *IdentityService) UpsertSignupToken(token string, tokenData services.SignupToken, ttl time.Duration) error {
if ttl < time.Second || ttl > defaults.MaxSignupTokenTTL {
ttl = defaults.MaxSignupTokenTTL
}
tokenData.Expires = time.Now().UTC().Add(ttl)
value, err := json.Marshal(tokenData)
if err != nil {
... | go | {
"resource": ""
} |
q23967 | GetSignupToken | train | func (s *IdentityService) GetSignupToken(token string) (*services.SignupToken, error) {
if token == "" {
return nil, trace.BadParameter("missing token")
}
item, err := s.Get(context.TODO(), backend.Key(userTokensPrefix, token))
if err != nil {
return nil, trace.Wrap(err)
}
var signupToken services.SignupToken... | go | {
"resource": ""
} |
q23968 | GetSignupTokens | train | func (s *IdentityService) GetSignupTokens() ([]services.SignupToken, error) {
startKey := backend.Key(userTokensPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tokens := make([]services.SignupToken, len(result.... | go | {
"resource": ""
} |
q23969 | DeleteSignupToken | train | func (s *IdentityService) DeleteSignupToken(token string) error {
if token == "" {
return trace.BadParameter("missing parameter token")
}
err := s.Delete(context.TODO(), backend.Key(userTokensPrefix, token))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23970 | UpsertOIDCConnector | train | func (s *IdentityService) UpsertOIDCConnector(connector services.OIDCConnector) error {
if err := connector.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: ... | go | {
"resource": ""
} |
q23971 | GetOIDCConnector | train | func (s *IdentityService) GetOIDCConnector(name string, withSecrets bool) (services.OIDCConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, name))
if err != nil {
... | go | {
"resource": ""
} |
q23972 | GetOIDCConnectors | train | func (s *IdentityService) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wra... | go | {
"resource": ""
} |
q23973 | CreateOIDCAuthRequest | train | func (s *IdentityService) CreateOIDCAuthRequest(req services.OIDCAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefi... | go | {
"resource": ""
} |
q23974 | CreateSAMLConnector | train | func (s *IdentityService) CreateSAMLConnector(connector services.SAMLConnector) error {
if err := connector.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
item := backend.I... | go | {
"resource": ""
} |
q23975 | DeleteSAMLConnector | train | func (s *IdentityService) DeleteSAMLConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23976 | GetSAMLConnector | train | func (s *IdentityService) GetSAMLConnector(name string, withSecrets bool) (services.SAMLConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
if err != nil {
... | go | {
"resource": ""
} |
q23977 | GetSAMLConnectors | train | func (s *IdentityService) GetSAMLConnectors(withSecrets bool) ([]services.SAMLConnector, error) {
startKey := backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wra... | go | {
"resource": ""
} |
q23978 | CreateSAMLAuthRequest | train | func (s *IdentityService) CreateSAMLAuthRequest(req services.SAMLAuthRequest, ttl time.Duration) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefi... | go | {
"resource": ""
} |
q23979 | GetSAMLAuthRequest | train | func (s *IdentityService) GetSAMLAuthRequest(id string) (*services.SAMLAuthRequest, error) {
if id == "" {
return nil, trace.BadParameter("missing parameter id")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, requestsPrefix, id))
if err != nil {
return nil, trace.Wrap(... | go | {
"resource": ""
} |
q23980 | GetGithubConnector | train | func (s *IdentityService) GetGithubConnector(name string, withSecrets bool) (services.GithubConnector, error) {
if name == "" {
return nil, trace.BadParameter("missing parameter name")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name))
if err != ni... | go | {
"resource": ""
} |
q23981 | DeleteGithubConnector | train | func (s *IdentityService) DeleteGithubConnector(name string) error {
if name == "" {
return trace.BadParameter("missing parameter name")
}
return trace.Wrap(s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name)))
} | go | {
"resource": ""
} |
q23982 | CreateGithubAuthRequest | train | func (s *IdentityService) CreateGithubAuthRequest(req services.GithubAuthRequest) error {
err := req.Check()
if err != nil {
return trace.Wrap(err)
}
value, err := json.Marshal(req)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(webPrefix, connectorsPrefix, githubPrefix... | go | {
"resource": ""
} |
q23983 | GetGithubAuthRequest | train | func (s *IdentityService) GetGithubAuthRequest(stateToken string) (*services.GithubAuthRequest, error) {
if stateToken == "" {
return nil, trace.BadParameter("missing parameter stateToken")
}
item, err := s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, stateToken))
if ... | go | {
"resource": ""
} |
q23984 | ServersToV1 | train | func ServersToV1(in []Server) []ServerV1 {
out := make([]ServerV1, len(in))
for i := range in {
out[i] = *(in[i].V1())
}
return out
} | go | {
"resource": ""
} |
q23985 | GetCmdLabels | train | func (s *ServerV2) GetCmdLabels() map[string]CommandLabel {
if s.Spec.CmdLabels == nil {
return nil
}
out := make(map[string]CommandLabel, len(s.Spec.CmdLabels))
for key := range s.Spec.CmdLabels {
val := s.Spec.CmdLabels[key]
out[key] = &val
}
return out
} | go | {
"resource": ""
} |
q23986 | MatchAgainst | train | func (s *ServerV2) MatchAgainst(labels map[string]string) bool {
if labels != nil {
myLabels := s.GetAllLabels()
for key, value := range labels {
if myLabels[key] != value {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q23987 | LabelsString | train | func (s *ServerV2) LabelsString() string {
labels := []string{}
for key, val := range s.Metadata.Labels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val))
}
for key, val := range s.Spec.CmdLabels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val.Result))
}
sort.Strings(labels)
return strings.Joi... | go | {
"resource": ""
} |
q23988 | CmdLabelMapsEqual | train | func CmdLabelMapsEqual(a, b map[string]CommandLabel) bool {
if len(a) != len(b) {
return false
}
for key, val := range a {
val2, ok := b[key]
if !ok {
return false
}
if !val.Equals(val2) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q23989 | LabelsToV2 | train | func LabelsToV2(labels map[string]CommandLabel) map[string]CommandLabelV2 {
out := make(map[string]CommandLabelV2, len(labels))
for key, val := range labels {
out[key] = CommandLabelV2{
Period: NewDuration(val.GetPeriod()),
Result: val.GetResult(),
Command: val.GetCommand(),
}
}
return out
} | go | {
"resource": ""
} |
q23990 | Equals | train | func (c *CommandLabelV2) Equals(other CommandLabel) bool {
if c.GetPeriod() != other.GetPeriod() {
return false
}
if c.GetResult() != other.GetResult() {
return false
}
if !utils.StringSlicesEqual(c.GetCommand(), other.GetCommand()) {
return false
}
return true
} | go | {
"resource": ""
} |
q23991 | Clone | train | func (c *CommandLabelV2) Clone() CommandLabel {
command := make([]string, len(c.Command))
copy(command, c.Command)
return &CommandLabelV2{
Command: command,
Period: c.Period,
Result: c.Result,
}
} | go | {
"resource": ""
} |
q23992 | SetPeriod | train | func (c *CommandLabelV2) SetPeriod(p time.Duration) {
c.Period = Duration(p)
} | go | {
"resource": ""
} |
q23993 | Clone | train | func (c *CommandLabels) Clone() CommandLabels {
out := make(CommandLabels, len(*c))
for name, label := range *c {
out[name] = label.Clone()
}
return out
} | go | {
"resource": ""
} |
q23994 | SetEnv | train | func (c *CommandLabels) SetEnv(v string) error {
if err := json.Unmarshal([]byte(v), c); err != nil {
return trace.Wrap(err, "can not parse Command Labels")
}
return nil
} | go | {
"resource": ""
} |
q23995 | GetServerSchema | train | func GetServerSchema() string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(ServerSpecV2Schema, RotationSchema), DefaultDefinitions)
} | go | {
"resource": ""
} |
q23996 | UnmarshalServerResource | train | func UnmarshalServerResource(data []byte, kind string, cfg *MarshalConfig) (Server, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing server data")
}
var h ResourceHeader
err := utils.FastUnmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var... | go | {
"resource": ""
} |
q23997 | UnmarshalServer | train | func (*TeleportServerMarshaler) UnmarshalServer(bytes []byte, kind string, opts ...MarshalOption) (Server, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
return UnmarshalServerResource(bytes, kind, cfg)
} | go | {
"resource": ""
} |
q23998 | MarshalServer | train | func (*TeleportServerMarshaler) MarshalServer(s Server, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type serverv1 interface {
V1() *ServerV1
}
type serverv2 interface {
V2() *ServerV2
}
version := cfg.GetVersion()
switch version ... | go | {
"resource": ""
} |
q23999 | UnmarshalServers | train | func (*TeleportServerMarshaler) UnmarshalServers(bytes []byte) ([]Server, error) {
var servers []ServerV2
err := utils.FastUnmarshal(bytes, &servers)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]Server, len(servers))
for i, v := range servers {
out[i] = Server(&v)
}
return out, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.