_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 {
re... | 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 n... | 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... | 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(str... | 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
... | 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)... | 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", fir... | 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,
}
}
/... | 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 = ""
... | 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 = ""... | 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... | 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
... | 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.Validation... | 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.Inte... | 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 exi... | 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... | 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: expireAft... | 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(" ... | 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... | 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) {
... | 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... | 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(ct... | 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]; ... | 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
}
r... | 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 creat... | 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 {
// ex... | 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{
... | 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) {
... | 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,
}
ret... | 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 && ... | 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, ... | 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 fi... | 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 {
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.