id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23800 | }
a.log.Debugf("Adding CA key for %s", ca.ClusterName)
err = a.keyStore.AddKnownHostKeys(ca.ClusterName, publicKeys)
if err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c23801 | return nil, trace.Wrap(err)
}
// load key into the teleport agent and system agent
return a.LoadKey(*key)
} | |
c23802 | this user from the teleport and
// system agents
err = a.UnloadKey()
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23803 | and system agents.
err = a.UnloadKeys()
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23804 | syscall.LOCK_EX); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | |
c23805 |
if err == syscall.EWOULDBLOCK {
return trace.CompareFailed("lock %v is acquired by another process", f.Name())
}
return trace.ConvertSystemError(err)
}
return nil
} | |
c23806 | syscall.LOCK_UN); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | |
c23807 | = &timetools.RealTime{}
}
limiter.clock = config.Clock
limiter.TokenLimiter, err = ratelimit.New(nil, ipExtractor,
limiter.rates, ratelimit.Clock(config.Clock))
if err != nil {
return nil, trace.Wrap(err)
}
maxNumberOfUsers := config.MaxNumberOfUsers
if maxNumberOfUsers <= 0 {
maxNumberOfUsers = Default... | |
c23808 |
err := l.rateLimits.Set(token, bucketSet, int(bucketSet.GetMaxPeriod()/time.Second)*10+1)
if err != nil {
return trace.Wrap(err)
}
}
delay, err := bucketSet.Consume(1)
if err != nil {
return err
}
if delay > 0 {
return &ratelimit.MaxRateError{}
}
return nil
} | |
c23809 | http.Handler) {
l.TokenLimiter.Wrap(h)
} | |
c23810 | prevent wildcard *. entry to match
return fmt.Sprintf("%v.%v", hex.EncodeToString([]byte(clusterName)), teleport.APIDomain)
} | |
c23811 | == nil {
return conn, nil
}
log.Errorf("Failed to dial auth server %v: %v.", addr.Addr, err)
}
// not wrapping on purpose to preserve the original error
return nil, err
}
} | |
c23812 | transport.IdleConnTimeout = timeout
transport.ResponseHeaderTimeout = timeout
return nil
}
} | |
c23813 | client to always send certificate
// regardless of the server setting, otherwise client may pick
// not to send the client certificate by looking at certificate request
if len(c.TLS.Certificates) != 0 {
cert := c.TLS.Certificates[0]
c.TLS.Certificates = nil
c.TLS.GetClientCertificate = func(_ *tls.Certificate... | |
c23814 | forever and
// will cause memory leaks in a long running process.
IdleConnTimeout: defaults.HTTPIdleTimeout,
}
clientParams := append(
[]roundtrip.ClientParam{
roundtrip.HTTPClient(&http.Client{Transport: transport}),
roundtrip.SanitizerEnabled(true),
},
params...,
)
roundtripClient, err := roundt... | |
c23815 | %v.", c.KeepAlivePeriod, c.KeepAliveCount)
conn, err := grpc.Dial(teleport.APIDomain,
dialer,
grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)),
grpc.WithKeepaliveParams(keepalive.ClientParameters{
Time: c.KeepAlivePeriod,
Timeout: c.KeepAlivePeriod * time.Duration(c.KeepAliveCount),
}),
... | |
c23816 | httplib.ConvertResponse(c.Client.PutJSON(context.TODO(), endpoint, val))
} | |
c23817 | return httplib.ConvertResponse(c.Client.PostForm(context.TODO(), endpoint, vals, files...))
} | |
c23818 | httplib.ConvertResponse(c.Client.Get(context.TODO(), u, params))
} | |
c23819 | httplib.ConvertResponse(c.Client.Delete(context.TODO(), u))
} | |
c23820 | sessions []session.Session
if err := json.Unmarshal(out.Bytes(), &sessions); err != nil {
return nil, err
}
return sessions, nil
} | |
c23821 | string(id)), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var sess *session.Session
if err := json.Unmarshal(out.Bytes(), &sess); err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | |
c23822 | err := c.Delete(c.Endpoint("namespaces", namespace, "sessions", id))
return trace.Wrap(err)
} | |
c23823 |
}
_, err := c.PostJSON(c.Endpoint("namespaces", sess.Namespace, "sessions"), createSessionReq{Session: sess})
return trace.Wrap(err)
} | |
c23824 | "sessions", string(req.ID)), updateSessionReq{Update: req})
return trace.Wrap(err)
} | |
c23825 | {
return "", trace.Wrap(err)
}
var domain string
if err := json.Unmarshal(out.Bytes(), &domain); err != nil {
return "", trace.Wrap(err)
}
return domain, nil
} | |
c23826 | if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("authorities", string(ca.GetType()), "rotate", "external"),
&rotateExternalCertAuthorityRawReq{CA: data})
return trace.Wrap(err)
} | |
c23827 | }
re := make([]services.CertAuthority, len(items))
for i, raw := range items {
ca, err := services.GetCertAuthorityMarshaler().UnmarshalCertAuthority(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = ca
}
return re, nil
} | |
c23828 |
_, err := c.Delete(c.Endpoint("authorities", string(id.Type), id.DomainName))
return trace.Wrap(err)
} | |
c23829 | if err := json.Unmarshal(out.Bytes(), &token); err != nil {
return "", trace.Wrap(err)
}
return token, nil
} | |
c23830 | nil, trace.Wrap(err)
}
var keys PackedKeys
if err := json.Unmarshal(out.Bytes(), &keys); err != nil {
return nil, trace.Wrap(err)
}
return &keys, nil
} | |
c23831 | json.Unmarshal(out.Bytes(), &tokens); err != nil {
return nil, trace.Wrap(err)
}
return services.ProvisionTokensFromV1(tokens), nil
} | |
c23832 | url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.UnmarshalProvisionToken(out.Bytes(), services.SkipValidation())
} | |
c23833 | registerNewAuthServerReq{
Token: token,
})
return trace.Wrap(err)
} | |
c23834 | if err != nil {
return nil, trace.Wrap(err)
}
keepAlive, err := clt.UpsertNode(context.TODO(), protoServer)
if err != nil {
return nil, trail.FromGRPC(err)
}
return keepAlive, nil
} | |
c23835 | trace.BadParameter("not implemented, use StreamKeepAlives instead")
} | |
c23836 |
k.closeWithError(trail.FromGRPC(err))
} | |
c23837 | Namespace: namespace,
Nodes: bytes,
}
_, err = c.PutJSON(c.Endpoint("namespaces", namespace, "nodes"), args)
return trace.Wrap(err)
} | |
c23838 | err := c.Delete(c.Endpoint("namespaces", namespace, "nodes", name))
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23839 | trace.Wrap(err)
}
re := make([]services.Server, len(items))
for i, raw := range items {
s, err := services.GetServerMarshaler().UnmarshalServer(
raw,
services.KindNode,
services.AddOptions(opts, services.SkipValidation())...)
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = s
}
return re... | |
c23840 | ReverseTunnel: data,
}
_, err = c.PostJSON(c.Endpoint("reversetunnels"), args)
return trace.Wrap(err)
} | |
c23841 | &items); err != nil {
return nil, trace.Wrap(err)
}
tunnels := make([]services.ReverseTunnel, len(items))
for i, raw := range items {
tunnel, err := services.GetReverseTunnelMarshaler().UnmarshalReverseTunnel(raw, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
tunnels[i] = tun... | |
c23842 |
return trace.BadParameter("empty domain name")
}
_, err := c.Delete(c.Endpoint("reversetunnels", domainName))
return trace.Wrap(err)
} | |
c23843 | TunnelConnection: data,
}
_, err = c.PostJSON(c.Endpoint("tunnelconnections"), args)
return trace.Wrap(err)
} | |
c23844 | nil {
return trace.Wrap(err)
}
args := &createRemoteClusterRawReq{
RemoteCluster: data,
}
_, err = c.PostJSON(c.Endpoint("remoteclusters"), args)
return trace.Wrap(err)
} | |
c23845 | for i, raw := range items {
server, err := services.GetServerMarshaler().UnmarshalServer(raw, services.KindAuthServer, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
re[i] = server
}
return re, nil
} | |
c23846 | Server: data,
}
_, err = c.PostJSON(c.Endpoint("proxies"), args)
return trace.Wrap(err)
} | |
c23847 | Password: string(password),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23848 | if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("users"), &upsertUserRawReq{User: data})
return trace.Wrap(err)
} | |
c23849 | := c.PutJSON(c.Endpoint("users", req.User, "web", "password"), req)
return trace.Wrap(err)
} | |
c23850 | checkPasswordReq{
Password: string(password),
OTPToken: otpToken,
})
return trace.Wrap(err)
} | |
c23851 | return nil, trace.Wrap(err)
}
var signRequest *u2f.SignRequest
if err := json.Unmarshal(out.Bytes(), &signRequest); err != nil {
return nil, err
}
return signRequest, nil
} | |
c23852 | err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | |
c23853 | "web", "sessions", sid), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | |
c23854 | c.Delete(c.Endpoint("users", user, "web", "sessions", sid))
return trace.Wrap(err)
} | |
c23855 | := services.GetUserMarshaler().UnmarshalUser(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return user, nil
} | |
c23856 | for i, userBytes := range items {
user, err := services.GetUserMarshaler().UnmarshalUser(userBytes, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
users[i] = user
}
return users, nil
} | |
c23857 | c.Delete(c.Endpoint("users", user))
return trace.Wrap(err)
} | |
c23858 | key,
HostID: hostID,
NodeName: nodeName,
Principals: principals,
ClusterName: clusterName,
Roles: roles,
TTL: ttl,
})
if err != nil {
return nil, trace.Wrap(err)
}
var cert string
if err := json.Unmarshal(out.Bytes(), &cert); err != nil {
return nil, err
}
... | |
c23859 | getSignupTokenDataResponse
if err := json.Unmarshal(out.Bytes(), &tokenData); err != nil {
return "", nil, err
}
return tokenData.User, tokenData.QRImg, nil
} | |
c23860 | ttl,
Compatibility: compatibility,
})
if err != nil {
return nil, trace.Wrap(err)
}
var cert string
if err := json.Unmarshal(out.Bytes(), &cert); err != nil {
return nil, trace.Wrap(err)
}
return []byte(cert), nil
} | |
c23861 | u2fRegReq u2f.RegisterRequest
if err := json.Unmarshal(out.Bytes(), &u2fRegReq); err != nil {
return nil, err
}
return &u2fRegReq, nil
} | |
c23862 |
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | |
c23863 | U2FRegisterResponse: u2fRegisterResponse,
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | |
c23864 | if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("oidc", "connectors"), &upsertOIDCConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23865 |
if err != nil {
return nil, err
}
return services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(out.Bytes(), services.SkipValidation())
} | |
c23866 | err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.OIDCConnector, len(items))
for i, raw := range items {
connector, err := services.GetOIDCConnectorMarshaler().UnmarshalOIDCConnector(raw, services.SkipValidation())
if err != nil {
return ni... | |
c23867 |
}
var response *services.OIDCAuthRequest
if err := json.Unmarshal(out.Bytes(), &response); err != nil {
return nil, trace.Wrap(err)
}
return response, nil
} | |
c23868 | if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("saml", "connectors"), &createSAMLConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23869 | if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("saml", "connectors"), &upsertSAMLConnectorRawReq{
Connector: data,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23870 | "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(out.Bytes(), services.SkipValidation())
} | |
c23871 | err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
connectors := make([]services.SAMLConnector, len(items))
for i, raw := range items {
connector, err := services.GetSAMLConnectorMarshaler().UnmarshalSAMLConnector(raw, services.SkipValidation())
if err != nil {
return ni... | |
c23872 | c.Delete(c.Endpoint("saml", "connectors", connectorID))
return trace.Wrap(err)
} | |
c23873 |
}
var response *services.SAMLAuthRequest
if err := json.Unmarshal(out.Bytes(), &response); err != nil {
return nil, trace.Wrap(err)
}
return response, nil
} | |
c23874 | session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(rawResponse.Session)
if err != nil {
return nil, trace.Wrap(err)
}
response.Session = session
}
response.HostSigners = make([]services.CertAuthority, len(rawResponse.HostSigners))
for i, raw := range rawResponse.HostSigners {
ca, err :... | |
c23875 | &upsertGithubConnectorRawReq{
Connector: bytes,
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23876 | if err != nil {
return nil, trace.Wrap(err)
}
return services.GetGithubConnectorMarshaler().Unmarshal(out.Bytes())
} | |
c23877 | err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23878 | session, err := services.GetWebSessionMarshaler().UnmarshalWebSession(
rawResponse.Session)
if err != nil {
return nil, trace.Wrap(err)
}
response.Session = session
}
response.HostSigners = make([]services.CertAuthority, len(rawResponse.HostSigners))
for i, raw := range rawResponse.HostSigners {
ca, e... | |
c23879 | {
return nil, trace.Wrap(err)
}
retval := make([]events.EventFields, 0)
if err := json.Unmarshal(response.Bytes(), &retval); err != nil {
return nil, trace.Wrap(err)
}
return retval, nil
} | |
c23880 | services.GetClusterConfigMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return cc, err
} | |
c23881 | err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration"), &setClusterConfigReq{ClusterConfig: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23882 | services.GetClusterNameMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return cn, err
} | |
c23883 | nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "name"), &setClusterNameReq{ClusterName: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23884 | services.GetStaticTokensMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
return nil, trace.Wrap(err)
}
return st, err
} | |
c23885 | nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "static_tokens"), &setStaticTokensReq{StaticTokens: data})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23886 | r.emitAuditEvent(err)
return trace.Wrap(err)
}
// copy back and forth between stdin, stdout, and stderr and the SSH channel.
go func() {
defer session.Close()
_, err := io.Copy(channel, stdout)
r.errorCh <- err
}()
go func() {
defer session.Close()
_, err := io.Copy(channel.Stderr(), stderr)
r.... | |
c23887 | case <-r.ctx.Done():
lastErr = trace.ConnectionProblem(nil, "context is closing")
}
}
// emit an event to the audit log with the result of execution
r.emitAuditEvent(lastErr)
return lastErr
} | |
c23888 | KindWebSession,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | |
c23889 | WebSession {
v2 := ws.V2()
v2.Spec.Priv = nil
return v2
} | |
c23890 | return "<undefined>"
}
return ws.Metadata.Name[:4]
} | |
c23891 | time.Time) {
ws.Spec.BearerTokenExpires = tm
} | |
c23892 |
ws.Spec.Expires = tm
} | |
c23893 | MetadataSchema, fmt.Sprintf(WebSessionSpecV2Schema, extension), DefaultDefinitions)
} | |
c23894 | trace.BadParameter(err.Error())
}
utils.UTC(&ws.Spec.BearerTokenExpires)
utils.UTC(&ws.Spec.Expires)
if err := ws.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &ws, nil
}
return nil, trace.BadParameter("web session resource version %v is not supported", h.Version)
} | |
c23895 | {
return nil, trace.BadParameter("don't know how to marshal session %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.Metadata.ID = 0
v2 = ©
}
return utils.FastMarshal(v2)
default:
return n... | |
c23896 | _, p := range s.getParties(ctx.session) {
eventPayload, err := json.Marshal(sessionJoinEvent)
if err != nil {
s.log.Warnf("Unable to marshal %v for %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err... | |
c23897 |
sid = string(rsession.NewID())
ctx.SetEnv(sshutils.SessionEnvVar, sid)
}
// This logic allows concurrent request to create a new session
// to fail, what is ok because we should never have this condition
sess, err := newSession(rsession.ID(sid), s, ctx)
if err != nil {
return trace.Wrap(err)
}
ctx.session... | |
c23898 |
if err != nil {
s.log.Warnf("Unable to marshal %v for %v: %v.", events.SessionJoinEvent, p.sconn.RemoteAddr(), err)
continue
}
_, _, err = p.sconn.SendRequest(teleport.SessionEvent, false, eventPayload)
if err != nil {
s.log.Warnf("Unable to send %v to %v: %v.", events.SessionJoinEvent, p.sconn.Remote... | |
c23899 | indicating that this session has ended
sess.recorder.GetAuditLog().EmitAuditEvent(events.SessionEnd, events.EventFields{
events.SessionEventID: string(sess.id),
events.EventUser: party.user,
events.EventNamespace: s.srv.GetNamespace(),
})
// close recorder to free up associated resources
// and ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.