id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c23700 | if trace.IsNotFound(err) {
return false, nil
}
return false, trace.Wrap(err)
}
defer f.Close()
return true, nil
} | |
c23701 | openTimeout})
if err != nil {
if err == bolt.ErrTimeout {
return nil, trace.Errorf("Local storage is locked. Another instance is running? (%v)", path)
}
return nil, trace.Wrap(err)
}
// Wrap the backend in a input sanitizer and return it.
return &BoltBackend{
locks: make(map[string]time.Time),
clock:... | |
c23702 | in 2.7.0 anyway.
items := make([]legacy.Item, 0, len(keys))
for _, e := range keys {
val, err := b.GetVal(path, e)
if err != nil {
continue
}
items = append(items, legacy.Item{
Key: e,
Value: val,
})
}
return items, nil
} | |
c23703 | is a bucket", key)
}
return trace.CompareFailed("%v %v is not found", bucket, key)
}
var currentVal kv
if err := json.Unmarshal(currentData, ¤tVal); err != nil {
return trace.Wrap(err)
}
if bytes.Compare(prevData, currentVal.Value) != 0 {
return trace.CompareFailed("%q is not matching expec... | |
c23704 | Spec: InviteTokenSpecV3{
URL: signupURL,
},
}
if !expires.IsZero() {
tok.Metadata.SetExpiry(expires)
}
return &tok
} | |
c23705 | err != nil {
return nil, trace.BadParameter("failed to parse Content-Length header: %q", contentLength)
}
fs := &httpFileSystem{
reader: req.HTTPRequest.Body,
fileName: req.FileName,
fileSize: fileSize,
}
flags := Flags{
// scp treats it as a list of files to upload
Target: []string{req.FileName},
... | |
c23706 | req.Progress,
RemoteLocation: req.RemoteLocation,
FileSystem: &httpFileSystem{
writer: req.HTTPResponse,
},
}
cmd, err := CreateDownloadCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
} | |
c23707 | are not supported in http file transfer")
} | |
c23708 | return nil, trace.BadParameter("missing reader")
}
return l.reader, nil
} | |
c23709 | filename = url.QueryEscape(filename)
header.Set("Content-Disposition", fmt.Sprintf(`attachment;filename="%v"`, filename))
return &nopWriteCloser{Writer: l.writer}, nil
} | |
c23710 | {
return &httpFileInfo{
name: l.fileName,
path: l.fileName,
size: l.fileSize,
}, nil
} | |
c23711 |
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
} | |
c23712 | err != nil {
cancel()
return nil, trace.Wrap(err)
}
m := &Memory{
Mutex: &sync.Mutex{},
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentMemory,
}),
Config: cfg,
tree: btree.New(cfg.BTreeDegree),
heap: newMinHeap(),
cancel: cancel,
ctx: ctx,
buf: buf,
}
return... | |
c23713 | m.Unlock()
m.buf.Close()
return nil
} | |
c23714 | }
if !m.Mirror {
i.ID = m.generateID()
}
event := backend.Event{
Type: backend.OpPut,
Item: i,
}
m.processEvent(event)
if !m.EventsOff {
m.buf.Push(event)
}
return m.newLease(i), nil
} | |
c23715 | }
existingItem := i.(*btreeItem).Item
if bytes.Compare(existingItem.Value, expected.Value) != 0 {
return nil, trace.CompareFailed("current value does not match expected for %v", string(expected.Key))
}
event := backend.Event{
Type: backend.OpPut,
Item: replaceWith,
}
m.processEvent(event)
if !m.EventsOff ... | |
c23716 | %v %v item.", string(item.Key), item.Expires)
removed++
}
if removed > 0 {
m.Debugf("Removed %v expired items.", removed)
}
return removed
} | |
c23717 | trace.Wrap(err)
}
*s = *id
return nil
} | |
c23718 | sec, nsec := tm.UnixTime()
return time.Unix(sec, nsec).UTC()
} | |
c23719 |
return trace.Wrap(err)
} | |
c23720 |
return nil, trace.BadParameter("'%v' is not a be a valid Time UUID v1", id)
}
uid := ID(id)
return &uid, nil
} | |
c23721 | == pid {
s.Parties = append(s.Parties[:i], s.Parties[i+1:]...)
return true
}
}
return false
} | |
c23722 | p.ID, p.RemoteAddr, p.User, p.ServerID, p.LastActive,
)
} | |
c23723 | fmt.Sprintf("TerminalParams(w=%v, h=%v)", p.W, p.H)
} | |
c23724 |
return &term.Winsize{
Width: uint16(p.W),
Height: uint16(p.H),
}
} | |
c23725 | Namespace")
}
if u.TerminalParams != nil {
_, err := NewTerminalParamsFromInt(u.TerminalParams.W, u.TerminalParams.H)
if err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c23726 |
s.activeSessionTTL = defaults.ActiveSessionTTL
}
return s, nil
} | |
c23727 | {
return nil, trace.Wrap(err)
}
out := make(Sessions, 0, len(result.Items))
for i := range result.Items {
var session Session
if err := json.Unmarshal(result.Items[i].Value, &session); err != nil {
return nil, trace.Wrap(err)
}
out = append(out, session)
}
sort.Stable(out)
return out, nil
} | |
c23728 | return nil, trace.Wrap(err)
}
var sess Session
if err := json.Unmarshal(item.Value, &sess); err != nil {
return nil, trace.Wrap(err)
}
return &sess, nil
} | |
c23729 | = nil
data, err := json.Marshal(sess)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: activeKey(sess.Namespace, string(sess.ID)),
Value: data,
Expires: s.clock.Now().UTC().Add(s.activeSessionTTL),
}
_, err = s.bk.Create(context.TODO(), item)
if err != nil {
return trace.Wrap(... | |
c23730 | key,
Value: newValue,
Expires: s.clock.Now().UTC().Add(s.activeSessionTTL),
}
_, err = s.bk.CompareAndSwap(context.TODO(), *item, newItem)
if err != nil {
if trace.IsCompareFailed(err) || trace.IsConnectionProblem(err) {
s.clock.Sleep(sessionUpdateRetryPeriod)
continue
}
return trace.... | |
c23731 | error) {
return &Session{}, nil
} | |
c23732 | nil, trace.BadParameter("bad height")
}
return &TerminalParams{W: int(w), H: int(h)}, nil
} | |
c23733 | services.RecordAtProxy
isTeleportNode := s.Component() == teleport.ComponentNode
if isRecordAtProxy && isTeleportNode {
return true
}
return false
} | |
c23734 |
s.Warningf("Failed to close heartbeat: %v.", err)
}
s.heartbeat = nil
}
return err
} | |
c23735 | connections to it arrive over a reverse tunnel,
// don't call Start() which listens on a socket, return right away.
if s.useTunnel {
return nil
}
return s.srv.Start()
} | |
c23736 | go s.heartbeat.Run()
return s.srv.Serve(l)
} | |
c23737 | net.Conn) {
s.srv.HandleConnection(conn)
} | |
c23738 | s.getRotation = getter
return nil
}
} | |
c23739 |
s.shell = shell
return nil
}
} | |
c23740 | s.sessionServer = sessionServer
return nil
}
} | |
c23741 | proxy is still used without it.
s.proxyMode = true
s.proxyTun = tsrv
return nil
}
} | |
c23742 | for name, label := range cmdLabels {
if label.GetPeriod() < time.Second {
label.SetPeriod(time.Second)
cmdLabels[name] = label
log.Warningf("label period can't be less that 1 second. Period for label '%v' was set to 1 second", name)
}
}
s.labels = labels
s.cmdLabels = cmdLabels
return nil
}
... | |
c23743 | *Server) error {
s.alog = alog
return nil
}
} | |
c23744 |
s.uuid = uuid
return nil
}
} | |
c23745 | s.permitUserEnvironment = permitUserEnvironment
return nil
}
} | |
c23746 | return trace.Wrap(err)
}
dirCloser := &utils.RemoveDirCloser{Path: socketDir}
socketPath := filepath.Join(socketDir, fmt.Sprintf("teleport-%v.socket", pid))
if err := os.Chown(socketDir, uid, gid); err != nil {
if err := dirCloser.Close(); err != nil {
log.Warnf("failed to remove directory: %v", err)
}
r... | |
c23747 | time with ms precision
fields[events.EventTime] = s.clock.Now().In(time.UTC).Round(time.Millisecond)
if err := alog.EmitAuditEvent(event, fields); err != nil {
log.Error(trace.DebugReport(err))
}
} else {
log.Warn("SSH server has no audit log")
}
} | |
c23748 |
nch.Reject(ssh.ConnectionFailed, fmt.Sprintf("unable to accept channel: %v", err))
return
}
go s.handleSessionRequests(wconn, sconn, identityContext, ch, requests)
// Channels of type "direct-tcpip" handles request for port forwarding.
case "direct-tcpip":
req, err := sshutils.ParseDirectTCPIPReq(nch.Ext... | |
c23749 | it can be used later
ctx.SetAgent(agent.NewClient(authChannel), authChannel)
// serve an agent on a unix socket on this node
err = s.serveAgent(ctx)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c23750 | != nil {
log.Warnf("Unable to reply to %q request: %v", req.Type, err)
return
}
}
log.Debugf("Replied to %q", req.Type)
} | |
c23751 | a
// bool if we are in recording mode or not
recordingProxy = clusterConfig.GetSessionRecording() == services.RecordAtProxy
err = req.Reply(true, []byte(strconv.FormatBool(recordingProxy)))
if err != nil {
log.Warnf("Unable to respond to global request (%v, %v): %v: %v", req.Type, req.WantReply, recordingPr... | |
c23752 | stringsVar []string
if err := json.Unmarshal(data, &stringsVar); err != nil {
return trace.Wrap(err)
}
*s = stringsVar
return nil
} | |
c23753 |
// try unmarshal as slice
var slice []string
err = unmarshal(&slice)
if err == nil {
*s = slice
return nil
}
return err
} | |
c23754 | return json.Marshal(s[0])
}
return json.Marshal([]string(s))
} | |
c23755 | return s[0], nil
}
return []string(s), nil
} | |
c23756 | &Tracer{Started: time.Now().UTC(), Description: description}
} | |
c23757 | t.Description, time.Now().Sub(t.Started))
return t
} | |
c23758 | return runtime.FuncForPC(pc[0]).Name()
} | |
c23759 | defer s.Unlock()
return s.string
} | |
c23760 | defer s.Unlock()
s.string = v
} | |
c23761 | _ := ParseBool(v)
return out
} | |
c23762 |
return true, nil
case "no", "nope", "n", "false", "0", "off":
return false, nil
default:
return false, trace.BadParameter("unsupported value: %q", value)
}
} | |
c23763 | if host == "" {
return "", "", trace.BadParameter("missing host parameter")
}
}
ip := net.ParseIP(host)
if len(ip) != 0 {
if ip.IsUnspecified() || ip.IsMulticast() {
return "", "", trace.BadParameter("unreachable advertise IP: %v", advertiseIP)
}
}
return host, port, nil
} | |
c23764 | return false, trace.BadParameter("bad %q parameter value: %q, supported values are on or off", parameterName, val)
}
} | |
c23765 | range groups {
if group == gid {
return true, nil
}
}
return false, nil
} | |
c23766 | "" {
return "", "", trace.BadParameter("empty hostname")
}
return host, port, nil
} | |
c23767 | }
abs, err := filepath.EvalSymlinks(s)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
bytes, err := ioutil.ReadFile(abs)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
return bytes, nil
} | |
c23768 | return false
}
return strings.Contains(trace.Unwrap(err).Error(), "ssh: handshake failed")
} | |
c23769 | is empty")
}
val := (*p)[len(*p)-1]
*p = (*p)[:len(*p)-1]
return val
} | |
c23770 | != nil {
panic(err)
}
return i
} | |
c23771 |
ports[i] = p.PopInt()
}
return ports
} | |
c23772 | i < start+n; i++ {
list = append(list, strconv.Itoa(i))
}
return list, nil
} | |
c23773 | return "", trace.Wrap(err)
}
return strings.TrimSpace(string(out)), nil
} | |
c23774 | if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | |
c23775 | if err = WriteHostUUID(dataDir, id); err != nil {
return "", trace.Wrap(err)
}
return id, nil
} | |
c23776 | := seen[val]; !ok {
out = append(out, val)
seen[val] = true
}
}
return out
} | |
c23777 | if slice[i] == value {
return true
}
}
return false
} | |
c23778 | _, s := range slice {
_, ok := remove[s]
if ok {
continue
}
output = append(output, s)
}
return output
} | |
c23779 | teleport.CertificateFormatUnspecified:
return s, nil
default:
return "", trace.BadParameter("invalid certificate format parameter: %q", s)
}
} | |
c23780 | range s {
addr, err := ParseHostPortAddr(val, defaultPort)
if err != nil {
return nil, trace.Wrap(err)
}
addrs[i] = *addr
}
return addrs, nil
} | |
c23781 | not present? this means the tctl is running NOT on the auth server.
if trace.IsNotFound(err) {
return nil, trace.AccessDenied("tctl must be used on the auth server")
}
return nil, trace.Wrap(err)
}
tlsConfig, err := i.TLSConfig(cfg.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
client, err... | |
c23782 |
return trace.Wrap(err)
}
// --debug flag
if ccf.Debug {
cfg.Debug = ccf.Debug
utils.InitLogger(utils.LoggingForCLI, logrus.DebugLevel)
logrus.Debugf("DEBUG logging enabled")
}
// read a host UUID for this node
cfg.HostUUID, err = utils.ReadHostUUID(cfg.DataDir)
if err != nil {
utils.FatalError(err)
... | |
c23783 | "expected JSON encoded remote certificate")
}
return nil
} | |
c23784 | if err != nil {
return nil, trace.Wrap(err)
}
limiter.rateLimiter, err = NewRateLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
return &limiter, nil
} | |
c23785 | l.ConnLimiter.Wrap(l.rateLimiter)
} | |
c23786 | {
if period < 0 {
return trace.BadParameter("period should be non zero")
}
h.sessionStreamPollPeriod = period
return nil
}
} | |
c23787 | Name: item.GetName(),
DisplayName: item.GetDisplay(),
})
}
// get all Github connectors
githubConnectors, err := h.cfg.ProxyClient.GetGithubConnectors(false)
if err != nil {
log.Errorf("Cannot retrieve Github connectors: %v.", err)
}
for _, item := range githubConnectors {
authProviders = appe... | |
c23788 | }
// NaCl based symmetric cipher (legacy).
case secretV1 != "":
secretKeyBytes, err := lemma_secret.EncodedStringToKey(secretV1)
if err != nil {
return nil, trace.BadParameter("bad secret")
}
encryptor, err := lemma_secret.New(&lemma_secret.Config{KeyBytes: secretKeyBytes})
if err != nil {
return nil... | |
c23789 | return time.Time{}, trace.BadParameter("failed to parse %v as RFC3339 time: %v", name, str)
}
return parsed, nil
} | |
c23790 | return 0, trace.BadParameter("failed to parse %v as limit: %v", name, str)
}
return limit, nil
} | |
c23791 | h.cfg.ProxyClient
packedKeys, err := authClient.RegisterUsingToken(req)
if err != nil {
return nil, trace.Wrap(err)
}
return packedKeys, nil
} | |
c23792 |
if err != nil {
log.Warn(err)
return nil, trace.Wrap(err)
}
siteName = res.GetClusterName()
}
site, err := h.cfg.Proxy.GetSite(siteName)
if err != nil {
log.Warn(err)
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx, site)
})
} | |
c23793 | := h.AuthenticateRequest(w, r, true)
if err != nil {
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx)
})
} | |
c23794 |
logger.Warningf("invalid session: %v", err)
ClearSession(w)
return nil, trace.AccessDenied("need auth")
}
if checkBearerToken {
creds, err := roundtrip.ParseAuthHeaders(r)
if err != nil {
logger.Warningf("no auth headers %v", err)
return nil, trace.AccessDenied("need auth")
}
if subtle.ConstantT... | |
c23795 | defaults.HTTPListenPort)
log.Debugf("public_address not set for proxy, returning proxyHost: %q", proxyHost)
}
}
u := &url.URL{
Scheme: "https",
Host: proxyHost,
Path: "web/newuser/" + token,
}
return u.String(), proxyHost
} | |
c23796 | tlsConfig, err := ctx.ClientTLSConfig()
if err != nil {
return nil, trace.BadParameter("failed to get client TLS config: %v", err)
}
config := &client.Config{
Username: ctx.user,
Agent: agent,
SkipLocalAuth: true,
TLS: tlsConfig,
AuthMethods: []ssh.AuthMethod{ssh... | |
c23797 | for i, _ := range agents {
for _, agentKey := range agentKeys {
err = agents[i].Add(*agentKey)
if err != nil {
a.log.Warnf("Unable to communicate with agent and add key: %v", err)
}
}
}
// return the first key because it has the embedded private key in it.
// see docs for AsAgentKeys for more deta... | |
c23798 | the agent for this user
for _, key := range keyList {
if key.Comment == fmt.Sprintf("teleport:%v", a.username) {
err = agents[i].Remove(key)
if err != nil {
a.log.Warnf("Unable to communicate with agent and remove key: %v", err)
}
}
}
}
return nil
} | |
c23799 | the agent
for _, key := range keyList {
if strings.HasPrefix(key.Comment, "teleport:") {
err = agents[i].Remove(key)
if err != nil {
a.log.Warnf("Unable to communicate with agent and remove key: %v", err)
}
}
}
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.