func mangleEvent(ctx context.Context, store *storage.Storage, txn storage.Transaction, event *topdown.Event) error {
// Replace bindings with ref values with the values from storage.
cpy := event.Locals.Copy()
var err error
event.Locals.Iter(func(k, v ast.Value) bool {
if r, ok := v.(ast.Ref); ok {
var path storage.Path
path, err = storage.NewPathForRef(r)
if err != nil {
return true
}
var doc interface{}
doc, err = store.Read(ctx, txn, path)
if err != nil {
return true
}
v, err = ast.InterfaceToValue(doc)
if err != nil {
return true
}
cpy.Put(k, v)
}
return false
})
event.Locals = cpy
switch node := event.Node.(type) {
case *ast.Rule:
event.Node = topdown.PlugHead(node.Head(), event.Locals.Get)
case *ast.Expr:
event.Node = topdown.PlugExpr(node, event.Locals.Get)
}
return nil
}
func dumpStorage(ctx context.Context, store *storage.Storage, txn storage.Transaction, w io.Writer) error {
data, err := store.Read(ctx, txn, storage.Path{})
if err != nil {
return err
}
e := json.NewEncoder(w)
return e.Encode(data)
}
func setupNodes(ctx context.Context, store *storage.Storage, txn storage.Transaction, n int) {
tmpl, err := template.New("node").Parse(nodeTemplate)
if err != nil {
panic(err)
}
if err := store.Write(ctx, txn, storage.AddOp, storage.MustParsePath("/nodes"), map[string]interface{}{}); err != nil {
panic(err)
}
for i := 0; i < n; i++ {
input := nodeTemplateInput{
Name: fmt.Sprintf("node%v", i),
}
v := runTemplate(tmpl, input)
path := storage.MustParsePath(fmt.Sprintf("/nodes/%v", input.Name))
if err := store.Write(ctx, txn, storage.AddOp, path, v); err != nil {
panic(err)
}
}
}
func compileAndStoreInputs(modules map[string]*loadedModule, store *storage.Storage, txn storage.Transaction) error {
policies := store.ListPolicies(txn)
for id, mod := range modules {
policies[id] = mod.Parsed
}
c := ast.NewCompiler()
if c.Compile(policies); c.Failed() {
return c.Errors
}
for id := range modules {
if err := store.InsertPolicy(txn, id, modules[id].Parsed, modules[id].Raw, false); err != nil {
return err
}
}
return nil
}