id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23900 | the party (except originator) that the size of the
// window has changed so the client can update it's own local PTY. Note that
// OpenSSH clients will ignore this and not update their own local PTY.
for _, p := range s.getParties(ctx.session) {
// Don't send the window change notification back to the originator.... | |
c23901 | return nil, trace.Wrap(err)
}
if existing.Login != rsess.Login {
return nil, trace.AccessDenied(
"can't switch users from %v to %v for session %v",
rsess.Login, existing.Login, id)
}
}
// return nil, trace.Wrap(err)
// No need to abort. Perhaps the auth server is down?
// Log the error a... | |
c23902 | s.Unlock()
return len(s.parties) == 0
} | |
c23903 | s.writer.Lock()
defer s.writer.Unlock()
for writerName, writer := range s.writer.writers {
s.log.Infof("Closing session writer: %v", writerName)
closer, ok := io.Writer(writer).(io.WriteCloser)
if ok {
closer.Close()
}
}
}()
})
return nil
} | |
c23904 | defer s.Unlock()
delete(s.parties, party.id)
} | |
c23905 | of party members.
s.removePartyMember(p)
s.writer.deleteWriter(string(p.id))
return nil
} | |
c23906 | partyList = append(partyList, rsession.Party{
ID: p.id,
User: p.user,
ServerID: p.serverID,
RemoteAddr: p.site,
LastActive: p.getLastActive(),
})
}
return partyList
} | |
c23907 | nil {
return
}
s.log.Debugf("Starting poll and sync of terminal size to all parties.")
defer s.log.Debugf("Stopping poll and sync of terminal size to all parties.")
tickerCh := time.NewTicker(defaults.SessionRefreshPeriod)
defer tickerCh.Stop()
// Loop as long as the session is active, updating the session ... | |
c23908 | defer s.Unlock()
s.parties[p.id] = p
} | |
c23909 | will go to it).
s.writer.addWriter(string(p.id), p, true)
p.ctx.AddCloser(p)
s.term.AddParty(1)
s.log.Infof("New party %v joined session: %v", p.String(), s.id)
// This goroutine keeps pumping party's input into the session.
go func() {
defer s.term.AddParty(-1)
_, err := io.Copy(s.term.PTY(), p)
if err ... | |
c23910 | return writers
}
// unlock and multiplex the write to all writers:
for _, w := range getWriters() {
n, err = w.Write(p)
if err != nil {
if w.closeOnError {
return
}
continue
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
} | |
c23911 | fmt.Sprintf("EventMapping(in=%v, out=%v)", e.In, e.Out)
} | |
c23912 | map[string]Event{},
eventsC: make(chan Event, 1024),
eventWaiters: make(map[string][]*waiter),
closeContext: closeContext,
signalClose: cancel,
exitContext: exitContext,
signalExit: signalExit,
reloadContext: reloadContext,
signalReload: signalReload,
}
go srv.fanOut()
return srv
} | |
c23913 |
defer s.Unlock()
return len(s.services)
} | |
c23914 | ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name})
} | |
c23915 | ServiceFunc) {
s.Register(&LocalService{Function: fn, ServiceName: name, Critical: true})
} | |
c23916 | s.services = append(s.services[:i], s.services[i+1:]...)
l.Debugf("Service is completed and removed.")
return nil
}
}
l.Warningf("Service is completed but not found.")
return trace.NotFound("service %v is not found", srv)
} | |
c23917 | m := range s.eventMappings {
if m.matches(event.Name, s.events) {
mappedEvent := Event{Name: m.Out}
s.events[mappedEvent.Name] = mappedEvent
go func(e Event) {
select {
case s.eventsC <- e:
case <-s.closeContext.Done():
return
}
}(mappedEvent)
log.WithFields(logrus.Fields{"in": ev... | |
c23918 | {
s.Lock()
defer s.Unlock()
s.eventMappings = append(s.eventMappings, m)
} | |
c23919 | &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)
} | |
c23920 |
}
if err := tc.Play(context.TODO(), cf.Namespace, cf.SessionID); err != nil {
utils.FatalError(err)
}
} | |
c23921 |
activateKey := !makeIdentityFile
key, err = tc.Login(cf.Context, activateKey)
if err != nil {
utils.FatalError(err)
}
if makeIdentityFile {
if err := setupNoninteractiveClient(tc, key); err != nil {
utils.FatalError(err)
}
authorities, err := tc.GetTrustedCA(cf.Context, key.ClusterName)
if err != n... | |
c23922 |
tc.HostLogin = certPrincipals[0]
identityAuth, err := authFromIdentity(key)
if err != nil {
return trace.Wrap(err)
}
tc.TLS, err = key.ClientTLSConfig()
if err != nil {
return trace.Wrap(err)
}
tc.AuthMethods = []ssh.AuthMethod{identityAuth}
tc.Interactive = false
tc.SkipLocalAuth = true
return nil
} | |
c23923 | // lines per node.
case false:
t := asciitable.MakeTable([]string{"Node Name", "Address", "Labels"})
for _, n := range nodes {
labelChunks := chunkLabels(n.GetAllLabels(), 2)
for i, v := range labelChunks {
var hostname string
var addr string
if i == 0 {
hostname = n.GetHostname()
addr... | |
c23924 |
// Then chunk labels into sized chunks.
var chunks [][]string
for chunkSize < len(sorted) {
sorted, chunks = sorted[chunkSize:], append(chunks, sorted[0:chunkSize:chunkSize])
}
chunks = append(chunks, sorted)
return chunks
} | |
c23925 | t = asciitable.MakeHeadlessTable(2)
} else {
t = asciitable.MakeTable([]string{"Cluster Name", "Status"})
}
if len(sites) == 0 {
return
}
for _, site := range sites {
t.AddRow([]string{site.Name, site.Status})
}
fmt.Println(t.AsBuffer().String())
} | |
c23926 | exit status as the failed command:
if tc.ExitStatus != 0 {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(tc.ExitStatus)
} else {
utils.FatalError(err)
}
}
} | |
c23927 | Requests originated: %v\n", result.RequestsOriginated)
fmt.Printf("* Requests failed: %v\n", result.RequestsFailed)
if result.LastError != nil {
fmt.Printf("* Last error: %v\n", result.LastError)
}
fmt.Printf("\nHistogram\n\n")
t := asciitable.MakeTable([]string{"Percentile", "Duration"})
for _, quantile := ra... | |
c23928 | not a valid session ID (must be GUID)", cf.SessionID))
}
err = client.RetryWithRelogin(cf.Context, tc, func() error {
return tc.Join(context.TODO(), cf.Namespace, *sid, nil)
})
if err != nil {
utils.FatalError(err)
}
} | |
c23929 | same exit status as the failed command:
if tc.ExitStatus != 0 {
fmt.Fprintln(os.Stderr, utils.UserMessageFromError(err))
os.Exit(tc.ExitStatus)
} else {
utils.FatalError(err)
}
}
} | |
c23930 | return nil, trace.Wrap(err)
}
return client.NewAuthMethodForCert(signer), nil
} | |
c23931 |
}
fmt.Printf(" Roles: %v*\n", strings.Join(p.Roles, ", "))
fmt.Printf(" Logins: %v\n", strings.Join(p.Logins, ", "))
fmt.Printf(" Valid until: %v [%v]\n", p.ValidUntil, humanDuration)
fmt.Printf(" Extensions: %v\n\n", strings.Join(p.Extensions, ", "))
} | |
c23932 | {
fmt.Printf("Not logged in.\n")
return
}
utils.FatalError(err)
}
printProfiles(profile, profiles)
} | |
c23933 |
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | |
c23934 | c.Connector.Type, c.Connector.ID, c.Connector.Identity, utils.HumanTimeFormat(c.Time))
}
return fmt.Sprintf("%v at %v", c.User.Name, c.Time)
} | |
c23935 | trace.BadParameter("missing parameter time")
}
return nil
} | |
c23936 | interface{} {
out := u.V1()
out.AllowedLogins = allowedLogins
return *out
} | |
c23937 | map[string][]string) {
u.Spec.Traits = traits
} | |
c23938 |
Status: u.Spec.Status,
Expires: u.Spec.Expires,
CreatedBy: u.Spec.CreatedBy,
}
} | |
c23939 |
otherGithubIdentities := other.GetGithubIdentities()
if len(u.Spec.GithubIdentities) != len(otherGithubIdentities) {
return false
}
for i := range u.Spec.GithubIdentities {
if !u.Spec.GithubIdentities[i].Equals(&otherGithubIdentities[i]) {
return false
}
}
return true
} | |
c23940 | nil && !u.Metadata.Expires.IsZero() {
return *u.Metadata.Expires
}
return u.Spec.Expires
} | |
c23941 | utils.Deduplicate(roles)
} | |
c23942 |
if r == name {
return
}
}
u.Spec.Roles = append(u.Spec.Roles, name)
} | |
c23943 |
Roles: u.Roles,
Traits: map[string][]string{
teleport.TraitLogins: u.AllowedLogins,
teleport.TraitKubeGroups: u.KubeGroups,
},
},
}
} | |
c23944 | userSchema = fmt.Sprintf(UserSpecV2SchemaTemplate, ExternalIdentitySchema, ExternalIdentitySchema, ExternalIdentitySchema, LoginStatusSchema, CreatedBySchema, ", "+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, userSchema, DefaultDefinitions)
} | |
c23945 | }
} else {
if err := utils.UnmarshalWithSchema(GetUserSchema(""), &u, bytes); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := u.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
u.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
... | |
c23946 | return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.Ba... | |
c23947 | defer s.RUnlock()
return s.readErr
} | |
c23948 | defer s.Unlock()
s.readErr = err
} | |
c23949 | usersPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | |
c23950 |
var out []services.User
for _, item := range result.Items {
if !bytes.HasSuffix(item.Key, []byte(paramsPrefix)) {
continue
}
u, err := services.GetUserMarshaler().UnmarshalUser(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(e... | |
c23951 | backend.Key(webPrefix, usersPrefix, user.GetName(), paramsPrefix),
Value: value,
Expires: user.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23952 |
}
u, err := services.GetUserMarshaler().UnmarshalUser(
item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
return u, nil
} | |
c23953 | range u.GetOIDCIdentities() {
if uid.Equals(&id) {
return u, nil
}
}
}
return nil, trace.NotFound("user with identity %q not found", &id)
} | |
c23954 | err = s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | |
c23955 | }
item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, username, pwdPrefix),
Value: hash,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23956 | item := backend.Item{
Key: backend.Key(webPrefix, usersPrefix, user, totpPrefix),
Value: []byte(secretKey),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23957 | return "", trace.NotFound("user %q is not found", user)
}
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | |
c23958 | Expires: s.Clock().Now().UTC().Add(usedTOTPTTL),
}
_, err := s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23959 | trace.BadParameter("missing user name")
}
return s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, usedTOTPPrefix))
} | |
c23960 | backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid),
Value: value,
Expires: backend.EarliestExpiry(session.GetBearerTokenExpiryTime(), sessionMetadata.Expiry()),
}
_, err = s.Put(context.TODO(), item)
return trace.Wrap(err)
} | |
c23961 | if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.LoginAttempt, len(result.Items))
for i, item := range result.Items {
var a services.LoginAttempt
if err := json.Unmarshal(item.Value, &a); err != nil {
return nil, trace.Wrap(err)
}
out[i] = a
}
sort.Sort(services.SortedLoginAttempt... | |
c23962 | := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23963 |
session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
// this is for backwards compatibility to ensure we
// always have these values
session.SetUser(user)
session.SetName(sid)
return session, nil
} | |
c23964 | := s.Delete(context.TODO(), backend.Key(webPrefix, usersPrefix, user, sessionsPrefix, sid))
return trace.Wrap(err)
} | |
c23965 |
if err != nil {
return trace.Wrap(err)
}
err = s.UpsertPasswordHash(user, hash)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23966 | }
item := backend.Item{
Key: backend.Key(userTokensPrefix, token),
Value: value,
Expires: tokenData.Expires,
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23967 | services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
return &signupToken, nil
} | |
c23968 | i, item := range result.Items {
var signupToken services.SignupToken
err = json.Unmarshal(item.Value, &signupToken)
if err != nil {
return nil, trace.Wrap(err)
}
tokens[i] = signupToken
}
return tokens, nil
} | |
c23969 | parameter token")
}
err := s.Delete(context.TODO(), backend.Key(userTokensPrefix, token))
return trace.Wrap(err)
} | |
c23970 | Key: backend.Key(webPrefix, connectorsPrefix, oidcPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
ID: connector.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23971 | err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(item.Value,
services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
return conn, nil
} | |
c23972 | item := range result.Items {
conn, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
conn.SetClientSecret("")
}
connectors[i] = conn
}
return connectors, nil
} | |
c23973 | backend.Key(webPrefix, connectorsPrefix, oidcPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23974 | Key: backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, connector.GetName()),
Value: value,
Expires: connector.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23975 | parameter name")
}
err := s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, samlPrefix, connectorsPrefix, name))
return trace.Wrap(err)
} | |
c23976 |
return nil, trace.NotFound("SAML connector %q is not configured", name)
}
return nil, trace.Wrap(err)
}
conn, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
keyPair := ... | |
c23977 | := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(
item.Value, services.WithExpires(item.Expires))
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
keyPair := conn.GetSigningKeyPair()
if keyPair != nil {
keyPair.PrivateKey = ""
conn.SetSigningKeyPair(keyPair)
}
... | |
c23978 | backend.Key(webPrefix, connectorsPrefix, samlPrefix, requestsPrefix, req.ID),
Value: value,
Expires: backend.Expiry(s.Clock(), ttl),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23979 |
var req services.SAMLAuthRequest
if err := json.Unmarshal(item.Value, &req); err != nil {
return nil, trace.Wrap(err)
}
return &req, nil
} | |
c23980 | connector, err := services.GetGithubConnectorMarshaler().Unmarshal(item.Value)
if err != nil {
return nil, trace.Wrap(err)
}
if !withSecrets {
connector.SetClientSecret("")
}
return connector, nil
} | |
c23981 | parameter name")
}
return trace.Wrap(s.Delete(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, connectorsPrefix, name)))
} | |
c23982 | backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, req.StateToken),
Value: value,
Expires: req.Expiry(),
}
_, err = s.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23983 | s.Get(context.TODO(), backend.Key(webPrefix, connectorsPrefix, githubPrefix, requestsPrefix, stateToken))
if err != nil {
return nil, trace.Wrap(err)
}
var req services.GithubAuthRequest
err = json.Unmarshal(item.Value, &req)
if err != nil {
return nil, trace.Wrap(err)
}
return &req, nil
} | |
c23984 | len(in))
for i := range in {
out[i] = *(in[i].V1())
}
return out
} | |
c23985 | := make(map[string]CommandLabel, len(s.Spec.CmdLabels))
for key := range s.Spec.CmdLabels {
val := s.Spec.CmdLabels[key]
out[key] = &val
}
return out
} | |
c23986 | s.GetAllLabels()
for key, value := range labels {
if myLabels[key] != value {
return false
}
}
}
return true
} | |
c23987 | val))
}
for key, val := range s.Spec.CmdLabels {
labels = append(labels, fmt.Sprintf("%s=%s", key, val.Result))
}
sort.Strings(labels)
return strings.Join(labels, ",")
} | |
c23988 | if !ok {
return false
}
if !val.Equals(val2) {
return false
}
}
return true
} | |
c23989 | NewDuration(val.GetPeriod()),
Result: val.GetResult(),
Command: val.GetCommand(),
}
}
return out
} | |
c23990 | }
if c.GetResult() != other.GetResult() {
return false
}
if !utils.StringSlicesEqual(c.GetCommand(), other.GetCommand()) {
return false
}
return true
} | |
c23991 |
copy(command, c.Command)
return &CommandLabelV2{
Command: command,
Period: c.Period,
Result: c.Result,
}
} | |
c23992 | time.Duration) {
c.Period = Duration(p)
} | |
c23993 | len(*c))
for name, label := range *c {
out[name] = label.Clone()
}
return out
} | |
c23994 | c); err != nil {
return trace.Wrap(err, "can not parse Command Labels")
}
return nil
} | |
c23995 | MetadataSchema, fmt.Sprintf(ServerSpecV2Schema, RotationSchema), DefaultDefinitions)
} | |
c23996 | nil {
return nil, trace.BadParameter(err.Error())
}
}
s.Kind = kind
if err := s.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
s.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
s.SetExpiry(cfg.Expires)
}
return &s, nil
}
return nil, trace.BadPa... | |
c23997 | {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
return UnmarshalServerResource(bytes, kind, cfg)
} | |
c23998 | return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.... | |
c23999 | make([]Server, len(servers))
for i, v := range servers {
out[i] = Server(&v)
}
return out, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.