_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24200 | SafeRedirect | train | func SafeRedirect(w http.ResponseWriter, r *http.Request, redirectURL string) error {
parsedURL, err := url.Parse(redirectURL)
if err != nil {
return trace.Wrap(err)
}
http.Redirect(w, r, parsedURL.RequestURI(), http.StatusFound)
return nil
} | go | {
"resource": ""
} |
q24201 | CreateOrJoinSession | train | func (c *ServerContext) CreateOrJoinSession(reg *SessionRegistry) error {
// As SSH conversation progresses, at some point a session will be created and
// its ID will be added to the environment
ssid, found := c.GetEnv(sshutils.SessionEnvVar)
if !found {
return nil
}
// make sure whatever session is requested ... | go | {
"resource": ""
} |
q24202 | UpdateClientActivity | train | func (c *ServerContext) UpdateClientActivity() {
c.Lock()
defer c.Unlock()
c.clientLastActive = c.srv.GetClock().Now().UTC()
} | go | {
"resource": ""
} |
q24203 | GetAgent | train | func (c *ServerContext) GetAgent() agent.Agent {
c.RLock()
defer c.RUnlock()
return c.agent
} | go | {
"resource": ""
} |
q24204 | GetAgentChannel | train | func (c *ServerContext) GetAgentChannel() ssh.Channel {
c.RLock()
defer c.RUnlock()
return c.agentChannel
} | go | {
"resource": ""
} |
q24205 | SetAgent | train | func (c *ServerContext) SetAgent(a agent.Agent, channel ssh.Channel) {
c.Lock()
defer c.Unlock()
if c.agentChannel != nil {
c.Infof("closing previous agent channel")
c.agentChannel.Close()
}
c.agentChannel = channel
c.agent = a
} | go | {
"resource": ""
} |
q24206 | GetTerm | train | func (c *ServerContext) GetTerm() Terminal {
c.RLock()
defer c.RUnlock()
return c.term
} | go | {
"resource": ""
} |
q24207 | SetTerm | train | func (c *ServerContext) SetTerm(t Terminal) {
c.Lock()
defer c.Unlock()
c.term = t
} | go | {
"resource": ""
} |
q24208 | SetEnv | train | func (c *ServerContext) SetEnv(key, val string) {
c.env[key] = val
} | go | {
"resource": ""
} |
q24209 | GetEnv | train | func (c *ServerContext) GetEnv(key string) (string, bool) {
val, ok := c.env[key]
return val, ok
} | go | {
"resource": ""
} |
q24210 | SendExecResult | train | func (c *ServerContext) SendExecResult(r ExecResult) {
select {
case c.ExecResultCh <- r:
default:
log.Infof("blocked on sending exec result %v", r)
}
} | go | {
"resource": ""
} |
q24211 | SendSubsystemResult | train | func (c *ServerContext) SendSubsystemResult(r SubsystemResult) {
select {
case c.SubsystemResultCh <- r:
default:
c.Infof("blocked on sending subsystem result")
}
} | go | {
"resource": ""
} |
q24212 | ProxyPublicAddress | train | func (c *ServerContext) ProxyPublicAddress() string {
proxyHost := "<proxyhost>:3080"
if c.srv == nil {
return proxyHost
}
proxies, err := c.srv.GetAccessPoint().GetProxies()
if err != nil {
c.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()... | go | {
"resource": ""
} |
q24213 | NewTrackingReader | train | func NewTrackingReader(ctx *ServerContext, r io.Reader) *TrackingReader {
return &TrackingReader{ctx: ctx, r: r}
} | go | {
"resource": ""
} |
q24214 | Read | train | func (a *TrackingReader) Read(b []byte) (int, error) {
a.ctx.UpdateClientActivity()
return a.r.Read(b)
} | go | {
"resource": ""
} |
q24215 | CheckDefaults | train | func (c *Config) CheckDefaults() error {
if c.ServiceName == "" {
return trace.BadParameter("required parameter ServiceName missing")
}
if c.Username == "" {
return trace.BadParameter("required parameter Username missing")
}
if c.Stdin == nil {
return trace.BadParameter("required parameter Stdin missing")
}... | go | {
"resource": ""
} |
q24216 | NewAdminContext | train | func NewAdminContext() (*AuthContext, error) {
authContext, err := contextForBuiltinRole("", nil, teleport.RoleAdmin, fmt.Sprintf("%v", teleport.RoleAdmin))
if err != nil {
return nil, trace.Wrap(err)
}
return authContext, nil
} | go | {
"resource": ""
} |
q24217 | NewRoleAuthorizer | train | func NewRoleAuthorizer(clusterName string, clusterConfig services.ClusterConfig, r teleport.Role) (Authorizer, error) {
authContext, err := contextForBuiltinRole(clusterName, clusterConfig, r, fmt.Sprintf("%v", r))
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext},... | go | {
"resource": ""
} |
q24218 | NewUserAuthorizer | train | func NewUserAuthorizer(username string, identity services.UserGetter, access services.Access) (Authorizer, error) {
authContext, err := contextForLocalUser(username, identity, access)
if err != nil {
return nil, trace.Wrap(err)
}
return &contextAuthorizer{authContext: *authContext}, nil
} | go | {
"resource": ""
} |
q24219 | NewAuthorizer | train | func NewAuthorizer(access services.Access, identity services.UserGetter, trust services.Trust) (Authorizer, error) {
if access == nil {
return nil, trace.BadParameter("missing parameter access")
}
if identity == nil {
return nil, trace.BadParameter("missing parameter identity")
}
if trust == nil {
return nil... | go | {
"resource": ""
} |
q24220 | authorizeLocalUser | train | func (a *authorizer) authorizeLocalUser(u LocalUser) (*AuthContext, error) {
return contextForLocalUser(u.Username, a.identity, a.access)
} | go | {
"resource": ""
} |
q24221 | authorizeRemoteUser | train | func (a *authorizer) authorizeRemoteUser(u RemoteUser) (*AuthContext, error) {
ca, err := a.trust.GetCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: u.ClusterName}, false)
if err != nil {
return nil, trace.Wrap(err)
}
roleNames, err := ca.CombinedMapping().Map(u.RemoteRoles)
if err != nil {
... | go | {
"resource": ""
} |
q24222 | authorizeBuiltinRole | train | func (a *authorizer) authorizeBuiltinRole(r BuiltinRole) (*AuthContext, error) {
config, err := r.GetClusterConfig()
if err != nil {
return nil, trace.Wrap(err)
}
return contextForBuiltinRole(r.ClusterName, config, r.Role, r.Username)
} | go | {
"resource": ""
} |
q24223 | Initialize | train | func (u *UserCommand) Initialize(app *kingpin.Application, config *service.Config) {
u.config = config
users := app.Command("users", "Manage user accounts")
u.userAdd = users.Command("add", "Generate a user invitation token")
u.userAdd.Arg("account", "Teleport user account name").Required().StringVar(&u.login)
u.... | go | {
"resource": ""
} |
q24224 | Add | train | func (u *UserCommand) Add(client auth.ClientI) error {
// if no local logins were specified, default to 'login'
if u.allowedLogins == "" {
u.allowedLogins = u.login
}
var kubeGroups []string
if u.kubeGroups != "" {
kubeGroups = strings.Split(u.kubeGroups, ",")
}
user := services.UserV1{
Name: u.lo... | go | {
"resource": ""
} |
q24225 | PrintSignupURL | train | func (u *UserCommand) PrintSignupURL(client auth.ClientI, token string, ttl time.Duration, format string) error {
signupURL, proxyHost := web.CreateSignupLink(client, token)
if format == teleport.Text {
fmt.Printf("Signup token has been created and is valid for %v hours. Share this URL with the user:\n%v\n\n",
... | go | {
"resource": ""
} |
q24226 | Update | train | func (u *UserCommand) Update(client auth.ClientI) error {
user, err := client.GetUser(u.login)
if err != nil {
return trace.Wrap(err)
}
roles := strings.Split(u.roles, ",")
for _, role := range roles {
if _, err := client.GetRole(role); err != nil {
return trace.Wrap(err)
}
}
user.SetRoles(roles)
if er... | go | {
"resource": ""
} |
q24227 | List | train | func (u *UserCommand) List(client auth.ClientI) error {
users, err := client.GetUsers()
if err != nil {
return trace.Wrap(err)
}
if u.format == teleport.Text {
if len(users) == 0 {
fmt.Println("No users found")
return nil
}
t := asciitable.MakeTable([]string{"User", "Allowed logins"})
for _, u := ra... | go | {
"resource": ""
} |
q24228 | ListenUnixSocket | train | func (a *AgentServer) ListenUnixSocket(path string, uid, gid int, mode os.FileMode) error {
l, err := net.Listen("unix", path)
if err != nil {
return trace.Wrap(err)
}
if err := os.Chown(path, uid, gid); err != nil {
l.Close()
return trace.ConvertSystemError(err)
}
if err := os.Chmod(path, mode); err != nil... | go | {
"resource": ""
} |
q24229 | Serve | train | func (a *AgentServer) Serve() error {
if a.listener == nil {
return trace.BadParameter("Serve needs a Listen call first")
}
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := a.listener.Accept()
if err != nil {
neterr, ok := err.(net.Error)
if !ok {
return trace.Wr... | go | {
"resource": ""
} |
q24230 | ListenAndServe | train | func (a *AgentServer) ListenAndServe(addr utils.NetAddr) error {
l, err := net.Listen(addr.AddrNetwork, addr.Addr)
if err != nil {
return trace.Wrap(err)
}
a.listener = l
return a.Serve()
} | go | {
"resource": ""
} |
q24231 | Close | train | func (a *AgentServer) Close() error {
var errors []error
if a.listener != nil {
log.Debugf("AgentServer(%v) is closing", a.listener.Addr())
if err := a.listener.Close(); err != nil {
errors = append(errors, trace.ConvertSystemError(err))
}
}
if a.path != "" {
if err := os.Remove(a.path); err != nil {
... | go | {
"resource": ""
} |
q24232 | VerifyHTTPHeader | train | func VerifyHTTPHeader(r *http.Request) error {
token := r.Header.Get(HeaderName)
if len(token) == 0 {
return trace.BadParameter("cannot retrieve CSRF token from HTTP header %q", HeaderName)
}
err := VerifyToken(token, r)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q24233 | VerifyToken | train | func VerifyToken(token string, r *http.Request) error {
realToken, err := ExtractTokenFromCookie(r)
if err != nil {
return trace.Wrap(err, "unable to extract CSRF token from cookie")
}
decodedTokenA, err := decode(token)
if err != nil {
return trace.Wrap(err, "unable to decode CSRF token")
}
decodedTokenB,... | go | {
"resource": ""
} |
q24234 | ExtractTokenFromCookie | train | func ExtractTokenFromCookie(r *http.Request) (string, error) {
cookie, err := r.Cookie(CookieName)
if err != nil {
return "", trace.Wrap(err)
}
return cookie.Value, nil
} | go | {
"resource": ""
} |
q24235 | save | train | func save(encodedToken string, w http.ResponseWriter) string {
cookie := &http.Cookie{
Name: CookieName,
Value: encodedToken,
MaxAge: defaultMaxAge,
HttpOnly: true,
Secure: true,
Path: "/",
}
// write the authenticated cookie to the response.
http.SetCookie(w, cookie)
w.Header().Add("Va... | go | {
"resource": ""
} |
q24236 | ValidateOIDCAuthCallback | train | func (a *AuthServer) ValidateOIDCAuthCallback(q url.Values) (*OIDCAuthResponse, error) {
re, err := a.validateOIDCAuthCallback(q)
if err != nil {
a.EmitAuditEvent(events.UserSSOLoginFailure, events.EventFields{
events.LoginMethod: events.LoginMethodOIDC,
events.AuthAttemptSuccess: false,
// log the ... | go | {
"resource": ""
} |
q24237 | buildOIDCRoles | train | func (a *AuthServer) buildOIDCRoles(connector services.OIDCConnector, claims jose.Claims) ([]string, error) {
roles := connector.MapClaims(claims)
if len(roles) == 0 {
return nil, trace.AccessDenied("unable to map claims to role for connector: %v", connector.GetName())
}
return roles, nil
} | go | {
"resource": ""
} |
q24238 | claimsToTraitMap | train | func claimsToTraitMap(claims jose.Claims) map[string][]string {
traits := make(map[string][]string)
for claimName := range claims {
claimValue, ok, _ := claims.StringClaim(claimName)
if ok {
traits[claimName] = []string{claimValue}
}
claimValues, ok, _ := claims.StringsClaim(claimName)
if ok {
traits... | go | {
"resource": ""
} |
q24239 | claimsFromIDToken | train | func claimsFromIDToken(oidcClient *oidc.Client, idToken string) (jose.Claims, error) {
jwt, err := jose.ParseJWT(idToken)
if err != nil {
return nil, trace.Wrap(err)
}
err = oidcClient.VerifyJWT(jwt)
if err != nil {
return nil, trace.Wrap(err)
}
log.Debugf("Extracting OIDC claims from ID token.")
claims,... | go | {
"resource": ""
} |
q24240 | fetchGroups | train | func (g *gsuiteClient) fetchGroups() (jose.Claims, error) {
count := 0
var groups []string
var nextPageToken string
collect:
for {
if count > MaxPages {
warningMessage := "Truncating list of teams used to populate claims: " +
"hit maximum number pages that can be fetched from GSuite."
// Print warning ... | go | {
"resource": ""
} |
q24241 | mergeClaims | train | func mergeClaims(a jose.Claims, b jose.Claims) (jose.Claims, error) {
for k, v := range b {
_, ok := a[k]
if !ok {
a[k] = v
}
}
return a, nil
} | go | {
"resource": ""
} |
q24242 | validateACRValues | train | func (a *AuthServer) validateACRValues(acrValue string, identityProvider string, claims jose.Claims) error {
switch identityProvider {
case teleport.NetIQ:
log.Debugf("Validating OIDC ACR values with '%v' rules.", identityProvider)
tokenAcr, ok := claims["acr"]
if !ok {
return trace.BadParameter("acr not fo... | go | {
"resource": ""
} |
q24243 | Benchmark | train | func (tc *TeleportClient) Benchmark(ctx context.Context, bench Benchmark) (*BenchmarkResult, error) {
tc.Stdout = ioutil.Discard
tc.Stderr = ioutil.Discard
tc.Stdin = &bytes.Buffer{}
ctx, cancel := context.WithTimeout(ctx, bench.Duration)
defer cancel()
requestC := make(chan *benchMeasure)
responseC := make(ch... | go | {
"resource": ""
} |
q24244 | NewCloserConn | train | func NewCloserConn(conn net.Conn, closers ...io.Closer) *CloserConn {
return &CloserConn{
Conn: conn,
closers: closers,
}
} | go | {
"resource": ""
} |
q24245 | ClientTLSConfig | train | func (k *Key) ClientTLSConfig() (*tls.Config, error) {
// Because Teleport clients can't be configured (yet), they take the default
// list of cipher suites from Go.
tlsConfig := utils.TLSConfig(nil)
pool := x509.NewCertPool()
for _, ca := range k.TrustedCA {
for _, certPEM := range ca.TLSCertificates {
if !... | go | {
"resource": ""
} |
q24246 | CertUsername | train | func (k *Key) CertUsername() (string, error) {
pubKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return "", trace.Wrap(err)
}
cert, ok := pubKey.(*ssh.Certificate)
if !ok {
return "", trace.BadParameter("expected SSH certificate, got public key")
}
return cert.KeyId, nil
} | go | {
"resource": ""
} |
q24247 | CertPrincipals | train | func (k *Key) CertPrincipals() ([]string, error) {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return nil, trace.Wrap(err)
}
cert, ok := publicKey.(*ssh.Certificate)
if !ok {
return nil, trace.BadParameter("no certificate found")
}
return cert.ValidPrincipals, nil
} | go | {
"resource": ""
} |
q24248 | EqualsTo | train | func (k *Key) EqualsTo(other *Key) bool {
if k == other {
return true
}
return bytes.Equal(k.Cert, other.Cert) &&
bytes.Equal(k.Priv, other.Priv) &&
bytes.Equal(k.Pub, other.Pub) &&
bytes.Equal(k.TLSCert, other.TLSCert)
} | go | {
"resource": ""
} |
q24249 | TLSCertValidBefore | train | func (k *Key) TLSCertValidBefore() (t time.Time, err error) {
cert, err := tlsca.ParseCertificatePEM(k.TLSCert)
if err != nil {
return t, trace.Wrap(err)
}
return cert.NotAfter, nil
} | go | {
"resource": ""
} |
q24250 | CertValidBefore | train | func (k *Key) CertValidBefore() (t time.Time, err error) {
pcert, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return t, trace.Wrap(err)
}
cert, ok := pcert.(*ssh.Certificate)
if !ok {
return t, trace.Errorf("not supported certificate type")
}
return time.Unix(int64(cert.ValidBefore), 0), n... | go | {
"resource": ""
} |
q24251 | AsAuthMethod | train | func (k *Key) AsAuthMethod() (ssh.AuthMethod, error) {
keys, err := k.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
signer, err := ssh.NewSignerFromKey(keys[0].PrivateKey)
if err != nil {
return nil, trace.Wrap(err)
}
if signer, err = ssh.NewCertSigner(keys[0].Certificate, signer); err != nil {... | go | {
"resource": ""
} |
q24252 | CheckCert | train | func (k *Key) CheckCert() error {
key, _, _, _, err := ssh.ParseAuthorizedKey(k.Cert)
if err != nil {
return trace.Wrap(err)
}
cert, ok := key.(*ssh.Certificate)
if !ok {
return trace.BadParameter("found key, not certificate")
}
if len(cert.ValidPrincipals) == 0 {
return trace.BadParameter("principals are... | go | {
"resource": ""
} |
q24253 | collectActiveShards | train | func (b *DynamoDBBackend) collectActiveShards(ctx context.Context, streamArn *string) ([]*dynamodbstreams.Shard, error) {
var out []*dynamodbstreams.Shard
input := &dynamodbstreams.DescribeStreamInput{
StreamArn: streamArn,
}
for {
streamInfo, err := b.streams.DescribeStreamWithContext(ctx, input)
if err != ... | go | {
"resource": ""
} |
q24254 | GetRange | train | func (b *DynamoDBBackend) GetRange(ctx context.Context, startKey []byte, endKey []byte, limit int) (*backend.GetResult, error) {
if len(startKey) == 0 {
return nil, trace.BadParameter("missing parameter startKey")
}
if len(endKey) == 0 {
return nil, trace.BadParameter("missing parameter endKey")
}
result, err ... | go | {
"resource": ""
} |
q24255 | CompareAndSwap | train | func (b *DynamoDBBackend) CompareAndSwap(ctx context.Context, expected backend.Item, replaceWith backend.Item) (*backend.Lease, error) {
if len(expected.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
if len(replaceWith.Key) == 0 {
return nil, trace.BadParameter("missing parameter Key")
}
... | go | {
"resource": ""
} |
q24256 | Close | train | func (b *DynamoDBBackend) Close() error {
b.setClosed()
b.cancel()
return b.buf.Close()
} | go | {
"resource": ""
} |
q24257 | deleteTable | train | func (b *DynamoDBBackend) deleteTable(ctx context.Context, tableName string, wait bool) error {
tn := aws.String(tableName)
_, err := b.svc.DeleteTable(&dynamodb.DeleteTableInput{TableName: tn})
if err != nil {
return trace.Wrap(err)
}
if wait {
return trace.Wrap(
b.svc.WaitUntilTableNotExists(&dynamodb.Des... | go | {
"resource": ""
} |
q24258 | getRecords | train | func (b *DynamoDBBackend) getRecords(ctx context.Context, startKey, endKey string, limit int, lastEvaluatedKey map[string]*dynamodb.AttributeValue) (*getResult, error) {
query := "HashKey = :hashKey AND FullPath BETWEEN :fullPath AND :rangeEnd"
attrV := map[string]interface{}{
":fullPath": startKey,
":hashKey": ... | go | {
"resource": ""
} |
q24259 | NewCircularBuffer | train | func NewCircularBuffer(ctx context.Context, size int) (*CircularBuffer, error) {
if size <= 0 {
return nil, trace.BadParameter("circular buffer size should be > 0")
}
ctx, cancel := context.WithCancel(ctx)
buf := &CircularBuffer{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentBuffer,
... | go | {
"resource": ""
} |
q24260 | Reset | train | func (c *CircularBuffer) Reset() {
c.Lock()
defer c.Unlock()
// could close mulitple times
c.watchers.walk(func(w *BufferWatcher) {
w.Close()
})
c.watchers = newWatcherTree()
c.start = -1
c.end = -1
c.size = 0
for i := 0; i < len(c.events); i++ {
c.events[i] = Event{}
}
} | go | {
"resource": ""
} |
q24261 | Events | train | func (c *CircularBuffer) Events() []Event {
c.Lock()
defer c.Unlock()
return c.eventsCopy()
} | go | {
"resource": ""
} |
q24262 | eventsCopy | train | func (c *CircularBuffer) eventsCopy() []Event {
if c.size == 0 {
return nil
}
var out []Event
for i := 0; i < c.size; i++ {
index := (c.start + i) % len(c.events)
if out == nil {
out = make([]Event, 0, c.size)
}
out = append(out, c.events[index])
}
return out
} | go | {
"resource": ""
} |
q24263 | PushBatch | train | func (c *CircularBuffer) PushBatch(events []Event) {
c.Lock()
defer c.Unlock()
for i := range events {
c.push(events[i])
}
} | go | {
"resource": ""
} |
q24264 | Push | train | func (c *CircularBuffer) Push(r Event) {
c.Lock()
defer c.Unlock()
c.push(r)
} | go | {
"resource": ""
} |
q24265 | NewWatcher | train | func (c *CircularBuffer) NewWatcher(ctx context.Context, watch Watch) (Watcher, error) {
c.Lock()
defer c.Unlock()
select {
case <-c.ctx.Done():
return nil, trace.BadParameter("buffer is closed")
default:
}
if watch.QueueSize == 0 {
watch.QueueSize = len(c.events)
}
if len(watch.Prefixes) == 0 {
// if... | go | {
"resource": ""
} |
q24266 | String | train | func (w *BufferWatcher) String() string {
return fmt.Sprintf("Watcher(name=%v, prefixes=%v, capacity=%v, size=%v)", w.Name, string(bytes.Join(w.Prefixes, []byte(", "))), w.capacity, len(w.eventsC))
} | go | {
"resource": ""
} |
q24267 | add | train | func (t *watcherTree) add(w *BufferWatcher) {
for _, p := range w.Prefixes {
prefix := string(p)
val, ok := t.Tree.Get(prefix)
var watchers []*BufferWatcher
if ok {
watchers = val.([]*BufferWatcher)
}
watchers = append(watchers, w)
t.Tree.Insert(prefix, watchers)
}
} | go | {
"resource": ""
} |
q24268 | rm | train | func (t *watcherTree) rm(w *BufferWatcher) bool {
if w == nil {
return false
}
var found bool
for _, p := range w.Prefixes {
prefix := string(p)
val, ok := t.Tree.Get(prefix)
if !ok {
continue
}
buffers := val.([]*BufferWatcher)
prevLen := len(buffers)
for i := range buffers {
if buffers[i] ==... | go | {
"resource": ""
} |
q24269 | walkPath | train | func (t *watcherTree) walkPath(key string, fn walkFn) {
t.Tree.WalkPath(key, func(prefix string, val interface{}) bool {
watchers := val.([]*BufferWatcher)
for _, w := range watchers {
fn(w)
}
return false
})
} | go | {
"resource": ""
} |
q24270 | walk | train | func (t *watcherTree) walk(fn walkFn) {
t.Tree.Walk(func(prefix string, val interface{}) bool {
watchers := val.([]*BufferWatcher)
for _, w := range watchers {
fn(w)
}
return false
})
} | go | {
"resource": ""
} |
q24271 | UpdateKubeconfig | train | func UpdateKubeconfig(tc *client.TeleportClient) error {
config, err := LoadKubeConfig()
if err != nil {
return trace.Wrap(err)
}
clusterName, proxyPort := tc.KubeProxyHostPort()
var clusterAddr string
if tc.SiteName != "" {
// In case of a remote cluster, use SNI subdomain to "point" to a remote cluster nam... | go | {
"resource": ""
} |
q24272 | RemoveKubeconifg | train | func RemoveKubeconifg(tc *client.TeleportClient, clusterName string) error {
// Load existing kubeconfig from disk.
config, err := LoadKubeConfig()
if err != nil {
return trace.Wrap(err)
}
// Remove Teleport related AuthInfos, Clusters, and Contexts from kubeconfig.
delete(config.AuthInfos, clusterName)
delet... | go | {
"resource": ""
} |
q24273 | LoadKubeConfig | train | func LoadKubeConfig() (*clientcmdapi.Config, error) {
filename, err := utils.EnsureLocalPath(
kubeconfigFromEnv(),
teleport.KubeConfigDir,
teleport.KubeConfigFile)
if err != nil {
return nil, trace.Wrap(err)
}
config, err := clientcmd.LoadFromFile(filename)
if err != nil && !os.IsNotExist(err) {
return n... | go | {
"resource": ""
} |
q24274 | SaveKubeConfig | train | func SaveKubeConfig(config clientcmdapi.Config) error {
filename, err := utils.EnsureLocalPath(
kubeconfigFromEnv(),
teleport.KubeConfigDir,
teleport.KubeConfigFile)
if err != nil {
return trace.Wrap(err)
}
err = clientcmd.WriteToFile(config, filename)
if err != nil {
return trace.ConvertSystemError(err... | go | {
"resource": ""
} |
q24275 | kubeconfigFromEnv | train | func kubeconfigFromEnv() string {
kubeconfig := os.Getenv(teleport.EnvKubeConfig)
// The KUBECONFIG environment variable is a list. On Windows it's
// semicolon-delimited. On Linux and macOS it's colon-delimited.
var parts []string
switch runtime.GOOS {
case teleport.WindowsOS:
parts = strings.Split(kubeconfig... | go | {
"resource": ""
} |
q24276 | CheckAndSetDefaults | train | func (cfg *FileLogConfig) CheckAndSetDefaults() error {
if cfg.Dir == "" {
return trace.BadParameter("missing parameter Dir")
}
if !utils.IsDir(cfg.Dir) {
return trace.BadParameter("path %q does not exist or is not a directory", cfg.Dir)
}
if cfg.SymlinkDir == "" {
cfg.SymlinkDir = cfg.Dir
}
if !utils.IsDi... | go | {
"resource": ""
} |
q24277 | NewFileLog | train | func NewFileLog(cfg FileLogConfig) (*FileLog, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
f := &FileLog{
FileLogConfig: cfg,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentAuditLog,
}),
}
return f, nil
} | go | {
"resource": ""
} |
q24278 | EmitAuditEvent | train | func (l *FileLog) EmitAuditEvent(event Event, fields EventFields) error {
// see if the log needs to be rotated
err := l.rotateLog()
if err != nil {
log.Error(err)
}
err = UpdateEventFields(event, fields, l.Clock, l.UIDGenerator)
if err != nil {
log.Error(err)
}
// line is the text to be logged
line, err :... | go | {
"resource": ""
} |
q24279 | Close | train | func (l *FileLog) Close() error {
l.Lock()
defer l.Unlock()
var err error
if l.file != nil {
err = l.file.Close()
l.file = nil
}
return err
} | go | {
"resource": ""
} |
q24280 | rotateLog | train | func (l *FileLog) rotateLog() (err error) {
l.Lock()
defer l.Unlock()
// determine the timestamp for the current log file
fileTime := l.Clock.Now().In(time.UTC)
// truncate time to the resolution of one day, cutting at the day end boundary
fileTime = time.Date(fileTime.Year(), fileTime.Month(), fileTime.Day(), ... | go | {
"resource": ""
} |
q24281 | matchingFiles | train | func (l *FileLog) matchingFiles(fromUTC, toUTC time.Time) ([]eventFile, error) {
var dirs []string
var err error
if l.SearchDirs != nil {
dirs, err = l.SearchDirs()
if err != nil {
return nil, trace.Wrap(err)
}
} else {
dirs = []string{l.Dir}
}
var filtered []eventFile
for _, dir := range dirs {
//... | go | {
"resource": ""
} |
q24282 | parseFileTime | train | func parseFileTime(filename string) (time.Time, error) {
base := strings.TrimSuffix(filename, filepath.Ext(filename))
return time.Parse(defaults.AuditLogTimeFormat, base)
} | go | {
"resource": ""
} |
q24283 | getTime | train | func getTime(v interface{}) time.Time {
sval, ok := v.(string)
if !ok {
return time.Time{}
}
t, err := time.Parse(time.RFC3339, sval)
if err != nil {
return time.Time{}
}
return t
} | go | {
"resource": ""
} |
q24284 | StringMapsEqual | train | func StringMapsEqual(a, b map[string]string) bool {
if len(a) != len(b) {
return false
}
for key := range a {
if a[key] != b[key] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q24285 | StringMapSlicesEqual | train | func StringMapSlicesEqual(a, b map[string][]string) bool {
if len(a) != len(b) {
return false
}
for key := range a {
if !StringSlicesEqual(a[key], b[key]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q24286 | NewSAMLConnector | train | func NewSAMLConnector(name string, spec SAMLConnectorSpecV2) SAMLConnector {
return &SAMLConnectorV2{
Kind: KindSAMLConnector,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
} | go | {
"resource": ""
} |
q24287 | UnmarshalSAMLConnector | train | func (*TeleportSAMLConnectorMarshaler) UnmarshalSAMLConnector(bytes []byte, opts ...MarshalOption) (SAMLConnector, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(bytes, &h)
if err != nil {
return nil, trace.Wrap(err)
}
s... | go | {
"resource": ""
} |
q24288 | MarshalSAMLConnector | train | func (*TeleportSAMLConnectorMarshaler) MarshalSAMLConnector(c SAMLConnector, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type connv2 interface {
V2() *SAMLConnectorV2
}
version := cfg.GetVersion()
switch version {
case V2:
v, ok :... | go | {
"resource": ""
} |
q24289 | Equals | train | func (o *SAMLConnectorV2) Equals(other SAMLConnector) bool {
if o.GetName() != other.GetName() {
return false
}
if o.GetCert() != other.GetCert() {
return false
}
if o.GetAudience() != other.GetAudience() {
return false
}
if o.GetEntityDescriptor() != other.GetEntityDescriptor() {
return false
}
if o.E... | go | {
"resource": ""
} |
q24290 | GetAttributes | train | func (o *SAMLConnectorV2) GetAttributes() []string {
var out []string
for _, mapping := range o.Spec.AttributesToRoles {
out = append(out, mapping.Name)
}
return utils.Deduplicate(out)
} | go | {
"resource": ""
} |
q24291 | MapAttributes | train | func (o *SAMLConnectorV2) MapAttributes(assertionInfo saml2.AssertionInfo) []string {
var roles []string
for _, mapping := range o.Spec.AttributesToRoles {
for _, attr := range assertionInfo.Values {
if attr.Name != mapping.Name {
continue
}
mappingLoop:
for _, value := range attr.Values {
for _,... | go | {
"resource": ""
} |
q24292 | GetAttributeNames | train | func GetAttributeNames(attributes map[string]types.Attribute) []string {
var out []string
for _, attr := range attributes {
out = append(out, attr.Name)
}
return out
} | go | {
"resource": ""
} |
q24293 | NewNamespace | train | func NewNamespace(name string) Namespace {
return Namespace{
Kind: KindNamespace,
Version: V2,
Metadata: Metadata{
Name: name,
},
}
} | go | {
"resource": ""
} |
q24294 | AddOptions | train | func AddOptions(opts []MarshalOption, add ...MarshalOption) []MarshalOption {
out := make([]MarshalOption, len(opts), len(opts)+len(add))
copy(out, opts)
return append(opts, add...)
} | go | {
"resource": ""
} |
q24295 | WithResourceID | train | func WithResourceID(id int64) MarshalOption {
return func(c *MarshalConfig) error {
c.ID = id
return nil
}
} | go | {
"resource": ""
} |
q24296 | WithExpires | train | func WithExpires(expires time.Time) MarshalOption {
return func(c *MarshalConfig) error {
c.Expires = expires
return nil
}
} | go | {
"resource": ""
} |
q24297 | WithVersion | train | func WithVersion(v string) MarshalOption {
return func(c *MarshalConfig) error {
switch v {
case V1, V2:
c.Version = v
return nil
default:
return trace.BadParameter("version '%v' is not supported", v)
}
}
} | go | {
"resource": ""
} |
q24298 | SetTTL | train | func (h *ResourceHeader) SetTTL(clock clockwork.Clock, ttl time.Duration) {
h.Metadata.SetTTL(clock, ttl)
} | go | {
"resource": ""
} |
q24299 | UnmarshalJSON | train | func (u *UnknownResource) UnmarshalJSON(raw []byte) error {
var h ResourceHeader
if err := json.Unmarshal(raw, &h); err != nil {
return trace.Wrap(err)
}
u.Raw = make([]byte, len(raw))
u.ResourceHeader = h
copy(u.Raw, raw)
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.