id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c22900 | marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_content_type SET (` +
`app_label, model` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, dct.AppLabel, dct.Model, dct.ID)
_, err = db.Exec(sqlstr, dct.AppLabel, dct.Model, dct.ID)
return err
} | |
c22901 | WHERE id = $1`
// run query
XOLog(sqlstr, dct.ID)
_, err = db.Exec(sqlstr, dct.ID)
if err != nil {
return err
}
// set deleted
dct._deleted = true
return nil
} | |
c22902 |
XOLog(sqlstr, groupID, permissionID)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, groupID, permissionID).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
} | |
c22903 | nil {
return nil, err
}
defer q.Close()
// load results
res := []*ProcParam{}
for q.Next() {
pp := ProcParam{}
// scan
err = q.Scan(&pp.ParamType)
if err != nil {
return nil, err
}
res = append(res, &pp)
}
return res, nil
} | |
c22904 |
aug := AuthUserGroup{
_exists: true,
}
// scan
err = q.Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
res = append(res, &aug)
}
return res, nil
} | |
c22905 | := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
} | |
c22906 | "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "binary", "varbinary":
typ = "[]byte"
case "datetime", "datetime2", "timestamp":
nilVal = "time.Time{}"
typ = "time.Time"
case "time with time zone", "time without time zone", "timestamp without time... | |
c22907 | err != nil {
return nil, err
}
// load columns
cols, err := models.MsTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
} | |
c22908 | true
// Look for a match in the table name where it contains the identity
for _, identity := range identities {
if identity.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
r... | |
c22909 | id = ?`
// run query
XOLog(sqlstr, dal.ID)
_, err = db.Exec(sqlstr, dal.ID)
if err != nil {
return err
}
// set deleted
dal._deleted = true
return nil
} | |
c22910 | q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
} | |
c22911 | ds := DjangoSession{
_exists: true,
}
err = db.QueryRow(sqlstr, sessionKey).Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
return &ds, nil
} | |
c22912 | SET ` +
`user_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
_, err = db.Exec(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
return err
} | |
c22913 | marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.django_migrations SET ` +
`app = :1, name = :2, applied = :3` +
` WHERE id = :4`
// run query
XOLog(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
_, err = db.Exec(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
return err
} | |
c22914 | id = :1`
// run query
XOLog(sqlstr, dm.ID)
_, err = db.Exec(sqlstr, dm.ID)
if err != nil {
return err
}
// set deleted
dm._deleted = true
return nil
} | |
c22915 | := DjangoMigration{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dm.ID, &dm.App, &dm.Name, &dm.Applied)
if err != nil {
return nil, err
}
return &dm, nil
} | |
c22916 | := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
} | |
c22917 | $8`
// run query
XOLog(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
_, err = db.Exec(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
return err
} | |
c22918 | := []*DjangoAdminLog{}
for q.Next() {
dal := DjangoAdminLog{
_exists: true,
}
// scan
err = q.Scan(&dal.ID, &dal.ActionTime, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID)
if err != nil {
return nil, err
}
res = append(res, &dal)
}
return... | |
c22919 | nil, err
}
defer q.Close()
// load results
res := []*Proc{}
for q.Next() {
p := Proc{}
// scan
err = q.Scan(&p.ProcName, &p.ReturnType)
if err != nil {
return nil, err
}
res = append(res, &p)
}
return res, nil
} | |
c22920 | = :1`
// run query
XOLog(sqlstr, ag.ID)
_, err = db.Exec(sqlstr, ag.ID)
if err != nil {
return err
}
// set deleted
ag._deleted = true
return nil
} | |
c22921 | query
const sqlstr = `UPDATE auth_group SET ` +
`name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ag.Name, ag.ID)
_, err = db.Exec(sqlstr, ag.Name, ag.ID)
return err
} | |
c22922 | = :1`
// run query
XOLog(sqlstr, au.ID)
_, err = db.Exec(sqlstr, au.ID)
if err != nil {
return err
}
// set deleted
au._deleted = true
return nil
} | |
c22923 | &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
return &au, nil
} | |
c22924 |
case "key":
*f = FkModeKey
default:
return errors.New("invalid FkMode")
}
return nil
} | |
c22925 |
// mode is FkModeSmart
// inspect all foreign keys and use FkModeField if conflict found
for _, f := range fkMap {
if fk != f && fk.Type.Name == f.Type.Name && fk.RefType.Name == f.RefType.Name {
return fkName(FkModeField, fkMap, fk)
}
}
// no conflict, so use FkModeParent
return fkName(FkModeParent, fk... | |
c22926 |
return fkName(*a.ForeignKeyMode, fkMap, fk)
} | |
c22927 | WHERE id = $1`
// run query
XOLog(sqlstr, auup.ID)
_, err = db.Exec(sqlstr, auup.ID)
if err != nil {
return err
}
// set deleted
auup._deleted = true
return nil
} | |
c22928 | := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
} | |
c22929 | = :1`
// run query
XOLog(sqlstr, aug.ID)
_, err = db.Exec(sqlstr, aug.ID)
if err != nil {
return err
}
// set deleted
aug._deleted = true
return nil
} | |
c22930 | AND column_name = ?`
// run query
XOLog(sqlstr, schema, enum)
var mev MyEnumValue
err = db.QueryRow(sqlstr, schema, enum).Scan(&mev.EnumValues)
if err != nil {
return nil, err
}
return &mev, nil
} | |
c22931 | for deletion")
}
// sql query
const sqlstr = `UPDATE public.auth_user_groups SET (` +
`user_id, group_id` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, aug.UserID, aug.GroupID, aug.ID)
_, err = db.Exec(sqlstr, aug.UserID, aug.GroupID, aug.ID)
return err
} | |
c22932 | schema, table)
q, err := db.Query(sqlstr, schema, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Column{}
for q.Next() {
c := Column{}
// scan
err = q.Scan(&c.FieldOrdinal, &c.ColumnName, &c.DataType, &c.NotNull, &c.DefaultValue, &c.IsPrimaryKey)
if err != nil {
... | |
c22933 | events.LoginMethodLocal,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
s.EmitAuditEvent(events.UserLocalLogin, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: tru... | |
c22934 |
}
if err := s.UpsertWebSession(req.Username, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | |
c22935 | 0 {
return trace.BadParameter("missing parameter 'public_key'")
}
certificateFormat, err := utils.CheckCertificateFormatFlag(a.CompatibilityMode)
if err != nil {
return trace.Wrap(err)
}
a.CompatibilityMode = certificateFormat
return nil
} | |
c22936 | range c.HostCertificates {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, publicKey)
}
return out, nil
} | |
c22937 | ca.GetClusterName(),
HostCertificates: ca.GetCheckingKeys(),
TLSCertificates: services.TLSCerts(ca),
}
}
return out
} | |
c22938 | // Return the host CA for this cluster only.
authority, err := s.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: clusterName.GetClusterName(),
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
hostCertAuthorities := []services.CertAuthority{
authority,
}
certs, err ... | |
c22939 | handlerMu.Unlock()
delete(handlers, handlerIndex)
} | |
c22940 | return nil, trace.BadParameter("handler with index %v not registered", handlerIndex)
}
return handle, nil
} | |
c22941 | != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
// Check that the *nix account is valid. Checking an account varies based off
// the PAM modules used in the account stack. Typically this consists of
// checking if the account is expired or has access restrictions.
//
// Note: This function does not p... | |
c22942 | allocated for the conversation function.
C.free(unsafe.Pointer(p.conv))
// Release strings that were allocated when opening the PAM context.
C.free(unsafe.Pointer(p.service_name))
C.free(unsafe.Pointer(p.user))
return nil
} | |
c22943 | C._pam_strerror(pamHandle, p.pamh, returnValue)
if err != nil {
return trace.BadParameter(C.GoString(err))
}
return nil
} | |
c22944 | clientConn := NewPipeNetConn(client, client, client, srcAddr, dstAddr)
return serverConn, clientConn
} | |
c22945 | },
Spec: spec,
}
if err := cn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &cn, nil
} | |
c22946 | fmt.Sprintf(ClusterNameSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, clusterNameSchema, DefaultDefinitions)
} | |
c22947 | return nil, trace.BadParameter(err.Error())
}
}
err = clusterName.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
clusterName.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
clusterName.SetExpiry(cfg.Expires)
}
return &clusterName, nil
} | |
c22948 |
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
} | |
c22949 | trace.BadParameter("'%v' authority type is not supported", c)
}
return nil
} | |
c22950 | return trace.BadParameter("identity validation error: empty domain name")
}
return nil
} | |
c22951 |
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: clusterName,
DialAddrs: dialAddrs,
},
}
} | |
c22952 |
Spec: ReverseTunnelSpecV2{
ClusterName: r.DomainName,
Type: ProxyTunnel,
DialAddrs: r.DialAddrs,
},
}
} | |
c22953 | := utils.UnmarshalWithSchema(GetReverseTunnelSchema(), &r, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := r.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
r.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
r.SetExpiry(cfg.... | |
c22954 | {
return UnmarshalReverseTunnel(bytes, opts...)
} | |
c22955 | if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return n... | |
c22956 | return trace.Wrap(err)
}
log.AddHook(hook)
// ... and disable stderr:
log.SetOutput(ioutil.Discard)
return nil
} | |
c22957 | services.UserCA}
case services.HostCA:
return []services.CertAuthType{services.HostCA}
case services.UserCA:
return []services.CertAuthType{services.UserCA}
}
return nil
} | |
c22958 | r.GracePeriod = &period
}
if r.Schedule == nil {
var err error
r.Schedule, err = services.GenerateSchedule(clock, *r.GracePeriod)
if err != nil {
return trace.Wrap(err)
}
} else {
if err := r.Schedule.CheckAndSetDefaults(clock); err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c22959 | if err != nil {
return trace.Wrap(err)
}
updated := existing.Clone()
updated.SetCheckingKeys(ca.GetCheckingKeys())
updated.SetTLSKeyPairs(ca.GetTLSKeyPairs())
updated.SetRotation(ca.GetRotation())
// use compare and swap to protect from concurrent updates
// by trusted cluster API
if err := a.CompareAndSwa... | |
c22960 | caType,
DomainName: clusterName.GetClusterName(),
}, true)
if err != nil {
return trace.Wrap(err)
}
if err := a.autoRotate(ca); err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c22961 |
if err := startRollingBackRotation(ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
default:
return nil, trace.BadParameter("can not transition to phase %q from %q phase.", req.targetPhase, rotation.Phase)
}
case services.RotationPhaseStandby:
// Transition to the standby phase mov... | |
c22962 | the cluster.
keyPairs = []services.TLSKeyPair{keyPairs[1], services.TLSKeyPair{Cert: keyPairs[0].Cert}}
rotation.State = services.RotationStateInProgress
rotation.Phase = services.RotationPhaseRollback
ca.SetSigningKeys(signingKeys)
ca.SetCheckingKeys(checkingKeys)
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(ro... | |
c22963 | keep the original certificate authority as trusted
// and remove everything else.
keyPairs = []services.TLSKeyPair{keyPairs[0]}
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | |
c22964 | rotation.LastRotated = clock.Now()
rotation.Mode = ""
rotation.Schedule = services.RotationSchedule{}
ca.SetSigningKeys(signingKeys)
ca.SetCheckingKeys(checkingKeys)
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | |
c22965 | return trace.Wrap(err)
}
if err := extractFile(tarball, header, dir); err != nil {
return trace.Wrap(err)
}
}
return nil
} | |
c22966 | return "", trace.Wrap(err)
}
return hex.EncodeToString(randomBytes), nil
} | |
c22967 | return max / 2
}
return time.Duration(randomVal.Int64())
} | |
c22968 | Namespace: namespace,
},
Spec: services.ServerSpecV2{
Addr: addr,
PublicAddr: addr,
},
}
} | |
c22969 |
gotAP, err := s.ConfigS.GetAuthPreference()
c.Assert(err, check.IsNil)
c.Assert(gotAP.GetType(), check.Equals, "local")
c.Assert(gotAP.GetSecondFactor(), check.Equals, "otp")
} | |
c22970 | suiteOpts SuiteOptions
for _, o := range opts {
o(&suiteOpts)
}
return suiteOpts
} | |
c22971 | fixtures.DeepCompare(c, config, gotConfig)
// Some parts (e.g. auth server) will not function
// without cluster name or cluster config
if CollectOptions(opts...).SkipDelete {
return
}
err = s.ConfigS.DeleteClusterConfig()
c.Assert(err, check.IsNil)
_, err = s.ConfigS.GetClusterConfig()
fixtures.ExpectNotF... | |
c22972 | ClusterName: "example.com",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterName(clusterName)
c.Assert(err, check.IsNil)
out, err := s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
err = s.ConfigS.DeleteClusterName()
c.Assert(err, check.IsNil)
return out
},
},
... | |
c22973 | teleport.RemoteClusterStatusOnline
}
return teleport.RemoteClusterStatusOffline
} | |
c22974 | := NewTunnelConnection(name, spec)
if err != nil {
panic(err)
}
return conn
} | |
c22975 | name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := conn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | |
c22976 | r.Metadata.Name, r.Spec.Type, r.Spec.ClusterName, r.Spec.ProxyName)
} | |
c22977 | time.Time) {
r.Spec.LastHeartbeat = tm
} | |
c22978 | if err := utils.UnmarshalWithSchema(GetTunnelConnectionSchema(), &r, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := r.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
r.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
r.S... | |
c22979 | if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", rt)
}
} | |
c22980 | *service.Config) {
c.config = config
c.status = app.Command("status", "Report cluster status")
} | |
c22981 |
rotation.Schedule.Standby.Format(teleport.HumanDateFormatSeconds),
)})
} else {
table.AddRow([]string{info, rotation.String()})
}
}
table.AddRow([]string{"CA pin", caPin})
return table.AsBuffer().String()
}
fmt.Printf(view())
// in debug mode, output mode of remote certificate authoriti... | |
c22982 | trace.Wrap(err)
}
}
err = a.DeleteReverseTunnel(name)
if err != nil {
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
}
err = a.Presence.DeleteTrustedCluster(name)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c22983 | CA in trusted clusters on the main cluster side
// per standard automation but clean up just in case
err = a.DeleteCertAuthority(services.CertAuthID{
Type: services.UserCA,
DomainName: clusterName,
})
if err != nil {
if !trace.IsNotFound(err) {
return trace.Wrap(err)
}
}
return a.Presence.Delete... | |
c22984 |
return nil, trace.Wrap(err)
}
if err := a.updateRemoteClusterStatus(remoteCluster); err != nil {
return nil, trace.Wrap(err)
}
return remoteCluster, nil
} | |
c22985 | return nil, trace.Wrap(err)
}
for i := range remoteClusters {
if err := a.updateRemoteClusterStatus(remoteClusters[i]); err != nil {
return nil, trace.Wrap(err)
}
}
return remoteClusters, nil
} | |
c22986 | trace.Wrap(a.ActivateCertAuthority(services.CertAuthID{Type: services.HostCA, DomainName: t.GetName()}))
} | |
c22987 | []string{t.GetReverseTunnelAddress()},
)
return trace.Wrap(a.UpsertReverseTunnel(reverseTunnel))
} | |
c22988 |
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("cluster configuration not found")
}
return trace.Wrap(err)
}
return nil
} | |
c22989 | backend.Key(clusterConfigPrefix, namePrefix),
Value: value,
Expires: c.Expiry(),
})
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c22990 | }
return nil, trace.Wrap(err)
}
return services.GetAuthPreferenceMarshaler().Unmarshal(item.Value,
services.WithResourceID(item.ID), services.WithExpires(item.Expires))
} | |
c22991 | preferencePrefix, generalPrefix),
Value: value,
ID: preferences.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c22992 |
if err != nil {
if trace.IsNotFound(err) {
return trace.NotFound("cluster configuration not found")
}
return trace.Wrap(err)
}
return nil
} | |
c22993 | Value: value,
ID: c.GetResourceID(),
}
_, err = s.Put(context.TODO(), item)
if err != nil {
return trace.Wrap(err)
}
return nil
} | |
c22994 | h.Set("Pragma", "no-cache")
h.Set("Expires", "0")
} | |
c22995 | through prompts on browsers
h.Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
// Prevent web browsers from using content sniffing to discover a file’s MIME type
h.Set("X-Content-Type-Options", "nosniff")
// Set content policy flags
var cspValue = strings.Join([]string{
"script-src 'sel... | |
c22996 | cfg.tlsConfig, followRedirects: cfg.followRedirects, dialWithContext: cfg.dial, ctx: cfg.ctx, authCtx: cfg.authCtx, bearerToken: cfg.bearerToken}
} | |
c22997 | return s.dialWithoutProxy(req.URL)
} | |
c22998 | certAuthority, err := h.authorityForCert(services.UserCA, certificate.SignatureKey)
if err != nil {
return IdentityContext{}, trace.Wrap(err)
}
identity.CertAuthority = certAuthority
roleSet, err := h.fetchRoleSet(certificate, certAuthority, identity.TeleportUser, clusterName.GetClusterName())
if err != nil {
... | |
c22999 | ctx.Identity.RoleSet.CheckAgentForward(ctx.Identity.Login); err != nil {
return trace.Wrap(err)
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.