This change adds a --dot option to the eval command, which will simply output the MuGL graph using the DOT language. This allows you to use tools like Graphviz to inspect the resulting graph, including using the `dot` command to generate images (like PNGs and whatnot). For example, the simple MuGL program: class C extends mu.Resource {...} class B extends mu.Resource {...} class A extends mu.Resource { private b: B; private c: C; constructor() { this.b = new B(); this.c = new C(); } } let a = new A(); Results in the following DOT file, from `mu eval --dot`: strict digraph { Resource0 [label="A"]; Resource0 -> {Resource1 Resource2} Resource1 [label="B"]; Resource2 [label="C"]; } Eventually the auto-generated ResourceN identifiers will go away in favor of using true object monikers (marapongo/mu#76).
156 lines
4.9 KiB
Go
156 lines
4.9 KiB
Go
// Copyright 2016 Marapongo, Inc. All rights reserved.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/marapongo/mu/pkg/compiler"
|
|
"github.com/marapongo/mu/pkg/compiler/core"
|
|
"github.com/marapongo/mu/pkg/graph"
|
|
"github.com/marapongo/mu/pkg/graph/dotconv"
|
|
"github.com/marapongo/mu/pkg/tokens"
|
|
"github.com/marapongo/mu/pkg/util/cmdutil"
|
|
"github.com/marapongo/mu/pkg/util/contract"
|
|
)
|
|
|
|
func newEvalCmd() *cobra.Command {
|
|
var dotOutput bool
|
|
var cmd = &cobra.Command{
|
|
Use: "eval [blueprint] [-- [args]]",
|
|
Short: "Evaluate a MuPackage and create its MuGL graph representation",
|
|
Long: "Evaluate a MuPackage and create its MuGL graph representation.\n" +
|
|
"\n" +
|
|
"A graph is a topologically sorted directed-acyclic-graph (DAG), representing a\n" +
|
|
"collection of resources that may be used in a deployment operation like plan or apply.\n" +
|
|
"This graph is produced by evaluating the contents of a Mu blueprint package, and\n" +
|
|
"does not actually perform any updates to the target environment.\n" +
|
|
"\n" +
|
|
"By default, a blueprint package is loaded from the current directory. Optionally,\n" +
|
|
"a path to a blueprint elsewhere can be provided as the [blueprint] argument.",
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
// If there's a --, we need to separate out the command args from the stack args.
|
|
flags := cmd.Flags()
|
|
dashdash := flags.ArgsLenAtDash()
|
|
var packArgs []string
|
|
if dashdash != -1 {
|
|
packArgs = args[dashdash:]
|
|
args = args[0:dashdash]
|
|
}
|
|
|
|
// Create a compiler options object and map any flags and arguments to settings on it.
|
|
opts := core.DefaultOptions()
|
|
opts.Args = dashdashArgsToMap(packArgs)
|
|
|
|
// In the case of an argument, load that specific package and new up a compiler based on its base path.
|
|
// Otherwise, use the default workspace and package logic (which consults the current working directory).
|
|
var mugl graph.Graph
|
|
if len(args) == 0 {
|
|
comp, err := compiler.Newwd(opts)
|
|
if err != nil {
|
|
contract.Failf("fatal: %v", err)
|
|
}
|
|
mugl = comp.Compile()
|
|
} else {
|
|
fn := args[0]
|
|
if pkg := cmdutil.ReadPackageFromArg(fn); pkg != nil {
|
|
var comp compiler.Compiler
|
|
var err error
|
|
if fn == "-" {
|
|
comp, err = compiler.Newwd(opts)
|
|
} else {
|
|
comp, err = compiler.New(filepath.Dir(fn), opts)
|
|
}
|
|
if err != nil {
|
|
contract.Failf("fatal: %v", err)
|
|
}
|
|
mugl = comp.CompilePackage(pkg)
|
|
}
|
|
}
|
|
if mugl == nil {
|
|
return
|
|
}
|
|
|
|
// Finally, serialize that MuGL graph so that it's suitable for printing/serializing.
|
|
if dotOutput {
|
|
// Convert the output to a DOT file.
|
|
if err := dotconv.Print(mugl, os.Stdout); err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: failed to write DOT file to output: %v\n", err)
|
|
os.Exit(-1)
|
|
}
|
|
} else {
|
|
// Just print a very basic, yet (hopefully) aesthetically pleasinge, ascii-ization of the graph.
|
|
shown := make(map[graph.Vertex]bool)
|
|
for _, root := range mugl.Roots() {
|
|
printVertex(root, shown, "")
|
|
}
|
|
}
|
|
},
|
|
}
|
|
|
|
cmd.PersistentFlags().BoolVar(
|
|
&dotOutput, "dot", false,
|
|
"Output the graph as a DOT digraph (graph description language)")
|
|
|
|
return cmd
|
|
}
|
|
|
|
// printVertex just pretty-prints a graph. The output is not serializable, it's just for display purposes.
|
|
// TODO: option to print properties.
|
|
// TODO: full serializability, including a DOT file option.
|
|
func printVertex(v graph.Vertex, shown map[graph.Vertex]bool, indent string) {
|
|
s := v.Obj().Type()
|
|
if shown[v] {
|
|
fmt.Printf("%v%v: <cycle...>\n", indent, s)
|
|
} else {
|
|
shown[v] = true // prevent cycles.
|
|
fmt.Printf("%v%v:\n", indent, s)
|
|
for _, out := range v.Outs() {
|
|
printVertex(out, shown, indent+" -> ")
|
|
}
|
|
}
|
|
}
|
|
|
|
// dashdashArgsToMap is a simple args parser that places incoming key/value pairs into a map. These are then used
|
|
// during MuPackage compilation as inputs to the main entrypoint function.
|
|
// TODO: this is fairly rudimentary; we eventually want to support arrays, maps, and complex types.
|
|
func dashdashArgsToMap(args []string) core.Args {
|
|
mapped := make(core.Args)
|
|
|
|
for i := 0; i < len(args); i++ {
|
|
arg := args[i]
|
|
|
|
// Eat - or -- at the start.
|
|
if arg[0] == '-' {
|
|
arg = arg[1:]
|
|
if arg[0] == '-' {
|
|
arg = arg[1:]
|
|
}
|
|
}
|
|
|
|
// Now find a k=v, and split the k/v part.
|
|
if eq := strings.IndexByte(arg, '='); eq != -1 {
|
|
// For --k=v, simply store v underneath k's entry.
|
|
mapped[tokens.Name(arg[:eq])] = arg[eq+1:]
|
|
} else {
|
|
if i+1 < len(args) && args[i+1][0] != '-' {
|
|
// If the next arg doesn't start with '-' (i.e., another flag) use its value.
|
|
mapped[tokens.Name(arg)] = args[i+1]
|
|
i++
|
|
} else if arg[0:3] == "no-" {
|
|
// For --no-k style args, strip off the no- prefix and store false underneath k.
|
|
mapped[tokens.Name(arg[3:])] = false
|
|
} else {
|
|
// For all other --k args, assume this is a boolean flag, and set the value of k to true.
|
|
mapped[tokens.Name(arg)] = true
|
|
}
|
|
}
|
|
}
|
|
|
|
return mapped
|
|
}
|