_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23700 | Exists | train | func Exists(path string) (bool, error) {
path, err := filepath.Abs(filepath.Join(path, keysBoltFile))
if err != nil {
return false, trace.Wrap(err)
}
f, err := os.Open(path)
err = trace.ConvertSystemError(err)
if err != nil {
if trace.IsNotFound(err) {
return false, nil
}
return false, trace.Wrap(err)
... | go | {
"resource": ""
} |
q23701 | New | train | func New(params legacy.Params) (*BoltBackend, error) {
// look at 'path' parameter, if it's missing use 'data_dir' (default):
path := params.GetString("path")
if len(path) == 0 {
path = params.GetString(teleport.DataDirParameterName)
}
// still nothing? return an error:
if path == "" {
return nil, trace.BadPa... | go | {
"resource": ""
} |
q23702 | GetItems | train | func (b *BoltBackend) GetItems(path []string, opts ...legacy.OpOption) ([]legacy.Item, error) {
cfg, err := legacy.CollectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.Recursive {
return b.getItemsRecursive(path)
}
keys, err := b.GetKeys(path)
if err != nil {
return nil, trace.Wrap(er... | go | {
"resource": ""
} |
q23703 | CompareAndSwapVal | train | func (b *BoltBackend) CompareAndSwapVal(bucket []string, key string, newData []byte, prevData []byte, ttl time.Duration) error {
if len(prevData) == 0 {
return trace.BadParameter("missing prevData parameter, to atomically create item, use CreateVal method")
}
v := &kv{
Created: b.clock.Now().UTC(),
Value: ne... | go | {
"resource": ""
} |
q23704 | NewInviteToken | train | func NewInviteToken(token, signupURL string, expires time.Time) *InviteTokenV3 {
tok := InviteTokenV3{
Kind: KindInviteToken,
Version: V3,
Metadata: Metadata{
Name: token,
},
Spec: InviteTokenSpecV3{
URL: signupURL,
},
}
if !expires.IsZero() {
tok.Metadata.SetExpiry(expires)
}
return &tok
} | go | {
"resource": ""
} |
q23705 | CreateHTTPUpload | train | func CreateHTTPUpload(req HTTPTransferRequest) (Command, error) {
if req.HTTPRequest == nil {
return nil, trace.BadParameter("missing parameter HTTPRequest")
}
if req.FileName == "" {
return nil, trace.BadParameter("missing file name")
}
if req.RemoteLocation == "" {
return nil, trace.BadParameter("missing... | go | {
"resource": ""
} |
q23706 | CreateHTTPDownload | train | func CreateHTTPDownload(req HTTPTransferRequest) (Command, error) {
_, filename, err := req.parseRemoteLocation()
if err != nil {
return nil, trace.Wrap(err)
}
flags := Flags{
Target: []string{filename},
}
cfg := Config{
Flags: flags,
User: req.User,
ProgressWriter: req.Progress,
... | go | {
"resource": ""
} |
q23707 | MkDir | train | func (l *httpFileSystem) MkDir(path string, mode int) error {
return trace.BadParameter("directories are not supported in http file transfer")
} | go | {
"resource": ""
} |
q23708 | OpenFile | train | func (l *httpFileSystem) OpenFile(filePath string) (io.ReadCloser, error) {
if l.reader == nil {
return nil, trace.BadParameter("missing reader")
}
return l.reader, nil
} | go | {
"resource": ""
} |
q23709 | CreateFile | train | func (l *httpFileSystem) CreateFile(filePath string, length uint64) (io.WriteCloser, error) {
_, filename := filepath.Split(filePath)
contentLength := strconv.FormatUint(length, 10)
header := l.writer.Header()
httplib.SetNoCacheHeaders(header)
httplib.SetNoSniff(header)
header.Set("Content-Length", contentLength... | go | {
"resource": ""
} |
q23710 | GetFileInfo | train | func (l *httpFileSystem) GetFileInfo(filePath string) (FileInfo, error) {
return &httpFileInfo{
name: l.fileName,
path: l.fileName,
size: l.fileSize,
}, nil
} | go | {
"resource": ""
} |
q23711 | Write | train | func (w *BroadcastWriter) Write(p []byte) (n int, err error) {
for _, writer := range w.writers {
n, err = writer.Write(p)
if err != nil {
return
}
if n != len(p) {
err = io.ErrShortWrite
return
}
}
return len(p), nil
} | go | {
"resource": ""
} |
q23712 | New | train | func New(cfg Config) (*Memory, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
buf, err := backend.NewCircularBuffer(ctx, cfg.BufferSize)
if err != nil {
cancel()
return nil, trace.Wrap(err)
}
m := &Memory{
Mutex: &sy... | go | {
"resource": ""
} |
q23713 | Close | train | func (m *Memory) Close() error {
m.cancel()
m.Lock()
defer m.Unlock()
m.buf.Close()
return nil
} | go | {
"resource": ""
} |
q23714 | Update | train | func (m *Memory) Update(ctx context.Context, i backend.Item) (*backend.Lease, error) {
if len(i.Key) == 0 {
return nil, trace.BadParameter("missing parameter key")
}
m.Lock()
defer m.Unlock()
m.removeExpired()
if m.tree.Get(&btreeItem{Item: i}) == nil {
return nil, trace.NotFound("key %q is not found", string... | go | {
"resource": ""
} |
q23715 | CompareAndSwap | train | func (m *Memory) 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")
}
if bytes... | go | {
"resource": ""
} |
q23716 | removeExpired | train | func (m *Memory) removeExpired() int {
removed := 0
now := m.Clock().Now().UTC()
for {
if len(*m.heap) == 0 {
break
}
item := m.heap.PeekEl()
if now.Before(item.Expires) {
break
}
m.heap.PopEl()
m.tree.Delete(item)
m.Debugf("Removed expired %v %v item.", string(item.Key), item.Expires)
remove... | go | {
"resource": ""
} |
q23717 | Set | train | func (s *ID) Set(v string) error {
id, err := ParseID(v)
if err != nil {
return trace.Wrap(err)
}
*s = *id
return nil
} | go | {
"resource": ""
} |
q23718 | Time | train | func (s *ID) Time() time.Time {
tm, ok := s.UUID().Time()
if !ok {
return time.Time{}
}
sec, nsec := tm.UnixTime()
return time.Unix(sec, nsec).UTC()
} | go | {
"resource": ""
} |
q23719 | Check | train | func (s *ID) Check() error {
_, err := ParseID(string(*s))
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23720 | ParseID | train | func ParseID(id string) (*ID, error) {
val := uuid.Parse(id)
if val == nil {
return nil, trace.BadParameter("'%v' is not a valid Time UUID v1", id)
}
if ver, ok := val.Version(); !ok || ver != 1 {
return nil, trace.BadParameter("'%v' is not a be a valid Time UUID v1", id)
}
uid := ID(id)
return &uid, nil
} | go | {
"resource": ""
} |
q23721 | RemoveParty | train | func (s *Session) RemoveParty(pid ID) bool {
for i := range s.Parties {
if s.Parties[i].ID == pid {
s.Parties = append(s.Parties[:i], s.Parties[i+1:]...)
return true
}
}
return false
} | go | {
"resource": ""
} |
q23722 | String | train | func (p *Party) String() string {
return fmt.Sprintf(
"party(id=%v, remote=%v, user=%v, server=%v, last_active=%v)",
p.ID, p.RemoteAddr, p.User, p.ServerID, p.LastActive,
)
} | go | {
"resource": ""
} |
q23723 | String | train | func (p *TerminalParams) String() string {
return fmt.Sprintf("TerminalParams(w=%v, h=%v)", p.W, p.H)
} | go | {
"resource": ""
} |
q23724 | Winsize | train | func (p *TerminalParams) Winsize() *term.Winsize {
return &term.Winsize{
Width: uint16(p.W),
Height: uint16(p.H),
}
} | go | {
"resource": ""
} |
q23725 | Check | train | func (u *UpdateRequest) Check() error {
if err := u.ID.Check(); err != nil {
return trace.Wrap(err)
}
if u.Namespace == "" {
return trace.BadParameter("missing parameter Namespace")
}
if u.TerminalParams != nil {
_, err := NewTerminalParamsFromInt(u.TerminalParams.W, u.TerminalParams.H)
if err != nil {
... | go | {
"resource": ""
} |
q23726 | New | train | func New(bk backend.Backend) (Service, error) {
s := &server{
bk: bk,
clock: clockwork.NewRealClock(),
}
if s.activeSessionTTL == 0 {
s.activeSessionTTL = defaults.ActiveSessionTTL
}
return s, nil
} | go | {
"resource": ""
} |
q23727 | GetSessions | train | func (s *server) GetSessions(namespace string) ([]Session, error) {
prefix := activePrefix(namespace)
result, err := s.bk.GetRange(context.TODO(), prefix, backend.RangeEnd(prefix), MaxSessionSliceLength)
if err != nil {
return nil, trace.Wrap(err)
}
out := make(Sessions, 0, len(result.Items))
for i := range r... | go | {
"resource": ""
} |
q23728 | GetSession | train | func (s *server) GetSession(namespace string, id ID) (*Session, error) {
item, err := s.bk.Get(context.TODO(), activeKey(namespace, string(id)))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("session(%v, %v) is not found", namespace, id)
}
return nil, trace.Wrap(err)
}
var sess Sess... | go | {
"resource": ""
} |
q23729 | CreateSession | train | func (s *server) CreateSession(sess Session) error {
if err := sess.ID.Check(); err != nil {
return trace.Wrap(err)
}
if sess.Namespace == "" {
return trace.BadParameter("session namespace can not be empty")
}
if sess.Login == "" {
return trace.BadParameter("session login can not be empty")
}
if sess.Creat... | go | {
"resource": ""
} |
q23730 | UpdateSession | train | func (s *server) UpdateSession(req UpdateRequest) error {
if err := req.Check(); err != nil {
return trace.Wrap(err)
}
key := activeKey(req.Namespace, string(req.ID))
// Try several times, then give up
for i := 0; i < sessionUpdateAttempts; i++ {
item, err := s.bk.Get(context.TODO(), key)
if err != nil {
... | go | {
"resource": ""
} |
q23731 | GetSession | train | func (d *discardSessionServer) GetSession(namespace string, id ID) (*Session, error) {
return &Session{}, nil
} | go | {
"resource": ""
} |
q23732 | NewTerminalParamsFromUint32 | train | func NewTerminalParamsFromUint32(w uint32, h uint32) (*TerminalParams, error) {
if w > maxSize || w < minSize {
return nil, trace.BadParameter("bad width")
}
if h > maxSize || h < minSize {
return nil, trace.BadParameter("bad height")
}
return &TerminalParams{W: int(w), H: int(h)}, nil
} | go | {
"resource": ""
} |
q23733 | isAuditedAtProxy | train | func (s *Server) isAuditedAtProxy() bool {
// always be safe, better to double record than not record at all
clusterConfig, err := s.GetAccessPoint().GetClusterConfig()
if err != nil {
return false
}
isRecordAtProxy := clusterConfig.GetSessionRecording() == services.RecordAtProxy
isTeleportNode := s.Component(... | go | {
"resource": ""
} |
q23734 | Shutdown | train | func (s *Server) Shutdown(ctx context.Context) error {
// wait until connections drain off
err := s.srv.Shutdown(ctx)
s.cancel()
s.reg.Close()
if s.heartbeat != nil {
if err := s.heartbeat.Close(); err != nil {
s.Warningf("Failed to close heartbeat: %v.", err)
}
s.heartbeat = nil
}
return err
} | go | {
"resource": ""
} |
q23735 | Start | train | func (s *Server) Start() error {
if len(s.getCommandLabels()) > 0 {
s.updateLabels()
}
go s.heartbeat.Run()
// If the server requested 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()
} | go | {
"resource": ""
} |
q23736 | Serve | train | func (s *Server) Serve(l net.Listener) error {
if len(s.getCommandLabels()) > 0 {
s.updateLabels()
}
go s.heartbeat.Run()
return s.srv.Serve(l)
} | go | {
"resource": ""
} |
q23737 | HandleConnection | train | func (s *Server) HandleConnection(conn net.Conn) {
s.srv.HandleConnection(conn)
} | go | {
"resource": ""
} |
q23738 | SetRotationGetter | train | func SetRotationGetter(getter RotationGetter) ServerOption {
return func(s *Server) error {
s.getRotation = getter
return nil
}
} | go | {
"resource": ""
} |
q23739 | SetShell | train | func SetShell(shell string) ServerOption {
return func(s *Server) error {
s.shell = shell
return nil
}
} | go | {
"resource": ""
} |
q23740 | SetSessionServer | train | func SetSessionServer(sessionServer rsession.Service) ServerOption {
return func(s *Server) error {
s.sessionServer = sessionServer
return nil
}
} | go | {
"resource": ""
} |
q23741 | SetProxyMode | train | func SetProxyMode(tsrv reversetunnel.Server) ServerOption {
return func(s *Server) error {
// always set proxy mode to true,
// because in some tests reverse tunnel is disabled,
// but proxy is still used without it.
s.proxyMode = true
s.proxyTun = tsrv
return nil
}
} | go | {
"resource": ""
} |
q23742 | SetLabels | train | func SetLabels(labels map[string]string,
cmdLabels services.CommandLabels) ServerOption {
return func(s *Server) error {
// make sure to clone labels to avoid
// concurrent writes to the map during reloads
cmdLabels = cmdLabels.Clone()
for name, label := range cmdLabels {
if label.GetPeriod() < time.Second... | go | {
"resource": ""
} |
q23743 | SetAuditLog | train | func SetAuditLog(alog events.IAuditLog) ServerOption {
return func(s *Server) error {
s.alog = alog
return nil
}
} | go | {
"resource": ""
} |
q23744 | SetUUID | train | func SetUUID(uuid string) ServerOption {
return func(s *Server) error {
s.uuid = uuid
return nil
}
} | go | {
"resource": ""
} |
q23745 | SetPermitUserEnvironment | train | func SetPermitUserEnvironment(permitUserEnvironment bool) ServerOption {
return func(s *Server) error {
s.permitUserEnvironment = permitUserEnvironment
return nil
}
} | go | {
"resource": ""
} |
q23746 | serveAgent | train | func (s *Server) serveAgent(ctx *srv.ServerContext) error {
// gather information about user and process. this will be used to set the
// socket path and permissions
systemUser, err := user.Lookup(ctx.Identity.Login)
if err != nil {
return trace.ConvertSystemError(err)
}
uid, err := strconv.Atoi(systemUser.Uid)... | go | {
"resource": ""
} |
q23747 | EmitAuditEvent | train | func (s *Server) EmitAuditEvent(event events.Event, fields events.EventFields) {
log.Debugf("server.EmitAuditEvent(%v)", event.Name)
alog := s.alog
if alog != nil {
// record the event time with ms precision
fields[events.EventTime] = s.clock.Now().In(time.UTC).Round(time.Millisecond)
if err := alog.EmitAuditE... | go | {
"resource": ""
} |
q23748 | HandleNewChan | train | func (s *Server) HandleNewChan(wconn net.Conn, sconn *ssh.ServerConn, nch ssh.NewChannel) {
identityContext, err := s.authHandlers.CreateIdentityContext(sconn)
if err != nil {
nch.Reject(ssh.Prohibited, fmt.Sprintf("Unable to create identity from connection: %v", err))
return
}
channelType := nch.ChannelType()... | go | {
"resource": ""
} |
q23749 | handleAgentForwardNode | train | func (s *Server) handleAgentForwardNode(req *ssh.Request, ctx *srv.ServerContext) error {
// check if the user's RBAC role allows agent forwarding
err := s.authHandlers.CheckAgentForward(ctx)
if err != nil {
return trace.Wrap(err)
}
// open a channel to the client where the client will serve an agent
authChann... | go | {
"resource": ""
} |
q23750 | handleKeepAlive | train | func (s *Server) handleKeepAlive(req *ssh.Request) {
log.Debugf("Received %q: WantReply: %v", req.Type, req.WantReply)
// only reply if the sender actually wants a response
if req.WantReply {
err := req.Reply(true, nil)
if err != nil {
log.Warnf("Unable to reply to %q request: %v", req.Type, err)
return
... | go | {
"resource": ""
} |
q23751 | handleRecordingProxy | train | func (s *Server) handleRecordingProxy(req *ssh.Request) {
var recordingProxy bool
log.Debugf("Global request (%v, %v) received", req.Type, req.WantReply)
if req.WantReply {
// get the cluster config, if we can't get it, reply false
clusterConfig, err := s.authService.GetClusterConfig()
if err != nil {
err... | go | {
"resource": ""
} |
q23752 | UnmarshalJSON | train | func (s *Strings) UnmarshalJSON(data []byte) error {
if len(data) == 0 {
return nil
}
var stringVar string
if err := json.Unmarshal(data, &stringVar); err == nil {
*s = []string{stringVar}
return nil
}
var stringsVar []string
if err := json.Unmarshal(data, &stringsVar); err != nil {
return trace.Wrap(err... | go | {
"resource": ""
} |
q23753 | UnmarshalYAML | train | func (s *Strings) UnmarshalYAML(unmarshal func(interface{}) error) error {
// try unmarshal as string
var val string
err := unmarshal(&val)
if err == nil {
*s = []string{val}
return nil
}
// try unmarshal as slice
var slice []string
err = unmarshal(&slice)
if err == nil {
*s = slice
return nil
}
re... | go | {
"resource": ""
} |
q23754 | MarshalJSON | train | func (s Strings) MarshalJSON() ([]byte, error) {
if len(s) == 1 {
return json.Marshal(s[0])
}
return json.Marshal([]string(s))
} | go | {
"resource": ""
} |
q23755 | MarshalYAML | train | func (s Strings) MarshalYAML() (interface{}, error) {
if len(s) == 1 {
return s[0], nil
}
return []string(s), nil
} | go | {
"resource": ""
} |
q23756 | NewTracer | train | func NewTracer(description string) *Tracer {
return &Tracer{Started: time.Now().UTC(), Description: description}
} | go | {
"resource": ""
} |
q23757 | Stop | train | func (t *Tracer) Stop() *Tracer {
log.Debugf("Tracer completed %v in %v.", t.Description, time.Now().Sub(t.Started))
return t
} | go | {
"resource": ""
} |
q23758 | ThisFunction | train | func ThisFunction() string {
var pc [32]uintptr
runtime.Callers(2, pc[:])
return runtime.FuncForPC(pc[0]).Name()
} | go | {
"resource": ""
} |
q23759 | Value | train | func (s *SyncString) Value() string {
s.Lock()
defer s.Unlock()
return s.string
} | go | {
"resource": ""
} |
q23760 | Set | train | func (s *SyncString) Set(v string) {
s.Lock()
defer s.Unlock()
s.string = v
} | go | {
"resource": ""
} |
q23761 | AsBool | train | func AsBool(v string) bool {
if v == "" {
return false
}
out, _ := ParseBool(v)
return out
} | go | {
"resource": ""
} |
q23762 | ParseBool | train | func ParseBool(value string) (bool, error) {
switch strings.ToLower(value) {
case "yes", "yeah", "y", "true", "1", "on":
return true, nil
case "no", "nope", "n", "false", "0", "off":
return false, nil
default:
return false, trace.BadParameter("unsupported value: %q", value)
}
} | go | {
"resource": ""
} |
q23763 | ParseAdvertiseAddr | train | func ParseAdvertiseAddr(advertiseIP string) (string, string, error) {
advertiseIP = strings.TrimSpace(advertiseIP)
host := advertiseIP
port := ""
if len(net.ParseIP(host)) == 0 && strings.Contains(advertiseIP, ":") {
var err error
host, port, err = net.SplitHostPort(advertiseIP)
if err != nil {
return "", ... | go | {
"resource": ""
} |
q23764 | ParseOnOff | train | func ParseOnOff(parameterName, val string, defaultValue bool) (bool, error) {
switch val {
case teleport.On:
return true, nil
case teleport.Off:
return false, nil
case "":
return defaultValue, nil
default:
return false, trace.BadParameter("bad %q parameter value: %q, supported values are on or off", parame... | go | {
"resource": ""
} |
q23765 | IsGroupMember | train | func IsGroupMember(gid int) (bool, error) {
groups, err := os.Getgroups()
if err != nil {
return false, trace.ConvertSystemError(err)
}
for _, group := range groups {
if group == gid {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q23766 | SplitHostPort | train | func SplitHostPort(hostname string) (string, string, error) {
host, port, err := net.SplitHostPort(hostname)
if err != nil {
return "", "", trace.Wrap(err)
}
if host == "" {
return "", "", trace.BadParameter("empty hostname")
}
return host, port, nil
} | go | {
"resource": ""
} |
q23767 | ReadPath | train | func ReadPath(path string) ([]byte, error) {
if path == "" {
return nil, trace.NotFound("empty path")
}
s, err := filepath.Abs(path)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
abs, err := filepath.EvalSymlinks(s)
if err != nil {
return nil, trace.ConvertSystemError(err)
}
bytes, err := i... | go | {
"resource": ""
} |
q23768 | IsHandshakeFailedError | train | func IsHandshakeFailedError(err error) bool {
if err == nil {
return false
}
return strings.Contains(trace.Unwrap(err).Error(), "ssh: handshake failed")
} | go | {
"resource": ""
} |
q23769 | Pop | train | func (p *PortList) Pop() string {
if len(*p) == 0 {
panic("list is empty")
}
val := (*p)[len(*p)-1]
*p = (*p)[:len(*p)-1]
return val
} | go | {
"resource": ""
} |
q23770 | PopInt | train | func (p *PortList) PopInt() int {
i, err := strconv.Atoi(p.Pop())
if err != nil {
panic(err)
}
return i
} | go | {
"resource": ""
} |
q23771 | PopIntSlice | train | func (p *PortList) PopIntSlice(num int) []int {
ports := make([]int, num)
for i := range ports {
ports[i] = p.PopInt()
}
return ports
} | go | {
"resource": ""
} |
q23772 | GetFreeTCPPorts | train | func GetFreeTCPPorts(n int, offset ...int) (PortList, error) {
list := make(PortList, 0, n)
start := PortStartingNumber
if len(offset) != 0 {
start = offset[0]
}
for i := start; i < start+n; i++ {
list = append(list, strconv.Itoa(i))
}
return list, nil
} | go | {
"resource": ""
} |
q23773 | ReadHostUUID | train | func ReadHostUUID(dataDir string) (string, error) {
out, err := ReadPath(filepath.Join(dataDir, HostUUIDFile))
if err != nil {
return "", trace.Wrap(err)
}
return strings.TrimSpace(string(out)), nil
} | go | {
"resource": ""
} |
q23774 | WriteHostUUID | train | func WriteHostUUID(dataDir string, id string) error {
err := ioutil.WriteFile(filepath.Join(dataDir, HostUUIDFile), []byte(id), os.ModeExclusive|0400)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23775 | ReadOrMakeHostUUID | train | func ReadOrMakeHostUUID(dataDir string) (string, error) {
id, err := ReadHostUUID(dataDir)
if err == nil {
return id, nil
}
if !trace.IsNotFound(err) {
return "", trace.Wrap(err)
}
id = uuid.New()
if err = WriteHostUUID(dataDir, id); err != nil {
return "", trace.Wrap(err)
}
return id, nil
} | go | {
"resource": ""
} |
q23776 | Deduplicate | train | func Deduplicate(in []string) []string {
if len(in) == 0 {
return in
}
out := make([]string, 0, len(in))
seen := make(map[string]bool, len(in))
for _, val := range in {
if _, ok := seen[val]; !ok {
out = append(out, val)
seen[val] = true
}
}
return out
} | go | {
"resource": ""
} |
q23777 | SliceContainsStr | train | func SliceContainsStr(slice []string, value string) bool {
for i := range slice {
if slice[i] == value {
return true
}
}
return false
} | go | {
"resource": ""
} |
q23778 | RemoveFromSlice | train | func RemoveFromSlice(slice []string, values ...string) []string {
output := make([]string, 0, len(slice))
remove := make(map[string]bool)
for _, value := range values {
remove[value] = true
}
for _, s := range slice {
_, ok := remove[s]
if ok {
continue
}
output = append(output, s)
}
return outpu... | go | {
"resource": ""
} |
q23779 | CheckCertificateFormatFlag | train | func CheckCertificateFormatFlag(s string) (string, error) {
switch s {
case teleport.CertificateFormatStandard, teleport.CertificateFormatOldSSH, teleport.CertificateFormatUnspecified:
return s, nil
default:
return "", trace.BadParameter("invalid certificate format parameter: %q", s)
}
} | go | {
"resource": ""
} |
q23780 | Addrs | train | func (s Strings) Addrs(defaultPort int) ([]NetAddr, error) {
addrs := make([]NetAddr, len(s))
for i, val := range s {
addr, err := ParseHostPortAddr(val, defaultPort)
if err != nil {
return nil, trace.Wrap(err)
}
addrs[i] = *addr
}
return addrs, nil
} | go | {
"resource": ""
} |
q23781 | connectToAuthService | train | func connectToAuthService(cfg *service.Config) (client auth.ClientI, err error) {
// connect to the local auth server by default:
cfg.Auth.Enabled = true
if len(cfg.AuthServers) == 0 {
cfg.AuthServers = []utils.NetAddr{
*defaults.AuthConnectAddr(),
}
}
// read the host SSH keys and use them to open an SSH c... | go | {
"resource": ""
} |
q23782 | applyConfig | train | func applyConfig(ccf *GlobalCLIFlags, cfg *service.Config) error {
// load /etc/teleport.yaml and apply it's values:
fileConf, err := config.ReadConfigFile(ccf.ConfigFile)
if err != nil {
return trace.Wrap(err)
}
// if configuration is passed as an environment variable,
// try to decode it and override the conf... | go | {
"resource": ""
} |
q23783 | SetEnv | train | func (l *LimiterConfig) SetEnv(v string) error {
if err := json.Unmarshal([]byte(v), l); err != nil {
return trace.Wrap(err, "expected JSON encoded remote certificate")
}
return nil
} | go | {
"resource": ""
} |
q23784 | NewLimiter | train | func NewLimiter(config LimiterConfig) (*Limiter, error) {
var err error
limiter := Limiter{}
limiter.ConnectionsLimiter, err = NewConnectionsLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
limiter.rateLimiter, err = NewRateLimiter(config)
if err != nil {
return nil, trace.Wrap(err)
}
retur... | go | {
"resource": ""
} |
q23785 | WrapHandle | train | func (l *Limiter) WrapHandle(h http.Handler) {
l.rateLimiter.Wrap(h)
l.ConnLimiter.Wrap(l.rateLimiter)
} | go | {
"resource": ""
} |
q23786 | SetSessionStreamPollPeriod | train | func SetSessionStreamPollPeriod(period time.Duration) HandlerOption {
return func(h *Handler) error {
if period < 0 {
return trace.BadParameter("period should be non zero")
}
h.sessionStreamPollPeriod = period
return nil
}
} | go | {
"resource": ""
} |
q23787 | getWebConfig | train | func (h *Handler) getWebConfig(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
httplib.SetWebConfigHeaders(w.Header())
authProviders := []ui.WebConfigAuthProvider{}
secondFactor := teleport.OFF
// get all OIDC connectors
oidcConnectors, err := h.cfg.ProxyClient.GetOIDCConnecto... | go | {
"resource": ""
} |
q23788 | ConstructSSHResponse | train | func ConstructSSHResponse(response AuthParams) (*url.URL, error) {
u, err := url.Parse(response.ClientRedirectURL)
if err != nil {
return nil, trace.Wrap(err)
}
consoleResponse := auth.SSHLoginResponse{
Username: response.Username,
Cert: response.Cert,
TLSCert: response.TLSCert,
HostSigners:... | go | {
"resource": ""
} |
q23789 | queryTime | train | func queryTime(query url.Values, name string, def time.Time) (time.Time, error) {
str := query.Get(name)
if str == "" {
return def, nil
}
parsed, err := time.Parse(time.RFC3339, str)
if err != nil {
return time.Time{}, trace.BadParameter("failed to parse %v as RFC3339 time: %v", name, str)
}
return parsed, n... | go | {
"resource": ""
} |
q23790 | queryLimit | train | func queryLimit(query url.Values, name string, def int) (int, error) {
str := query.Get(name)
if str == "" {
return def, nil
}
limit, err := strconv.Atoi(str)
if err != nil {
return 0, trace.BadParameter("failed to parse %v as limit: %v", name, str)
}
return limit, nil
} | go | {
"resource": ""
} |
q23791 | hostCredentials | train | func (h *Handler) hostCredentials(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
var req auth.RegisterUsingTokenRequest
if err := httplib.ReadJSON(r, &req); err != nil {
return nil, trace.Wrap(err)
}
authClient := h.cfg.ProxyClient
packedKeys, err := authClient.RegisterUsing... | go | {
"resource": ""
} |
q23792 | WithClusterAuth | train | func (h *Handler) WithClusterAuth(fn ClusterHandler) httprouter.Handle {
return httplib.MakeHandler(func(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
ctx, err := h.AuthenticateRequest(w, r, true)
if err != nil {
log.Info(err)
// clear session just in case if the authent... | go | {
"resource": ""
} |
q23793 | WithAuth | train | func (h *Handler) WithAuth(fn ContextHandler) httprouter.Handle {
return httplib.MakeHandler(func(w http.ResponseWriter, r *http.Request, p httprouter.Params) (interface{}, error) {
ctx, err := h.AuthenticateRequest(w, r, true)
if err != nil {
return nil, trace.Wrap(err)
}
return fn(w, r, p, ctx)
})
} | go | {
"resource": ""
} |
q23794 | AuthenticateRequest | train | func (h *Handler) AuthenticateRequest(w http.ResponseWriter, r *http.Request, checkBearerToken bool) (*SessionContext, error) {
const missingCookieMsg = "missing session cookie"
logger := log.WithFields(log.Fields{
"request": fmt.Sprintf("%v %v", r.Method, r.URL.Path),
})
cookie, err := r.Cookie("session")
if er... | go | {
"resource": ""
} |
q23795 | CreateSignupLink | train | func CreateSignupLink(client auth.ClientI, token string) (string, string) {
proxyHost := "<proxyhost>:3080"
proxies, err := client.GetProxies()
if err != nil {
log.Errorf("Unable to retrieve proxy list: %v", err)
}
if len(proxies) > 0 {
proxyHost = proxies[0].GetPublicAddr()
if proxyHost == "" {
proxyHo... | go | {
"resource": ""
} |
q23796 | makeTeleportClientConfig | train | func makeTeleportClientConfig(ctx *SessionContext) (*client.Config, error) {
agent, cert, err := ctx.GetAgent()
if err != nil {
return nil, trace.BadParameter("failed to get user credentials: %v", err)
}
signers, err := agent.Signers()
if err != nil {
return nil, trace.BadParameter("failed to get user credent... | go | {
"resource": ""
} |
q23797 | LoadKey | train | func (a *LocalKeyAgent) LoadKey(key Key) (*agent.AddedKey, error) {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// convert keys into a format understood by the ssh agent
agentKeys, err := key.AsAgentKeys()
if err != nil {
return nil, trace.Wrap(err)
}
// r... | go | {
"resource": ""
} |
q23798 | UnloadKey | train | func (a *LocalKeyAgent) UnloadKey() error {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// iterate over all agents we have and unload keys for this user
for i, _ := range agents {
// get a list of all keys in the agent
keyList, err := agents[i].List()
if e... | go | {
"resource": ""
} |
q23799 | UnloadKeys | train | func (a *LocalKeyAgent) UnloadKeys() error {
agents := []agent.Agent{a.Agent}
if a.sshAgent != nil {
agents = append(agents, a.sshAgent)
}
// iterate over all agents we have
for i, _ := range agents {
// get a list of all keys in the agent
keyList, err := agents[i].List()
if err != nil {
a.log.Warnf("U... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.