_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q22900 | Update | train | func (dct *DjangoContentType) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dct._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.... | go | {
"resource": ""
} |
q22901 | Delete | train | func (dct *DjangoContentType) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return nil
}
// if deleted, bail
if dct._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.django_content_type WHERE id = $1`
// run query
XOLog(sqlstr, dct.ID)
_, err... | go | {
"resource": ""
} |
q22902 | AuthGroupPermissionByGroupIDPermissionID | train | func AuthGroupPermissionByGroupIDPermissionID(db XODB, groupID float64, permissionID float64) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE group_id = :1 AND permission_id = :2`
// run que... | go | {
"resource": ""
} |
q22903 | PgProcParams | train | func PgProcParams(db XODB, schema string, proc string) ([]*ProcParam, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) ` + // ::varchar AS param_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE... | go | {
"resource": ""
} |
q22904 | AuthUserGroupsByGroupID | train | func AuthUserGroupsByGroupID(db XODB, groupID int) ([]*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE group_id = ?`
// run query
XOLog(sqlstr, groupID)
q, err := db.Query(sqlstr, groupID)
if err != nil {
... | go | {
"resource": ""
} |
q22905 | AuthUserGroupByID | train | func AuthUserGroupByID(db XODB, id int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(... | go | {
"resource": ""
} |
q22906 | MsParseType | train | func MsParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
var typ string
switch dt {
case "tinyint", "bit":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool... | go | {
"resource": ""
} |
q22907 | MsQueryColumns | train | func MsQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// process inspect -- cannot have 'order by' in a CREATE VIEW
ins := []string{}
for _, l := range inspect {
if !strings.HasPrefix(strings.ToUpper(l), "ORDER BY ") {
ins = append(ins, l)
}
}
// create t... | go | {
"resource": ""
} |
q22908 | MsTables | train | func MsTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MsTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Identity included
identities, err := models.MsIdentities(db, schema)
if err ... | go | {
"resource": ""
} |
q22909 | Delete | train | func (dal *DjangoAdminLog) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return nil
}
// if deleted, bail
if dal._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_admin_log WHERE id = ?`
// run query
XOLog(sqlstr, dal.ID)
_, err = db.E... | go | {
"resource": ""
} |
q22910 | DjangoSessionsByExpireDate | train | func DjangoSessionsByExpireDate(db XODB, expireDate *time.Time) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE expire_date = ?`
// run query
XOLog(sqlstr, expireDate)
q, err := db.Query(sq... | go | {
"resource": ""
} |
q22911 | DjangoSessionBySessionKey | train | func DjangoSessionBySessionKey(db XODB, sessionKey string) (*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE session_key = ?`
// run query
XOLog(sqlstr, sessionKey)
ds := DjangoSession{
_exis... | go | {
"resource": ""
} |
q22912 | Update | train | func (auup *AuthUserUserPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if auup._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE... | go | {
"resource": ""
} |
q22913 | Update | train | func (dm *DjangoMigration) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dm._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.djang... | go | {
"resource": ""
} |
q22914 | Delete | train | func (dm *DjangoMigration) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return nil
}
// if deleted, bail
if dm._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_migrations WHERE id = :1`
// run query
XOLog(sqlstr, dm.ID)
_, err = db.Ex... | go | {
"resource": ""
} |
q22915 | DjangoMigrationByID | train | func DjangoMigrationByID(db XODB, id float64) (*DjangoMigration, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app, name, applied ` +
`FROM django.django_migrations ` +
`WHERE id = :1`
// run query
XOLog(sqlstr, id)
dm := DjangoMigration{
_exists: true,
}
err = db.QueryRow(sqlst... | go | {
"resource": ""
} |
q22916 | DjangoContentTypeByID | train | func DjangoContentTypeByID(db XODB, id int) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django_content_type ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, id... | go | {
"resource": ""
} |
q22917 | Update | train | func (dal *DjangoAdminLog) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dal._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.dja... | go | {
"resource": ""
} |
q22918 | DjangoAdminLogsByContentTypeID | train | func DjangoAdminLogsByContentTypeID(db XODB, contentTypeID sql.NullInt64) ([]*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id ` +
`FROM public.django_admin_log ` +
`WHERE content_type... | go | {
"resource": ""
} |
q22919 | PgProcs | train | func PgProcs(db XODB, schema string) ([]*Proc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`p.proname, ` + // ::varchar AS proc_name
`pg_get_function_result(p.oid) ` + // ::varchar AS return_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspnam... | go | {
"resource": ""
} |
q22920 | Delete | train | func (ag *AuthGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return nil
}
// if deleted, bail
if ag._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_group WHERE id = :1`
// run query
XOLog(sqlstr, ag.ID)
_, err = db.Exec(sqlstr, ag... | go | {
"resource": ""
} |
q22921 | Update | train | func (ag *AuthGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ag._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group SET ` +... | go | {
"resource": ""
} |
q22922 | Delete | train | func (au *AuthUser) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !au._exists {
return nil
}
// if deleted, bail
if au._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user WHERE id = :1`
// run query
XOLog(sqlstr, au.ID)
_, err = db.Exec(sqlstr, au.I... | go | {
"resource": ""
} |
q22923 | AuthUserByUsername | train | func AuthUserByUsername(db XODB, username sql.NullString) (*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM django.auth_user ` +
`WHERE username = :1`
// run q... | go | {
"resource": ""
} |
q22924 | UnmarshalText | train | func (f *FkMode) UnmarshalText(text []byte) error {
switch strings.ToLower(string(text)) {
case "smart", "default":
*f = FkModeSmart
case "parent":
*f = FkModeParent
case "field":
*f = FkModeField
case "key":
*f = FkModeKey
default:
return errors.New("invalid FkMode")
}
return nil
} | go | {
"resource": ""
} |
q22925 | fkName | train | func fkName(mode FkMode, fkMap map[string]*ForeignKey, fk *ForeignKey) string {
switch mode {
case FkModeParent:
return fk.RefType.Name
case FkModeField:
return fk.RefType.Name + "By" + fk.Field.Name
case FkModeKey:
return fk.RefType.Name + "By" + snaker.SnakeToCamelIdentifier(fk.ForeignKey.ForeignKeyName)
}... | go | {
"resource": ""
} |
q22926 | ForeignKeyName | train | func (a *ArgType) ForeignKeyName(fkMap map[string]*ForeignKey, fk *ForeignKey) string {
return fkName(*a.ForeignKeyMode, fkMap, fk)
} | go | {
"resource": ""
} |
q22927 | Delete | train | func (auup *AuthUserUserPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return nil
}
// if deleted, bail
if auup._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.auth_user_user_permissions WHERE id = $1`
// run query
XOLog(sqlstr, ... | go | {
"resource": ""
} |
q22928 | AuthUserUserPermissionByID | train | func AuthUserUserPermissionByID(db XODB, id int) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM public.auth_user_user_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
auup := AuthUserUserPermission{
_exists: tr... | go | {
"resource": ""
} |
q22929 | Delete | train | func (aug *AuthUserGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return nil
}
// if deleted, bail
if aug._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user_groups WHERE id = :1`
// run query
XOLog(sqlstr, aug.ID)
_, err = db.E... | go | {
"resource": ""
} |
q22930 | MyEnumValues | train | func MyEnumValues(db XODB, schema string, enum string) (*MyEnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values ` +
`FROM information_schema.columns ` +
`WHERE data_type = 'enum' AND table_schema = ? AND column_name =... | go | {
"resource": ""
} |
q22931 | Update | train | func (aug *AuthUserGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if aug._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.auth... | go | {
"resource": ""
} |
q22932 | MyTableColumns | train | func MyTableColumns(db XODB, schema string, table string) ([]*Column, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`ordinal_position AS field_ordinal, ` +
`column_name, ` +
`IF(data_type = 'enum', column_name, column_type) AS data_type, ` +
`IF(is_nullable = 'YES', false, true) AS not_null... | go | {
"resource": ""
} |
q22933 | AuthenticateUser | train | func (s *AuthServer) AuthenticateUser(req AuthenticateUserRequest) error {
err := s.authenticateUser(req)
if err != nil {
s.EmitAuditEvent(events.UserLocalLoginFailure, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess... | go | {
"resource": ""
} |
q22934 | AuthenticateWebUser | train | func (s *AuthServer) AuthenticateWebUser(req AuthenticateUserRequest) (services.WebSession, error) {
if req.Session != nil {
session, err := s.GetWebSession(req.Username, req.Session.ID)
if err != nil {
return nil, trace.AccessDenied("session is invalid or has expired")
}
return session, nil
}
if err := s... | go | {
"resource": ""
} |
q22935 | CheckAndSetDefaults | train | func (a *AuthenticateSSHRequest) CheckAndSetDefaults() error {
if err := a.AuthenticateUserRequest.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
if len(a.PublicKey) == 0 {
return trace.BadParameter("missing parameter 'public_key'")
}
certificateFormat, err := utils.CheckCertificateFormatFlag(a.C... | go | {
"resource": ""
} |
q22936 | SSHCertPublicKeys | train | func (c *TrustedCerts) SSHCertPublicKeys() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(c.HostCertificates))
for _, keyBytes := range c.HostCertificates {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, publicKey)... | go | {
"resource": ""
} |
q22937 | AuthoritiesToTrustedCerts | train | func AuthoritiesToTrustedCerts(authorities []services.CertAuthority) []TrustedCerts {
out := make([]TrustedCerts, len(authorities))
for i, ca := range authorities {
out[i] = TrustedCerts{
ClusterName: ca.GetClusterName(),
HostCertificates: ca.GetCheckingKeys(),
TLSCertificates: services.TLSCerts(ca),... | go | {
"resource": ""
} |
q22938 | AuthenticateSSHUser | train | func (s *AuthServer) AuthenticateSSHUser(req AuthenticateSSHRequest) (*SSHLoginResponse, error) {
clusterName, err := s.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.AuthenticateUser(req.AuthenticateUserRequest); err != nil {
return nil, trace.Wrap(err)
}
user, err := s.GetUser(r... | go | {
"resource": ""
} |
q22939 | unregisterHandler | train | func unregisterHandler(handlerIndex int) {
handlerMu.Lock()
defer handlerMu.Unlock()
delete(handlers, handlerIndex)
} | go | {
"resource": ""
} |
q22940 | lookupHandler | train | func lookupHandler(handlerIndex int) (handler, error) {
handlerMu.Lock()
defer handlerMu.Unlock()
handle, ok := handlers[handlerIndex]
if !ok {
return nil, trace.BadParameter("handler with index %v not registered", handlerIndex)
}
return handle, nil
} | go | {
"resource": ""
} |
q22941 | Open | train | func Open(config *Config) (*PAM, error) {
if config == nil {
return nil, trace.BadParameter("PAM configuration is required.")
}
err := config.CheckDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
p := &PAM{
pamh: nil,
stdin: config.Stdin,
stdout: config.Stdout,
stderr: config.Stderr,
}
... | go | {
"resource": ""
} |
q22942 | Close | train | func (p *PAM) Close() error {
// Close the PAM session. Closing a session can entail anything from
// unmounting a home directory and updating auth.log.
p.retval = C._pam_close_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return p.codeToError(p.retval)
}
// Terminate the PAM transaction.
retva... | go | {
"resource": ""
} |
q22943 | codeToError | train | func (p *PAM) codeToError(returnValue C.int) error {
// Error strings are not allocated on the heap, so memory does not need
// released.
err := C._pam_strerror(pamHandle, p.pamh, returnValue)
if err != nil {
return trace.BadParameter(C.GoString(err))
}
return nil
} | go | {
"resource": ""
} |
q22944 | DualPipeNetConn | train | func DualPipeNetConn(srcAddr net.Addr, dstAddr net.Addr) (*PipeNetConn, *PipeNetConn) {
server, client := net.Pipe()
serverConn := NewPipeNetConn(server, server, server, dstAddr, srcAddr)
clientConn := NewPipeNetConn(client, client, client, srcAddr, dstAddr)
return serverConn, clientConn
} | go | {
"resource": ""
} |
q22945 | NewClusterName | train | func NewClusterName(spec ClusterNameSpecV2) (ClusterName, error) {
cn := ClusterNameV2{
Kind: KindClusterName,
Version: V2,
Metadata: Metadata{
Name: MetaNameClusterName,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := cn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(... | go | {
"resource": ""
} |
q22946 | GetClusterNameSchema | train | func GetClusterNameSchema(extensionSchema string) string {
var clusterNameSchema string
if clusterNameSchema == "" {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, "")
} else {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTempl... | go | {
"resource": ""
} |
q22947 | Unmarshal | train | func (t *TeleportClusterNameMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (ClusterName, error) {
var clusterName ClusterNameV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.Sk... | go | {
"resource": ""
} |
q22948 | Marshal | train | func (t *TeleportClusterNameMarshaler) Marshal(c ClusterName, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *ClusterNameV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// t... | go | {
"resource": ""
} |
q22949 | Check | train | func (c CertAuthType) Check() error {
if c != HostCA && c != UserCA {
return trace.BadParameter("'%v' authority type is not supported", c)
}
return nil
} | go | {
"resource": ""
} |
q22950 | Check | train | func (c *CertAuthID) Check() error {
if err := c.Type.Check(); err != nil {
return trace.Wrap(err)
}
if strings.TrimSpace(c.DomainName) == "" {
return trace.BadParameter("identity validation error: empty domain name")
}
return nil
} | go | {
"resource": ""
} |
q22951 | NewReverseTunnel | train | func NewReverseTunnel(clusterName string, dialAddrs []string) ReverseTunnel {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: clusterName,
DialAddrs: dialAddrs... | go | {
"resource": ""
} |
q22952 | V2 | train | func (r *ReverseTunnelV1) V2() *ReverseTunnelV2 {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: r.DomainName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: r.DomainName,
Type: ProxyTunnel,
DialAddrs: r.Dial... | go | {
"resource": ""
} |
q22953 | UnmarshalReverseTunnel | train | func UnmarshalReverseTunnel(data []byte, opts ...MarshalOption) (ReverseTunnel, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing tunnel data")
}
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != n... | go | {
"resource": ""
} |
q22954 | UnmarshalReverseTunnel | train | func (*TeleportTunnelMarshaler) UnmarshalReverseTunnel(bytes []byte, opts ...MarshalOption) (ReverseTunnel, error) {
return UnmarshalReverseTunnel(bytes, opts...)
} | go | {
"resource": ""
} |
q22955 | MarshalReverseTunnel | train | func (*TeleportTunnelMarshaler) MarshalReverseTunnel(rt ReverseTunnel, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type tunv1 interface {
V1() *ReverseTunnelV1
}
type tunv2 interface {
V2() *ReverseTunnelV2
}
version := cfg.GetVer... | go | {
"resource": ""
} |
q22956 | SwitchLoggingtoSyslog | train | func SwitchLoggingtoSyslog() error {
log.StandardLogger().SetHooks(make(log.LevelHooks))
hook, err := logrusSyslog.NewSyslogHook("", "", syslog.LOG_WARNING, "")
if err != nil {
// syslog is not available
log.SetOutput(os.Stderr)
return trace.Wrap(err)
}
log.AddHook(hook)
// ... and disable stderr:
log.SetO... | go | {
"resource": ""
} |
q22957 | Types | train | func (r *RotateRequest) Types() []services.CertAuthType {
switch r.Type {
case "":
return []services.CertAuthType{services.HostCA, services.UserCA}
case services.HostCA:
return []services.CertAuthType{services.HostCA}
case services.UserCA:
return []services.CertAuthType{services.UserCA}
}
return nil
} | go | {
"resource": ""
} |
q22958 | CheckAndSetDefaults | train | func (r *RotateRequest) CheckAndSetDefaults(clock clockwork.Clock) error {
if r.TargetPhase == "" {
// if phase if not set, imply that the first meaningful phase
// is set as a target phase
r.TargetPhase = services.RotationPhaseInit
}
// if mode is not set, default to manual (as it's safer)
if r.Mode == "" {
... | go | {
"resource": ""
} |
q22959 | RotateExternalCertAuthority | train | func (a *AuthServer) RotateExternalCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
clusterName, err := a.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
// this is just an extra precaution against local admins,
// because... | go | {
"resource": ""
} |
q22960 | autoRotateCertAuthorities | train | func (a *AuthServer) autoRotateCertAuthorities() error {
clusterName, err := a.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
for _, caType := range []services.CertAuthType{services.HostCA, services.UserCA} {
ca, err := a.Trust.GetCertAuthority(services.CertAuthID{
Type: caType,
DomainNam... | go | {
"resource": ""
} |
q22961 | processRotationRequest | train | func processRotationRequest(req rotationReq) (services.CertAuthority, error) {
rotation := req.ca.GetRotation()
ca := req.ca.Clone()
switch req.targetPhase {
case services.RotationPhaseInit:
// This is the first stage of the rotation - new certificate authorities
// are being generated, but no components are u... | go | {
"resource": ""
} |
q22962 | startRollingBackRotation | train | func startRollingBackRotation(ca services.CertAuthority) error {
rotation := ca.GetRotation()
// Rollback always sets rotation to manual mode.
rotation.Mode = services.RotationModeManual
signingKeys := ca.GetSigningKeys()
checkingKeys := ca.GetCheckingKeys()
keyPairs := ca.GetTLSKeyPairs()
// Rotation sets th... | go | {
"resource": ""
} |
q22963 | completeRollingBackRotation | train | func completeRollingBackRotation(clock clockwork.Clock, ca services.CertAuthority) error {
rotation := ca.GetRotation()
// clean up the state
rotation.Started = time.Time{}
rotation.State = services.RotationStateStandby
rotation.Phase = services.RotationPhaseStandby
rotation.Mode = ""
rotation.Schedule = servic... | go | {
"resource": ""
} |
q22964 | completeRotation | train | func completeRotation(clock clockwork.Clock, ca services.CertAuthority) error {
rotation := ca.GetRotation()
signingKeys := ca.GetSigningKeys()
checkingKeys := ca.GetCheckingKeys()
keyPairs := ca.GetTLSKeyPairs()
signingKeys = signingKeys[:1]
checkingKeys = checkingKeys[:1]
keyPairs = keyPairs[:1]
rotation.St... | go | {
"resource": ""
} |
q22965 | Extract | train | func Extract(r io.Reader, dir string) error {
tarball := tar.NewReader(r)
for {
header, err := tarball.Next()
if err == io.EOF {
break
} else if err != nil {
return trace.Wrap(err)
}
if err := extractFile(tarball, header, dir); err != nil {
return trace.Wrap(err)
}
}
return nil
} | go | {
"resource": ""
} |
q22966 | CryptoRandomHex | train | func CryptoRandomHex(len int) (string, error) {
randomBytes := make([]byte, len)
if _, err := rand.Reader.Read(randomBytes); err != nil {
return "", trace.Wrap(err)
}
return hex.EncodeToString(randomBytes), nil
} | go | {
"resource": ""
} |
q22967 | RandomDuration | train | func RandomDuration(max time.Duration) time.Duration {
randomVal, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
if err != nil {
return max / 2
}
return time.Duration(randomVal.Int64())
} | go | {
"resource": ""
} |
q22968 | NewServer | train | func NewServer(kind, name, addr, namespace string) *services.ServerV2 {
return &services.ServerV2{
Kind: kind,
Version: services.V2,
Metadata: services.Metadata{
Name: name,
Namespace: namespace,
},
Spec: services.ServerSpecV2{
Addr: addr,
PublicAddr: addr,
},
}
} | go | {
"resource": ""
} |
q22969 | AuthPreference | train | func (s *ServicesTestSuite) AuthPreference(c *check.C) {
ap, err := services.NewAuthPreference(services.AuthPreferenceSpecV2{
Type: "local",
SecondFactor: "otp",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetAuthPreference(ap)
c.Assert(err, check.IsNil)
gotAP, err := s.ConfigS.GetAuthPreference()... | go | {
"resource": ""
} |
q22970 | CollectOptions | train | func CollectOptions(opts ...SuiteOption) SuiteOptions {
var suiteOpts SuiteOptions
for _, o := range opts {
o(&suiteOpts)
}
return suiteOpts
} | go | {
"resource": ""
} |
q22971 | ClusterConfig | train | func (s *ServicesTestSuite) ClusterConfig(c *check.C, opts ...SuiteOption) {
config, err := services.NewClusterConfig(services.ClusterConfigSpecV3{
ClientIdleTimeout: services.NewDuration(17 * time.Second),
DisconnectExpiredCert: services.NewBool(true),
ClusterID: "27",
SessionRecording: s... | go | {
"resource": ""
} |
q22972 | EventsClusterConfig | train | func (s *ServicesTestSuite) EventsClusterConfig(c *check.C) {
testCases := []eventTest{
{
name: "Cluster config",
kind: services.WatchKind{
Kind: services.KindClusterConfig,
},
crud: func() services.Resource {
config, err := services.NewClusterConfig(services.ClusterConfigSpecV3{})
c.Assert(e... | go | {
"resource": ""
} |
q22973 | TunnelConnectionStatus | train | func TunnelConnectionStatus(clock clockwork.Clock, conn TunnelConnection) string {
diff := clock.Now().Sub(conn.GetLastHeartbeat())
if diff < defaults.ReverseTunnelOfflineThreshold {
return teleport.RemoteClusterStatusOnline
}
return teleport.RemoteClusterStatusOffline
} | go | {
"resource": ""
} |
q22974 | MustCreateTunnelConnection | train | func MustCreateTunnelConnection(name string, spec TunnelConnectionSpecV2) TunnelConnection {
conn, err := NewTunnelConnection(name, spec)
if err != nil {
panic(err)
}
return conn
} | go | {
"resource": ""
} |
q22975 | NewTunnelConnection | train | func NewTunnelConnection(name string, spec TunnelConnectionSpecV2) (TunnelConnection, error) {
conn := &TunnelConnectionV2{
Kind: KindTunnelConnection,
SubKind: spec.ClusterName,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := conn.Chec... | go | {
"resource": ""
} |
q22976 | String | train | func (r *TunnelConnectionV2) String() string {
return fmt.Sprintf("TunnelConnection(name=%v, type=%v, cluster=%v, proxy=%v)",
r.Metadata.Name, r.Spec.Type, r.Spec.ClusterName, r.Spec.ProxyName)
} | go | {
"resource": ""
} |
q22977 | SetLastHeartbeat | train | func (r *TunnelConnectionV2) SetLastHeartbeat(tm time.Time) {
r.Spec.LastHeartbeat = tm
} | go | {
"resource": ""
} |
q22978 | UnmarshalTunnelConnection | train | func UnmarshalTunnelConnection(data []byte, opts ...MarshalOption) (TunnelConnection, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing tunnel connection data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
var h ResourceHeader
err = utils.FastUnmarshal(d... | go | {
"resource": ""
} |
q22979 | MarshalTunnelConnection | train | func MarshalTunnelConnection(rt TunnelConnection, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := rt.(type) {
case *TunnelConnectionV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prev... | go | {
"resource": ""
} |
q22980 | Initialize | train | func (c *StatusCommand) Initialize(app *kingpin.Application, config *service.Config) {
c.config = config
c.status = app.Command("status", "Report cluster status")
} | go | {
"resource": ""
} |
q22981 | Status | train | func (c *StatusCommand) Status(client auth.ClientI) error {
clusterNameResource, err := client.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
clusterName := clusterNameResource.GetClusterName()
hostCAs, err := client.GetCertAuthorities(services.HostCA, false)
if err != nil {
return trace.Wrap(err)... | go | {
"resource": ""
} |
q22982 | DeleteTrustedCluster | train | func (a *AuthServer) DeleteTrustedCluster(name string) error {
err := a.DeleteCertAuthority(services.CertAuthID{Type: services.HostCA, DomainName: name})
if err != nil {
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
}
err = a.DeleteCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: ... | go | {
"resource": ""
} |
q22983 | DeleteRemoteCluster | train | func (a *AuthServer) DeleteRemoteCluster(clusterName string) error {
// To make sure remote cluster exists - to protect against random
// clusterName requests (e.g. when clusterName is set to local cluster name)
_, err := a.Presence.GetRemoteCluster(clusterName)
if err != nil {
return trace.Wrap(err)
}
// delet... | go | {
"resource": ""
} |
q22984 | GetRemoteCluster | train | func (a *AuthServer) GetRemoteCluster(clusterName string) (services.RemoteCluster, error) {
// To make sure remote cluster exists - to protect against random
// clusterName requests (e.g. when clusterName is set to local cluster name)
remoteCluster, err := a.Presence.GetRemoteCluster(clusterName)
if err != nil {
... | go | {
"resource": ""
} |
q22985 | GetRemoteClusters | train | func (a *AuthServer) GetRemoteClusters(opts ...services.MarshalOption) ([]services.RemoteCluster, error) {
// To make sure remote cluster exists - to protect against random
// clusterName requests (e.g. when clusterName is set to local cluster name)
remoteClusters, err := a.Presence.GetRemoteClusters(opts...)
if er... | go | {
"resource": ""
} |
q22986 | activateCertAuthority | train | func (a *AuthServer) activateCertAuthority(t services.TrustedCluster) error {
err := a.ActivateCertAuthority(services.CertAuthID{Type: services.UserCA, DomainName: t.GetName()})
if err != nil {
return trace.Wrap(err)
}
return trace.Wrap(a.ActivateCertAuthority(services.CertAuthID{Type: services.HostCA, DomainNam... | go | {
"resource": ""
} |
q22987 | createReverseTunnel | train | func (a *AuthServer) createReverseTunnel(t services.TrustedCluster) error {
reverseTunnel := services.NewReverseTunnel(
t.GetName(),
[]string{t.GetReverseTunnelAddress()},
)
return trace.Wrap(a.UpsertReverseTunnel(reverseTunnel))
} | go | {
"resource": ""
} |
q22988 | DeleteClusterName | train | func (s *ClusterConfigurationService) DeleteClusterName() error {
err := s.Delete(context.TODO(), backend.Key(clusterConfigPrefix, namePrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("cluster configuration not found")
}
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q22989 | SetClusterName | train | func (s *ClusterConfigurationService) SetClusterName(c services.ClusterName) error {
value, err := services.GetClusterNameMarshaler().Marshal(c)
if err != nil {
return trace.Wrap(err)
}
_, err = s.Create(context.TODO(), backend.Item{
Key: backend.Key(clusterConfigPrefix, namePrefix),
Value: value,
Ex... | go | {
"resource": ""
} |
q22990 | GetAuthPreference | train | func (s *ClusterConfigurationService) GetAuthPreference() (services.AuthPreference, error) {
item, err := s.Get(context.TODO(), backend.Key(authPrefix, preferencePrefix, generalPrefix))
if err != nil {
if trace.IsNotFound(err) {
return nil, trace.NotFound("authentication preference not found")
}
return nil, ... | go | {
"resource": ""
} |
q22991 | SetAuthPreference | train | func (s *ClusterConfigurationService) SetAuthPreference(preferences services.AuthPreference) error {
value, err := services.GetAuthPreferenceMarshaler().Marshal(preferences)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(authPrefix, preferencePrefix, generalPrefix),
Value: ... | go | {
"resource": ""
} |
q22992 | DeleteClusterConfig | train | func (s *ClusterConfigurationService) DeleteClusterConfig() error {
err := s.Delete(context.TODO(), backend.Key(clusterConfigPrefix, generalPrefix))
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("cluster configuration not found")
}
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
q22993 | SetClusterConfig | train | func (s *ClusterConfigurationService) SetClusterConfig(c services.ClusterConfig) error {
value, err := services.GetClusterConfigMarshaler().Marshal(c)
if err != nil {
return trace.Wrap(err)
}
item := backend.Item{
Key: backend.Key(clusterConfigPrefix, generalPrefix),
Value: value,
ID: c.GetResourceID(... | go | {
"resource": ""
} |
q22994 | SetNoCacheHeaders | train | func SetNoCacheHeaders(h http.Header) {
h.Set("Cache-Control", "no-cache, no-store, must-revalidate")
h.Set("Pragma", "no-cache")
h.Set("Expires", "0")
} | go | {
"resource": ""
} |
q22995 | SetIndexHTMLHeaders | train | func SetIndexHTMLHeaders(h http.Header) {
SetNoCacheHeaders(h)
SetSameOriginIFrame(h)
SetNoSniff(h)
// X-Frame-Options indicates that the page can only be displayed in iframe on the same origin as the page itself
h.Set("X-Frame-Options", "SAMEORIGIN")
// X-XSS-Protection is a feature of Internet Explorer, Chrom... | go | {
"resource": ""
} |
q22996 | NewSpdyRoundTripperWithDialer | train | func NewSpdyRoundTripperWithDialer(cfg roundTripperConfig) *SpdyRoundTripper {
return &SpdyRoundTripper{tlsConfig: cfg.tlsConfig, followRedirects: cfg.followRedirects, dialWithContext: cfg.dial, ctx: cfg.ctx, authCtx: cfg.authCtx, bearerToken: cfg.bearerToken}
} | go | {
"resource": ""
} |
q22997 | dial | train | func (s *SpdyRoundTripper) dial(req *http.Request) (net.Conn, error) {
return s.dialWithoutProxy(req.URL)
} | go | {
"resource": ""
} |
q22998 | CreateIdentityContext | train | func (h *AuthHandlers) CreateIdentityContext(sconn *ssh.ServerConn) (IdentityContext, error) {
identity := IdentityContext{
TeleportUser: sconn.Permissions.Extensions[utils.CertTeleportUser],
Certificate: []byte(sconn.Permissions.Extensions[utils.CertTeleportUserCertificate]),
Login: sconn.User(),
}
c... | go | {
"resource": ""
} |
q22999 | CheckAgentForward | train | func (h *AuthHandlers) CheckAgentForward(ctx *ServerContext) error {
if err := ctx.Identity.RoleSet.CheckAgentForward(ctx.Identity.Login); err != nil {
return trace.Wrap(err)
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.