_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q180500 | Run | test | func Run(enforcers ...*Enforcer) *Authorizer {
return A("ash/Run", fire.All(), func(ctx *fire.Context) ([]*Enforcer, error) {
return enforcers, nil
})
} | go | {
"resource": ""
} |
q180501 | And | test | func And(a, b *Authorizer) *Authorizer {
return A("ash/And", func(ctx *fire.Context) bool {
return a.Matcher(ctx) && b.Matcher(ctx)
}, func(ctx *fire.Context) ([]*Enforcer, error) {
// run first callback
enforcers1, err := a.Handler(ctx)
if err != nil {
return nil, err
} else if enforcers1 == nil {
return nil, nil
}
// run second callback
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
})
} | go | {
"resource": ""
} |
q180502 | Or | test | func Or(a, b *Authorizer) *Authorizer {
return A("ash/Or", func(ctx *fire.Context) bool {
return a.Matcher(ctx) || b.Matcher(ctx)
}, func(ctx *fire.Context) ([]*Enforcer, error) {
// check first authorizer
if a.Matcher(ctx) {
// run callback
enforcers, err := a.Handler(ctx)
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
})
} | go | {
"resource": ""
} |
q180503 | Enqueue | test | func (q *Queue) Enqueue(name string, data Model, delay time.Duration) (*Job, error) {
// copy store
store := q.store.Copy()
defer store.Close()
// enqueue job
job, err := Enqueue(store, name, data, delay)
if err != nil {
return nil, err
}
return job, nil
} | go | {
"resource": ""
} |
q180504 | Callback | test | func (q *Queue) Callback(name string, delay time.Duration, matcher fire.Matcher, cb func(ctx *fire.Context) Model) *fire.Callback {
return fire.C("axe/Queue.Callback", matcher, func(ctx *fire.Context) error {
// set task tag
ctx.Tracer.Tag("task", name)
// get data
var data Model
if cb != nil {
data = cb(ctx)
}
// check if controller 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
})
} | go | {
"resource": ""
} |
q180505 | NewWatcher | test | func NewWatcher() *Watcher {
// prepare watcher
w := &Watcher{
streams: make(map[string]*Stream),
}
// create and add manager
w.manager = newManager(w)
return w
} | go | {
"resource": ""
} |
q180506 | Add | test | func (w *Watcher) Add(stream *Stream) {
// initialize model
coal.Init(stream.Model)
// check existence
if w.streams[stream.Name()] != nil {
panic(fmt.Sprintf(`spark: stream with name "%s" already exists`, stream.Name()))
}
// save stream
w.streams[stream.Name()] = stream
// open stream
coal.OpenStream(stream.Store, stream.Model, nil, func(e coal.Event, id bson.ObjectId, m coal.Model, token []byte) {
// ignore real deleted events when soft delete has been enabled
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
})
} | go | {
"resource": ""
} |
q180507 | Action | test | func (w *Watcher) Action() *fire.Action {
return &fire.Action{
Methods: []string{"GET"},
Callback: fire.C("spark/Watcher.Action", fire.All(), func(ctx *fire.Context) error {
// handle connection
w.manager.handle(ctx)
return nil
}),
}
} | go | {
"resource": ""
} |
q180508 | Write | test | func (o Operation) Write() bool {
return o == Create || o == Update || o == Delete
} | go | {
"resource": ""
} |
q180509 | String | test | func (o Operation) String() string {
switch o {
case List:
return "List"
case Find:
return "Find"
case Create:
return "Create"
case Update:
return "Update"
case Delete:
return "Delete"
case CollectionAction:
return "CollectionAction"
case ResourceAction:
return "ResourceAction"
}
return ""
} | go | {
"resource": ""
} |
q180510 | Query | test | func (c *Context) Query() bson.M {
return bson.M{"$and": append([]bson.M{c.Selector}, c.Filters...)}
} | go | {
"resource": ""
} |
q180511 | Respond | test | func (c *Context) Respond(value interface{}) error {
// encode response
bytes, err := json.Marshal(value)
if err != nil {
return err
}
// write token
_, err = c.ResponseWriter.Write(bytes)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q180512 | EnsureApplication | test | func EnsureApplication(store *coal.Store, name, key, secret string) (string, error) {
// copy store
s := store.Copy()
defer s.Close()
// count main applications
var apps []Application
err := s.C(&Application{}).Find(bson.M{
coal.F(&Application{}, "Name"): name,
}).All(&apps)
if err != nil {
return "", err
}
// check existence
if len(apps) > 1 {
return "", errors.New("to many applications with that name")
} else if len(apps) == 1 {
return apps[0].Key, nil
}
// application 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
} | go | {
"resource": ""
} |
q180513 | EnsureFirstUser | test | func EnsureFirstUser(store *coal.Store, name, email, password string) error {
// copy store
s := store.Copy()
defer s.Close()
// check existence
n, err := s.C(&User{}).Count()
if err != nil {
return err
} else if n > 0 {
return nil
}
// user is missing
// create user
user := coal.Init(&User{}).(*User)
user.Name = name
user.Email = email
user.Password = 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
} | go | {
"resource": ""
} |
q180514 | Callback | test | func (s *Strategy) Callback() *fire.Callback {
// enforce defaults
if s.CollectionAction == nil {
s.CollectionAction = make(map[string][]*Authorizer)
}
if s.ResourceAction == nil {
s.ResourceAction = make(map[string][]*Authorizer)
}
// construct and return callback
return fire.C("ash/Strategy.Callback", fire.All(), func(ctx *fire.Context) (err error) {
switch ctx.Operation {
case fire.List:
err = s.call(ctx, s.List, s.Read, s.All)
case fire.Find:
err = s.call(ctx, s.Find, s.Read, s.All)
case fire.Create:
err = s.call(ctx, s.Create, s.Write, s.All)
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
})
} | go | {
"resource": ""
} |
q180515 | OpenStream | test | func OpenStream(store *Store, model Model, token []byte, receiver Receiver, opened func(), manager func(error) bool) *Stream {
// prepare resume token
var resumeToken *bson.Raw
// create resume token if available
if token != nil {
resumeToken = &bson.Raw{
Kind: bson.ElementDocument,
Data: token,
}
}
// create stream
s := &Stream{
store: store,
model: model,
token: resumeToken,
receiver: receiver,
opened: opened,
manager: manager,
}
// open stream
go s.open()
return s
} | go | {
"resource": ""
} |
q180516 | Close | test | func (s *Stream) Close() {
// get mutex
s.mutex.Lock()
defer s.mutex.Unlock()
// set flag
s.closed = true
// close active change stream
if s.current != nil {
_ = s.current.Close()
}
} | go | {
"resource": ""
} |
q180517 | AddTokenIndexes | test | func AddTokenIndexes(i *coal.Indexer, autoExpire bool) {
i.Add(&Token{}, false, 0, "Type")
i.Add(&Token{}, false, 0, "Application")
i.Add(&Token{}, false, 0, "User")
if autoExpire {
i.Add(&Token{}, false, time.Minute, "ExpiresAt")
}
} | go | {
"resource": ""
} |
q180518 | GetTokenData | test | func (t *Token) GetTokenData() (TokenType, []string, time.Time, bson.ObjectId, *bson.ObjectId) {
return t.Type, t.Scope, t.ExpiresAt, t.Application, t.User
} | go | {
"resource": ""
} |
q180519 | SetTokenData | test | func (t *Token) SetTokenData(typ TokenType, scope []string, expiresAt time.Time, client Client, resourceOwner ResourceOwner) {
t.Type = typ
t.Scope = scope
t.ExpiresAt = expiresAt
t.Application = client.ID()
if resourceOwner != nil {
t.User = coal.P(resourceOwner.ID())
}
} | go | {
"resource": ""
} |
q180520 | ValidSecret | test | func (a *Application) ValidSecret(secret string) bool {
return bcrypt.CompareHashAndPassword(a.SecretHash, []byte(secret)) == nil
} | go | {
"resource": ""
} |
q180521 | HashSecret | test | func (a *Application) HashSecret() error {
// check length
if len(a.Secret) == 0 {
return nil
}
// generate hash from password
hash, err := bcrypt.GenerateFromPassword([]byte(a.Secret), bcrypt.DefaultCost)
if err != nil {
return err
}
// save hash
a.SecretHash = hash
// clear password
a.Secret = ""
return nil
} | go | {
"resource": ""
} |
q180522 | ValidPassword | test | func (u *User) ValidPassword(password string) bool {
return bcrypt.CompareHashAndPassword(u.PasswordHash, []byte(password)) == nil
} | go | {
"resource": ""
} |
q180523 | HashPassword | test | func (u *User) HashPassword() error {
// check length
if len(u.Password) == 0 {
return nil
}
// generate hash from password
hash, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
if err != nil {
return err
}
// save hash
u.PasswordHash = hash
// clear password
u.Password = ""
return nil
} | go | {
"resource": ""
} |
q180524 | MustCreateStore | test | func MustCreateStore(uri string) *Store {
store, err := CreateStore(uri)
if err != nil {
panic(err)
}
return store
} | go | {
"resource": ""
} |
q180525 | CreateStore | test | func CreateStore(uri string) (*Store, error) {
session, err := mgo.Dial(uri)
if err != nil {
return nil, err
}
return NewStore(session), nil
} | go | {
"resource": ""
} |
q180526 | C | test | func (s *SubStore) C(model Model) *mgo.Collection {
return s.DB().C(C(model))
} | go | {
"resource": ""
} |
q180527 | NewAssetServer | test | func NewAssetServer(prefix, directory string) http.Handler {
// ensure prefix
prefix = "/" + strings.Trim(prefix, "/")
// create dir server
dir := http.Dir(directory)
// create file server
fs := http.FileServer(dir)
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))
} | go | {
"resource": ""
} |
q180528 | DefaultGrantStrategy | test | func DefaultGrantStrategy(scope oauth2.Scope, _ Client, _ ResourceOwner) (oauth2.Scope, error) {
// check scope
if !scope.Empty() {
return nil, ErrInvalidScope
}
return scope, nil
} | go | {
"resource": ""
} |
q180529 | DefaultTokenData | test | func DefaultTokenData(_ Client, ro ResourceOwner, _ GenericToken) map[string]interface{} {
if ro != nil {
return map[string]interface{}{
"user": ro.ID(),
}
}
return nil
} | go | {
"resource": ""
} |
q180530 | GenerateToken | test | func (p *Policy) GenerateToken(id bson.ObjectId, issuedAt, expiresAt time.Time, client Client, resourceOwner ResourceOwner, token GenericToken) (string, error) {
// prepare claims
claims := &TokenClaims{}
claims.Id = id.Hex()
claims.IssuedAt = issuedAt.Unix()
claims.ExpiresAt = expiresAt.Unix()
// set user data
if p.TokenData != nil {
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
} | go | {
"resource": ""
} |
q180531 | ParseToken | test | func (p *Policy) ParseToken(str string) (*TokenClaims, bool, error) {
// parse token and check id
var claims TokenClaims
_, err := jwt.ParseWithClaims(str, &claims, func(_ *jwt.Token) (interface{}, error) {
return p.Secret, nil
})
if valErr, ok := err.(*jwt.ValidationError); ok && valErr.Errors == jwt.ValidationErrorExpired {
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
} | go | {
"resource": ""
} |
q180532 | E | test | func E(name string, m fire.Matcher, h fire.Handler) *Enforcer {
return fire.C(name, m, h)
} | go | {
"resource": ""
} |
q180533 | MustGet | test | func (b *Base) MustGet(name string) interface{} {
// find field
field := b.meta.Fields[name]
if field == nil {
panic(fmt.Sprintf(`coal: field "%s" not found on "%s"`, name, b.meta.Name))
}
// read value from model struct
structField := reflect.ValueOf(b.model).Elem().Field(field.index)
return structField.Interface()
} | go | {
"resource": ""
} |
q180534 | MustSet | test | func (b *Base) MustSet(name string, value interface{}) {
// find field
field := b.meta.Fields[name]
if field == nil {
panic(fmt.Sprintf(`coal: field "%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))
} | go | {
"resource": ""
} |
q180535 | NewGroup | test | func NewGroup() *Group {
return &Group{
controllers: make(map[string]*Controller),
actions: make(map[string]*GroupAction),
}
} | go | {
"resource": ""
} |
q180536 | Add | test | func (g *Group) Add(controllers ...*Controller) {
for _, controller := range controllers {
// prepare controller
controller.prepare()
// get name
name := controller.Model.Meta().PluralName
// 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
}
} | go | {
"resource": ""
} |
q180537 | Endpoint | test | func (g *Group) Endpoint(prefix string) http.Handler {
// trim prefix
prefix = strings.Trim(prefix, "/")
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// create tracer
tracer := NewTracerFromRequest(r, "fire/Group.Endpoint")
defer tracer.Finish(true)
// continue any previous aborts
defer stack.Resume(func(err error) {
// directly write jsonapi errors
if jsonapiError, ok := err.(*jsonapi.Error); ok {
_ = jsonapi.WriteError(w, jsonapiError)
return
}
// set critical error on last span
tracer.Tag("error", true)
tracer.Log("error", err.Error())
tracer.Log("stack", stack.Trace())
// report critical errors if possible
if g.Reporter != nil {
g.Reporter(err)
}
// ignore errors caused by writing critical errors
_ = jsonapi.WriteError(w, jsonapi.InternalServerError(""))
})
// trim path
path := strings.Trim(r.URL.Path, "/")
path = strings.TrimPrefix(path, prefix)
path = strings.Trim(path, "/")
// check path
if path == "" {
stack.Abort(jsonapi.NotFound("resource not found"))
}
// split path
s := strings.Split(path, "/")
// prepare context
ctx := &Context{
Data: Map{},
HTTPRequest: r,
ResponseWriter: w,
Group: g,
Tracer: tracer,
}
// get controller
controller, ok := g.controllers[s[0]]
if ok {
// set controller
ctx.Controller = controller
// call controller with context
controller.generalHandler(prefix, ctx)
return
}
// 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"))
})
} | go | {
"resource": ""
} |
q180538 | Add | test | func (i *Indexer) Add(model Model, unique bool, expireAfter time.Duration, fields ...string) {
// construct key from fields
var key []string
for _, f := range fields {
key = append(key, F(model, f))
}
// add index
i.AddRaw(C(model), mgo.Index{
Key: key,
Unique: unique,
ExpireAfter: expireAfter,
Background: true,
})
} | go | {
"resource": ""
} |
q180539 | AddRaw | test | func (i *Indexer) AddRaw(coll string, idx mgo.Index) {
i.indexes = append(i.indexes, index{
coll: coll,
index: idx,
})
} | go | {
"resource": ""
} |
q180540 | Ensure | test | func (i *Indexer) Ensure(store *Store) error {
// copy store
s := store.Copy()
defer s.Close()
// go through all raw indexes
for _, i := range i.indexes {
// ensure single index
err := s.DB().C(i.coll).EnsureIndex(i.index)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q180541 | NewCatalog | test | func NewCatalog(models ...Model) *Catalog {
// create catalog
c := &Catalog{
models: make(map[string]Model),
}
// add models
c.Add(models...)
return c
} | go | {
"resource": ""
} |
q180542 | Add | test | func (c *Catalog) Add(models ...Model) {
for _, model := range models {
// get name
name := Init(model).Meta().PluralName
// check existence
if c.models[name] != nil {
panic(fmt.Sprintf(`coal: model with name "%s" already exists in catalog`, name))
}
// add model
c.models[name] = model
}
} | go | {
"resource": ""
} |
q180543 | All | test | func (c *Catalog) All() []Model {
// prepare models
models := make([]Model, 0, len(c.models))
// add models
for _, model := range c.models {
models = append(models, model)
}
return models
} | go | {
"resource": ""
} |
q180544 | Visualize | test | func (c *Catalog) Visualize(title string) string {
// prepare buffer
var out bytes.Buffer
// start graph
out.WriteString("graph G {\n")
out.WriteString(" rankdir=\"LR\";\n")
out.WriteString(" sep=\"0.3\";\n")
out.WriteString(" ranksep=\"0.5\";\n")
out.WriteString(" nodesep=\"0.4\";\n")
out.WriteString(" pad=\"0.4,0.4\";\n")
out.WriteString(" margin=\"0,0\";\n")
out.WriteString(" labelloc=\"t\";\n")
out.WriteString(" fontsize=\"13\";\n")
out.WriteString(" fontname=\"Arial BoldMT\";\n")
out.WriteString(" splines=\"spline\";\n")
out.WriteString(" overlap=\"voronoi\";\n")
out.WriteString(" outputorder=\"edgesfirst\";\n")
out.WriteString(" edge[headclip=true, tailclip=false];\n")
out.WriteString(" label=\"" + title + "\";\n")
// get a sorted list of model names and lookup table
var names []string
lookup := make(map[string]string)
for name, model := range c.models {
names = append(names, name)
lookup[name] = model.Meta().Name
}
sort.Strings(names)
// add model nodes
for _, name := range names {
// get model
model := c.models[name]
// write begin of node
out.WriteString(fmt.Sprintf(` "%s" [ style=filled, fillcolor=white, label=`, lookup[name]))
// write head table
out.WriteString(fmt.Sprintf(`<<table border="0" align="center" cellspacing="0.5" cellpadding="0" width="134"><tr><td align="center" valign="bottom" width="130"><font face="Arial BoldMT" point-size="11">%s</font></td></tr></table>|`, lookup[name]))
// write begin of tail table
out.WriteString(fmt.Sprintf(`<table border="0" align="left" cellspacing="2" cellpadding="0" width="134">`))
// write attributes
for _, field := range model.Meta().OrderedFields {
out.WriteString(fmt.Sprintf(`<tr><td align="left" width="130" port="%s">%s<font face="Arial ItalicMT" color="grey60"> %s</font></td></tr>`, field.Name, field.Name, field.Type.String()))
}
// write end of tail table
out.WriteString(fmt.Sprintf(`</table>>`))
// write end of node
out.WriteString(`, shape=Mrecord, fontsize=10, fontname="ArialMT", margin="0.07,0.05", penwidth="1.0" ];` + "\n")
}
// define temporary struct
type rel struct {
from, to string
srcMany bool
dstMany bool
hasInverse bool
}
// prepare list
list := make(map[string]*rel)
var relNames []string
// prepare relationships
for _, name := range names {
// get model
model := c.models[name]
// 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()
} | go | {
"resource": ""
} |
q180545 | NewErrorReporter | test | func NewErrorReporter(out io.Writer) func(error) {
return func(err error) {
_, _ = fmt.Fprintf(out, "===> Begin Error: %s\n", err.Error())
_, _ = out.Write(debug.Stack())
_, _ = fmt.Fprintln(out, "<=== End Error")
}
} | go | {
"resource": ""
} |
q180546 | EnsureIndexes | test | func EnsureIndexes(store *coal.Store) error {
// ensure model indexes
err := indexer.Ensure(store)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q180547 | E | test | func E(format string, a ...interface{}) error {
return Safe(fmt.Errorf(format, a...))
} | go | {
"resource": ""
} |
q180548 | Compose | test | func Compose(chain ...interface{}) http.Handler {
// check length
if len(chain) < 2 {
panic("fire: expected chain to have at least two items")
}
// get handler
h, ok := chain[len(chain)-1].(http.Handler)
if !ok {
panic(`fire: expected last chain item to be a "http.Handler"`)
}
// chain all middleware
for i := len(chain) - 2; i >= 0; i-- {
// get middleware
m, 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
} | go | {
"resource": ""
} |
q180549 | Includes | test | func Includes(all, subset []string) bool {
for _, item := range subset {
if !Contains(all, item) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q180550 | Intersect | test | func Intersect(listA, listB []string) []string {
// prepare new list
list := make([]string, 0, len(listA))
// add items that are part of both lists
for _, item := range listA {
if Contains(listB, item) {
list = append(list, item)
}
}
return list
} | go | {
"resource": ""
} |
q180551 | E | test | func E(reason string, retry bool) *Error {
return &Error{
Reason: reason,
Retry: retry,
}
} | go | {
"resource": ""
} |
q180552 | RootTracer | test | func RootTracer() func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// split url
segments := strings.Split(r.URL.Path, "/")
// replace ids
for i, s := range segments {
if bson.IsObjectIdHex(s) {
segments[i] = ":id"
}
}
// construct name
path := strings.Join(segments, "/")
name := fmt.Sprintf("%s %s", r.Method, path)
// create root span from request
tracer := NewTracerFromRequest(r, name)
tracer.Tag("peer.address", r.RemoteAddr)
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)
})
}
} | go | {
"resource": ""
} |
q180553 | NewTracerFromRequest | test | func NewTracerFromRequest(r *http.Request, name string) *Tracer {
span, _ := opentracing.StartSpanFromContext(r.Context(), name)
return NewTracer(span)
} | go | {
"resource": ""
} |
q180554 | NewTracer | test | func NewTracer(root opentracing.Span) *Tracer {
return &Tracer{
root: root,
spans: make([]opentracing.Span, 0, 32),
}
} | go | {
"resource": ""
} |
q180555 | Push | test | func (t *Tracer) Push(name string) {
// get context
var ctx opentracing.SpanContext
if len(t.spans) > 0 {
ctx = t.Last().Context()
} else {
ctx = t.root.Context()
}
// create new span
span := opentracing.StartSpan(name, opentracing.ChildOf(ctx))
// push span
t.spans = append(t.spans, span)
} | go | {
"resource": ""
} |
q180556 | Last | test | func (t *Tracer) Last() opentracing.Span {
// return root if empty
if len(t.spans) == 0 {
return t.root
}
return t.spans[len(t.spans)-1]
} | go | {
"resource": ""
} |
q180557 | Tag | test | func (t *Tracer) Tag(key string, value interface{}) {
t.Last().SetTag(key, value)
} | go | {
"resource": ""
} |
q180558 | Log | test | func (t *Tracer) Log(key string, value interface{}) {
t.Last().LogKV(key, value)
} | go | {
"resource": ""
} |
q180559 | Context | test | func (t *Tracer) Context(ctx context.Context) context.Context {
return opentracing.ContextWithSpan(ctx, t.Last())
} | go | {
"resource": ""
} |
q180560 | Pop | test | func (t *Tracer) Pop() {
// check list
if len(t.spans) == 0 {
return
}
// finish last span
t.Last().Finish()
// resize slice
t.spans = t.spans[:len(t.spans)-1]
} | go | {
"resource": ""
} |
q180561 | Finish | test | func (t *Tracer) Finish(root bool) {
for _, span := range t.spans {
span.Finish()
}
if root {
t.root.Finish()
}
} | go | {
"resource": ""
} |
q180562 | NewPool | test | func NewPool() *Pool {
return &Pool{
tasks: make(map[string]*Task),
queues: make(map[*Queue]bool),
closed: make(chan struct{}),
}
} | go | {
"resource": ""
} |
q180563 | Add | test | func (p *Pool) Add(task *Task) {
// check existence
if p.tasks[task.Name] != nil {
panic(fmt.Sprintf(`axe: task with name "%s" already exists`, task.Name))
}
// save task
p.tasks[task.Name] = task
// add task to queue
task.Queue.tasks = append(task.Queue.tasks, task.Name)
// save queue
p.queues[task.Queue] = true
} | go | {
"resource": ""
} |
q180564 | Run | test | func (p *Pool) Run() {
// start all queues
for queue := range p.queues {
queue.start(p)
}
// start all tasks
for _, task := range p.tasks {
task.start(p)
}
} | go | {
"resource": ""
} |
q180565 | NewBodyLimiter | test | func NewBodyLimiter(w http.ResponseWriter, r *http.Request, n int64) *BodyLimiter {
return &BodyLimiter{
Original: r.Body,
ReadCloser: http.MaxBytesReader(w, r.Body, n),
}
} | go | {
"resource": ""
} |
q180566 | LimitBody | test | func LimitBody(w http.ResponseWriter, r *http.Request, n int64) {
// get original body from existing limiter
if bl, ok := r.Body.(*BodyLimiter); ok {
r.Body = bl.Original
}
// set new limiter
r.Body = NewBodyLimiter(w, r, n)
} | go | {
"resource": ""
} |
q180567 | C | test | func C(name string, m Matcher, h Handler) *Callback {
// panic if matcher or handler is not set
if m == nil || h == nil {
panic("fire: missing matcher or handler")
}
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
},
}
} | go | {
"resource": ""
} |
q180568 | Only | test | func Only(ops ...Operation) Matcher {
return func(ctx *Context) bool {
// allow if operation is listed
for _, op := range ops {
if op == ctx.Operation {
return true
}
}
return false
}
} | go | {
"resource": ""
} |
q180569 | BasicAuthorizer | test | func BasicAuthorizer(credentials map[string]string) *Callback {
return C("fire/BasicAuthorizer", All(), func(ctx *Context) error {
// check for credentials
user, password, ok := ctx.HTTPRequest.BasicAuth()
if !ok {
return ErrAccessDenied
}
// check if credentials match
if val, ok := credentials[user]; !ok || val != password {
return ErrAccessDenied
}
return nil
})
} | go | {
"resource": ""
} |
q180570 | ModelValidator | test | func ModelValidator() *Callback {
return C("fire/ModelValidator", Only(Create, Update), func(ctx *Context) error {
// check model
m, ok := ctx.Model.(ValidatableModel)
if !ok {
return fmt.Errorf("model is not validatable")
}
// validate model
err := m.Validate()
if err != nil {
return err
}
return nil
})
} | go | {
"resource": ""
} |
q180571 | TimestampValidator | test | func TimestampValidator() *Callback {
return C("fire/TimestampValidator", Only(Create, Update), func(ctx *Context) error {
// get time
now := time.Now()
// get timestamp fields
ctf := coal.L(ctx.Model, "fire-created-timestamp", false)
utf := coal.L(ctx.Model, "fire-updated-timestamp", false)
// set created timestamp on creation and set missing create timestamps
// to the timestamp inferred from the model id
if ctf != "" {
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
})
} | go | {
"resource": ""
} |
q180572 | RelationshipValidator | test | func RelationshipValidator(model coal.Model, catalog *coal.Catalog, excludedFields ...string) *Callback {
// prepare lists
dependentResources := make(map[coal.Model]string)
references := make(map[string]coal.Model)
// iterate through all fields
for _, field := range coal.Init(model).Meta().Relationships {
// exclude field if requested
if Contains(excludedFields, field.Name) {
continue
}
// handle has-one and has-many relationships
if field.HasOne || field.HasMany {
// get related model
relatedModel := catalog.Find(field.RelType)
if relatedModel == nil {
panic(fmt.Sprintf(`fire: missing model in catalog: "%s"`, field.RelType))
}
// get related bson field
bsonField := ""
for _, relatedField := range relatedModel.Meta().Relationships {
if relatedField.RelName == field.RelInverse {
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
})
} | go | {
"resource": ""
} |
q180573 | Inspect | test | func (s *Seekret) Inspect(Nworkers int) {
jobs := make(chan workerJob)
results := make(chan workerResult)
for w := 1; w <= Nworkers; w++ {
go inspect_worker(w, jobs, results)
}
objectGroupMap := s.GroupObjectsByPrimaryKeyHash()
go func() {
for _, objectGroup := range objectGroupMap {
jobs <- workerJob{
objectGroup: objectGroup,
ruleList: s.ruleList,
exceptionList: s.exceptionList,
}
}
close(jobs)
}()
for i := 0; i < len(objectGroupMap); i++ {
result := <-results
s.secretList = append(s.secretList, result.secretList...)
}
} | go | {
"resource": ""
} |
q180574 | NewRule | test | func NewRule(name string, match string) (*Rule, error) {
matchRegexp, err := regexp.Compile("(?i)" + match)
if err != nil {
return nil, err
}
if err != nil {
fmt.Println(err)
}
r := &Rule{
Enabled: false,
Name: name,
Match: matchRegexp,
}
return r, nil
} | go | {
"resource": ""
} |
q180575 | AddUnmatch | test | func (r *Rule) AddUnmatch(unmatch string) error {
unmatchRegexp, err := regexp.Compile("(?i)" + unmatch)
if err != nil {
return err
}
r.Unmatch = append(r.Unmatch, unmatchRegexp)
return nil
} | go | {
"resource": ""
} |
q180576 | Run | test | func (r *Rule) Run(content []byte) []RunResult {
var results []RunResult
b := bufio.NewScanner(bytes.NewReader(content))
nLine := 0
for b.Scan() {
nLine = nLine + 1
line := b.Text()
if 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
} | go | {
"resource": ""
} |
q180577 | NewSecret | test | func NewSecret(object *Object, rule *Rule, nLine int, line string) *Secret {
s := &Secret{
Object: object,
Rule: rule,
Nline: nLine,
Line: line,
}
return s
} | go | {
"resource": ""
} |
q180578 | NewObject | test | func NewObject(name string, t string, st string, content []byte) *Object {
if len(content) > MaxObjectContentLen {
content = content[:MaxObjectContentLen]
}
o := &Object{
Type: t,
SubType: st,
Name: name,
Content: content,
Metadata: make(map[string]MetadataData),
PrimaryKeyHash: nil,
}
return o
} | go | {
"resource": ""
} |
q180579 | SetMetadata | test | func (o *Object) SetMetadata(key string, value string, attr MetadataAttributes) error {
o.Metadata[key] = MetadataData{
value: value,
attr: attr,
}
if attr.PrimaryKey {
o.updatePrimaryKeyHash()
}
return nil
} | go | {
"resource": ""
} |
q180580 | GetMetadata | test | func (o *Object) GetMetadata(key string) (string, error) {
data, ok := o.Metadata[key]
if !ok {
return "", fmt.Errorf("%s unexistent key", key)
}
return data.value, nil
} | go | {
"resource": ""
} |
q180581 | GetMetadataAll | test | func (o *Object) GetMetadataAll(attr bool) map[string]string {
metadataAll := make(map[string]string)
for k, v := range o.Metadata {
metadataAll[k] = v.value
}
return metadataAll
} | go | {
"resource": ""
} |
q180582 | SetRule | test | func (x *Exception) SetRule(rule string) error {
ruleRegexp, err := regexp.Compile("(?i)" + rule)
if err != nil {
return err
}
x.Rule = ruleRegexp
return nil
} | go | {
"resource": ""
} |
q180583 | SetObject | test | func (x *Exception) SetObject(object string) error {
objectRegexp, err := regexp.Compile("(?i)" + object)
if err != nil {
return err
}
x.Object = objectRegexp
return nil
} | go | {
"resource": ""
} |
q180584 | SetNline | test | func (x *Exception) SetNline(nLine int) error {
x.Nline = &nLine
return nil
} | go | {
"resource": ""
} |
q180585 | SetContent | test | func (x *Exception) SetContent(content string) error {
contentRegexp, err := regexp.Compile("(?i)" + content)
if err != nil {
return err
}
x.Content = contentRegexp
return nil
} | go | {
"resource": ""
} |
q180586 | Run | test | func (x *Exception) Run(s *Secret) bool {
match := true
if match && x.Rule != nil && !x.Rule.MatchString(s.Rule.Name) {
match = false
}
if match && x.Object != nil && !x.Object.MatchString(s.Object.Name) {
match = false
}
if match && x.Nline != nil && *x.Nline != s.Nline {
match = false
}
if match && x.Content != nil && !x.Content.MatchString(s.Line) {
match = false
}
return match
} | go | {
"resource": ""
} |
q180587 | AddRule | test | func (s *Seekret) AddRule(rule models.Rule, enabled bool) {
if enabled {
rule.Enable()
}
s.ruleList = append(s.ruleList, rule)
} | go | {
"resource": ""
} |
q180588 | LoadRulesFromFile | test | func (s *Seekret) LoadRulesFromFile(file string, defaulEnabled bool) error {
var ruleYamlMap map[string]ruleYaml
if file == "" {
return nil
}
filename, _ := filepath.Abs(file)
ruleBase := filepath.Base(filename)
if filepath.Ext(ruleBase) == ".rule" {
ruleBase = ruleBase[0 : len(ruleBase)-5]
}
yamlData, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
err = yaml.Unmarshal(yamlData, &ruleYamlMap)
if err != nil {
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
} | go | {
"resource": ""
} |
q180589 | LoadRulesFromDir | test | func (s *Seekret) LoadRulesFromDir(dir string, defaulEnabled bool) error {
fi, err := os.Stat(dir)
if err != nil {
return err
}
if !fi.IsDir() {
err := fmt.Errorf("%s is not a directory", dir)
return err
}
fileList, err := filepath.Glob(dir + "/*")
if err != nil {
return err
}
for _, file := range fileList {
if strings.HasSuffix(file, ".rule") {
err := s.LoadRulesFromFile(file, defaulEnabled)
if err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q180590 | DefaultRulesPath | test | func DefaultRulesPath() string {
rulesPath := os.Getenv("SEEKRET_RULES_PATH")
if rulesPath == "" {
rulesPath = os.ExpandEnv(defaultRulesDir)
}
return rulesPath
} | go | {
"resource": ""
} |
q180591 | EnableRule | test | func (s *Seekret) EnableRule(name string) error {
return setRuleEnabled(s.ruleList, name, true)
} | go | {
"resource": ""
} |
q180592 | DisableRule | test | func (s *Seekret) DisableRule(name string) error {
return setRuleEnabled(s.ruleList, name, false)
} | go | {
"resource": ""
} |
q180593 | EnableRuleByRegexp | test | func (s *Seekret) EnableRuleByRegexp(name string) int {
return setRuleEnabledByRegexp(s.ruleList, name, true)
} | go | {
"resource": ""
} |
q180594 | DisableRuleByRegexp | test | func (s *Seekret) DisableRuleByRegexp(name string) int {
return setRuleEnabledByRegexp(s.ruleList, name, false)
} | go | {
"resource": ""
} |
q180595 | LoadObjects | test | func (s *Seekret) LoadObjects(st SourceType, source string, opt LoadOptions) error {
objectList, err := st.LoadObjects(source, opt)
if err != nil {
return err
}
s.objectList = append(s.objectList, objectList...)
return nil
} | go | {
"resource": ""
} |
q180596 | GroupObjectsByMetadata | test | func (s *Seekret) GroupObjectsByMetadata(k string) map[string][]models.Object {
return models.GroupObjectsByMetadata(s.objectList, k)
} | go | {
"resource": ""
} |
q180597 | GroupObjectsByPrimaryKeyHash | test | func (s *Seekret) GroupObjectsByPrimaryKeyHash() map[string][]models.Object {
return models.GroupObjectsByPrimaryKeyHash(s.objectList)
} | go | {
"resource": ""
} |
q180598 | AddException | test | func (s *Seekret) AddException(exception models.Exception) {
s.exceptionList = append(s.exceptionList, exception)
} | go | {
"resource": ""
} |
q180599 | LoadExceptionsFromFile | test | func (s *Seekret) LoadExceptionsFromFile(file string) error {
var exceptionYamlList []exceptionYaml
if file == "" {
return nil
}
filename, _ := filepath.Abs(file)
yamlData, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
err = yaml.Unmarshal(yamlData, &exceptionYamlList)
if err != nil {
return err
}
for _, v := range exceptionYamlList {
x := models.NewException()
if v.Rule != nil {
err := x.SetRule(*v.Rule)
if err != nil {
return err
}
}
if v.Object != nil {
err := x.SetObject(*v.Object)
if err != nil {
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
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.