id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c180500 | fire.All(), func(ctx *fire.Context) ([]*Enforcer, error) {
return enforcers, nil
})
} | |
c180501 | enforcers2, err := b.Handler(ctx)
if err != nil {
return nil, err
} else if enforcers2 == nil {
return nil, nil
}
// merge both sets
enforcers := append(S{}, enforcers1...)
enforcers = append(enforcers, enforcers2...)
return enforcers, nil
})
} | |
c180502 | if err != nil {
return nil, err
}
// return on success
if enforcers != nil {
return enforcers, nil
}
}
// check second authorizer
if b.Matcher(ctx) {
// run callback
enforcers, err := b.Handler(ctx)
if err != nil {
return nil, err
}
// return on success
if enforcers != nil {
return enforcers, nil
}
}
return nil, nil
})
} | |
c180503 | job
job, err := Enqueue(store, name, data, delay)
if err != nil {
return nil, err
}
return job, nil
} | |
c180504 | uses same store
if q.store == ctx.Controller.Store {
// enqueue job using context store
_, err := Enqueue(ctx.Store, name, data, delay)
if err != nil {
return err
}
} else {
// enqueue job using queue store
_, err := q.Enqueue(name, data, delay)
if err != nil {
return err
}
}
// respond with an empty object
if ctx.Operation.Action() {
err := ctx.Respond(fire.Map{})
if err != nil {
return err
}
}
return nil
})
} | |
c180505 | make(map[string]*Stream),
}
// create and add manager
w.manager = newManager(w)
return w
} | |
c180506 | if stream.SoftDelete && e == coal.Deleted {
return
}
// handle soft deleted documents
if stream.SoftDelete && e == coal.Updated {
// get soft delete field
softDeleteField := coal.L(stream.Model, "fire-soft-delete", true)
// get deleted time
t := m.MustGet(softDeleteField).(*time.Time)
// change type if document has been soft deleted
if t != nil && !t.IsZero() {
e = coal.Deleted
}
}
// create event
evt := &Event{
Type: e,
ID: id,
Model: m,
Stream: stream,
}
// broadcast event
w.manager.broadcast(evt)
}, nil, func(err error) bool {
// report error
w.Reporter(err)
return true
})
} | |
c180507 | error {
// handle connection
w.manager.handle(ctx)
return nil
}),
}
} | |
c180508 | || o == Update || o == Delete
} | |
c180509 |
case Update:
return "Update"
case Delete:
return "Delete"
case CollectionAction:
return "CollectionAction"
case ResourceAction:
return "ResourceAction"
}
return ""
} | |
c180510 | bson.M{"$and": append([]bson.M{c.Selector}, c.Filters...)}
} | |
c180511 | _, err = c.ResponseWriter.Write(bytes)
if err != nil {
return err
}
return nil
} | |
c180512 | is missing
// create application
app := coal.Init(&Application{}).(*Application)
app.Key = key
app.Name = name
app.Secret = secret
// validate model
err = app.Validate()
if err != nil {
return "", err
}
// save application
err = s.C(app).Insert(app)
if err != nil {
return "", err
}
return app.Key, nil
} | |
c180513 | password
// set key and secret
err = user.Validate()
if err != nil {
return err
}
// save user
err = s.C(user).Insert(user)
if err != nil {
return err
}
return nil
} | |
c180514 | case fire.Update:
err = s.call(ctx, s.Update, s.Write, s.All)
case fire.Delete:
err = s.call(ctx, s.Delete, s.Write, s.All)
case fire.CollectionAction:
err = s.call(ctx, s.CollectionAction[ctx.JSONAPIRequest.CollectionAction], s.CollectionActions, s.Actions, s.All)
case fire.ResourceAction:
err = s.call(ctx, s.ResourceAction[ctx.JSONAPIRequest.ResourceAction], s.ResourceActions, s.Actions, s.All)
}
return err
})
} | |
c180515 | store: store,
model: model,
token: resumeToken,
receiver: receiver,
opened: opened,
manager: manager,
}
// open stream
go s.open()
return s
} | |
c180516 |
// set flag
s.closed = true
// close active change stream
if s.current != nil {
_ = s.current.Close()
}
} | |
c180517 |
if autoExpire {
i.Add(&Token{}, false, time.Minute, "ExpiresAt")
}
} | |
c180518 | return t.Type, t.Scope, t.ExpiresAt, t.Application, t.User
} | |
c180519 |
t.ExpiresAt = expiresAt
t.Application = client.ID()
if resourceOwner != nil {
t.User = coal.P(resourceOwner.ID())
}
} | |
c180520 | {
return bcrypt.CompareHashAndPassword(a.SecretHash, []byte(secret)) == nil
} | |
c180521 | != nil {
return err
}
// save hash
a.SecretHash = hash
// clear password
a.Secret = ""
return nil
} | |
c180522 | return bcrypt.CompareHashAndPassword(u.PasswordHash, []byte(password)) == nil
} | |
c180523 | {
return err
}
// save hash
u.PasswordHash = hash
// clear password
u.Password = ""
return nil
} | |
c180524 | err := CreateStore(uri)
if err != nil {
panic(err)
}
return store
} | |
c180525 | return nil, err
}
return NewStore(session), nil
} | |
c180526 | *mgo.Collection {
return s.DB().C(C(model))
} | |
c180527 | h := func(w http.ResponseWriter, r *http.Request) {
// pre-check if file does exist
f, err := dir.Open(r.URL.Path)
if err != nil {
r.URL.Path = "/"
} else if f != nil {
_ = f.Close()
}
// serve file
fs.ServeHTTP(w, r)
}
return http.StripPrefix(prefix, http.HandlerFunc(h))
} | |
c180528 | {
return nil, ErrInvalidScope
}
return scope, nil
} | |
c180529 | return map[string]interface{}{
"user": ro.ID(),
}
}
return nil
} | |
c180530 |
claims.Data = p.TokenData(client, resourceOwner, token)
}
// create token
tkn := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
// sign token
str, err := tkn.SignedString(p.Secret)
if err != nil {
return "", nil
}
return str, nil
} | |
c180531 | return nil, true, err
} else if err != nil {
return nil, false, err
} else if !bson.IsObjectIdHex(claims.Id) {
return nil, false, errors.New("invalid id")
}
return &claims, false, nil
} | |
c180532 | return fire.C(name, m, h)
} | |
c180533 |
structField := reflect.ValueOf(b.model).Elem().Field(field.index)
return structField.Interface()
} | |
c180534 | "%s" not found on "%s"`, name, b.meta.Name))
}
// set the value on model struct
reflect.ValueOf(b.model).Elem().Field(field.index).Set(reflect.ValueOf(value))
} | |
c180535 | make(map[string]*Controller),
actions: make(map[string]*GroupAction),
}
} | |
c180536 |
// check existence
if g.controllers[name] != nil {
panic(fmt.Sprintf(`fire: controller with name "%s" already exists`, name))
}
// create entry in controller map
g.controllers[name] = controller
}
} | |
c180537 |
}
// get action
action, ok := g.actions[s[0]]
if ok {
// check if action is allowed
if Contains(action.Action.Methods, r.Method) {
// check if action matches the context
if action.Action.Callback.Matcher(ctx) {
// run authorizers and handle errors
for _, cb := range action.Authorizers {
// check if callback should be run
if !cb.Matcher(ctx) {
continue
}
// call callback
err := cb.Handler(ctx)
if IsSafe(err) {
stack.Abort(&jsonapi.Error{
Status: http.StatusUnauthorized,
Detail: err.Error(),
})
} else if err != nil {
stack.Abort(err)
}
}
// limit request body size
LimitBody(ctx.ResponseWriter, ctx.HTTPRequest, int64(action.Action.BodyLimit))
// call action with context
stack.AbortIf(action.Action.Callback.Handler(ctx))
return
}
}
}
// otherwise return error
stack.Abort(jsonapi.NotFound("resource not found"))
})
} | |
c180538 |
// add index
i.AddRaw(C(model), mgo.Index{
Key: key,
Unique: unique,
ExpireAfter: expireAfter,
Background: true,
})
} | |
c180539 | append(i.indexes, index{
coll: coll,
index: idx,
})
} | |
c180540 | err := s.DB().C(i.coll).EnsureIndex(i.index)
if err != nil {
return err
}
}
return nil
} | |
c180541 | := &Catalog{
models: make(map[string]Model),
}
// add models
c.Add(models...)
return c
} | |
c180542 | with name "%s" already exists in catalog`, name))
}
// add model
c.models[name] = model
}
} | |
c180543 | model := range c.models {
models = append(models, model)
}
return models
} | |
c180544 |
// add all direct relationships
for _, field := range model.Meta().OrderedFields {
if field.RelName != "" && (field.ToOne || field.ToMany) {
list[name+"-"+field.RelName] = &rel{
from: name,
to: field.RelType,
srcMany: field.ToMany,
}
relNames = append(relNames, name+"-"+field.RelName)
}
}
}
// update relationships
for _, name := range names {
// get model
model := c.models[name]
// add all indirect relationships
for _, field := range model.Meta().OrderedFields {
if field.RelName != "" && (field.HasOne || field.HasMany) {
r := list[field.RelType+"-"+field.RelInverse]
r.dstMany = field.HasMany
r.hasInverse = true
}
}
}
// sort relationship names
sort.Strings(relNames)
// add relationships
for _, name := range relNames {
// get relationship
r := list[name]
// get style
style := "solid"
if !r.hasInverse {
style = "dotted"
}
// get color
color := "black"
if r.srcMany {
color = "black:white:black"
}
// write edge
out.WriteString(fmt.Sprintf(` "%s"--"%s"[ fontname="ArialMT", fontsize=7, dir=both, arrowsize="0.9", penwidth="0.9", labelangle=32, labeldistance="1.8", style=%s, color="%s", arrowhead=%s, arrowtail=%s ];`, lookup[r.from], lookup[r.to], style, color, "normal", "none") + "\n")
}
// end graph
out.WriteString("}\n")
return out.String()
} | |
c180545 | = out.Write(debug.Stack())
_, _ = fmt.Fprintln(out, "<=== End Error")
}
} | |
c180546 | indexer.Ensure(store)
if err != nil {
return err
}
return nil
} | |
c180547 | Safe(fmt.Errorf(format, a...))
} | |
c180548 | ok := chain[i].(func(http.Handler) http.Handler)
if !ok {
panic(`fire: expected intermediary chain item to be a "func(http.handler) http.Handler"`)
}
// chain
h = m(h)
}
return h
} | |
c180549 | range subset {
if !Contains(all, item) {
return false
}
}
return true
} | |
c180550 | {
if Contains(listB, item) {
list = append(list, item)
}
}
return list
} | |
c180551 | {
return &Error{
Reason: reason,
Retry: retry,
}
} | |
c180552 | tracer.Tag("http.proto", r.Proto)
tracer.Tag("http.method", r.Method)
tracer.Tag("http.host", r.Host)
tracer.Log("http.url", r.URL.String())
tracer.Log("http.length", r.ContentLength)
tracer.Log("http.header", r.Header)
r = r.WithContext(tracer.Context(r.Context()))
defer tracer.Finish(true)
// call next handler
next.ServeHTTP(w, r)
})
}
} | |
c180553 | := opentracing.StartSpanFromContext(r.Context(), name)
return NewTracer(span)
} | |
c180554 | make([]opentracing.Span, 0, 32),
}
} | |
c180555 | span := opentracing.StartSpan(name, opentracing.ChildOf(ctx))
// push span
t.spans = append(t.spans, span)
} | |
c180556 | return t.root
}
return t.spans[len(t.spans)-1]
} | |
c180557 | interface{}) {
t.Last().SetTag(key, value)
} | |
c180558 | interface{}) {
t.Last().LogKV(key, value)
} | |
c180559 | {
return opentracing.ContextWithSpan(ctx, t.Last())
} | |
c180560 | t.Last().Finish()
// resize slice
t.spans = t.spans[:len(t.spans)-1]
} | |
c180561 | := range t.spans {
span.Finish()
}
if root {
t.root.Finish()
}
} | |
c180562 |
queues: make(map[*Queue]bool),
closed: make(chan struct{}),
}
} | |
c180563 | to queue
task.Queue.tasks = append(task.Queue.tasks, task.Name)
// save queue
p.queues[task.Queue] = true
} | |
c180564 | start all tasks
for _, task := range p.tasks {
task.start(p)
}
} | |
c180565 | r.Body,
ReadCloser: http.MaxBytesReader(w, r.Body, n),
}
} | |
c180566 |
r.Body = bl.Original
}
// set new limiter
r.Body = NewBodyLimiter(w, r, n)
} | |
c180567 | return &Callback{
Matcher: m,
Handler: func(ctx *Context) error {
// begin trace
ctx.Tracer.Push(name)
// call handler
err := h(ctx)
if err != nil {
return err
}
// finish trace
ctx.Tracer.Pop()
return nil
},
}
} | |
c180568 | == ctx.Operation {
return true
}
}
return false
}
} | |
c180569 | }
// check if credentials match
if val, ok := credentials[user]; !ok || val != password {
return ErrAccessDenied
}
return nil
})
} | |
c180570 | }
// validate model
err := m.Validate()
if err != nil {
return err
}
return nil
})
} | |
c180571 | if ctx.Operation == Create {
ctx.Model.MustSet(ctf, now)
} else if t := ctx.Model.MustGet(ctf).(time.Time); t.IsZero() {
ctx.Model.MustSet(ctf, ctx.Model.ID().Time())
}
}
// always set updated timestamp
if utf != "" {
ctx.Model.MustSet(utf, now)
}
return nil
})
} | |
c180572 | {
bsonField = relatedField.Name
}
}
if bsonField == "" {
panic(fmt.Sprintf(`fire: missing field for inverse relationship: "%s"`, field.RelInverse))
}
// add relationship
dependentResources[relatedModel] = bsonField
}
// handle to-one and to-many relationships
if field.ToOne || field.ToMany {
// get related model
relatedModel := catalog.Find(field.RelType)
if relatedModel == nil {
panic(fmt.Sprintf(`fire: missing model in catalog: "%s"`, field.RelType))
}
// add relationship
references[field.Name] = relatedModel
}
}
// create callbacks
cb1 := DependentResourcesValidator(dependentResources)
cb2 := VerifyReferencesValidator(references)
return C("RelationshipValidator", func(ctx *Context) bool {
return cb1.Matcher(ctx) || cb2.Matcher(ctx)
}, func(ctx *Context) error {
// run dependent resources validator
if cb1.Matcher(ctx) {
err := cb1.Handler(ctx)
if err != nil {
return err
}
}
// run dependent resources validator
if cb2.Matcher(ctx) {
err := cb2.Handler(ctx)
if err != nil {
return err
}
}
return nil
})
} | |
c180573 | s.ruleList,
exceptionList: s.exceptionList,
}
}
close(jobs)
}()
for i := 0; i < len(objectGroupMap); i++ {
result := <-results
s.secretList = append(s.secretList, result.secretList...)
}
} | |
c180574 | fmt.Println(err)
}
r := &Rule{
Enabled: false,
Name: name,
Match: matchRegexp,
}
return r, nil
} | |
c180575 | unmatch)
if err != nil {
return err
}
r.Unmatch = append(r.Unmatch, unmatchRegexp)
return nil
} | |
c180576 | r.Match.MatchString(line) {
unmatch := false
for _, Unmatch := range r.Unmatch {
if Unmatch.MatchString(line) {
unmatch = true
}
}
if !unmatch {
results = append(results, RunResult{
Line: line,
Nline: nLine,
})
}
}
}
return results
} | |
c180577 |
Rule: rule,
Nline: nLine,
Line: line,
}
return s
} | |
c180578 | name,
Content: content,
Metadata: make(map[string]MetadataData),
PrimaryKeyHash: nil,
}
return o
} | |
c180579 | = MetadataData{
value: value,
attr: attr,
}
if attr.PrimaryKey {
o.updatePrimaryKeyHash()
}
return nil
} | |
c180580 | fmt.Errorf("%s unexistent key", key)
}
return data.value, nil
} | |
c180581 | := make(map[string]string)
for k, v := range o.Metadata {
metadataAll[k] = v.value
}
return metadataAll
} | |
c180582 |
return err
}
x.Rule = ruleRegexp
return nil
} | |
c180583 | {
return err
}
x.Object = objectRegexp
return nil
} | |
c180584 | x.Nline = &nLine
return nil
} | |
c180585 | {
return err
}
x.Content = contentRegexp
return nil
} | |
c180586 | != nil && *x.Nline != s.Nline {
match = false
}
if match && x.Content != nil && !x.Content.MatchString(s.Line) {
match = false
}
return match
} | |
c180587 | }
s.ruleList = append(s.ruleList, rule)
} | |
c180588 | return err
}
for k, v := range ruleYamlMap {
rule, err := models.NewRule(ruleBase+"."+k, v.Match)
if err != nil {
return err
}
for _, e := range v.Unmatch {
rule.AddUnmatch(e)
}
s.AddRule(*rule, defaulEnabled)
}
return nil
} | |
c180589 | if strings.HasSuffix(file, ".rule") {
err := s.LoadRulesFromFile(file, defaulEnabled)
if err != nil {
return err
}
}
}
return nil
} | |
c180590 | = os.ExpandEnv(defaultRulesDir)
}
return rulesPath
} | |
c180591 | setRuleEnabled(s.ruleList, name, true)
} | |
c180592 | setRuleEnabled(s.ruleList, name, false)
} | |
c180593 | setRuleEnabledByRegexp(s.ruleList, name, true)
} | |
c180594 | setRuleEnabledByRegexp(s.ruleList, name, false)
} | |
c180595 | {
return err
}
s.objectList = append(s.objectList, objectList...)
return nil
} | |
c180596 | {
return models.GroupObjectsByMetadata(s.objectList, k)
} | |
c180597 | {
return models.GroupObjectsByPrimaryKeyHash(s.objectList)
} | |
c180598 | append(s.exceptionList, exception)
} | |
c180599 | return err
}
}
if v.Line != nil {
err := x.SetNline(*v.Line)
if err != nil {
return err
}
}
if v.Content != nil {
err := x.SetContent(*v.Content)
if err != nil {
return err
}
}
s.AddException(*x)
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.