cli: convert pop to mixin

cmd/pop/eval.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+	"github.com/go-clix/cli"
+	"github.com/pollypkg/polly/pkg/pop"
+)
+
+func mixCmd() *cli.Command {
+	cmd := &cli.Command{
+		Use:   "mix <path>",
+		Short: "output pop in mixin compatible format",
+		Args:  cli.ArgsExact(1),
+	}
+
+	printer := cmd.Flags().StringP("output", "o", "json", "output format. One of json, yaml")
+	system := cmd.Flags().StringP("system", "s", "", "choose subsystem. One of alerts, rules, grafana (default all)")
+
+	cmd.Run = func(cmd *cli.Command, args []string) error {
+		p, err := pop.Load(args[0])
+		if err != nil {
+			return err
+		}
+
+		mix, err := p.Mixin()
+		if err != nil {
+			return err
+		}
+
+		var out interface{} = mix
+		switch *system {
+		case "alerts":
+			out = map[string]interface{}{"groups": mix.PrometheusAlerts}
+		case "rules":
+			out = map[string]interface{}{"groups": mix.PrometheusRules}
+		case "grafana":
+			out = mix.GrafanaDashboards
+		}
+
+		return choosePrinter(*printer).Print(out)
+	}
+
+	return cmd
+}

cmd/pop/main.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"cuelang.org/go/cue/errors"
+	"github.com/go-clix/cli"
+)
+
+func main() {
+	log.SetFlags(0)
+
+	cmd := cli.Command{
+		Use: "pop",
+	}
+
+	cmd.AddCommand(
+		mixCmd(),
+	)
+
+	if err := cmd.Execute(); err != nil {
+		errors.Print(os.Stderr, err, nil)
+		os.Exit(1)
+	}
+}

cmd/pop/out.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+
+	"sigs.k8s.io/yaml"
+)
+
+type Printer interface {
+	Print(interface{}) error
+}
+
+func choosePrinter(p string) Printer {
+	switch p {
+	case "json":
+		return JSONPrinter{}
+	case "yaml", "yml":
+		return YAMLPrinter{}
+	}
+
+	log.Printf("warning: unknown printer '%s'. Falling back to 'json'", p)
+	return JSONPrinter{}
+}
+
+type JSONPrinter struct{}
+
+func (j JSONPrinter) Print(i interface{}) error {
+	data, err := json.MarshalIndent(i, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(string(data))
+	return nil
+}
+
+type YAMLPrinter struct{}
+
+func (y YAMLPrinter) Print(i interface{}) error {
+	data, err := yaml.Marshal(i)
+	if err != nil {
+		return err
+	}
+
+	fmt.Print(string(data))
+	return nil
+}

go.mod

@@ -0,0 +1,9 @@
+module github.com/pollypkg/polly
+
+go 1.16
+
+require (
+	cuelang.org/go v0.4.0
+	github.com/go-clix/cli v0.2.0
+	sigs.k8s.io/yaml v1.2.0
+)

pkg/pop/mix.cue

@@ -0,0 +1,49 @@
+import "encoding/json"
+
+// TODO: include full schema?
+// TODO: figure out why it stops working when uncommented (cue eval works tho)
+// prometheusAlerts: v0: {...}
+// prometheusRules: v0: {...}
+// grafanaDashboards: v0: {...}
+
+// TODO: handle different versions, deal with migrations, etc, etc
+mixin: {
+    // TODO: change to ruleConvert() once syntax sugar is available
+    _alerts: #ruleConvert&{_, #rules: prometheusAlerts.v0}
+    _rules: #ruleConvert&{_, #rules: prometheusRules.v0}
+    _dashboards: #dashboardConvert&{#dashboards: grafanaDashboards.v0}
+
+    {
+        prometheusAlerts: _alerts
+        prometheusRules: _rules
+        grafanaDashboards: _dashboards
+    }
+}
+
+#ruleConvert: {
+    #rules: [string]: {group: string, alert: {...}, ...}
+
+    [for n, r in (#flattenAlerts & {arg: #rules}).out {
+        name: n, rules: r
+    }]
+}
+
+#dashboardConvert: {
+    #dashboards: [string]: _
+
+    for k, v in #dashboards {
+        "\(k).json": json.Indent(json.Marshal(v), "", "  ")
+    }
+}
+
+#flattenAlerts: {
+    arg: [string]: { group: string, alert: {...} }
+    out: [string]: [...]
+    _inter: [string]: [string]: {...}
+    for n, v in arg {
+        _inter: "\(v.group)": "\(n)": v.alert
+    }
+    for g, a in _inter {
+        out: "\(g)": [ for v in a {v}, ...]
+    }
+}

pkg/pop/pop.go

@@ -0,0 +1,92 @@
+package pop
+
+import (
+	_ "embed"
+	"fmt"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/cuecontext"
+	"cuelang.org/go/cue/errors"
+	"cuelang.org/go/cue/load"
+)
+
+// Pop represents a polly package
+type Pop struct {
+	v   cue.Value
+	ctx *cue.Context
+}
+
+// New constructs a pop from a cue.Value
+func New(v cue.Value) *Pop {
+	return &Pop{v: v, ctx: v.Context()}
+}
+
+// Load a polly package from disk
+func Load(path string) (*Pop, error) {
+	inst := load.Instances([]string{path}, nil)
+	if len(inst) != 1 {
+		return nil, fmt.Errorf("polly requires exactly one instance. Found %d at '%s'", len(inst), path)
+	}
+
+	ctx := cuecontext.New()
+	v := ctx.BuildInstance(inst[0])
+	if err := v.Err(); err != nil {
+		return nil, err
+	}
+
+	if err := v.Validate(); err != nil {
+		return nil, err
+	}
+
+	return New(v), nil
+}
+
+// Value returns the underlying cue.Value
+func (p Pop) Value() cue.Value {
+	return p.v
+}
+
+// special CUE file to convert polly packages to mixin format
+//go:embed mix.cue
+var mixCue string
+
+// Mixin converts the polly package to mixin compatible format
+func (p Pop) Mixin() (*Mixin, error) {
+	mixer := p.v.Context().CompileString(mixCue,
+		cue.Filename("<polly/mix.cue>"),
+		cue.Scope(p.v),
+	)
+	if mixer.Err() != nil {
+		panic(fmt.Errorf("failed loading internal mix.cue! Please raise an issue. Error:\n%s", errors.Details(mixer.Err(), nil)))
+	}
+
+	mixed := mixer.Unify(p.v)
+	if mixed.Err() != nil {
+		return nil, mixed.Err()
+	}
+
+	if err := mixed.Validate(cue.Concrete(true)); err != nil {
+		return nil, err
+	}
+
+	mixin := mixer.LookupPath(cue.ParsePath("mixin"))
+
+	m := Mixin{
+		GrafanaDashboards: make(map[string]string),
+		PrometheusRules:   make([]interface{}, 0),
+		PrometheusAlerts:  make([]interface{}, 0),
+	}
+
+	if err := mixin.Decode(&m); err != nil {
+		return nil, fmt.Errorf("decoding CUE into struct: %w", err)
+	}
+
+	return &m, nil
+}
+
+// Mixin compatible format representation
+type Mixin struct {
+	GrafanaDashboards map[string]string `json:"grafanaDashboards"`
+	PrometheusRules   []interface{}     `json:"prometheusRules"`
+	PrometheusAlerts  []interface{}     `json:"prometheusAlerts"`
+}