_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23800 | AddHostSignersToCache | train | func (a *LocalKeyAgent) AddHostSignersToCache(certAuthorities []auth.TrustedCerts) error {
for _, ca := range certAuthorities {
publicKeys, err := ca.SSHCertPublicKeys()
if err != nil {
a.log.Error(err)
return trace.Wrap(err)
}
a.log.Debugf("Adding CA key for %s", ca.ClusterName)
err = a.keyStore.AddKn... | go | {
"resource": ""
} |
q23801 | AddKey | train | func (a *LocalKeyAgent) AddKey(key *Key) (*agent.AddedKey, error) {
// save it to disk (usually into ~/.tsh)
err := a.keyStore.AddKey(a.proxyHost, a.username, key)
if err != nil {
return nil, trace.Wrap(err)
}
// load key into the teleport agent and system agent
return a.LoadKey(*key)
} | go | {
"resource": ""
} |
q23802 | DeleteKey | train | func (a *LocalKeyAgent) DeleteKey() error {
// remove key from key store
err := a.keyStore.DeleteKey(a.proxyHost, a.username)
if err != nil {
return trace.Wrap(err)
}
// remove any keys that are loaded for this user from the teleport and
// system agents
err = a.UnloadKey()
if err != nil {
return trace.Wra... | go | {
"resource": ""
} |
q23803 | DeleteKeys | train | func (a *LocalKeyAgent) DeleteKeys() error {
// Remove keys from the filesystem.
err := a.keyStore.DeleteKeys()
if err != nil {
return trace.Wrap(err)
}
// Remove all keys from the Teleport and system agents.
err = a.UnloadKeys()
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23804 | FSWriteLock | train | func FSWriteLock(f *os.File) error {
if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23805 | FSTryWriteLock | train | func FSTryWriteLock(f *os.File) error {
err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
if err != nil {
if err == syscall.EWOULDBLOCK {
return trace.CompareFailed("lock %v is acquired by another process", f.Name())
}
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23806 | FSUnlock | train | func FSUnlock(f *os.File) error {
if err := syscall.Flock(int(f.Fd()), syscall.LOCK_UN); err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23807 | NewRateLimiter | train | func NewRateLimiter(config LimiterConfig) (*RateLimiter, error) {
limiter := RateLimiter{
Mutex: &sync.Mutex{},
}
ipExtractor, err := utils.NewExtractor("client.ip")
if err != nil {
return nil, trace.Wrap(err)
}
limiter.rates = ratelimit.NewRateSet()
for _, rate := range config.Rates {
err := limiter.rat... | go | {
"resource": ""
} |
q23808 | RegisterRequest | train | func (l *RateLimiter) RegisterRequest(token string) error {
l.Lock()
defer l.Unlock()
bucketSetI, exists := l.rateLimits.Get(token)
var bucketSet *ratelimit.TokenBucketSet
if exists {
bucketSet = bucketSetI.(*ratelimit.TokenBucketSet)
bucketSet.Update(l.rates)
} else {
bucketSet = ratelimit.NewTokenBucket... | go | {
"resource": ""
} |
q23809 | WrapHandle | train | func (l *RateLimiter) WrapHandle(h http.Handler) {
l.TokenLimiter.Wrap(h)
} | go | {
"resource": ""
} |
q23810 | EncodeClusterName | train | func EncodeClusterName(clusterName string) string {
// hex is used to hide "." that will prevent wildcard *. entry to match
return fmt.Sprintf("%v.%v", hex.EncodeToString([]byte(clusterName)), teleport.APIDomain)
} | go | {
"resource": ""
} |
q23811 | NewAddrDialer | train | func NewAddrDialer(addrs []utils.NetAddr) DialContext {
dialer := net.Dialer{
Timeout: defaults.DefaultDialTimeout,
KeepAlive: defaults.ReverseTunnelAgentHeartbeatPeriod,
}
return func(in context.Context, network, _ string) (net.Conn, error) {
var err error
var conn net.Conn
for _, addr := range addrs {
... | go | {
"resource": ""
} |
q23812 | ClientTimeout | train | func ClientTimeout(timeout time.Duration) roundtrip.ClientParam {
return func(c *roundtrip.Client) error {
transport, ok := (c.HTTPClient().Transport).(*http.Transport)
if !ok {
return nil
}
transport.IdleConnTimeout = timeout
transport.ResponseHeaderTimeout = timeout
return nil
}
} | go | {
"resource": ""
} |
q23813 | CheckAndSetDefaults | train | func (c *ClientConfig) CheckAndSetDefaults() error {
if len(c.Addrs) == 0 && c.DialContext == nil {
return trace.BadParameter("set parameter Addrs or DialContext")
}
if c.TLS == nil {
return trace.BadParameter("missing parameter TLS")
}
if c.KeepAlivePeriod == 0 {
c.KeepAlivePeriod = defaults.ServerKeepAlive... | go | {
"resource": ""
} |
q23814 | NewTLSClient | train | func NewTLSClient(cfg ClientConfig, params ...roundtrip.ClientParam) (*Client, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
transport := &http.Transport{
// notice that below roundtrip.Client is passed
// teleport.APIEndpoint as an address for the API server, this is... | go | {
"resource": ""
} |
q23815 | grpc | train | func (c *Client) grpc() (proto.AuthServiceClient, error) {
// it's ok to lock here, because Dial below is not locking
c.Lock()
defer c.Unlock()
if c.grpcClient != nil {
return c.grpcClient, nil
}
dialer := grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
if c.isClosed() {
retur... | go | {
"resource": ""
} |
q23816 | PutJSON | train | func (c *Client) PutJSON(
endpoint string, val interface{}) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.PutJSON(context.TODO(), endpoint, val))
} | go | {
"resource": ""
} |
q23817 | PostForm | train | func (c *Client) PostForm(
endpoint string,
vals url.Values,
files ...roundtrip.File) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.PostForm(context.TODO(), endpoint, vals, files...))
} | go | {
"resource": ""
} |
q23818 | Get | train | func (c *Client) Get(u string, params url.Values) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.Get(context.TODO(), u, params))
} | go | {
"resource": ""
} |
q23819 | Delete | train | func (c *Client) Delete(u string) (*roundtrip.Response, error) {
return httplib.ConvertResponse(c.Client.Delete(context.TODO(), u))
} | go | {
"resource": ""
} |
q23820 | GetSessions | train | func (c *Client) GetSessions(namespace string) ([]session.Session, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
out, err := c.Get(c.Endpoint("namespaces", namespace, "sessions"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var sessions []session.Session... | go | {
"resource": ""
} |
q23821 | GetSession | train | func (c *Client) GetSession(namespace string, id session.ID) (*session.Session, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
// saving extra round-trip
if err := id.Check(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("namespaces", namespace... | go | {
"resource": ""
} |
q23822 | DeleteSession | train | func (c *Client) DeleteSession(namespace, id string) error {
if namespace == "" {
return trace.BadParameter(MissingNamespaceError)
}
_, err := c.Delete(c.Endpoint("namespaces", namespace, "sessions", id))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23823 | CreateSession | train | func (c *Client) CreateSession(sess session.Session) error {
if sess.Namespace == "" {
return trace.BadParameter(MissingNamespaceError)
}
_, err := c.PostJSON(c.Endpoint("namespaces", sess.Namespace, "sessions"), createSessionReq{Session: sess})
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23824 | UpdateSession | train | func (c *Client) UpdateSession(req session.UpdateRequest) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
_, err := c.PutJSON(c.Endpoint("namespaces", req.Namespace, "sessions", string(req.ID)), updateSessionReq{Update: req})
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23825 | GetDomainName | train | func (c *Client) GetDomainName() (string, error) {
out, err := c.Get(c.Endpoint("domain"), url.Values{})
if err != nil {
return "", trace.Wrap(err)
}
var domain string
if err := json.Unmarshal(out.Bytes(), &domain); err != nil {
return "", trace.Wrap(err)
}
return domain, nil
} | go | {
"resource": ""
} |
q23826 | RotateExternalCertAuthority | train | func (c *Client) RotateExternalCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
data, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("authorities", string(c... | go | {
"resource": ""
} |
q23827 | GetCertAuthorities | train | func (c *Client) GetCertAuthorities(caType services.CertAuthType, loadKeys bool, opts ...services.MarshalOption) ([]services.CertAuthority, error) {
if err := caType.Check(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("authorities", string(caType)), url.Values{
"load_keys": []string{... | go | {
"resource": ""
} |
q23828 | DeleteCertAuthority | train | func (c *Client) DeleteCertAuthority(id services.CertAuthID) error {
if err := id.Check(); err != nil {
return trace.Wrap(err)
}
_, err := c.Delete(c.Endpoint("authorities", string(id.Type), id.DomainName))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23829 | GenerateToken | train | func (c *Client) GenerateToken(req GenerateTokenRequest) (string, error) {
out, err := c.PostJSON(c.Endpoint("tokens"), req)
if err != nil {
return "", trace.Wrap(err)
}
var token string
if err := json.Unmarshal(out.Bytes(), &token); err != nil {
return "", trace.Wrap(err)
}
return token, nil
} | go | {
"resource": ""
} |
q23830 | RegisterUsingToken | train | func (c *Client) RegisterUsingToken(req RegisterUsingTokenRequest) (*PackedKeys, error) {
if err := req.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
out, err := c.PostJSON(c.Endpoint("tokens", "register"), req)
if err != nil {
return nil, trace.Wrap(err)
}
var keys PackedKeys
if err := j... | go | {
"resource": ""
} |
q23831 | GetTokens | train | func (c *Client) GetTokens(opts ...services.MarshalOption) ([]services.ProvisionToken, error) {
out, err := c.Get(c.Endpoint("tokens"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var tokens []services.ProvisionTokenV1
if err := json.Unmarshal(out.Bytes(), &tokens); err != nil {
return nil, tra... | go | {
"resource": ""
} |
q23832 | GetToken | train | func (c *Client) GetToken(token string) (services.ProvisionToken, error) {
out, err := c.Get(c.Endpoint("tokens", token), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.UnmarshalProvisionToken(out.Bytes(), services.SkipValidation())
} | go | {
"resource": ""
} |
q23833 | RegisterNewAuthServer | train | func (c *Client) RegisterNewAuthServer(token string) error {
_, err := c.PostJSON(c.Endpoint("tokens", "register", "auth"), registerNewAuthServerReq{
Token: token,
})
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23834 | UpsertNode | train | func (c *Client) UpsertNode(s services.Server) (*services.KeepAlive, error) {
if s.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
protoServer, ok := s.(*services.ServerV2)
if !ok {
return nil, trace.BadParameter("unsupported client")
}
clt, err := c.grpc()
if err != nil {
... | go | {
"resource": ""
} |
q23835 | KeepAliveNode | train | func (c *Client) KeepAliveNode(ctx context.Context, keepAlive services.KeepAlive) error {
return trace.BadParameter("not implemented, use StreamKeepAlives instead")
} | go | {
"resource": ""
} |
q23836 | recv | train | func (k *streamKeepAliver) recv() {
err := k.stream.RecvMsg(&empty.Empty{})
k.closeWithError(trail.FromGRPC(err))
} | go | {
"resource": ""
} |
q23837 | UpsertNodes | train | func (c *Client) UpsertNodes(namespace string, servers []services.Server) error {
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
bytes, err := services.GetServerMarshaler().MarshalServers(servers)
if err != nil {
return trace.Wrap(err)
}
args := &upsertNodesReq{
Namespace: names... | go | {
"resource": ""
} |
q23838 | DeleteNode | train | func (c *Client) DeleteNode(namespace string, name string) error {
if namespace == "" {
return trace.BadParameter("missing parameter namespace")
}
if name == "" {
return trace.BadParameter("missing parameter name")
}
_, err := c.Delete(c.Endpoint("namespaces", namespace, "nodes", name))
if err != nil {
retu... | go | {
"resource": ""
} |
q23839 | GetNodes | train | func (c *Client) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter(MissingNamespaceError)
}
cfg, err := services.CollectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
out, err := c.Get(c.Endpoint("namespace... | go | {
"resource": ""
} |
q23840 | UpsertReverseTunnel | train | func (c *Client) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
data, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
args := &upsertReverseTunnelRawReq{
ReverseTunnel: data,
}
_, err = c.PostJSON(c.Endpoint("reversetunnels"), args)... | go | {
"resource": ""
} |
q23841 | GetReverseTunnels | train | func (c *Client) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
out, err := c.Get(c.Endpoint("reversetunnels"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, ... | go | {
"resource": ""
} |
q23842 | DeleteReverseTunnel | train | func (c *Client) DeleteReverseTunnel(domainName string) error {
// this is to avoid confusing error in case if domain empty for example
// HTTP route will fail producing generic not found error
// instead we catch the error here
if strings.TrimSpace(domainName) == "" {
return trace.BadParameter("empty domain name... | go | {
"resource": ""
} |
q23843 | UpsertTunnelConnection | train | func (c *Client) UpsertTunnelConnection(conn services.TunnelConnection) error {
data, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
args := &upsertTunnelConnectionRawReq{
TunnelConnection: data,
}
_, err = c.PostJSON(c.Endpoint("tunnelconnections"), args)
return trace... | go | {
"resource": ""
} |
q23844 | CreateRemoteCluster | train | func (c *Client) CreateRemoteCluster(rc services.RemoteCluster) error {
data, err := services.MarshalRemoteCluster(rc)
if err != nil {
return trace.Wrap(err)
}
args := &createRemoteClusterRawReq{
RemoteCluster: data,
}
_, err = c.PostJSON(c.Endpoint("remoteclusters"), args)
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23845 | GetAuthServers | train | func (c *Client) GetAuthServers() ([]services.Server, error) {
out, err := c.Get(c.Endpoint("authservers"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
re := make([]services.S... | go | {
"resource": ""
} |
q23846 | UpsertProxy | train | func (c *Client) UpsertProxy(s services.Server) error {
data, err := services.GetServerMarshaler().MarshalServer(s)
if err != nil {
return trace.Wrap(err)
}
args := &upsertServerRawReq{
Server: data,
}
_, err = c.PostJSON(c.Endpoint("proxies"), args)
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23847 | UpsertPassword | train | func (c *Client) UpsertPassword(user string, password []byte) error {
_, err := c.PostJSON(
c.Endpoint("users", user, "web", "password"),
upsertPasswordReq{
Password: string(password),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23848 | UpsertUser | train | func (c *Client) UpsertUser(user services.User) error {
data, err := services.GetUserMarshaler().MarshalUser(user)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("users"), &upsertUserRawReq{User: data})
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23849 | ChangePassword | train | func (c *Client) ChangePassword(req services.ChangePasswordReq) error {
_, err := c.PutJSON(c.Endpoint("users", req.User, "web", "password"), req)
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23850 | CheckPassword | train | func (c *Client) CheckPassword(user string, password []byte, otpToken string) error {
_, err := c.PostJSON(
c.Endpoint("users", user, "web", "password", "check"),
checkPasswordReq{
Password: string(password),
OTPToken: otpToken,
})
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23851 | GetU2FSignRequest | train | func (c *Client) GetU2FSignRequest(user string, password []byte) (*u2f.SignRequest, error) {
out, err := c.PostJSON(
c.Endpoint("u2f", "users", user, "sign"),
signInReq{
Password: string(password),
},
)
if err != nil {
return nil, trace.Wrap(err)
}
var signRequest *u2f.SignRequest
if err := json.Unmars... | go | {
"resource": ""
} |
q23852 | ExtendWebSession | train | func (c *Client) ExtendWebSession(user string, prevSessionID string) (services.WebSession, error) {
out, err := c.PostJSON(
c.Endpoint("users", user, "web", "sessions"),
createWebSessionReq{
PrevSessionID: prevSessionID,
},
)
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMar... | go | {
"resource": ""
} |
q23853 | GetWebSessionInfo | train | func (c *Client) GetWebSessionInfo(user string, sid string) (services.WebSession, error) {
out, err := c.Get(
c.Endpoint("users", user, "web", "sessions", sid), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetWebSessionMarshaler().UnmarshalWebSession(out.Bytes())
} | go | {
"resource": ""
} |
q23854 | DeleteWebSession | train | func (c *Client) DeleteWebSession(user string, sid string) error {
_, err := c.Delete(c.Endpoint("users", user, "web", "sessions", sid))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23855 | GetUser | train | func (c *Client) GetUser(name string) (services.User, error) {
if name == "" {
return nil, trace.BadParameter("missing username")
}
out, err := c.Get(c.Endpoint("users", name), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
user, err := services.GetUserMarshaler().UnmarshalUser(out.Bytes(), servi... | go | {
"resource": ""
} |
q23856 | GetUsers | train | func (c *Client) GetUsers() ([]services.User, error) {
out, err := c.Get(c.Endpoint("users"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), &items); err != nil {
return nil, trace.Wrap(err)
}
users := make([]services.User, len(it... | go | {
"resource": ""
} |
q23857 | DeleteUser | train | func (c *Client) DeleteUser(user string) error {
_, err := c.Delete(c.Endpoint("users", user))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23858 | GenerateHostCert | train | func (c *Client) GenerateHostCert(
key []byte, hostID, nodeName string, principals []string, clusterName string, roles teleport.Roles, ttl time.Duration) ([]byte, error) {
out, err := c.PostJSON(c.Endpoint("ca", "host", "certs"),
generateHostCertReq{
Key: key,
HostID: hostID,
NodeName: nod... | go | {
"resource": ""
} |
q23859 | GetSignupTokenData | train | func (c *Client) GetSignupTokenData(token string) (user string, otpQRCode []byte, e error) {
out, err := c.Get(c.Endpoint("signuptokens", token), url.Values{})
if err != nil {
return "", nil, err
}
var tokenData getSignupTokenDataResponse
if err := json.Unmarshal(out.Bytes(), &tokenData); err != nil {
return ... | go | {
"resource": ""
} |
q23860 | GenerateUserCert | train | func (c *Client) GenerateUserCert(key []byte, user string, ttl time.Duration, compatibility string) ([]byte, error) {
out, err := c.PostJSON(c.Endpoint("ca", "user", "certs"),
generateUserCertReq{
Key: key,
User: user,
TTL: ttl,
Compatibility: compatibility,
})
if err != n... | go | {
"resource": ""
} |
q23861 | GetSignupU2FRegisterRequest | train | func (c *Client) GetSignupU2FRegisterRequest(token string) (u2fRegisterRequest *u2f.RegisterRequest, e error) {
out, err := c.Get(c.Endpoint("u2f", "signuptokens", token), url.Values{})
if err != nil {
return nil, err
}
var u2fRegReq u2f.RegisterRequest
if err := json.Unmarshal(out.Bytes(), &u2fRegReq); err != n... | go | {
"resource": ""
} |
q23862 | CreateUserWithOTP | train | func (c *Client) CreateUserWithOTP(token, password, otpToken string) (services.WebSession, error) {
out, err := c.PostJSON(c.Endpoint("signuptokens", "users"), createUserWithTokenReq{
Token: token,
Password: password,
OTPToken: otpToken,
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.G... | go | {
"resource": ""
} |
q23863 | CreateUserWithU2FToken | train | func (c *Client) CreateUserWithU2FToken(token string, password string, u2fRegisterResponse u2f.RegisterResponse) (services.WebSession, error) {
out, err := c.PostJSON(c.Endpoint("u2f", "users"), createUserWithU2FTokenReq{
Token: token,
Password: password,
U2FRegisterResponse: u2fRegister... | go | {
"resource": ""
} |
q23864 | UpsertOIDCConnector | train | func (c *Client) UpsertOIDCConnector(connector services.OIDCConnector) error {
data, err := services.GetOIDCConnectorMarshaler().MarshalOIDCConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("oidc", "connectors"), &upsertOIDCConnectorRawReq{
Connector: data,
})
if err... | go | {
"resource": ""
} |
q23865 | GetOIDCConnector | train | func (c *Client) GetOIDCConnector(id string, withSecrets bool) (services.OIDCConnector, error) {
if id == "" {
return nil, trace.BadParameter("missing connector id")
}
out, err := c.Get(c.Endpoint("oidc", "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
... | go | {
"resource": ""
} |
q23866 | GetOIDCConnectors | train | func (c *Client) GetOIDCConnectors(withSecrets bool) ([]services.OIDCConnector, error) {
out, err := c.Get(c.Endpoint("oidc", "connectors"),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), ... | go | {
"resource": ""
} |
q23867 | CreateOIDCAuthRequest | train | func (c *Client) CreateOIDCAuthRequest(req services.OIDCAuthRequest) (*services.OIDCAuthRequest, error) {
out, err := c.PostJSON(c.Endpoint("oidc", "requests", "create"), createOIDCAuthRequestReq{
Req: req,
})
if err != nil {
return nil, trace.Wrap(err)
}
var response *services.OIDCAuthRequest
if err := json.... | go | {
"resource": ""
} |
q23868 | CreateSAMLConnector | train | func (c *Client) CreateSAMLConnector(connector services.SAMLConnector) error {
data, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("saml", "connectors"), &createSAMLConnectorRawReq{
Connector: data,
})
if err... | go | {
"resource": ""
} |
q23869 | UpsertSAMLConnector | train | func (c *Client) UpsertSAMLConnector(connector services.SAMLConnector) error {
data, err := services.GetSAMLConnectorMarshaler().MarshalSAMLConnector(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("saml", "connectors"), &upsertSAMLConnectorRawReq{
Connector: data,
})
if err ... | go | {
"resource": ""
} |
q23870 | GetSAMLConnector | train | func (c *Client) GetSAMLConnector(id string, withSecrets bool) (services.SAMLConnector, error) {
if id == "" {
return nil, trace.BadParameter("missing connector id")
}
out, err := c.Get(c.Endpoint("saml", "connectors", id),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
... | go | {
"resource": ""
} |
q23871 | GetSAMLConnectors | train | func (c *Client) GetSAMLConnectors(withSecrets bool) ([]services.SAMLConnector, error) {
out, err := c.Get(c.Endpoint("saml", "connectors"),
url.Values{"with_secrets": []string{fmt.Sprintf("%t", withSecrets)}})
if err != nil {
return nil, err
}
var items []json.RawMessage
if err := json.Unmarshal(out.Bytes(), ... | go | {
"resource": ""
} |
q23872 | DeleteSAMLConnector | train | func (c *Client) DeleteSAMLConnector(connectorID string) error {
if connectorID == "" {
return trace.BadParameter("missing connector id")
}
_, err := c.Delete(c.Endpoint("saml", "connectors", connectorID))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23873 | CreateSAMLAuthRequest | train | func (c *Client) CreateSAMLAuthRequest(req services.SAMLAuthRequest) (*services.SAMLAuthRequest, error) {
out, err := c.PostJSON(c.Endpoint("saml", "requests", "create"), createSAMLAuthRequestReq{
Req: req,
})
if err != nil {
return nil, trace.Wrap(err)
}
var response *services.SAMLAuthRequest
if err := json.... | go | {
"resource": ""
} |
q23874 | ValidateSAMLResponse | train | func (c *Client) ValidateSAMLResponse(re string) (*SAMLAuthResponse, error) {
out, err := c.PostJSON(c.Endpoint("saml", "requests", "validate"), validateSAMLResponseReq{
Response: re,
})
if err != nil {
return nil, trace.Wrap(err)
}
var rawResponse *samlAuthRawResponse
if err := json.Unmarshal(out.Bytes(), &r... | go | {
"resource": ""
} |
q23875 | UpsertGithubConnector | train | func (c *Client) UpsertGithubConnector(connector services.GithubConnector) error {
bytes, err := services.GetGithubConnectorMarshaler().Marshal(connector)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PutJSON(c.Endpoint("github", "connectors"), &upsertGithubConnectorRawReq{
Connector: bytes,
})
if err !... | go | {
"resource": ""
} |
q23876 | GetGithubConnector | train | func (c *Client) GetGithubConnector(id string, withSecrets bool) (services.GithubConnector, error) {
out, err := c.Get(c.Endpoint("github", "connectors", id), url.Values{
"with_secrets": []string{strconv.FormatBool(withSecrets)},
})
if err != nil {
return nil, trace.Wrap(err)
}
return services.GetGithubConnect... | go | {
"resource": ""
} |
q23877 | DeleteGithubConnector | train | func (c *Client) DeleteGithubConnector(id string) error {
_, err := c.Delete(c.Endpoint("github", "connectors", id))
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23878 | ValidateGithubAuthCallback | train | func (c *Client) ValidateGithubAuthCallback(q url.Values) (*GithubAuthResponse, error) {
out, err := c.PostJSON(c.Endpoint("github", "requests", "validate"),
validateGithubAuthCallbackReq{Query: q})
if err != nil {
return nil, trace.Wrap(err)
}
var rawResponse githubAuthRawResponse
if err := json.Unmarshal(out... | go | {
"resource": ""
} |
q23879 | SearchEvents | train | func (c *Client) SearchEvents(from, to time.Time, query string, limit int) ([]events.EventFields, error) {
q, err := url.ParseQuery(query)
if err != nil {
return nil, trace.BadParameter("query")
}
q.Set("from", from.Format(time.RFC3339))
q.Set("to", to.Format(time.RFC3339))
q.Set("limit", fmt.Sprintf("%v", limi... | go | {
"resource": ""
} |
q23880 | GetClusterConfig | train | func (c *Client) GetClusterConfig(opts ...services.MarshalOption) (services.ClusterConfig, error) {
out, err := c.Get(c.Endpoint("configuration"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
cc, err := services.GetClusterConfigMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err ... | go | {
"resource": ""
} |
q23881 | SetClusterConfig | train | func (c *Client) SetClusterConfig(cc services.ClusterConfig) error {
data, err := services.GetClusterConfigMarshaler().Marshal(cc)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration"), &setClusterConfigReq{ClusterConfig: data})
if err != nil {
return trace.Wrap(err)
}
re... | go | {
"resource": ""
} |
q23882 | GetClusterName | train | func (c *Client) GetClusterName(opts ...services.MarshalOption) (services.ClusterName, error) {
out, err := c.Get(c.Endpoint("configuration", "name"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
cn, err := services.GetClusterNameMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if er... | go | {
"resource": ""
} |
q23883 | SetClusterName | train | func (c *Client) SetClusterName(cn services.ClusterName) error {
data, err := services.GetClusterNameMarshaler().Marshal(cn)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "name"), &setClusterNameReq{ClusterName: data})
if err != nil {
return trace.Wrap(err)
}
retu... | go | {
"resource": ""
} |
q23884 | GetStaticTokens | train | func (c *Client) GetStaticTokens() (services.StaticTokens, error) {
out, err := c.Get(c.Endpoint("configuration", "static_tokens"), url.Values{})
if err != nil {
return nil, trace.Wrap(err)
}
st, err := services.GetStaticTokensMarshaler().Unmarshal(out.Bytes(), services.SkipValidation())
if err != nil {
retur... | go | {
"resource": ""
} |
q23885 | SetStaticTokens | train | func (c *Client) SetStaticTokens(st services.StaticTokens) error {
data, err := services.GetStaticTokensMarshaler().Marshal(st)
if err != nil {
return trace.Wrap(err)
}
_, err = c.PostJSON(c.Endpoint("configuration", "static_tokens"), &setStaticTokensReq{StaticTokens: data})
if err != nil {
return trace.Wrap(... | go | {
"resource": ""
} |
q23886 | Start | train | func (r *remoteSubsystem) Start(channel ssh.Channel) error {
session := r.serverContext.RemoteSession
stdout, err := session.StdoutPipe()
if err != nil {
return trace.Wrap(err)
}
stderr, err := session.StderrPipe()
if err != nil {
return trace.Wrap(err)
}
stdin, err := session.StdinPipe()
if err != nil {
... | go | {
"resource": ""
} |
q23887 | Wait | train | func (r *remoteSubsystem) Wait() error {
var lastErr error
for i := 0; i < 3; i++ {
select {
case err := <-r.errorCh:
if err != nil && err != io.EOF {
r.log.Warnf("Connection problem: %v %T", trace.DebugReport(err), err)
lastErr = err
}
case <-r.ctx.Done():
lastErr = trace.ConnectionProblem(ni... | go | {
"resource": ""
} |
q23888 | NewWebSession | train | func NewWebSession(name string, spec WebSessionSpecV2) WebSession {
return &WebSessionV2{
Kind: KindWebSession,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | go | {
"resource": ""
} |
q23889 | WithoutSecrets | train | func (ws *WebSessionV2) WithoutSecrets() WebSession {
v2 := ws.V2()
v2.Spec.Priv = nil
return v2
} | go | {
"resource": ""
} |
q23890 | GetShortName | train | func (ws *WebSessionV2) GetShortName() string {
if len(ws.Metadata.Name) < 4 {
return "<undefined>"
}
return ws.Metadata.Name[:4]
} | go | {
"resource": ""
} |
q23891 | SetBearerTokenExpiryTime | train | func (ws *WebSessionV2) SetBearerTokenExpiryTime(tm time.Time) {
ws.Spec.BearerTokenExpires = tm
} | go | {
"resource": ""
} |
q23892 | SetExpiryTime | train | func (ws *WebSessionV2) SetExpiryTime(tm time.Time) {
ws.Spec.Expires = tm
} | go | {
"resource": ""
} |
q23893 | GetWebSessionSchemaWithExtensions | train | func GetWebSessionSchemaWithExtensions(extension string) string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(WebSessionSpecV2Schema, extension), DefaultDefinitions)
} | go | {
"resource": ""
} |
q23894 | UnmarshalWebSession | train | func (*TeleportWebSessionMarshaler) UnmarshalWebSession(bytes []byte) (WebSession, error) {
var h ResourceHeader
err := json.Unmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var ws WebSessionV1
err := json.Unmarshal(bytes, &ws)
if err != nil {
return nil, t... | go | {
"resource": ""
} |
q23895 | MarshalWebSession | train | func (*TeleportWebSessionMarshaler) MarshalWebSession(ws WebSession, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type ws1 interface {
V1() *WebSessionV1
}
type ws2 interface {
V2() *WebSessionV2
}
version := cfg.GetVersion()
swit... | go | {
"resource": ""
} |
q23896 | emitSessionJoinEvent | train | func (s *SessionRegistry) emitSessionJoinEvent(ctx *ServerContext) {
sessionJoinEvent := events.EventFields{
events.EventType: events.SessionJoinEvent,
events.SessionEventID: string(ctx.session.id),
events.EventNamespace: s.srv.GetNamespace(),
events.EventLogin: ctx.Identity.Login,
events.EventU... | go | {
"resource": ""
} |
q23897 | OpenSession | train | func (s *SessionRegistry) OpenSession(ch ssh.Channel, req *ssh.Request, ctx *ServerContext) error {
if ctx.session != nil {
ctx.Infof("Joining existing session %v.", ctx.session.id)
// Update the in-memory data structure that a party member has joined.
_, err := ctx.session.join(ch, req, ctx)
if err != nil {
... | go | {
"resource": ""
} |
q23898 | emitSessionLeaveEvent | train | func (s *SessionRegistry) emitSessionLeaveEvent(party *party) {
sessionLeaveEvent := events.EventFields{
events.EventType: events.SessionLeaveEvent,
events.SessionEventID: party.id.String(),
events.EventUser: party.user,
events.SessionServerID: party.serverID,
events.EventNamespace: s.srv.GetNa... | go | {
"resource": ""
} |
q23899 | leaveSession | train | func (s *SessionRegistry) leaveSession(party *party) error {
sess := party.s
s.Lock()
defer s.Unlock()
// Emit session leave event to both the Audit Log as well as over the
// "x-teleport-event" channel in the SSH connection.
s.emitSessionLeaveEvent(party)
// Remove member from in-members representation of par... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.