Experiment Creation (WIP)

cmd/labapp/command/root.go

@@ -105,7 +105,6 @@ func appAction(c *cli.Context) error {
 	if err != nil {
 		return err
 	}
-
 	ctx := cliutil.CommandContext(c)
 	ctx, tracer, closer := traceutil.New(ctx, "labapp", nil)
 	defer closer.Close()
@@ -125,7 +124,6 @@ func appAction(c *cli.Context) error {
 			ctx = opentracing.ContextWithSpan(ctx, span)
 		}
 	}
-
 	app, err := labapp.New(ctx, root, c.GlobalString("address"), c.GlobalInt("libp2p-port"), zerolog.Ctx(ctx), metadata.PeerDefinition{
 		Transports:         c.GlobalStringSlice("libp2p-transports"),
 		Muxers:             c.GlobalStringSlice("libp2p-muxers"),

cmd/labctl/command/debug.go

@@ -19,8 +19,11 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/Netflix/p2plab"
 	"github.com/Netflix/p2plab/metadata"
+	"github.com/Netflix/p2plab/nodes"
 	"github.com/Netflix/p2plab/pkg/cliutil"
+	"github.com/Netflix/p2plab/query"
 	"github.com/urfave/cli"
 )
 
@@ -58,6 +61,19 @@ var debugCommand = cli.Command{
 				},
 			},
 		},
+		{
+			Name:      "connect",
+			Aliases:   []string{"c"},
+			Usage:     "Connects a cluster together",
+			ArgsUsage: "<cluster>",
+			Action:    connectAction,
+			Flags: []cli.Flag{
+				cli.StringFlag{
+					Name:  "query,q",
+					Usage: "Runs a query to filter the listed nodes.",
+				},
+			},
+		},
 	},
 }
 
@@ -103,3 +119,41 @@ func runTaskAction(c *cli.Context) error {
 
 	return nil
 }
+
+func connectAction(c *cli.Context) error {
+	if c.NArg() != 1 {
+		return errors.New("cluster id must be provided")
+	}
+
+	control, err := ResolveControl(c)
+	if err != nil {
+		return err
+	}
+
+	var opts []p2plab.ListOption
+	ctx := cliutil.CommandContext(c)
+	if c.IsSet("query") {
+		q, err := query.Parse(ctx, c.String("query"))
+		if err != nil {
+			return err
+		}
+
+		opts = append(opts, p2plab.WithQuery(q.String()))
+	}
+
+	cluster := c.Args().First()
+	ns, err := control.Node().List(ctx, cluster)
+	if err != nil {
+		return err
+	}
+	if len(ns) == 0 {
+		return fmt.Errorf("No nodes found for %q", cluster)
+	}
+
+	err = nodes.WaitHealthy(ctx, ns)
+	if err != nil {
+		return err
+	}
+
+	return nodes.Connect(ctx, ns)
+}

cmd/labctl/command/experiment.go

@@ -16,6 +16,7 @@ package command
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/Netflix/p2plab"
 	"github.com/Netflix/p2plab/experiments"
@@ -33,7 +34,7 @@ var experimentCommand = cli.Command{
 	Subcommands: []cli.Command{
 		{
 			Name:      "create",
-			Aliases:   []string{"s"},
+			Aliases:   []string{"c"},
 			Usage:     "Creates an experiment from a definition file",
 			ArgsUsage: "<filename>",
 			Action:    createExperimentAction,
@@ -42,6 +43,10 @@ var experimentCommand = cli.Command{
 					Name:  "name",
 					Usage: "Name of the experiment, by default takes the name of the experiment definition.",
 				},
+				&cli.BoolFlag{
+					Name:  "dry-run",
+					Usage: "dry run the epxeriment creation, parsing the cue file and printing it to stdout",
+				},
 			},
 		},
 		{
@@ -96,7 +101,7 @@ func createExperimentAction(c *cli.Context) error {
 		return errors.New("experiment definition must be provided")
 	}
 
-	p, err := CommandPrinter(c, printer.OutputID)
+	p, err := CommandPrinter(c, printer.OutputJSON)
 	if err != nil {
 		return err
 	}
@@ -112,18 +117,32 @@ func createExperimentAction(c *cli.Context) error {
 		return err
 	}
 
+	if c.Bool("dry-run") {
+		dt, err := edef.ToJSON()
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(dt))
+		return nil
+	}
+
 	control, err := ResolveControl(c)
 	if err != nil {
 		return err
 	}
 
 	ctx := cliutil.CommandContext(c)
-	experiment, err := control.Experiment().Create(ctx, name, edef)
+	id, err := control.Experiment().Create(ctx, name, edef)
 	if err != nil {
 		return err
 	}
 
+	experiment, err := control.Experiment().Get(ctx, id)
+	if err != nil {
+		return err
+	}
 	zerolog.Ctx(ctx).Info().Msgf("Completed experiment %q", experiment.Metadata().ID)
+
 	return p.Print(experiment.Metadata())
 }
 

cue/cue.mod/Makefile

@@ -1,3 +1,3 @@
 .PHONY: build
 build:
-	cue export p2plab_example.cue p2plab.cue
+	cue export p2plab_example1.cue p2plab.cue

cue/cue.mod/p2plab.cue

@@ -9,6 +9,17 @@ Group :: {
     region: string
     // labels is an optional field
     labels?: [...string]
+    // although not optional if left unspecified
+    // then we use the default values of Peer
+    peer: Peer | *Peer
+}
+
+Peer :: {
+	gitReference: string | *"HEAD"
+	transports: [...string] | *["tcp"]
+	muxers: [...string] | *["mplex"]
+	securityTransports: [...string] | *["secio"]
+	routing: string | *"nil"
 }
 
 // a cluster is a collection of 1 or more groups of nodes

cue/cue.mod/p2plab_example1.cue

@@ -34,18 +34,17 @@ scen1:: Scenario & {
             "neighbors": "golang"
         }
         benchmark: {
-            "(not neighbors)": "golang"
+            "(not 'neighbors')": "golang"
         }
 }
 
 scen2:: Scenario & {
         objects:  [ items ]
         seed: {
-            "neighbors": "golang"
+            "neighbors": "mysql"
         }
         benchmark: {
-            "(neighbors)": "golang"
-            "(not neighbors)": "mysql"
+            "(not 'neighbors')": "mysql"
         }
 }
 
@@ -60,5 +59,4 @@ experiment: Experiment & {
             scenario: scen2
         }
     ]
-//    trials: [[clust1,scen1],[clust1,scen2]]
-}
+}

cue/cue.mod/p2plab_example2.cue

@@ -21,12 +21,13 @@ experiment: Experiment & {
 					"neighbors": "image"
 				}
 				benchmark: {
-					"(not neighbors)": "image"
+					"(not 'neighbors')": "image"
 				}
 			}
 		} for o in objects
 	]
 }
+
 objects :: [
 	[{
 		image: {
@@ -40,4 +41,4 @@ objects :: [
 			source: "docker.io/library/mysql:latest"
 		}
 	}],
-]
+]

cue/parser/p2plab_instance.go

@@ -20,7 +20,7 @@ func (p *P2PLabInstance) ToExperimentDefinition() (metadata.ExperimentDefinition
 		return metadata.ExperimentDefinition{}, err
 	}
 	return metadata.ExperimentDefinition{
-		TrialDefinition: trials,
+		Trials: trials,
 	}, nil
 }
 

cue/parser/parser.go

@@ -4,6 +4,65 @@ import (
 	"cuelang.org/go/cue"
 )
 
+var (
+	// CueTemplate contains the bare cue source template used to generate
+	// cue files
+	CueTemplate = `
+	// defines a set of nodes of size 1 or higher
+	// a "node" is simply an EC2 instance provisioned of the given type
+	// and there may be more than 1 node in a group, however there must always be 1
+	Group :: {
+		// must be greater than or equal to 1
+		// default value of this field is 1
+		size: >=1 | *1
+		instanceType: string
+		region: string
+		// labels is an optional field
+		labels?: [...string]
+		// although not optional if left unspecified
+		// then we use the default values of Peer
+		peer: Peer | *Peer
+	}
+
+	Peer :: {
+		gitReference: string | *"HEAD"
+		transports: [...string] | *["tcp"]
+		muxers: [...string] | *["mplex"]
+		securityTransports: [...string] | *["secio"]
+		routing: string | *"nil"
+	}
+
+	// a cluster is a collection of 1 or more groups of nodes
+	// that will be participating in a given benchmark
+	Cluster :: {
+		groups: [...Group]
+	}
+
+	// an object is a particular data format to be used in benchmarking
+	// typically these are container images
+	object :: [Name=_]: { 
+		type: string
+		source: string
+	}
+
+	Scenario :: {
+		objects: [...object]
+		seed: { ... }
+		// enable any fields for benchmark
+		benchmark:  { ... }
+	}
+
+	Trial :: {
+		cluster: Cluster
+		scenario: Scenario
+	}
+
+	Experiment :: {
+		trials: [...Trial]
+	}
+`
+)
+
 // Parser bundles the cue runtime with helper functions
 // to enable parsing of cue source files
 type Parser struct {

experiment.go

@@ -23,7 +23,7 @@ import (
 // ExperimentAPI is an unimplemented layer to run experiments, a collection
 // of benchmarks while varying some aspect.
 type ExperimentAPI interface {
-	Create(ctx context.Context, id string, edef metadata.ExperimentDefinition) (Experiment, error)
+	Create(ctx context.Context, name string, edef metadata.ExperimentDefinition) (id string, err error)
 
 	Get(ctx context.Context, id string) (Experiment, error)
 

experiments/definition.go

@@ -15,23 +15,26 @@
 package experiments
 
 import (
-	"encoding/json"
 	"io/ioutil"
 
+	"github.com/Netflix/p2plab/cue/parser"
 	"github.com/Netflix/p2plab/metadata"
 )
 
+// Parse reads the cue source file at filename and converts it to a
+// metadata.ExperimentDefinition type
 func Parse(filename string) (metadata.ExperimentDefinition, error) {
-	var edef metadata.ExperimentDefinition
 	content, err := ioutil.ReadFile(filename)
 	if err != nil {
-		return edef, err
+		return metadata.ExperimentDefinition{}, err
 	}
-
-	err = json.Unmarshal(content, &edef)
+	psr := parser.NewParser([]string{parser.CueTemplate})
+	inst, err := psr.Compile(
+		"p2plab_experiment",
+		string(content),
+	)
 	if err != nil {
-		return edef, err
+		return metadata.ExperimentDefinition{}, err
 	}
-
-	return edef, nil
+	return inst.ToExperimentDefinition()
 }

experiments/experiments_test.go

@@ -2,12 +2,10 @@ package experiments
 
 import (
 	"context"
-	"io/ioutil"
 	"os"
 	"strings"
 	"testing"
 
-	parser "github.com/Netflix/p2plab/cue/parser"
 	"github.com/Netflix/p2plab/metadata"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
@@ -85,17 +83,7 @@ func TestExperimentDefinition(t *testing.T) {
 }
 
 func newTestExperiment(t *testing.T, sourceFile, name string) metadata.Experiment {
-	data, err := ioutil.ReadFile("../cue/cue.mod/p2plab.cue")
-	require.NoError(t, err)
-	sourceData, err := ioutil.ReadFile(sourceFile)
-	require.NoError(t, err)
-	psr := parser.NewParser([]string{string(data)})
-	inst, err := psr.Compile(
-		name,
-		string(sourceData),
-	)
-	require.NoError(t, err)
-	edef, err := inst.ToExperimentDefinition()
+	edef, err := Parse(sourceFile)
 	require.NoError(t, err)
 	return metadata.Experiment{
 		ID:         uuid.New().String(),