_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23300 | readTrustedClusters | train | func readTrustedClusters(clusters []TrustedCluster, conf *service.Config) error {
if len(clusters) == 0 {
return nil
}
// go over all trusted clusters:
for i := range clusters {
tc := &clusters[i]
// parse "allow_logins"
var allowedLogins []string
for _, login := range strings.Split(tc.AllowedLogins, ",")... | go | {
"resource": ""
} |
q23301 | applyString | train | func applyString(src string, target *string) bool {
if src != "" {
*target = src
return true
}
return false
} | go | {
"resource": ""
} |
q23302 | applyListenIP | train | func applyListenIP(ip net.IP, cfg *service.Config) {
listeningAddresses := []*utils.NetAddr{
&cfg.Auth.SSHAddr,
&cfg.Auth.SSHAddr,
&cfg.Proxy.SSHAddr,
&cfg.Proxy.WebAddr,
&cfg.SSH.Addr,
&cfg.Proxy.ReverseTunnelListenAddr,
}
for _, addr := range listeningAddresses {
replaceHost(addr, ip.String())
}
} | go | {
"resource": ""
} |
q23303 | replaceHost | train | func replaceHost(addr *utils.NetAddr, newHost string) {
_, port, err := net.SplitHostPort(addr.Addr)
if err != nil {
log.Errorf("failed parsing address: '%v'", addr.Addr)
}
addr.Addr = net.JoinHostPort(newHost, port)
} | go | {
"resource": ""
} |
q23304 | MarshalJSON | train | func (d Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(fmt.Sprintf("%v", d.Duration))
} | go | {
"resource": ""
} |
q23305 | initializeTOTP | train | func (s *AuthServer) initializeTOTP(accountName string) (key string, qr []byte, err error) {
// create totp key
otpKey, err := totp.Generate(totp.GenerateOpts{
Issuer: "Teleport",
AccountName: accountName,
})
if err != nil {
return "", nil, trace.Wrap(err)
}
// create QR code
var otpQRBuf bytes.Buffe... | go | {
"resource": ""
} |
q23306 | rotateAndFetchSignupToken | train | func (s *AuthServer) rotateAndFetchSignupToken(token string) (*services.SignupToken, error) {
var err error
// Fetch original signup token.
st, err := s.GetSignupToken(token)
if err != nil {
return nil, trace.Wrap(err)
}
// Generate and set new OTP code for user in *services.SignupToken.
accountName := st.Us... | go | {
"resource": ""
} |
q23307 | CreateUserWithOTP | train | func (s *AuthServer) CreateUserWithOTP(token string, password string, otpToken string) (services.WebSession, error) {
tokenData, err := s.GetSignupToken(token)
if err != nil {
log.Debugf("failed to get signup token: %v", err)
return nil, trace.AccessDenied("expired or incorrect signup token")
}
err = s.UpsertT... | go | {
"resource": ""
} |
q23308 | CreateUserWithoutOTP | train | func (s *AuthServer) CreateUserWithoutOTP(token string, password string) (services.WebSession, error) {
authPreference, err := s.GetAuthPreference()
if err != nil {
return nil, trace.Wrap(err)
}
if authPreference.GetSecondFactor() != teleport.OFF {
return nil, trace.AccessDenied("missing second factor")
}
tok... | go | {
"resource": ""
} |
q23309 | NewStaticTokens | train | func NewStaticTokens(spec StaticTokensSpecV2) (StaticTokens, error) {
st := StaticTokensV2{
Kind: KindStaticTokens,
Version: V2,
Metadata: Metadata{
Name: MetaNameStaticTokens,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := st.CheckAndSetDefaults(); err != nil {
return nil, trace... | go | {
"resource": ""
} |
q23310 | GetStaticTokensSchema | train | func GetStaticTokensSchema(extensionSchema string) string {
var staticTokensSchema string
if staticTokensSchema == "" {
staticTokensSchema = fmt.Sprintf(StaticTokensSpecSchemaTemplate, "")
} else {
staticTokensSchema = fmt.Sprintf(StaticTokensSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2Sche... | go | {
"resource": ""
} |
q23311 | Unmarshal | train | func (t *TeleportStaticTokensMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (StaticTokens, error) {
var staticTokens StaticTokensV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cf... | go | {
"resource": ""
} |
q23312 | Marshal | train | func (t *TeleportStaticTokensMarshaler) Marshal(c StaticTokens, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *StaticTokensV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
/... | go | {
"resource": ""
} |
q23313 | DeleteAllCertAuthorities | train | func (s *CA) DeleteAllCertAuthorities(caType services.CertAuthType) error {
startKey := backend.Key(authoritiesPrefix, string(caType))
return s.DeleteRange(context.TODO(), startKey, backend.RangeEnd(startKey))
} | go | {
"resource": ""
} |
q23314 | CreateCertAuthority | train | func (s *CA) CreateCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, s... | go | {
"resource": ""
} |
q23315 | UpsertCertAuthority | train | func (s *CA) UpsertCertAuthority(ca services.CertAuthority) error {
if err := ca.Check(); err != nil {
return trace.Wrap(err)
}
value, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(ca)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authoritiesPrefix, s... | go | {
"resource": ""
} |
q23316 | CompareAndSwapCertAuthority | train | func (s *CA) CompareAndSwapCertAuthority(new, existing services.CertAuthority) error {
if err := new.Check(); err != nil {
return trace.Wrap(err)
}
newValue, err := services.GetCertAuthorityMarshaler().MarshalCertAuthority(new)
if err != nil {
return trace.Wrap(err)
}
newItem := backend.Item{
Key: backe... | go | {
"resource": ""
} |
q23317 | DeleteCertAuthority | train | func (s *CA) DeleteCertAuthority(id services.CertAuthID) error {
if err := id.Check(); err != nil {
return trace.Wrap(err)
}
// when removing a services.CertAuthority also remove any deactivated
// services.CertAuthority as well if they exist.
err := s.Delete(context.TODO(), backend.Key(authoritiesPrefix, deacti... | go | {
"resource": ""
} |
q23318 | ActivateCertAuthority | train | func (s *CA) ActivateCertAuthority(id services.CertAuthID) error {
item, err := s.Get(context.TODO(), backend.Key(authoritiesPrefix, deactivatedPrefix, string(id.Type), id.DomainName))
if err != nil {
if trace.IsNotFound(err) {
return trace.BadParameter("can not activate cert authority %q which has not been deac... | go | {
"resource": ""
} |
q23319 | DeactivateCertAuthority | train | func (s *CA) DeactivateCertAuthority(id services.CertAuthID) error {
certAuthority, err := s.GetCertAuthority(id, true)
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("can not deactivate cert authority %q which does not exist", id.DomainName)
}
return trace.Wrap(err)
}
err = s.DeleteCert... | go | {
"resource": ""
} |
q23320 | newSession | train | func newSession(client *NodeClient,
joinSession *session.Session,
env map[string]string,
stdin io.Reader,
stdout io.Writer,
stderr io.Writer) (*NodeSession, error) {
if stdin == nil {
stdin = os.Stdin
}
if stdout == nil {
stdout = os.Stdout
}
if stderr == nil {
stderr = os.Stderr
}
if env == nil {
... | go | {
"resource": ""
} |
q23321 | interactiveSession | train | func (ns *NodeSession) interactiveSession(callback interactiveCallback) error {
// determine what kind of a terminal we need
termType := os.Getenv("TERM")
if termType == "" {
termType = teleport.SafeTerminalType
}
// create the server-side session:
sess, err := ns.createServerSession()
if err != nil {
return... | go | {
"resource": ""
} |
q23322 | runShell | train | func (ns *NodeSession) runShell(callback ShellCreatedCallback) error {
return ns.interactiveSession(func(s *ssh.Session, shell io.ReadWriteCloser) error {
// start the shell on the server:
if err := s.Shell(); err != nil {
return trace.Wrap(err)
}
// call the client-supplied callback
if callback != nil {
... | go | {
"resource": ""
} |
q23323 | watchSignals | train | func (ns *NodeSession) watchSignals(shell io.Writer) {
exitSignals := make(chan os.Signal, 1)
// catch SIGTERM
signal.Notify(exitSignals, syscall.SIGTERM)
go func() {
defer ns.closer.Close()
<-exitSignals
}()
// Catch Ctrl-C signal
ctrlCSignal := make(chan os.Signal, 1)
signal.Notify(ctrlCSignal, syscall.SI... | go | {
"resource": ""
} |
q23324 | CheckAndSetDefaults | train | func (c *Config) CheckAndSetDefaults() error {
if c.Listener == nil {
return trace.BadParameter("missing parameter Listener")
}
if c.Context == nil {
c.Context = context.TODO()
}
if c.ReadDeadline == 0 {
c.ReadDeadline = defaults.ReadHeadersTimeout
}
if c.Clock == nil {
c.Clock = clockwork.NewRealClock()... | go | {
"resource": ""
} |
q23325 | New | train | func New(cfg Config) (*Mux, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
waitContext, waitCancel := context.WithCancel(context.TODO())
return &Mux{
Entry: log.WithFields(log.Fields{
trace.Component: teleport.Componen... | go | {
"resource": ""
} |
q23326 | Serve | train | func (m *Mux) Serve() error {
defer m.waitCancel()
backoffTimer := time.NewTicker(5 * time.Second)
defer backoffTimer.Stop()
for {
conn, err := m.Listener.Accept()
if err == nil {
if tcpConn, ok := conn.(*net.TCPConn); ok {
tcpConn.SetKeepAlive(true)
tcpConn.SetKeepAlivePeriod(3 * time.Minute)
}
... | go | {
"resource": ""
} |
q23327 | SendKeepAlives | train | func (g *GRPCServer) SendKeepAlives(stream proto.AuthService_SendKeepAlivesServer) error {
defer stream.SendAndClose(&empty.Empty{})
auth, err := g.authenticate(stream.Context())
if err != nil {
return trail.ToGRPC(err)
}
g.Debugf("Got heartbeat connection from %v.", auth.User.GetName())
for {
keepAlive, err ... | go | {
"resource": ""
} |
q23328 | WatchEvents | train | func (g *GRPCServer) WatchEvents(watch *proto.Watch, stream proto.AuthService_WatchEventsServer) error {
auth, err := g.authenticate(stream.Context())
if err != nil {
return trail.ToGRPC(err)
}
servicesWatch := services.Watch{
Name: auth.User.GetName(),
}
for _, kind := range watch.Kinds {
servicesWatch.Kin... | go | {
"resource": ""
} |
q23329 | UpsertNode | train | func (g *GRPCServer) UpsertNode(ctx context.Context, server *services.ServerV2) (*services.KeepAlive, error) {
auth, err := g.authenticate(ctx)
if err != nil {
return nil, trail.ToGRPC(err)
}
keepAlive, err := auth.UpsertNode(server)
if err != nil {
return nil, trail.ToGRPC(err)
}
return keepAlive, nil
} | go | {
"resource": ""
} |
q23330 | authenticate | train | func (g *GRPCServer) authenticate(ctx context.Context) (*grpcContext, error) {
// HTTPS server expects auth context to be set by the auth middleware
authContext, err := g.Authorizer.Authorize(ctx)
if err != nil {
// propagate connection problem error so we can differentiate
// between connection failed and acce... | go | {
"resource": ""
} |
q23331 | NewGRPCServer | train | func NewGRPCServer(cfg APIConfig) http.Handler {
authServer := &GRPCServer{
APIConfig: cfg,
Entry: logrus.WithFields(logrus.Fields{
trace.Component: teleport.Component(teleport.ComponentAuth, teleport.ComponentGRPC),
}),
httpHandler: NewAPIServer(&cfg),
grpcHandler: grpc.NewServer(),
}
proto.RegisterAut... | go | {
"resource": ""
} |
q23332 | ServeHTTP | train | func (g *GRPCServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// magic combo match signifying GRPC request
// https://grpc.io/blog/coreos
if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
g.grpcHandler.ServeHTTP(w, r)
} else {
g.httpHandler.ServeHTTP(w, r)
... | go | {
"resource": ""
} |
q23333 | Start | train | func (t *proxySitesSubsys) Start(sconn *ssh.ServerConn, ch ssh.Channel, req *ssh.Request, ctx *srv.ServerContext) error {
log.Debugf("proxysites.start(%v)", ctx)
remoteSites := t.srv.proxyTun.GetSites()
// build an arary of services.Site structures:
retval := make([]services.Site, 0, len(remoteSites))
for _, s :=... | go | {
"resource": ""
} |
q23334 | Close | train | func (m *MultiLog) Close() error {
var errors []error
for _, log := range m.loggers {
errors = append(errors, log.Close())
}
return trace.NewAggregate(errors...)
} | go | {
"resource": ""
} |
q23335 | FindServersByLabels | train | func (proxy *ProxyClient) FindServersByLabels(ctx context.Context, namespace string, labels map[string]string) ([]services.Server, error) {
if namespace == "" {
return nil, trace.BadParameter(auth.MissingNamespaceError)
}
nodes := make([]services.Server, 0)
site, err := proxy.CurrentClusterAccessPoint(ctx, false)... | go | {
"resource": ""
} |
q23336 | CurrentClusterAccessPoint | train | func (proxy *ProxyClient) CurrentClusterAccessPoint(ctx context.Context, quiet bool) (auth.AccessPoint, error) {
// get the current cluster:
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ClusterAccessPoint(ctx, cluster.Name, quiet)
} | go | {
"resource": ""
} |
q23337 | ClusterAccessPoint | train | func (proxy *ProxyClient) ClusterAccessPoint(ctx context.Context, clusterName string, quiet bool) (auth.AccessPoint, error) {
if clusterName == "" {
return nil, trace.BadParameter("parameter clusterName is missing")
}
clt, err := proxy.ConnectToCluster(ctx, clusterName, quiet)
if err != nil {
return nil, trace.... | go | {
"resource": ""
} |
q23338 | ConnectToCurrentCluster | train | func (proxy *ProxyClient) ConnectToCurrentCluster(ctx context.Context, quiet bool) (auth.ClientI, error) {
cluster, err := proxy.currentCluster()
if err != nil {
return nil, trace.Wrap(err)
}
return proxy.ConnectToCluster(ctx, cluster.Name, quiet)
} | go | {
"resource": ""
} |
q23339 | ConnectToCluster | train | func (proxy *ProxyClient) ConnectToCluster(ctx context.Context, clusterName string, quiet bool) (auth.ClientI, error) {
dialer := func(ctx context.Context, network, _ string) (net.Conn, error) {
return proxy.dialAuthServer(ctx, clusterName)
}
if proxy.teleportClient.SkipLocalAuth {
return auth.NewTLSClient(auth... | go | {
"resource": ""
} |
q23340 | addCloser | train | func (c *closerConn) addCloser(closer io.Closer) {
c.closers = append(c.closers, closer)
} | go | {
"resource": ""
} |
q23341 | nodeName | train | func nodeName(node string) string {
n, _, err := net.SplitHostPort(node)
if err != nil {
return node
}
return n
} | go | {
"resource": ""
} |
q23342 | isRecordingProxy | train | func (proxy *ProxyClient) isRecordingProxy() (bool, error) {
responseCh := make(chan proxyResponse)
// we have to run this in a goroutine because older version of Teleport handled
// global out-of-band requests incorrectly: Teleport would ignore requests it
// does not know about and never reply to them. So if we ... | go | {
"resource": ""
} |
q23343 | dialAuthServer | train | func (proxy *ProxyClient) dialAuthServer(ctx context.Context, clusterName string) (net.Conn, error) {
log.Debugf("Client %v is connecting to auth server on cluster %q.", proxy.clientAddr, clusterName)
address := "@" + clusterName
// parse destination first:
localAddr, err := utils.ParseAddr("tcp://" + proxy.proxy... | go | {
"resource": ""
} |
q23344 | newClientConn | train | func newClientConn(ctx context.Context,
conn net.Conn,
nodeAddress string,
config *ssh.ClientConfig) (ssh.Conn, <-chan ssh.NewChannel, <-chan *ssh.Request, error) {
type response struct {
conn ssh.Conn
chanCh <-chan ssh.NewChannel
reqCh <-chan *ssh.Request
err error
}
respCh := make(chan response,... | go | {
"resource": ""
} |
q23345 | listenAndForward | train | func (c *NodeClient) listenAndForward(ctx context.Context, ln net.Listener, remoteAddr string) {
defer ln.Close()
defer c.Close()
for {
// Accept connections from the client.
conn, err := ln.Accept()
if err != nil {
log.Errorf("Port forwarding failed: %v.", err)
break
}
// Proxy the connection to t... | go | {
"resource": ""
} |
q23346 | dynamicListenAndForward | train | func (c *NodeClient) dynamicListenAndForward(ctx context.Context, ln net.Listener) {
defer ln.Close()
defer c.Close()
for {
// Accept connection from the client. Here the client is typically
// something like a web browser or other SOCKS5 aware application.
conn, err := ln.Accept()
if err != nil {
log.Er... | go | {
"resource": ""
} |
q23347 | currentCluster | train | func (proxy *ProxyClient) currentCluster() (*services.Site, error) {
sites, err := proxy.GetSites()
if err != nil {
return nil, trace.Wrap(err)
}
if len(sites) == 0 {
return nil, trace.NotFound("no clusters registered")
}
if proxy.siteName == "" {
return &sites[0], nil
}
for _, site := range sites {
if ... | go | {
"resource": ""
} |
q23348 | CreateDownloadCommand | train | func CreateDownloadCommand(cfg Config) (Command, error) {
cfg.Flags.Sink = true
cfg.Flags.Source = false
cmd, err := CreateCommand(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
return cmd, nil
} | go | {
"resource": ""
} |
q23349 | CreateCommand | train | func CreateCommand(cfg Config) (Command, error) {
err := cfg.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
cmd := command{
Config: cfg,
}
cmd.log = log.WithFields(log.Fields{
trace.Component: "SCP",
trace.ComponentFields: log.Fields{
"LocalAddr": cfg.Flags.LocalAddr,
"Re... | go | {
"resource": ""
} |
q23350 | sendError | train | func (cmd *command) sendError(ch io.ReadWriter, err error) error {
if err == nil {
return nil
}
cmd.log.Error(err)
message := err.Error()
bytes := make([]byte, 0, len(message)+2)
bytes = append(bytes, ErrByte)
bytes = append(bytes, message...)
bytes = append(bytes, []byte{'\n'}...)
_, writeErr := ch.Write(by... | go | {
"resource": ""
} |
q23351 | read | train | func (r *reader) read() error {
n, err := r.r.Read(r.b)
if err != nil {
return trace.Wrap(err)
}
if n < 1 {
return trace.Errorf("unexpected error, read 0 bytes")
}
switch r.b[0] {
case OKByte:
return nil
case WarnByte, ErrByte:
r.s.Scan()
if err := r.s.Err(); err != nil {
return trace.Wrap(err)
... | go | {
"resource": ""
} |
q23352 | AddKey | train | func (fs *FSLocalKeyStore) AddKey(host, username string, key *Key) error {
dirPath, err := fs.dirFor(host, true)
if err != nil {
return trace.Wrap(err)
}
writeBytes := func(fname string, data []byte) error {
fp := filepath.Join(dirPath, fname)
err := ioutil.WriteFile(fp, data, keyFilePerms)
if err != nil {
... | go | {
"resource": ""
} |
q23353 | DeleteKey | train | func (fs *FSLocalKeyStore) DeleteKey(host string, username string) error {
dirPath, err := fs.dirFor(host, false)
if err != nil {
return trace.Wrap(err)
}
files := []string{
filepath.Join(dirPath, username+fileExtCert),
filepath.Join(dirPath, username+fileExtTLSCert),
filepath.Join(dirPath, username+fileExt... | go | {
"resource": ""
} |
q23354 | DeleteKeys | train | func (fs *FSLocalKeyStore) DeleteKeys() error {
dirPath := filepath.Join(fs.KeyDir, sessionKeyDir)
err := os.RemoveAll(dirPath)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23355 | GetKey | train | func (fs *FSLocalKeyStore) GetKey(proxyHost string, username string) (*Key, error) {
dirPath, err := fs.dirFor(proxyHost, false)
if err != nil {
return nil, trace.Wrap(err)
}
_, err = ioutil.ReadDir(dirPath)
if err != nil {
return nil, trace.NotFound("no session keys for %v in %v", username, proxyHost)
}
ce... | go | {
"resource": ""
} |
q23356 | SaveCerts | train | func (fs *FSLocalKeyStore) SaveCerts(proxy string, cas []auth.TrustedCerts) error {
dir, err := fs.dirFor(proxy, true)
if err != nil {
return trace.Wrap(err)
}
fp, err := os.OpenFile(filepath.Join(dir, fileNameTLSCerts), os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0640)
if err != nil {
return trace.Wrap(err)
}
defer f... | go | {
"resource": ""
} |
q23357 | GetCertsPEM | train | func (fs *FSLocalKeyStore) GetCertsPEM(proxy string) ([]byte, error) {
dir, err := fs.dirFor(proxy, false)
if err != nil {
return nil, trace.Wrap(err)
}
return ioutil.ReadFile(filepath.Join(dir, fileNameTLSCerts))
} | go | {
"resource": ""
} |
q23358 | GetCerts | train | func (fs *FSLocalKeyStore) GetCerts(proxy string) (*x509.CertPool, error) {
dir, err := fs.dirFor(proxy, false)
if err != nil {
return nil, trace.Wrap(err)
}
bytes, err := ioutil.ReadFile(filepath.Join(dir, fileNameTLSCerts))
if err != nil {
return nil, trace.ConvertSystemError(err)
}
pool := x509.NewCertPoo... | go | {
"resource": ""
} |
q23359 | AddKnownHostKeys | train | func (fs *FSLocalKeyStore) AddKnownHostKeys(hostname string, hostKeys []ssh.PublicKey) error {
fp, err := os.OpenFile(filepath.Join(fs.KeyDir, fileNameKnownHosts), os.O_CREATE|os.O_RDWR, 0640)
if err != nil {
return trace.Wrap(err)
}
defer fp.Sync()
defer fp.Close()
// read all existing entries into a map (this... | go | {
"resource": ""
} |
q23360 | GetKnownHostKeys | train | func (fs *FSLocalKeyStore) GetKnownHostKeys(hostname string) ([]ssh.PublicKey, error) {
bytes, err := ioutil.ReadFile(filepath.Join(fs.KeyDir, fileNameKnownHosts))
if err != nil {
if os.IsNotExist(err) {
return nil, nil
}
return nil, trace.Wrap(err)
}
var (
pubKey ssh.PublicKey
retval []ssh.Publi... | go | {
"resource": ""
} |
q23361 | Initialize | train | func (c *NodeCommand) Initialize(app *kingpin.Application, config *service.Config) {
c.config = config
// add node command
nodes := app.Command("nodes", "Issue invites for other nodes to join the cluster")
c.nodeAdd = nodes.Command("add", "Generate a node invitation token")
c.nodeAdd.Flag("roles", "Comma-separate... | go | {
"resource": ""
} |
q23362 | Invite | train | func (c *NodeCommand) Invite(client auth.ClientI) error {
// parse --roles flag
roles, err := teleport.ParseRoles(c.roles)
if err != nil {
return trace.Wrap(err)
}
token, err := client.GenerateToken(auth.GenerateTokenRequest{Roles: roles, TTL: c.ttl, Token: c.token})
if err != nil {
return trace.Wrap(err)
}
... | go | {
"resource": ""
} |
q23363 | ListActive | train | func (c *NodeCommand) ListActive(client auth.ClientI) error {
nodes, err := client.GetNodes(c.namespace, services.SkipValidation())
if err != nil {
return trace.Wrap(err)
}
coll := &serverCollection{servers: nodes}
coll.writeText(os.Stdout)
return nil
} | go | {
"resource": ""
} |
q23364 | GetTokenFromHOTPMockFile | train | func GetTokenFromHOTPMockFile(path string) (token string, e error) {
otp, err := LoadHOTPMockFromFile(path)
if err != nil {
return "", trace.Wrap(err)
}
token = otp.OTP()
err = otp.SaveToFile(path)
if err != nil {
return "", trace.Wrap(err)
}
return token, nil
} | go | {
"resource": ""
} |
q23365 | useProxy | train | func useProxy(addr string) bool {
if len(addr) == 0 {
return true
}
var noProxy string
for _, env := range []string{teleport.NoProxy, strings.ToLower(teleport.NoProxy)} {
noProxy = os.Getenv(env)
if noProxy != "" {
break
}
}
if noProxy == "" {
return true
}
if noProxy == "*" {
return false
}
... | go | {
"resource": ""
} |
q23366 | Dial | train | func Dial(socket string) (net.Conn, error) {
conn, err := winio.DialPipe(defaults.WindowsOpenSSHNamedPipe, nil)
if err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | go | {
"resource": ""
} |
q23367 | Infoln | train | func (g *GLogger) Infoln(args ...interface{}) {
// GRPC is very verbose, so this is intentionally
// pushes info level statements as Teleport's debug level ones
g.Entry.Debug(fmt.Sprintln(args...))
} | go | {
"resource": ""
} |
q23368 | Infof | train | func (g *GLogger) Infof(format string, args ...interface{}) {
// GRPC is very verbose, so this is intentionally
// pushes info level statements as Teleport's debug level ones
g.Entry.Debugf(format, args...)
} | go | {
"resource": ""
} |
q23369 | Warningln | train | func (g *GLogger) Warningln(args ...interface{}) {
g.Entry.Warning(fmt.Sprintln(args...))
} | go | {
"resource": ""
} |
q23370 | Warningf | train | func (g *GLogger) Warningf(format string, args ...interface{}) {
g.Entry.Warningf(format, args...)
} | go | {
"resource": ""
} |
q23371 | Errorln | train | func (g *GLogger) Errorln(args ...interface{}) {
g.Entry.Error(fmt.Sprintln(args...))
} | go | {
"resource": ""
} |
q23372 | Handshake | train | func Handshake(conn net.Conn) (string, error) {
// Read in the version and reject anything other than SOCKS5.
version, err := readByte(conn)
if err != nil {
return "", trace.Wrap(err)
}
if version != socks5Version {
return "", trace.BadParameter("only SOCKS5 is supported")
}
// Read in the authentication me... | go | {
"resource": ""
} |
q23373 | readAuthenticationMethod | train | func readAuthenticationMethod(conn net.Conn) ([]byte, error) {
// Read in the number of authentication methods supported.
nmethods, err := readByte(conn)
if err != nil {
return nil, trace.Wrap(err)
}
// Read nmethods number of bytes from the connection return the list of
// supported authentication methods to ... | go | {
"resource": ""
} |
q23374 | writeMethodSelection | train | func writeMethodSelection(conn net.Conn) error {
message := []byte{socks5Version, socks5AuthNotRequired}
n, err := conn.Write(message)
if err != nil {
return trace.Wrap(err)
}
if n != len(message) {
return trace.BadParameter("wrote: %v wanted to write: %v", n, len(message))
}
return nil
} | go | {
"resource": ""
} |
q23375 | readAddrType | train | func readAddrType(conn net.Conn) (int, error) {
// Read in the type of the remote host.
addrType, err := readByte(conn)
if err != nil {
return 0, trace.Wrap(err)
}
// Based off the type, determine how many more bytes to read in for the
// remote address. For IPv4 it's 4 bytes, for IPv6 it's 16, and for domain
... | go | {
"resource": ""
} |
q23376 | writeReply | train | func writeReply(conn net.Conn) error {
// Write success reply, similar to OpenSSH only success is written.
// https://github.com/openssh/openssh-portable/blob/5d14019/channels.c#L1442-L1452
message := []byte{
socks5Version,
socks5Succeeded,
socks5Reserved,
socks5AddressTypeIPv4,
}
n, err := conn.Write(mess... | go | {
"resource": ""
} |
q23377 | readByte | train | func readByte(conn net.Conn) (byte, error) {
b := make([]byte, 1)
_, err := io.ReadFull(conn, b)
if err != nil {
return 0, trace.Wrap(err)
}
return b[0], nil
} | go | {
"resource": ""
} |
q23378 | byteSliceContains | train | func byteSliceContains(a []byte, b byte) bool {
for _, v := range a {
if v == b {
return true
}
}
return false
} | go | {
"resource": ""
} |
q23379 | GetLoginShell | train | func GetLoginShell(username string) (string, error) {
var err error
var shellcmd string
shellcmd, err = getLoginShell(username)
if err != nil {
if !trace.IsNotFound(err) {
logrus.Warnf("No shell specified for %v, using default %v.", username, DefaultShell)
return DefaultShell, nil
}
return "", trace.Wr... | go | {
"resource": ""
} |
q23380 | GetRoles | train | func (s *InstanceSecrets) GetRoles() []services.Role {
var roles []services.Role
for _, ca := range s.GetCAs() {
if ca.GetType() != services.UserCA {
continue
}
role := services.RoleForCertAuthority(ca)
role.SetLogins(services.Allow, s.AllowedLogins())
roles = append(roles, role)
}
return roles
} | go | {
"resource": ""
} |
q23381 | SetupUserCreds | train | func SetupUserCreds(tc *client.TeleportClient, proxyHost string, creds UserCreds) error {
_, err := tc.AddKey(proxyHost, &creds.Key)
if err != nil {
return trace.Wrap(err)
}
err = tc.AddTrustedCA(creds.HostCA)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23382 | SetupUser | train | func SetupUser(process *service.TeleportProcess, username string, roles []services.Role) error {
auth := process.GetAuthServer()
teleUser, err := services.NewUser(username)
if err != nil {
return trace.Wrap(err)
}
if len(roles) == 0 {
role := services.RoleForUser(teleUser)
role.SetLogins(services.Allow, []st... | go | {
"resource": ""
} |
q23383 | GenerateUserCreds | train | func GenerateUserCreds(process *service.TeleportProcess, username string) (*UserCreds, error) {
priv, pub, err := testauthority.New().GenerateKeyPair("")
if err != nil {
return nil, trace.Wrap(err)
}
a := process.GetAuthServer()
sshCert, x509Cert, err := a.GenerateUserCerts(pub, username, time.Hour, teleport.Cer... | go | {
"resource": ""
} |
q23384 | StartNode | train | func (i *TeleInstance) StartNode(tconf *service.Config) (*service.TeleportProcess, error) {
dataDir, err := ioutil.TempDir("", "cluster-"+i.Secrets.SiteName)
if err != nil {
return nil, trace.Wrap(err)
}
tconf.DataDir = dataDir
authServer := utils.MustParseAddr(net.JoinHostPort(i.Hostname, i.GetPortAuth()))
tc... | go | {
"resource": ""
} |
q23385 | StartNodeAndProxy | train | func (i *TeleInstance) StartNodeAndProxy(name string, sshPort, proxyWebPort, proxySSHPort int) error {
dataDir, err := ioutil.TempDir("", "cluster-"+i.Secrets.SiteName)
if err != nil {
return trace.Wrap(err)
}
tconf := service.MakeDefaultConfig()
authServer := utils.MustParseAddr(net.JoinHostPort(i.Hostname, i... | go | {
"resource": ""
} |
q23386 | StartProxy | train | func (i *TeleInstance) StartProxy(cfg ProxyConfig) error {
dataDir, err := ioutil.TempDir("", "cluster-"+i.Secrets.SiteName+"-"+cfg.Name)
if err != nil {
return trace.Wrap(err)
}
tconf := service.MakeDefaultConfig()
authServer := utils.MustParseAddr(net.JoinHostPort(i.Hostname, i.GetPortAuth()))
tconf.AuthSer... | go | {
"resource": ""
} |
q23387 | Reset | train | func (i *TeleInstance) Reset() (err error) {
i.Process, err = service.NewTeleport(i.Config)
if err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23388 | AddUserWithRole | train | func (i *TeleInstance) AddUserWithRole(username string, role services.Role) *User {
user := &User{
Username: username,
Roles: []services.Role{role},
}
i.Secrets.Users[username] = user
return user
} | go | {
"resource": ""
} |
q23389 | AddUser | train | func (i *TeleInstance) AddUser(username string, mappings []string) *User {
log.Infof("teleInstance.AddUser(%v) mapped to %v", username, mappings)
if mappings == nil {
mappings = make([]string, 0)
}
user := &User{
Username: username,
AllowedLogins: mappings,
}
i.Secrets.Users[username] = user
return us... | go | {
"resource": ""
} |
q23390 | Start | train | func (i *TeleInstance) Start() error {
// Build a list of expected events to wait for before unblocking based off
// the configuration passed in.
expectedEvents := []string{}
if i.Config.Auth.Enabled {
expectedEvents = append(expectedEvents, service.AuthTLSReady)
}
if i.Config.Proxy.Enabled {
expectedEvents =... | go | {
"resource": ""
} |
q23391 | NewClientWithCreds | train | func (i *TeleInstance) NewClientWithCreds(cfg ClientConfig, creds UserCreds) (tc *client.TeleportClient, err error) {
clt, err := i.NewUnauthenticatedClient(cfg)
if err != nil {
return nil, trace.Wrap(err)
}
err = SetupUserCreds(clt, i.Config.Proxy.SSHAddr.Addr, creds)
if err != nil {
return nil, trace.Wrap(er... | go | {
"resource": ""
} |
q23392 | StopProxy | train | func (i *TeleInstance) StopProxy() error {
var errors []error
for _, p := range i.Nodes {
if p.Config.Proxy.Enabled {
if err := p.Close(); err != nil {
errors = append(errors, err)
log.Errorf("Failed closing extra proxy: %v.", err)
}
if err := p.Wait(); err != nil {
errors = append(errors, err... | go | {
"resource": ""
} |
q23393 | StopNodes | train | func (i *TeleInstance) StopNodes() error {
var errors []error
for _, node := range i.Nodes {
if err := node.Close(); err != nil {
errors = append(errors, err)
log.Errorf("failed closing extra node %v", err)
}
if err := node.Wait(); err != nil {
errors = append(errors, err)
log.Errorf("failed stoppin... | go | {
"resource": ""
} |
q23394 | ServeHTTP | train | func (p *proxyServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Validate http connect parameters.
if r.Method != http.MethodConnect {
trace.WriteError(w, trace.BadParameter("%v not supported", r.Method))
return
}
if r.Host == "" {
trace.WriteError(w, trace.BadParameter("host not set"))
return
... | go | {
"resource": ""
} |
q23395 | Count | train | func (p *proxyServer) Count() int {
p.Lock()
defer p.Unlock()
return p.count
} | go | {
"resource": ""
} |
q23396 | createAgent | train | func createAgent(me *user.User, privateKeyByte []byte, certificateBytes []byte) (*teleagent.AgentServer, string, string, error) {
// create a path to the unix socket
sockDir, err := ioutil.TempDir("", "int-test")
if err != nil {
return nil, "", "", trace.Wrap(err)
}
sockPath := filepath.Join(sockDir, "agent.sock... | go | {
"resource": ""
} |
q23397 | SetClock | train | func SetClock(clock clockwork.Clock) KeygenOption {
return func(k *Keygen) error {
k.clock = clock
return nil
}
} | go | {
"resource": ""
} |
q23398 | PrecomputeKeys | train | func PrecomputeKeys(count int) KeygenOption {
return func(k *Keygen) error {
k.precomputeCount = count
return nil
}
} | go | {
"resource": ""
} |
q23399 | New | train | func New(ctx context.Context, opts ...KeygenOption) (*Keygen, error) {
ctx, cancel := context.WithCancel(ctx)
k := &Keygen{
ctx: ctx,
cancel: cancel,
precomputeCount: PrecomputedNum,
clock: clockwork.NewRealClock(),
}
for _, opt := range opts {
if err := opt(k); err != nil {... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.