_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23200 | CheckCert | train | func (c *CertChecker) CheckCert(principal string, cert *ssh.Certificate) error {
err := validate(cert)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckCert(principal, cert)
} | go | {
"resource": ""
} |
q23201 | CheckHostKey | train | func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key ssh.PublicKey) error {
err := validate(key)
if err != nil {
return trace.Wrap(err)
}
return c.CertChecker.CheckHostKey(addr, remote, key)
} | go | {
"resource": ""
} |
q23202 | CreateCertificate | train | func CreateCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create RSA key for CA and certificate to be signed by CA.
caKey, err := rsa.GenerateKey(rand.Reader, teleport.RSAKeySize)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := rsa.GenerateKey(rand.Reader... | go | {
"resource": ""
} |
q23203 | CreateEllipticCertificate | train | func CreateEllipticCertificate(principal string, certType uint32) (*ssh.Certificate, ssh.Signer, error) {
// Create ECDSA key for CA and certificate to be signed by CA.
caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, nil, trace.Wrap(err)
}
key, err := ecdsa.GenerateKey(e... | go | {
"resource": ""
} |
q23204 | createCertificate | train | func createCertificate(principal string, certType uint32, caKey crypto.Signer, key crypto.Signer) (*ssh.Certificate, ssh.Signer, error) {
// Create CA.
caPublicKey, err := ssh.NewPublicKey(caKey.Public())
if err != nil {
return nil, nil, trace.Wrap(err)
}
caSigner, err := ssh.NewSignerFromKey(caKey)
if err != n... | go | {
"resource": ""
} |
q23205 | upsertServer | train | func (s *APIServer) upsertServer(auth ClientI, role teleport.Role, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertServerRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
var kind string
switch role {
case tel... | go | {
"resource": ""
} |
q23206 | keepAliveNode | train | func (s *APIServer) keepAliveNode(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var handle services.KeepAlive
if err := httplib.ReadJSON(r, &handle); err != nil {
return nil, trace.Wrap(err)
}
if err := auth.KeepAliveNode(r.Context(), handle); er... | go | {
"resource": ""
} |
q23207 | upsertNodes | train | func (s *APIServer) upsertNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertNodesReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
if !services.IsValidNamespace(req.Namespace) {
return nil, trac... | go | {
"resource": ""
} |
q23208 | getNodes | train | func (s *APIServer) getNodes(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
namespace := p.ByName("namespace")
if !services.IsValidNamespace(namespace) {
return nil, trace.BadParameter("invalid namespace %q", namespace)
}
skipValidation, _, err :=... | go | {
"resource": ""
} |
q23209 | deleteProxy | train | func (s *APIServer) deleteProxy(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
name := p.ByName("name")
if name == "" {
return nil, trace.BadParameter("missing proxy name")
}
err := auth.DeleteProxy(name)
if err != nil {
return nil, trace.Wrap(... | go | {
"resource": ""
} |
q23210 | upsertAuthServer | train | func (s *APIServer) upsertAuthServer(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
return s.upsertServer(auth, teleport.RoleAuth, w, r, p, version)
} | go | {
"resource": ""
} |
q23211 | getAuthServers | train | func (s *APIServer) getAuthServers(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
servers, err := auth.GetAuthServers()
if err != nil {
return nil, trace.Wrap(err)
}
return marshalServers(servers, version)
} | go | {
"resource": ""
} |
q23212 | upsertReverseTunnel | train | func (s *APIServer) upsertReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertReverseTunnelRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
tun, err := services.GetReverseTunnelMarshaler... | go | {
"resource": ""
} |
q23213 | getReverseTunnels | train | func (s *APIServer) getReverseTunnels(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
reverseTunnels, err := auth.GetReverseTunnels()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(reverseTunnels))
for i, tunnel... | go | {
"resource": ""
} |
q23214 | deleteReverseTunnel | train | func (s *APIServer) deleteReverseTunnel(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
domainName := p.ByName("domain")
err := auth.DeleteReverseTunnel(domainName)
if err != nil {
return nil, trace.Wrap(err)
}
return message(fmt.Sprintf("reverse ... | go | {
"resource": ""
} |
q23215 | getClusterCACert | train | func (s *APIServer) getClusterCACert(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
localCA, err := auth.GetClusterCACert()
if err != nil {
return nil, trace.Wrap(err)
}
return localCA, nil
} | go | {
"resource": ""
} |
q23216 | getU2FAppID | train | func (s *APIServer) getU2FAppID(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cap, err := auth.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
universalSecondFactor, err := cap.GetU2F()
if err != nil {
return nil, trace.Wrap... | go | {
"resource": ""
} |
q23217 | getSignupTokenData | train | func (s *APIServer) getSignupTokenData(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
token := p.ByName("token")
user, otpQRCode, err := auth.GetSignupTokenData(token)
if err != nil {
return nil, trace.Wrap(err)
}
return &getSignupTokenDataResp... | go | {
"resource": ""
} |
q23218 | upsertTunnelConnection | train | func (s *APIServer) upsertTunnelConnection(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req upsertTunnelConnectionRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalTunnelCon... | go | {
"resource": ""
} |
q23219 | getTunnelConnections | train | func (s *APIServer) getTunnelConnections(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
conns, err := auth.GetTunnelConnections(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(conns))
for i,... | go | {
"resource": ""
} |
q23220 | createRemoteCluster | train | func (s *APIServer) createRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
var req createRemoteClusterRawReq
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
conn, err := services.UnmarshalRemoteCluster(r... | go | {
"resource": ""
} |
q23221 | getRemoteClusters | train | func (s *APIServer) getRemoteClusters(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
clusters, err := auth.GetRemoteClusters()
if err != nil {
return nil, trace.Wrap(err)
}
items := make([]json.RawMessage, len(clusters))
for i, cluster := range c... | go | {
"resource": ""
} |
q23222 | getRemoteCluster | train | func (s *APIServer) getRemoteCluster(auth ClientI, w http.ResponseWriter, r *http.Request, p httprouter.Params, version string) (interface{}, error) {
cluster, err := auth.GetRemoteCluster(p.ByName("cluster"))
if err != nil {
return nil, trace.Wrap(err)
}
return rawMessage(services.MarshalRemoteCluster(cluster, s... | go | {
"resource": ""
} |
q23223 | buildSAMLRoles | train | func (a *AuthServer) buildSAMLRoles(connector services.SAMLConnector, assertionInfo saml2.AssertionInfo) ([]string, error) {
roles := connector.MapAttributes(assertionInfo)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map attributes to role for connector: %v", connector.GetName())
}
return role... | go | {
"resource": ""
} |
q23224 | assertionsToTraitMap | train | func assertionsToTraitMap(assertionInfo saml2.AssertionInfo) map[string][]string {
traits := make(map[string][]string)
for _, assr := range assertionInfo.Values {
var vals []string
for _, value := range assr.Values {
vals = append(vals, value.Value)
}
traits[assr.Name] = vals
}
return traits
} | go | {
"resource": ""
} |
q23225 | ValidateSAMLResponse | train | func (a *AuthServer) ValidateSAMLResponse(samlResponse string) (*SAMLAuthResponse, error) {
re, err := a.validateSAMLResponse(samlResponse)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodSAML,
events.AuthAttemptSuccess: false,
e... | go | {
"resource": ""
} |
q23226 | ForAuth | train | func ForAuth(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: true},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindStaticTokens},
{Kind: services.KindToken},
{Kind: services.KindUser},
{Kind: services.Kind... | go | {
"resource": ""
} |
q23227 | ForProxy | train | func ForProxy(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
{Kind: services.KindNamespace},
{Kind: services.KindNo... | go | {
"resource": ""
} |
q23228 | ForNode | train | func ForNode(cfg Config) Config {
cfg.Watches = []services.WatchKind{
{Kind: services.KindCertAuthority, LoadSecrets: false},
{Kind: services.KindClusterName},
{Kind: services.KindClusterConfig},
{Kind: services.KindUser},
{Kind: services.KindRole},
// Node only needs to "know" about default
// namespace... | go | {
"resource": ""
} |
q23229 | New | train | func New(config Config) (*Cache, error) {
if err := config.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
wrapper := backend.NewWrapper(config.Backend)
ctx, cancel := context.WithCancel(config.Context)
cs := &Cache{
wrapper: wrapper,
ctx: ctx,
cancel: ... | go | {
"resource": ""
} |
q23230 | NewWatcher | train | func (c *Cache) NewWatcher(ctx context.Context, watch services.Watch) (services.Watcher, error) {
return c.eventsCache.NewWatcher(ctx, watch)
} | go | {
"resource": ""
} |
q23231 | setCacheState | train | func (c *Cache) setCacheState(err error) error {
if !c.OnlyRecent.Enabled {
return err
}
if err := c.eraseAll(); err != nil {
if !c.isClosed() {
c.Warningf("Failed to erase the data: %v.", err)
}
}
c.wrapper.SetReadError(trace.ConnectionProblem(err, "cache is unavailable"))
return err
} | go | {
"resource": ""
} |
q23232 | eraseAll | train | func (c *Cache) eraseAll() error {
var errors []error
for _, collection := range c.collections {
errors = append(errors, collection.erase())
}
return trace.NewAggregate(errors...)
} | go | {
"resource": ""
} |
q23233 | findMatchingConn | train | func (s *localSite) findMatchingConn(principals []string) (*remoteConn, bool) {
for _, principal := range principals {
rconn, err := s.getConn(principal)
if err == nil {
return rconn, true
}
}
return nil, false
} | go | {
"resource": ""
} |
q23234 | setupClientTLS | train | func setupClientTLS() (*tls.Config, error) {
storage, err := auth.NewProcessStorage(filepath.Join("/var/lib/teleport", teleport.ComponentProcess))
if err != nil {
return nil, trace.Wrap(err)
}
defer storage.Close()
identity, err := storage.ReadIdentity(auth.IdentityCurrent, teleport.RoleAdmin)
if err != nil {
... | go | {
"resource": ""
} |
q23235 | NewPresenceService | train | func NewPresenceService(b backend.Backend) *PresenceService {
return &PresenceService{
log: logrus.WithFields(logrus.Fields{trace.Component: "Presence"}),
Backend: b,
}
} | go | {
"resource": ""
} |
q23236 | UpsertLocalClusterName | train | func (s *PresenceService) UpsertLocalClusterName(name string) error {
_, err := s.Put(context.TODO(), backend.Item{
Key: backend.Key(localClusterPrefix, valPrefix),
Value: []byte(name),
})
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23237 | GetLocalClusterName | train | func (s *PresenceService) GetLocalClusterName() (string, error) {
item, err := s.Get(context.TODO(), backend.Key(localClusterPrefix, valPrefix))
if err != nil {
return "", trace.Wrap(err)
}
return string(item.Value), nil
} | go | {
"resource": ""
} |
q23238 | DeleteAllNamespaces | train | func (s *PresenceService) DeleteAllNamespaces() error {
return s.DeleteRange(context.TODO(), backend.Key(namespacesPrefix), backend.RangeEnd(backend.Key(namespacesPrefix)))
} | go | {
"resource": ""
} |
q23239 | GetNamespace | train | func (s *PresenceService) GetNamespace(name string) (*services.Namespace, error) {
if name == "" {
return nil, trace.BadParameter("missing namespace name")
}
item, err := s.Get(context.TODO(), backend.Key(namespacesPrefix, name, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotF... | go | {
"resource": ""
} |
q23240 | DeleteNamespace | train | func (s *PresenceService) DeleteNamespace(namespace string) error {
if namespace == "" {
return trace.BadParameter("missing namespace name")
}
err := s.Delete(context.TODO(), backend.Key(namespacesPrefix, namespace, paramsPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("namespace %q... | go | {
"resource": ""
} |
q23241 | DeleteAllNodes | train | func (s *PresenceService) DeleteAllNodes(namespace string) error {
startKey := backend.Key(nodesPrefix, namespace)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | {
"resource": ""
} |
q23242 | DeleteNode | train | func (s *PresenceService) DeleteNode(namespace string, name string) error {
key := backend.Key(nodesPrefix, namespace, name)
return s.Delete(context.TODO(), key)
} | go | {
"resource": ""
} |
q23243 | GetNodes | train | func (s *PresenceService) GetNodes(namespace string, opts ...services.MarshalOption) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter("missing namespace value")
}
// Get all items in the bucket.
startKey := backend.Key(nodesPrefix, namespace)
result, err := s.GetRange(context.TOD... | go | {
"resource": ""
} |
q23244 | UpsertNode | train | func (s *PresenceService) UpsertNode(server services.Server) (*services.KeepAlive, error) {
if server.GetNamespace() == "" {
return nil, trace.BadParameter("missing node namespace")
}
value, err := services.GetServerMarshaler().MarshalServer(server)
if err != nil {
return nil, trace.Wrap(err)
}
lease, err := ... | go | {
"resource": ""
} |
q23245 | KeepAliveNode | train | func (s *PresenceService) KeepAliveNode(ctx context.Context, h services.KeepAlive) error {
if err := h.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
err := s.KeepAlive(ctx, backend.Lease{
ID: h.LeaseID,
Key: backend.Key(nodesPrefix, h.Namespace, h.ServerName),
}, h.Expires)
return trace.Wrap(... | go | {
"resource": ""
} |
q23246 | UpsertNodes | train | func (s *PresenceService) UpsertNodes(namespace string, servers []services.Server) error {
batch, ok := s.Backend.(backend.Batch)
if !ok {
return trace.BadParameter("backend does not support batch interface")
}
if namespace == "" {
return trace.BadParameter("missing node namespace")
}
start := time.Now()
i... | go | {
"resource": ""
} |
q23247 | GetAuthServers | train | func (s *PresenceService) GetAuthServers() ([]services.Server, error) {
return s.getServers(services.KindAuthServer, authServersPrefix)
} | go | {
"resource": ""
} |
q23248 | UpsertAuthServer | train | func (s *PresenceService) UpsertAuthServer(server services.Server) error {
return s.upsertServer(authServersPrefix, server)
} | go | {
"resource": ""
} |
q23249 | UpsertProxy | train | func (s *PresenceService) UpsertProxy(server services.Server) error {
return s.upsertServer(proxiesPrefix, server)
} | go | {
"resource": ""
} |
q23250 | GetProxies | train | func (s *PresenceService) GetProxies() ([]services.Server, error) {
return s.getServers(services.KindProxy, proxiesPrefix)
} | go | {
"resource": ""
} |
q23251 | DeleteProxy | train | func (s *PresenceService) DeleteProxy(name string) error {
key := backend.Key(proxiesPrefix, name)
return s.Delete(context.TODO(), key)
} | go | {
"resource": ""
} |
q23252 | DeleteAllReverseTunnels | train | func (s *PresenceService) DeleteAllReverseTunnels() error {
startKey := backend.Key(reverseTunnelsPrefix)
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | {
"resource": ""
} |
q23253 | UpsertReverseTunnel | train | func (s *PresenceService) UpsertReverseTunnel(tunnel services.ReverseTunnel) error {
if err := tunnel.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetReverseTunnelMarshaler().MarshalReverseTunnel(tunnel)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.I... | go | {
"resource": ""
} |
q23254 | GetReverseTunnels | train | func (s *PresenceService) GetReverseTunnels(opts ...services.MarshalOption) ([]services.ReverseTunnel, error) {
startKey := backend.Key(reverseTunnelsPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
tunnels := m... | go | {
"resource": ""
} |
q23255 | DeleteReverseTunnel | train | func (s *PresenceService) DeleteReverseTunnel(clusterName string) error {
err := s.Delete(context.TODO(), backend.Key(reverseTunnelsPrefix, clusterName))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23256 | UpsertTrustedCluster | train | func (s *PresenceService) UpsertTrustedCluster(trustedCluster services.TrustedCluster) (services.TrustedCluster, error) {
if err := trustedCluster.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
value, err := services.GetTrustedClusterMarshaler().Marshal(trustedCluster)
if err != nil {
return ... | go | {
"resource": ""
} |
q23257 | GetTrustedCluster | train | func (s *PresenceService) GetTrustedCluster(name string) (services.TrustedCluster, error) {
if name == "" {
return nil, trace.BadParameter("missing trusted cluster name")
}
item, err := s.Get(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
return nil, trace.Wrap(err)
}
return service... | go | {
"resource": ""
} |
q23258 | GetTrustedClusters | train | func (s *PresenceService) GetTrustedClusters() ([]services.TrustedCluster, error) {
startKey := backend.Key(trustedClustersPrefix)
result, err := s.GetRange(context.TODO(), startKey, backend.RangeEnd(startKey), backend.NoLimit)
if err != nil {
return nil, trace.Wrap(err)
}
out := make([]services.TrustedCluster, ... | go | {
"resource": ""
} |
q23259 | DeleteTrustedCluster | train | func (s *PresenceService) DeleteTrustedCluster(name string) error {
if name == "" {
return trace.BadParameter("missing trusted cluster name")
}
err := s.Delete(context.TODO(), backend.Key(trustedClustersPrefix, name))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("trusted cluster %q is not... | go | {
"resource": ""
} |
q23260 | UpsertTunnelConnection | train | func (s *PresenceService) UpsertTunnelConnection(conn services.TunnelConnection) error {
if err := conn.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
value, err := services.MarshalTunnelConnection(conn)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Put(context.TODO(), backend.Item{
Key:... | go | {
"resource": ""
} |
q23261 | GetTunnelConnection | train | func (s *PresenceService) GetTunnelConnection(clusterName, connectionName string, opts ...services.MarshalOption) (services.TunnelConnection, error) {
item, err := s.Get(context.TODO(), backend.Key(tunnelConnectionsPrefix, clusterName, connectionName))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace... | go | {
"resource": ""
} |
q23262 | GetTunnelConnections | train | func (s *PresenceService) GetTunnelConnections(clusterName string, opts ...services.MarshalOption) ([]services.TunnelConnection, error) {
if clusterName == "" {
return nil, trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
result, err := s.GetRange(context.... | go | {
"resource": ""
} |
q23263 | DeleteTunnelConnections | train | func (s *PresenceService) DeleteTunnelConnections(clusterName string) error {
if clusterName == "" {
return trace.BadParameter("missing cluster name")
}
startKey := backend.Key(tunnelConnectionsPrefix, clusterName)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
... | go | {
"resource": ""
} |
q23264 | DeleteAllTunnelConnections | train | func (s *PresenceService) DeleteAllTunnelConnections() error {
startKey := backend.Key(tunnelConnectionsPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23265 | CreateRemoteCluster | train | func (s *PresenceService) CreateRemoteCluster(rc services.RemoteCluster) error {
value, err := json.Marshal(rc)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(remoteClustersPrefix, rc.GetName()),
Value: value,
Expires: rc.Expiry(),
}
_, err = s.Create(context.TODO(),... | go | {
"resource": ""
} |
q23266 | DeleteAllRemoteClusters | train | func (s *PresenceService) DeleteAllRemoteClusters() error {
startKey := backend.Key(remoteClustersPrefix)
err := s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23267 | timestampFrame | train | func timestampFrame(message string) {
const (
saveCursor = "7"
restoreCursor = "8"
)
sz, err := term.GetWinsize(0)
if err != nil {
return
}
esc := func(s string) {
os.Stdout.Write([]byte("\x1b" + s))
}
esc(saveCursor)
defer esc(restoreCursor)
// move cursor to -10:0
esc(fmt.Sprintf("[%d;%df", 0, ... | go | {
"resource": ""
} |
q23268 | FastUnmarshal | train | func FastUnmarshal(data []byte, v interface{}) error {
iter := jsoniter.ConfigFastest.BorrowIterator(data)
defer jsoniter.ConfigFastest.ReturnIterator(iter)
iter.ReadVal(v)
if iter.Error != nil {
return trace.Wrap(iter.Error)
}
return nil
} | go | {
"resource": ""
} |
q23269 | FastMarshal | train | func FastMarshal(v interface{}) ([]byte, error) {
data, err := jsoniter.ConfigFastest.Marshal(v)
if err != nil {
return nil, trace.Wrap(err)
}
return data, nil
} | go | {
"resource": ""
} |
q23270 | isDoc | train | func isDoc(val reflect.Value) bool {
iterations := 0
for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
val = val.Elem()
// preventing cycles
iterations++
if iterations > 10 {
return false
}
}
return val.Kind() == reflect.Struct || val.Kind() == reflect.Map
} | go | {
"resource": ""
} |
q23271 | writeYAML | train | func writeYAML(w io.Writer, values interface{}) error {
data, err := yaml.Marshal(values)
if err != nil {
return trace.Wrap(err)
}
_, err = w.Write(data)
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23272 | ReadYAML | train | func ReadYAML(reader io.Reader) (interface{}, error) {
decoder := kyaml.NewYAMLOrJSONDecoder(reader, 32*1024)
var values []interface{}
for {
var val interface{}
err := decoder.Decode(&val)
if err != nil {
if err == io.EOF {
if len(values) == 0 {
return nil, trace.BadParameter("no resources found, e... | go | {
"resource": ""
} |
q23273 | NewRedirector | train | func NewRedirector(login SSHLogin) (*Redirector, error) {
//clt, proxyURL, err := initClient(login.ProxyAddr, login.Insecure, login.Pool)
//if err != nil {
// return nil, trace.Wrap(err)
//}
clt, err := NewCredentialsClient(login.ProxyAddr, login.Insecure, login.Pool)
if err != nil {
return nil, trace.Wrap(err... | go | {
"resource": ""
} |
q23274 | Start | train | func (rd *Redirector) Start() error {
if rd.BindAddr != "" {
log.Debugf("Binding to %v.", rd.BindAddr)
listener, err := net.Listen("tcp", rd.BindAddr)
if err != nil {
return trace.Wrap(err, "%v: could not bind to %v, make sure the address is host:port format for ipv4 and [ipv6]:port format for ipv6, and the a... | go | {
"resource": ""
} |
q23275 | ClickableURL | train | func (rd *Redirector) ClickableURL() string {
if rd.server == nil {
return "<undefined - server is not started>"
}
return utils.ClickableURL(rd.server.URL + rd.shortPath)
} | go | {
"resource": ""
} |
q23276 | callback | train | func (rd *Redirector) callback(w http.ResponseWriter, r *http.Request) (*auth.SSHLoginResponse, error) {
if r.URL.Path != "/callback" {
return nil, trace.NotFound("path not found")
}
// Decrypt ciphertext to get login response.
plaintext, err := rd.key.Open([]byte(r.URL.Query().Get("response")))
if err != nil {... | go | {
"resource": ""
} |
q23277 | Close | train | func (rd *Redirector) Close() error {
rd.cancel()
if rd.server != nil {
rd.server.Close()
}
return nil
} | go | {
"resource": ""
} |
q23278 | wrapCallback | train | func (rd *Redirector) wrapCallback(fn func(http.ResponseWriter, *http.Request) (*auth.SSHLoginResponse, error)) http.Handler {
clone := *rd.proxyURL
clone.Path = "/web/msg/error/login_failed"
errorURL := clone.String()
clone.Path = "/web/msg/info/login_success"
successURL := clone.String()
return http.HandlerFun... | go | {
"resource": ""
} |
q23279 | NewLicense | train | func NewLicense(name string, spec LicenseSpecV3) (License, error) {
return &LicenseV3{
Kind: KindLicense,
Version: V3,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
} | go | {
"resource": ""
} |
q23280 | SetLabels | train | func (c *LicenseV3) SetLabels(labels map[string]string) {
c.Metadata.Labels = labels
} | go | {
"resource": ""
} |
q23281 | String | train | func (c *LicenseV3) String() string {
var features []string
if !c.Expiry().IsZero() {
features = append(features, fmt.Sprintf("expires at %v", c.Expiry()))
}
if c.Spec.ReportsUsage.Value() {
features = append(features, "reports usage")
}
if c.Spec.SupportsKubernetes.Value() {
features = append(features, "su... | go | {
"resource": ""
} |
q23282 | UnmarshalLicense | train | func UnmarshalLicense(bytes []byte) (License, error) {
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
schema := fmt.Sprintf(V2SchemaTemplate, MetadataSchema, LicenseSpecV3Template, DefaultDefinitions)
var license LicenseV3
err := utils.UnmarshalWithSchema(schema, &license, bytes... | go | {
"resource": ""
} |
q23283 | MarshalLicense | train | func MarshalLicense(license License, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := license.(type) {
case *LicenseV3:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected da... | go | {
"resource": ""
} |
q23284 | NewAgentPool | train | func NewAgentPool(cfg AgentPoolConfig) (*AgentPool, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
pool := &AgentPool{
agents: make(map[agentKey][]*Agent),
cfg: cfg,
ctx: ctx,
cancel: cancel,
d... | go | {
"resource": ""
} |
q23285 | reportStats | train | func (m *AgentPool) reportStats() {
var logReport bool
if m.cfg.Clock.Now().Sub(m.lastReport) > defaults.ReportingPeriod {
m.lastReport = m.cfg.Clock.Now()
logReport = true
}
for key, agents := range m.agents {
m.Debugf("Outbound tunnel for %v connected to %v proxies.", key.tunnelID, len(agents))
countPer... | go | {
"resource": ""
} |
q23286 | removeDisconnected | train | func (m *AgentPool) removeDisconnected() {
for agentKey, agentSlice := range m.agents {
// Filter and close all disconnected agents.
validAgents := filterAndClose(agentSlice, func(agent *Agent) bool {
if agent.getState() == agentStateDisconnected {
return true
}
return false
})
// Update (or dele... | go | {
"resource": ""
} |
q23287 | SetAddresses | train | func (fs *FileAddrStorage) SetAddresses(addrs []NetAddr) error {
bytes, err := json.Marshal(addrs)
if err != nil {
return trace.Wrap(err)
}
err = ioutil.WriteFile(fs.filePath, bytes, 0666)
if err != nil {
log.Error(err)
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23288 | GetAddresses | train | func (fs *FileAddrStorage) GetAddresses() ([]NetAddr, error) {
bytes, err := ioutil.ReadFile(fs.filePath)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
var addrs []NetAddr
if len(bytes) > 0 {
err = json.Unmarshal(bytes, &addrs)
if err != nil {
return nil, trace.Wrap(err)
}
}
return addrs... | go | {
"resource": ""
} |
q23289 | TLSDial | train | func TLSDial(ctx context.Context, dial DialWithContextFunc, network, addr string, tlsConfig *tls.Config) (*tls.Conn, error) {
if tlsConfig == nil {
tlsConfig = &tls.Config{}
}
plainConn, err := dial(ctx, network, addr)
if err != nil {
return nil, trace.Wrap(err)
}
colonPos := strings.LastIndex(addr, ":")
i... | go | {
"resource": ""
} |
q23290 | NewUserContext | train | func NewUserContext(user services.User, userRoles services.RoleSet) (*userContext, error) {
ctx := &services.Context{User: user}
sessionAccess := newAccess(userRoles, ctx, services.KindSession)
roleAccess := newAccess(userRoles, ctx, services.KindRole)
authConnectors := newAccess(userRoles, ctx, services.KindAuthCo... | go | {
"resource": ""
} |
q23291 | Serve | train | func (t *TLSServer) Serve(listener net.Listener) error {
return t.Server.Serve(tls.NewListener(listener, t.TLS))
} | go | {
"resource": ""
} |
q23292 | GetUser | train | func (a *AuthMiddleware) GetUser(r *http.Request) (interface{}, error) {
peers := r.TLS.PeerCertificates
if len(peers) > 1 {
// when turning intermediaries on, don't forget to verify
// https://github.com/kubernetes/kubernetes/pull/34524/files#diff-2b283dde198c92424df5355f39544aa4R59
return nil, trace.AccessDen... | go | {
"resource": ""
} |
q23293 | ServeHTTP | train | func (a *AuthMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
baseContext := r.Context()
if baseContext == nil {
baseContext = context.TODO()
}
user, err := a.GetUser(r)
if err != nil {
trace.WriteError(w, err)
return
}
// determine authenticated user based on the request parameters
reques... | go | {
"resource": ""
} |
q23294 | ClientCertPool | train | func ClientCertPool(client AccessCache, clusterName string) (*x509.CertPool, error) {
pool := x509.NewCertPool()
var authorities []services.CertAuthority
if clusterName == "" {
hostCAs, err := client.GetCertAuthorities(services.HostCA, false, services.SkipValidation())
if err != nil {
return nil, trace.Wrap(e... | go | {
"resource": ""
} |
q23295 | applySSHConfig | train | func applySSHConfig(fc *FileConfig, cfg *service.Config) error {
if fc.SSH.ListenAddress != "" {
addr, err := utils.ParseHostPortAddr(fc.SSH.ListenAddress, int(defaults.SSHServerListenPort))
if err != nil {
return trace.Wrap(err)
}
cfg.SSH.Addr = *addr
}
if fc.SSH.Labels != nil {
cfg.SSH.Labels = make(m... | go | {
"resource": ""
} |
q23296 | parseAuthorizedKeys | train | func parseAuthorizedKeys(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
pubkey, comment, _, _, err := ssh.ParseAuthorizedKey(bytes)
if err != nil {
return nil, nil, trace.Wrap(err)
}
comments, err := url.ParseQuery(comment)
if err != nil {
return nil, nil, trace.Wrap(er... | go | {
"resource": ""
} |
q23297 | parseKnownHosts | train | func parseKnownHosts(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
marker, options, pubKey, comment, _, err := ssh.ParseKnownHosts(bytes)
if marker != "cert-authority" {
return nil, nil, trace.BadParameter("invalid file format. expected '@cert-authority` marker")
}
if err ... | go | {
"resource": ""
} |
q23298 | certificateAuthorityFormat | train | func certificateAuthorityFormat(bytes []byte) (string, error) {
_, _, _, _, err := ssh.ParseAuthorizedKey(bytes)
if err != nil {
_, _, _, _, _, err := ssh.ParseKnownHosts(bytes)
if err != nil {
return "", trace.BadParameter("unknown ca format")
}
return teleport.KnownHosts, nil
}
return teleport.Authoriz... | go | {
"resource": ""
} |
q23299 | parseCAKey | train | func parseCAKey(bytes []byte, allowedLogins []string) (services.CertAuthority, services.Role, error) {
caFormat, err := certificateAuthorityFormat(bytes)
if err != nil {
return nil, nil, trace.Wrap(err)
}
if caFormat == teleport.AuthorizedKeys {
return parseAuthorizedKeys(bytes, allowedLogins)
}
return parse... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.