_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q23500 | MakeHeadlessTable | train | func MakeHeadlessTable(columnCount int) Table {
return Table{
columns: make([]column, columnCount),
rows: make([][]string, 0),
}
} | go | {
"resource": ""
} |
q23501 | AddRow | train | func (t *Table) AddRow(row []string) {
limit := min(len(row), len(t.columns))
for i := 0; i < limit; i++ {
cellWidth := len(row[i])
t.columns[i].width = max(cellWidth, t.columns[i].width)
}
t.rows = append(t.rows, row[:limit])
} | go | {
"resource": ""
} |
q23502 | IsHeadless | train | func (t *Table) IsHeadless() bool {
total := 0
for i := range t.columns {
total += len(t.columns[i].title)
}
return total == 0
} | go | {
"resource": ""
} |
q23503 | ParseSessionsURI | train | func ParseSessionsURI(in string) (*url.URL, error) {
if in == "" {
return nil, trace.BadParameter("uri is empty")
}
u, err := url.Parse(in)
if err != nil {
return nil, trace.BadParameter("failed to parse URI %q: %v", in, err)
}
if u.Scheme == "" {
u.Scheme = teleport.SchemeFile
}
return u, nil
} | go | {
"resource": ""
} |
q23504 | GetIterations | train | func GetIterations() int {
out := os.Getenv(teleport.IterationsEnvVar)
if out == "" {
return 1
}
iter, err := strconv.Atoi(out)
if err != nil {
panic(err)
}
log.Debugf("Starting tests with %v iterations.", iter)
return iter
} | go | {
"resource": ""
} |
q23505 | UserMessageFromError | train | func UserMessageFromError(err error) string {
// untrusted cert?
switch innerError := trace.Unwrap(err).(type) {
case x509.HostnameError:
return fmt.Sprintf("Cannot establish https connection to %s:\n%s\n%s\n",
innerError.Host,
innerError.Error(),
"try a different hostname for --proxy or specify --insecur... | go | {
"resource": ""
} |
q23506 | InitCLIParser | train | func InitCLIParser(appName, appHelp string) (app *kingpin.Application) {
app = kingpin.New(appName, appHelp)
// hide "--help" flag
app.HelpFlag.Hidden()
app.HelpFlag.NoEnvar()
// set our own help template
return app.UsageTemplate(defaultUsageTemplate)
} | go | {
"resource": ""
} |
q23507 | needsQuoting | train | func needsQuoting(text string) bool {
for _, r := range text {
if !strconv.IsPrint(r) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q23508 | MakeServers | train | func MakeServers(clusterName string, servers []services.Server) []Server {
uiServers := []Server{}
for _, server := range servers {
uiLabels := []Label{}
serverLabels := server.GetLabels()
for name, value := range serverLabels {
uiLabels = append(uiLabels, Label{
Name: name,
Value: value,
})
}
... | go | {
"resource": ""
} |
q23509 | printShutdownStatus | train | func (process *TeleportProcess) printShutdownStatus(ctx context.Context) {
t := time.NewTicker(defaults.HighResReportingPeriod)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
log.Infof("Waiting for services: %v to finish.", process.Supervisor.Services())
}
}
} | go | {
"resource": ""
} |
q23510 | closeImportedDescriptors | train | func (process *TeleportProcess) closeImportedDescriptors(prefix string) error {
process.Lock()
defer process.Unlock()
var errors []error
for i := range process.importedDescriptors {
d := process.importedDescriptors[i]
if strings.HasPrefix(d.Type, prefix) {
process.Infof("Closing imported but unused descript... | go | {
"resource": ""
} |
q23511 | importListener | train | func (process *TeleportProcess) importListener(listenerType, address string) (net.Listener, error) {
process.Lock()
defer process.Unlock()
for i := range process.importedDescriptors {
d := process.importedDescriptors[i]
if d.Type == listenerType && d.Address == address {
l, err := d.ToListener()
if err !=... | go | {
"resource": ""
} |
q23512 | createListener | train | func (process *TeleportProcess) createListener(listenerType, address string) (net.Listener, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, trace.Wrap(err)
}
process.Lock()
defer process.Unlock()
r := RegisteredListener{Type: listenerType, Address: address, Listener: listener}
... | go | {
"resource": ""
} |
q23513 | ExportFileDescriptors | train | func (process *TeleportProcess) ExportFileDescriptors() ([]FileDescriptor, error) {
var out []FileDescriptor
process.Lock()
defer process.Unlock()
for _, r := range process.registeredListeners {
file, err := utils.GetListenerFile(r.Listener)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out,... | go | {
"resource": ""
} |
q23514 | importFileDescriptors | train | func importFileDescriptors() ([]FileDescriptor, error) {
// These files may be passed in by the parent process
filesString := os.Getenv(teleportFilesEnvVar)
if filesString == "" {
return nil, nil
}
files, err := filesFromString(filesString)
if err != nil {
return nil, trace.BadParameter("child process has fa... | go | {
"resource": ""
} |
q23515 | NewForwardRecorder | train | func NewForwardRecorder(cfg ForwardRecorderConfig) (*ForwardRecorder, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
// Always write sessions to local disk first, then forward them to the Auth
// Server later.
auditLog, err := NewForwarder(ForwarderConfig{
SessionID: ... | go | {
"resource": ""
} |
q23516 | Write | train | func (r *ForwardRecorder) Write(data []byte) (int, error) {
// we are copying buffer to prevent data corruption:
// io.Copy allocates single buffer and calls multiple writes in a loop
// our PostSessionSlice is async and sends reader wrapping buffer
// to the channel. This can lead to cases when the buffer is re-us... | go | {
"resource": ""
} |
q23517 | Close | train | func (r *ForwardRecorder) Close() error {
var errors []error
err := r.AuditLog.Close()
errors = append(errors, err)
// wait until all events from recorder get flushed, it is important
// to do so before we send SessionEndEvent to advise the audit log
// to release resources associated with this session.
// not ... | go | {
"resource": ""
} |
q23518 | AcquireLock | train | func AcquireLock(ctx context.Context, backend Backend, lockName string, ttl time.Duration) (err error) {
if lockName == "" {
return trace.BadParameter("missing parameter lock name")
}
key := []byte(filepath.Join(locksPrefix, lockName))
for {
// Get will clear TTL on a lock
backend.Get(ctx, key)
// CreateVa... | go | {
"resource": ""
} |
q23519 | ReleaseLock | train | func ReleaseLock(ctx context.Context, backend Backend, lockName string) error {
if lockName == "" {
return trace.BadParameter("missing parameter lockName")
}
key := []byte(filepath.Join(locksPrefix, lockName))
if err := backend.Delete(ctx, key); err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q23520 | Check | train | func (c *HostCertParams) Check() error {
if c.HostID == "" && len(c.Principals) == 0 {
return trace.BadParameter("HostID [%q] or Principals [%q] are required",
c.HostID, c.Principals)
}
if c.ClusterName == "" {
return trace.BadParameter("ClusterName [%q] is required", c.ClusterName)
}
if err := c.Roles.Che... | go | {
"resource": ""
} |
q23521 | MarshalCertRoles | train | func MarshalCertRoles(roles []string) (string, error) {
out, err := json.Marshal(CertRoles{Version: V1, Roles: roles})
if err != nil {
return "", trace.Wrap(err)
}
return string(out), err
} | go | {
"resource": ""
} |
q23522 | UnmarshalCertRoles | train | func UnmarshalCertRoles(data string) ([]string, error) {
var certRoles CertRoles
if err := utils.UnmarshalWithSchema(CertRolesSchema, &certRoles, []byte(data)); err != nil {
return nil, trace.BadParameter(err.Error())
}
return certRoles.Roles, nil
} | go | {
"resource": ""
} |
q23523 | CertPoolFromCertAuthorities | train | func CertPoolFromCertAuthorities(cas []CertAuthority) (*x509.CertPool, error) {
certPool := x509.NewCertPool()
for _, ca := range cas {
keyPairs := ca.GetTLSKeyPairs()
if len(keyPairs) == 0 {
continue
}
for _, keyPair := range keyPairs {
cert, err := tlsca.ParseCertificatePEM(keyPair.Cert)
if err != ... | go | {
"resource": ""
} |
q23524 | TLSCerts | train | func TLSCerts(ca CertAuthority) [][]byte {
pairs := ca.GetTLSKeyPairs()
out := make([][]byte, len(pairs))
for i, pair := range pairs {
out[i] = append([]byte{}, pair.Cert...)
}
return out
} | go | {
"resource": ""
} |
q23525 | NewCertAuthority | train | func NewCertAuthority(caType CertAuthType, clusterName string, signingKeys, checkingKeys [][]byte, roles []string) CertAuthority {
return &CertAuthorityV2{
Kind: KindCertAuthority,
Version: V2,
SubKind: string(caType),
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
S... | go | {
"resource": ""
} |
q23526 | CertAuthoritiesToV1 | train | func CertAuthoritiesToV1(in []CertAuthority) ([]CertAuthorityV1, error) {
out := make([]CertAuthorityV1, len(in))
type cav1 interface {
V1() *CertAuthorityV1
}
for i, ca := range in {
v1, ok := ca.(cav1)
if !ok {
return nil, trace.BadParameter("could not transform object to V1")
}
out[i] = *(v1.V1())
... | go | {
"resource": ""
} |
q23527 | Clone | train | func (c *CertAuthorityV2) Clone() CertAuthority {
out := *c
out.Spec.CheckingKeys = utils.CopyByteSlices(c.Spec.CheckingKeys)
out.Spec.SigningKeys = utils.CopyByteSlices(c.Spec.SigningKeys)
for i, kp := range c.Spec.TLSKeyPairs {
out.Spec.TLSKeyPairs[i] = TLSKeyPair{
Key: utils.CopyByteSlice(kp.Key),
Cert:... | go | {
"resource": ""
} |
q23528 | GetRotation | train | func (c *CertAuthorityV2) GetRotation() Rotation {
if c.Spec.Rotation == nil {
return Rotation{}
}
return *c.Spec.Rotation
} | go | {
"resource": ""
} |
q23529 | TLSCA | train | func (c *CertAuthorityV2) TLSCA() (*tlsca.CertAuthority, error) {
if len(c.Spec.TLSKeyPairs) == 0 {
return nil, trace.BadParameter("no TLS key pairs found for certificate authority")
}
return tlsca.New(c.Spec.TLSKeyPairs[0].Cert, c.Spec.TLSKeyPairs[0].Key)
} | go | {
"resource": ""
} |
q23530 | String | train | func (c *CertAuthorityV2) String() string {
return fmt.Sprintf("CA(name=%v, type=%v)", c.GetClusterName(), c.GetType())
} | go | {
"resource": ""
} |
q23531 | AddRole | train | func (ca *CertAuthorityV2) AddRole(name string) {
for _, r := range ca.Spec.Roles {
if r == name {
return
}
}
ca.Spec.Roles = append(ca.Spec.Roles, name)
} | go | {
"resource": ""
} |
q23532 | SetSigningKeys | train | func (ca *CertAuthorityV2) SetSigningKeys(keys [][]byte) error {
ca.Spec.SigningKeys = keys
return nil
} | go | {
"resource": ""
} |
q23533 | SetCheckingKeys | train | func (ca *CertAuthorityV2) SetCheckingKeys(keys [][]byte) error {
ca.Spec.CheckingKeys = keys
return nil
} | go | {
"resource": ""
} |
q23534 | GetID | train | func (ca *CertAuthorityV2) GetID() CertAuthID {
return CertAuthID{Type: ca.Spec.Type, DomainName: ca.Metadata.Name}
} | go | {
"resource": ""
} |
q23535 | SetRoleMap | train | func (c *CertAuthorityV2) SetRoleMap(m RoleMap) {
c.Spec.RoleMap = []RoleMapping(m)
} | go | {
"resource": ""
} |
q23536 | FirstSigningKey | train | func (ca *CertAuthorityV2) FirstSigningKey() ([]byte, error) {
if len(ca.Spec.SigningKeys) == 0 {
return nil, trace.NotFound("%v has no signing keys", ca.Metadata.Name)
}
return ca.Spec.SigningKeys[0], nil
} | go | {
"resource": ""
} |
q23537 | Checkers | train | func (ca *CertAuthorityV2) Checkers() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(ca.Spec.CheckingKeys))
for _, keyBytes := range ca.Spec.CheckingKeys {
key, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.BadParameter("invalid authority public key (len=%d)... | go | {
"resource": ""
} |
q23538 | Signers | train | func (ca *CertAuthorityV2) Signers() ([]ssh.Signer, error) {
out := make([]ssh.Signer, 0, len(ca.Spec.SigningKeys))
for _, keyBytes := range ca.Spec.SigningKeys {
signer, err := ssh.ParsePrivateKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, signer)
}
return out, nil
} | go | {
"resource": ""
} |
q23539 | Check | train | func (ca *CertAuthorityV2) Check() error {
err := ca.ID().Check()
if err != nil {
return trace.Wrap(err)
}
_, err = ca.Checkers()
if err != nil {
return trace.Wrap(err)
}
_, err = ca.Signers()
if err != nil {
return trace.Wrap(err)
}
// This is to force users to migrate
if len(ca.Spec.Roles) != 0 && le... | go | {
"resource": ""
} |
q23540 | RemoveCASecrets | train | func RemoveCASecrets(ca CertAuthority) {
ca.SetSigningKeys(nil)
keyPairs := ca.GetTLSKeyPairs()
for i := range keyPairs {
keyPairs[i].Key = nil
}
ca.SetTLSKeyPairs(keyPairs)
} | go | {
"resource": ""
} |
q23541 | Matches | train | func (s *Rotation) Matches(rotation Rotation) bool {
return s.CurrentID == rotation.CurrentID && s.State == rotation.State && s.Phase == rotation.Phase
} | go | {
"resource": ""
} |
q23542 | LastRotatedDescription | train | func (r *Rotation) LastRotatedDescription() string {
if r.LastRotated.IsZero() {
return "never updated"
}
return fmt.Sprintf("last rotated %v", r.LastRotated.Format(teleport.HumanDateFormatSeconds))
} | go | {
"resource": ""
} |
q23543 | PhaseDescription | train | func (r *Rotation) PhaseDescription() string {
switch r.Phase {
case RotationPhaseInit:
return "initialized"
case RotationPhaseStandby, "":
return "on standby"
case RotationPhaseUpdateClients:
return "rotating clients"
case RotationPhaseUpdateServers:
return "rotating servers"
case RotationPhaseRollback:
... | go | {
"resource": ""
} |
q23544 | String | train | func (r *Rotation) String() string {
switch r.State {
case "", RotationStateStandby:
if r.LastRotated.IsZero() {
return "never updated"
}
return fmt.Sprintf("rotated %v", r.LastRotated.Format(teleport.HumanDateFormatSeconds))
case RotationStateInProgress:
return fmt.Sprintf("%v (mode: %v, started: %v, end... | go | {
"resource": ""
} |
q23545 | CheckAndSetDefaults | train | func (r *Rotation) CheckAndSetDefaults(clock clockwork.Clock) error {
switch r.Phase {
case "", RotationPhaseRollback, RotationPhaseUpdateClients, RotationPhaseUpdateServers:
default:
return trace.BadParameter("unsupported phase: %q", r.Phase)
}
switch r.Mode {
case "", RotationModeAuto, RotationModeManual:
de... | go | {
"resource": ""
} |
q23546 | GenerateSchedule | train | func GenerateSchedule(clock clockwork.Clock, gracePeriod time.Duration) (*RotationSchedule, error) {
if gracePeriod <= 0 {
return nil, trace.BadParameter("invalid grace period %q, provide value > 0", gracePeriod)
}
return &RotationSchedule{
UpdateClients: clock.Now().UTC().Add(gracePeriod / 3).UTC(),
UpdateSer... | go | {
"resource": ""
} |
q23547 | CheckAndSetDefaults | train | func (s *RotationSchedule) CheckAndSetDefaults(clock clockwork.Clock) error {
if s.UpdateServers.IsZero() {
return trace.BadParameter("phase %q has no time switch scheduled", RotationPhaseUpdateServers)
}
if s.Standby.IsZero() {
return trace.BadParameter("phase %q has no time switch scheduled", RotationPhaseStan... | go | {
"resource": ""
} |
q23548 | String | train | func (c *CertAuthorityV1) String() string {
return fmt.Sprintf("CA(name=%v, type=%v)", c.DomainName, c.Type)
} | go | {
"resource": ""
} |
q23549 | GetCertAuthoritySchema | train | func GetCertAuthoritySchema() string {
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, fmt.Sprintf(CertAuthoritySpecV2Schema, RotationSchema, RoleMapSchema), DefaultDefinitions)
} | go | {
"resource": ""
} |
q23550 | UnmarshalCertAuthority | train | func (*TeleportCertAuthorityMarshaler) UnmarshalCertAuthority(bytes []byte, opts ...MarshalOption) (CertAuthority, 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": ""
} |
q23551 | MarshalCertAuthority | train | func (*TeleportCertAuthorityMarshaler) MarshalCertAuthority(ca CertAuthority, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type cav1 interface {
V1() *CertAuthorityV1
}
type cav2 interface {
V2() *CertAuthorityV2
}
version := cfg.... | go | {
"resource": ""
} |
q23552 | UpdateEventFields | train | func UpdateEventFields(event Event, fields EventFields, clock clockwork.Clock, uid utils.UID) (err error) {
additionalFields := make(map[string]interface{})
if fields.GetType() == "" {
additionalFields[EventType] = event.Name
}
if fields.GetID() == "" {
additionalFields[EventID] = uid.New()
}
if fields.GetTim... | go | {
"resource": ""
} |
q23553 | CheckAndSetDefaults | train | func (d *DialParams) CheckAndSetDefaults() error {
if d.From == nil {
return trace.BadParameter("parameter From required")
}
if d.To == nil {
return trace.BadParameter("parameter To required")
}
return nil
} | go | {
"resource": ""
} |
q23554 | NewTrustedCluster | train | func NewTrustedCluster(name string, spec TrustedClusterSpecV2) (TrustedCluster, error) {
return &TrustedClusterV2{
Kind: KindTrustedCluster,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}, nil
} | go | {
"resource": ""
} |
q23555 | Equals | train | func (r RoleMap) Equals(o RoleMap) bool {
if len(r) != len(o) {
return false
}
for i := range r {
if !r[i].Equals(o[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q23556 | String | train | func (r RoleMap) String() string {
values, err := r.parse()
if err != nil {
return fmt.Sprintf("<failed to parse: %v", err)
}
if len(values) != 0 {
return fmt.Sprintf("%v", values)
}
return "<empty>"
} | go | {
"resource": ""
} |
q23557 | Map | train | func (r RoleMap) Map(remoteRoles []string) ([]string, error) {
_, err := r.parse()
if err != nil {
return nil, trace.Wrap(err)
}
var outRoles []string
// when no remote roles is specified, assume that
// there is a single empty remote role (that should match wildcards)
if len(remoteRoles) == 0 {
remoteRoles ... | go | {
"resource": ""
} |
q23558 | Check | train | func (r RoleMap) Check() error {
_, err := r.parse()
return trace.Wrap(err)
} | go | {
"resource": ""
} |
q23559 | Equals | train | func (r RoleMapping) Equals(o RoleMapping) bool {
if r.Remote != o.Remote {
return false
}
if !utils.StringSlicesEqual(r.Local, r.Local) {
return false
}
return true
} | go | {
"resource": ""
} |
q23560 | CanChangeStateTo | train | func (c *TrustedClusterV2) CanChangeStateTo(t TrustedCluster) error {
if c.GetToken() != t.GetToken() {
return trace.BadParameter("can not update token for existing trusted cluster")
}
if c.GetProxyAddress() != t.GetProxyAddress() {
return trace.BadParameter("can not update proxy address for existing trusted clu... | go | {
"resource": ""
} |
q23561 | String | train | func (c *TrustedClusterV2) String() string {
return fmt.Sprintf("TrustedCluster(Enabled=%v,Roles=%v,Token=%v,ProxyAddress=%v,ReverseTunnelAddress=%v)",
c.Spec.Enabled, c.Spec.Roles, c.Spec.Token, c.Spec.ProxyAddress, c.Spec.ReverseTunnelAddress)
} | go | {
"resource": ""
} |
q23562 | GetTrustedClusterSchema | train | func GetTrustedClusterSchema(extensionSchema string) string {
var trustedClusterSchema string
if extensionSchema == "" {
trustedClusterSchema = fmt.Sprintf(TrustedClusterSpecSchemaTemplate, RoleMapSchema, "")
} else {
trustedClusterSchema = fmt.Sprintf(TrustedClusterSpecSchemaTemplate, RoleMapSchema, ","+extensi... | go | {
"resource": ""
} |
q23563 | Less | train | func (s SortedTrustedCluster) Less(i, j int) bool {
return s[i].GetName() < s[j].GetName()
} | go | {
"resource": ""
} |
q23564 | Swap | train | func (s SortedTrustedCluster) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q23565 | Name | train | func (c *ClientProfile) Name() string {
if c.ProxyHost != "" {
return c.ProxyHost
}
addr, _, err := net.SplitHostPort(c.WebProxyAddr)
if err != nil {
return c.WebProxyAddr
}
return addr
} | go | {
"resource": ""
} |
q23566 | UnlinkCurrentProfile | train | func UnlinkCurrentProfile() error {
return trace.Wrap(os.Remove(filepath.Join(FullProfilePath(""), CurrentProfileSymlink)))
} | go | {
"resource": ""
} |
q23567 | ProfileFromFile | train | func ProfileFromFile(filePath string) (*ClientProfile, error) {
bytes, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, trace.Wrap(err)
}
var cp *ClientProfile
if err = yaml.Unmarshal(bytes, &cp); err != nil {
return nil, trace.Wrap(err)
}
return cp, nil
} | go | {
"resource": ""
} |
q23568 | SaveTo | train | func (cp *ClientProfile) SaveTo(loc ProfileLocation) error {
bytes, err := yaml.Marshal(&cp)
if err != nil {
return trace.Wrap(err)
}
if err = ioutil.WriteFile(loc.Path, bytes, 0660); err != nil {
return trace.Wrap(err)
}
if loc.AliasPath != "" && filepath.Base(loc.AliasPath) != filepath.Base(loc.Path) {
if... | go | {
"resource": ""
} |
q23569 | CreateUploaderDir | train | func CreateUploaderDir(dir string) error {
err := os.MkdirAll(filepath.Join(dir, teleport.LogsDir, teleport.ComponentUpload,
events.SessionLogsDir, defaults.Namespace), teleport.SharedDirMode)
if err != nil {
return trace.ConvertSystemError(err)
}
return nil
} | go | {
"resource": ""
} |
q23570 | GenerateCertificate | train | func GenerateCertificate(authServer *AuthServer, identity TestIdentity) ([]byte, []byte, error) {
switch id := identity.I.(type) {
case LocalUser:
user, err := authServer.GetUser(id.Username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), authServer, u... | go | {
"resource": ""
} |
q23571 | NewCertificate | train | func (a *TestAuthServer) NewCertificate(identity TestIdentity) (*tls.Certificate, error) {
cert, key, err := GenerateCertificate(a.AuthServer, identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsCert, err := tls.X509KeyPair(cert, key)
if err != nil {
return nil, trace.Wrap(err)
}
return &tlsCert, nil
... | go | {
"resource": ""
} |
q23572 | Trust | train | func (a *TestAuthServer) Trust(remote *TestAuthServer, roleMap services.RoleMap) error {
remoteCA, err := remote.AuthServer.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: remote.ClusterName,
}, false)
if err != nil {
return trace.Wrap(err)
}
err = a.AuthServer.UpsertCertAuthor... | go | {
"resource": ""
} |
q23573 | NewRemoteClient | train | func (a *TestAuthServer) NewRemoteClient(identity TestIdentity, addr net.Addr, pool *x509.CertPool) (*Client, error) {
tlsConfig := utils.TLSConfig(a.CipherSuites)
cert, err := a.NewCertificate(identity)
if err != nil {
return nil, trace.Wrap(err)
}
tlsConfig.Certificates = []tls.Certificate{*cert}
tlsConfig.Ro... | go | {
"resource": ""
} |
q23574 | CheckAndSetDefaults | train | func (cfg *TestTLSServerConfig) CheckAndSetDefaults() error {
if cfg.APIConfig == nil {
return trace.BadParameter("missing parameter APIConfig")
}
if cfg.AuthServer == nil {
return trace.BadParameter("missing parameter AuthServer")
}
// use very permissive limiter configuration by default
if cfg.Limiter == ni... | go | {
"resource": ""
} |
q23575 | NewClientFromWebSession | train | func (t *TestTLSServer) NewClientFromWebSession(sess services.WebSession) (*Client, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
tlsCert, err := tls.X509KeyPair(sess.GetTLSCert(), sess.GetPriv())
if err != nil {
return nil, trace.Wrap(... | go | {
"resource": ""
} |
q23576 | CertPool | train | func (t *TestTLSServer) CertPool() (*x509.CertPool, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
return tlsConfig.RootCAs, nil
} | go | {
"resource": ""
} |
q23577 | ClientTLSConfig | train | func (t *TestTLSServer) ClientTLSConfig(identity TestIdentity) (*tls.Config, error) {
tlsConfig, err := t.Identity.TLSConfig(t.AuthServer.CipherSuites)
if err != nil {
return nil, trace.Wrap(err)
}
if identity.I != nil {
cert, err := t.AuthServer.NewCertificate(identity)
if err != nil {
return nil, trace.W... | go | {
"resource": ""
} |
q23578 | CloneClient | train | func (t *TestTLSServer) CloneClient(clt *Client) *Client {
addr := []utils.NetAddr{{Addr: t.Addr().String(), AddrNetwork: t.Addr().Network()}}
newClient, err := NewTLSClient(ClientConfig{Addrs: addr, TLS: clt.TLSConfig()})
if err != nil {
panic(err)
}
return newClient
} | go | {
"resource": ""
} |
q23579 | NewClient | train | func (t *TestTLSServer) NewClient(identity TestIdentity) (*Client, error) {
tlsConfig, err := t.ClientTLSConfig(identity)
if err != nil {
return nil, trace.Wrap(err)
}
addrs := []utils.NetAddr{utils.FromAddr(t.Listener.Addr())}
return NewTLSClient(ClientConfig{Addrs: addrs, TLS: tlsConfig})
} | go | {
"resource": ""
} |
q23580 | Start | train | func (t *TestTLSServer) Start() error {
var err error
if t.Listener == nil {
t.Listener, err = net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return trace.Wrap(err)
}
}
go t.TLSServer.Serve(t.Listener)
return nil
} | go | {
"resource": ""
} |
q23581 | Close | train | func (t *TestTLSServer) Close() error {
err := t.TLSServer.Close()
if t.Listener != nil {
t.Listener.Close()
}
if t.AuthServer.Backend != nil {
t.AuthServer.Backend.Close()
}
return err
} | go | {
"resource": ""
} |
q23582 | Stop | train | func (t *TestTLSServer) Stop() error {
err := t.TLSServer.Close()
if t.Listener != nil {
t.Listener.Close()
}
return err
} | go | {
"resource": ""
} |
q23583 | NewServerIdentity | train | func NewServerIdentity(clt *AuthServer, hostID string, role teleport.Role) (*Identity, error) {
keys, err := clt.GenerateServerKeys(GenerateServerKeysRequest{
HostID: hostID,
NodeName: hostID,
Roles: teleport.Roles{teleport.RoleAuth},
})
if err != nil {
return nil, trace.Wrap(err)
}
return ReadIdentit... | go | {
"resource": ""
} |
q23584 | CreateUserAndRole | train | func CreateUserAndRole(clt clt, username string, allowedLogins []string) (services.User, services.Role, error) {
user, err := services.NewUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
role := services.RoleForUser(user)
role.SetLogins(services.Allow, []string{user.GetName()})
err = clt.Upsert... | go | {
"resource": ""
} |
q23585 | CreateUserAndRoleWithoutRoles | train | func CreateUserAndRoleWithoutRoles(clt clt, username string, allowedLogins []string) (services.User, services.Role, error) {
user, err := services.NewUser(username)
if err != nil {
return nil, nil, trace.Wrap(err)
}
role := services.RoleForUser(user)
set := services.MakeRuleSet(role.GetRules(services.Allow))
d... | go | {
"resource": ""
} |
q23586 | CheckAndSetDefaults | train | func (cfg *UploaderConfig) CheckAndSetDefaults() error {
if cfg.ServerID == "" {
return trace.BadParameter("missing parameter ServerID")
}
if cfg.AuditLog == nil {
return trace.BadParameter("missing parameter AuditLog")
}
if cfg.DataDir == "" {
return trace.BadParameter("missing parameter DataDir")
}
if cf... | go | {
"resource": ""
} |
q23587 | NewUploader | train | func NewUploader(cfg UploaderConfig) (*Uploader, error) {
if err := cfg.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
ctx, cancel := context.WithCancel(cfg.Context)
uploader := &Uploader{
UploaderConfig: cfg,
Entry: log.WithFields(log.Fields{
trace.Component: teleport.ComponentAuditLog... | go | {
"resource": ""
} |
q23588 | Scan | train | func (u *Uploader) Scan() error {
df, err := os.Open(u.scanDir)
err = trace.ConvertSystemError(err)
if err != nil {
return trace.Wrap(err)
}
defer df.Close()
entries, err := df.Readdir(-1)
if err != nil {
return trace.ConvertSystemError(err)
}
var count int
for i := range entries {
fi := entries[i]
if... | go | {
"resource": ""
} |
q23589 | MakeDefaultConfig | train | func MakeDefaultConfig() *Config {
return &Config{
Stdout: os.Stdout,
Stderr: os.Stderr,
Stdin: os.Stdin,
}
} | go | {
"resource": ""
} |
q23590 | IsExpired | train | func (p *ProfileStatus) IsExpired(clock clockwork.Clock) bool {
return p.ValidUntil.Sub(clock.Now()) <= 0
} | go | {
"resource": ""
} |
q23591 | RetryWithRelogin | train | func RetryWithRelogin(ctx context.Context, tc *TeleportClient, fn func() error) error {
err := fn()
if err == nil {
return nil
}
// Assume that failed handshake is a result of expired credentials,
// retry the login procedure
if !utils.IsHandshakeFailedError(err) && !utils.IsCertExpiredError(err) && !trace.IsBa... | go | {
"resource": ""
} |
q23592 | fullProfileName | train | func fullProfileName(profileDir string, proxyHost string) (string, error) {
var err error
var profileName string
// If no profile name was passed in, try and extract the active profile from
// the ~/.tsh/profile symlink. If one was passed in, append .yaml to name.
if proxyHost == "" {
profileName, err = os.Read... | go | {
"resource": ""
} |
q23593 | Status | train | func Status(profileDir string, proxyHost string) (*ProfileStatus, []*ProfileStatus, error) {
var err error
var profile *ProfileStatus
var others []*ProfileStatus
// remove ports from proxy host, because profile name is stored
// by host name
if proxyHost != "" {
proxyHost, err = utils.Host(proxyHost)
if err ... | go | {
"resource": ""
} |
q23594 | KubeProxyHostPort | train | func (c *Config) KubeProxyHostPort() (string, int) {
if c.KubeProxyAddr != "" {
addr, err := utils.ParseAddr(c.KubeProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.KubeProxyListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.KubeProxyListenPort
} | go | {
"resource": ""
} |
q23595 | WebProxyHostPort | train | func (c *Config) WebProxyHostPort() (string, int) {
if c.WebProxyAddr != "" {
addr, err := utils.ParseAddr(c.WebProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.HTTPListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.HTTPListenPort
} | go | {
"resource": ""
} |
q23596 | SSHProxyHostPort | train | func (c *Config) SSHProxyHostPort() (string, int) {
if c.SSHProxyAddr != "" {
addr, err := utils.ParseAddr(c.SSHProxyAddr)
if err == nil {
return addr.Host(), addr.Port(defaults.SSHProxyListenPort)
}
}
webProxyHost, _ := c.WebProxyHostPort()
return webProxyHost, defaults.SSHProxyListenPort
} | go | {
"resource": ""
} |
q23597 | NewClient | train | func NewClient(c *Config) (tc *TeleportClient, err error) {
// validate configuration
if c.Username == "" {
c.Username, err = Username()
if err != nil {
return nil, trace.Wrap(err)
}
log.Infof("No teleport login given. defaulting to %s", c.Username)
}
if c.WebProxyAddr == "" {
return nil, trace.BadPara... | go | {
"resource": ""
} |
q23598 | accessPoint | train | func (tc *TeleportClient) accessPoint(clt auth.AccessPoint, proxyHostPort string, clusterName string) (auth.AccessPoint, error) {
// If no caching policy was set or on Windows (where Teleport does not
// support file locking at the moment), return direct access to the access
// point.
if tc.CachePolicy == nil || ru... | go | {
"resource": ""
} |
q23599 | getTargetNodes | train | func (tc *TeleportClient) getTargetNodes(ctx context.Context, proxy *ProxyClient) ([]string, error) {
var (
err error
nodes []services.Server
retval = make([]string, 0)
)
if tc.Labels != nil && len(tc.Labels) > 0 {
nodes, err = proxy.FindServersByLabels(ctx, tc.Namespace, tc.Labels)
if err != nil {
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.