New executors

api/server_test.go

@@ -26,12 +26,15 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/loadimpact/k6/api/common"
 	"github.com/loadimpact/k6/core"
+	"github.com/loadimpact/k6/core/local"
 	"github.com/loadimpact/k6/lib"
-	log "github.com/sirupsen/logrus"
 	logtest "github.com/sirupsen/logrus/hooks/test"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/urfave/negroni"
 )
 
@@ -51,7 +54,7 @@ func TestLogger(t *testing.T) {
 					r := httptest.NewRequest(method, "http://example.com"+path, nil)
 
 					l, hook := logtest.NewNullLogger()
-					l.Level = log.DebugLevel
+					l.Level = logrus.DebugLevel
 					NewLogger(l)(negroni.NewResponseWriter(rw), r, testHTTPHandler)
 
 					res := rw.Result()
@@ -63,7 +66,7 @@ func TestLogger(t *testing.T) {
 					}
 
 					e := hook.LastEntry()
-					assert.Equal(t, log.DebugLevel, e.Level)
+					assert.Equal(t, logrus.DebugLevel, e.Level)
 					assert.Equal(t, fmt.Sprintf("%s %s", method, path), e.Message)
 					assert.Equal(t, http.StatusOK, e.Data["status"])
 				})
@@ -73,10 +76,10 @@ func TestLogger(t *testing.T) {
 }
 
 func TestWithEngine(t *testing.T) {
-	engine, err := core.NewEngine(nil, lib.Options{})
-	if !assert.NoError(t, err) {
-		return
-	}
+	executor, err := local.New(&lib.MiniRunner{}, logrus.StandardLogger())
+	require.NoError(t, err)
+	engine, err := core.NewEngine(executor, lib.Options{}, logrus.StandardLogger())
+	require.NoError(t, err)
 
 	rw := httptest.NewRecorder()
 	r := httptest.NewRequest("GET", "http://example.com/", nil)

api/v1/group_routes_test.go

@@ -30,7 +30,9 @@ import (
 	"github.com/loadimpact/k6/core/local"
 	"github.com/loadimpact/k6/lib"
 	"github.com/manyminds/api2go/jsonapi"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetGroups(t *testing.T) {
@@ -41,8 +43,10 @@ func TestGetGroups(t *testing.T) {
 	g2, err := g1.Group("group 2")
 	assert.NoError(t, err)
 
-	engine, err := core.NewEngine(local.New(&lib.MiniRunner{Group: g0}), lib.Options{})
-	assert.NoError(t, err)
+	executor, err := local.New(&lib.MiniRunner{Group: g0}, logrus.StandardLogger())
+	require.NoError(t, err)
+	engine, err := core.NewEngine(executor, lib.Options{}, logrus.StandardLogger())
+	require.NoError(t, err)
 
 	t.Run("list", func(t *testing.T) {
 		rw := httptest.NewRecorder()

api/v1/metric_routes.go

@@ -34,7 +34,7 @@ func HandleGetMetrics(rw http.ResponseWriter, r *http.Request, p httprouter.Para
 
 	var t time.Duration
 	if engine.Executor != nil {
-		t = engine.Executor.GetTime()
+		t = engine.Executor.GetState().GetCurrentTestRunDuration()
 	}
 
 	metrics := make([]Metric, 0)
@@ -56,7 +56,7 @@ func HandleGetMetric(rw http.ResponseWriter, r *http.Request, p httprouter.Param
 
 	var t time.Duration
 	if engine.Executor != nil {
-		t = engine.Executor.GetTime()
+		t = engine.Executor.GetState().GetCurrentTestRunDuration()
 	}
 
 	var metric Metric

api/v1/metric_routes_test.go

@@ -26,7 +26,12 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
+	"github.com/sirupsen/logrus"
+
 	"github.com/loadimpact/k6/core"
+	"github.com/loadimpact/k6/core/local"
 	"github.com/loadimpact/k6/lib"
 	"github.com/loadimpact/k6/stats"
 	"github.com/manyminds/api2go/jsonapi"
@@ -35,8 +40,10 @@ import (
 )
 
 func TestGetMetrics(t *testing.T) {
-	engine, err := core.NewEngine(nil, lib.Options{})
-	assert.NoError(t, err)
+	executor, err := local.New(&lib.MiniRunner{}, logrus.StandardLogger())
+	require.NoError(t, err)
+	engine, err := core.NewEngine(executor, lib.Options{}, logrus.StandardLogger())
+	require.NoError(t, err)
 
 	engine.Metrics = map[string]*stats.Metric{
 		"my_metric": stats.New("my_metric", stats.Trend, stats.Time),
@@ -74,8 +81,10 @@ func TestGetMetrics(t *testing.T) {
 }
 
 func TestGetMetric(t *testing.T) {
-	engine, err := core.NewEngine(nil, lib.Options{})
-	assert.NoError(t, err)
+	executor, err := local.New(&lib.MiniRunner{}, logrus.StandardLogger())
+	require.NoError(t, err)
+	engine, err := core.NewEngine(executor, lib.Options{}, logrus.StandardLogger())
+	require.NoError(t, err)
 
 	engine.Metrics = map[string]*stats.Metric{
 		"my_metric": stats.New("my_metric", stats.Trend, stats.Time),

api/v1/setup_teardown_routes_test.go

@@ -29,6 +29,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/sirupsen/logrus"
+
 	"github.com/loadimpact/k6/core"
 	"github.com/loadimpact/k6/core/local"
 	"github.com/loadimpact/k6/js"
@@ -140,14 +142,14 @@ func TestSetupData(t *testing.T) {
 			runner.SetOptions(lib.Options{
 				Paused:          null.BoolFrom(true),
 				VUs:             null.IntFrom(2),
-				VUsMax:          null.IntFrom(2),
 				Iterations:      null.IntFrom(3),
+				NoSetup:         null.BoolFrom(true),
 				SetupTimeout:    types.NullDurationFrom(1 * time.Second),
 				TeardownTimeout: types.NullDurationFrom(1 * time.Second),
 			})
-			executor := local.New(runner)
-			executor.SetRunSetup(false)
-			engine, err := core.NewEngine(executor, runner.GetOptions())
+			executor, err := local.New(runner, logrus.StandardLogger())
+			require.NoError(t, err)
+			engine, err := core.NewEngine(executor, runner.GetOptions(), logrus.StandardLogger())
 			require.NoError(t, err)
 
 			ctx, cancel := context.WithCancel(context.Background())

api/v1/status.go

@@ -36,11 +36,12 @@ type Status struct {
 }
 
 func NewStatus(engine *core.Engine) Status {
+	executorState := engine.Executor.GetState()
 	return Status{
-		Paused:  null.BoolFrom(engine.Executor.IsPaused()),
-		VUs:     null.IntFrom(engine.Executor.GetVUs()),
-		VUsMax:  null.IntFrom(engine.Executor.GetVUsMax()),
-		Running: engine.Executor.IsRunning(),
+		Running: executorState.HasStarted(),
+		Paused:  null.BoolFrom(executorState.IsPaused()),
+		VUs:     null.IntFrom(int64(executorState.GetCurrentlyActiveVUsCount())),
+		VUsMax:  null.IntFrom(int64(executorState.GetInitializedVUsCount())),
 		Tainted: engine.IsTainted(),
 	}
 }

api/v1/status_routes.go

@@ -56,22 +56,28 @@ func HandlePatchStatus(rw http.ResponseWriter, r *http.Request, p httprouter.Par
 		return
 	}
 
-	if status.VUsMax.Valid {
-		if err := engine.Executor.SetVUsMax(status.VUsMax.Int64); err != nil {
-			apiError(rw, "Couldn't change cap", err.Error(), http.StatusBadRequest)
-			return
-		}
-	}
-	if status.VUs.Valid {
-		if err := engine.Executor.SetVUs(status.VUs.Int64); err != nil {
-			apiError(rw, "Couldn't scale", err.Error(), http.StatusBadRequest)
+	if status.Paused.Valid {
+		if err = engine.Executor.SetPaused(status.Paused.Bool); err != nil {
+			apiError(rw, "Pause error", err.Error(), http.StatusInternalServerError)
 			return
 		}
 	}
-	if status.Paused.Valid {
-		engine.Executor.SetPaused(status.Paused.Bool)
-	}
 
+	/*
+		//TODO: handle manual executor update
+		if status.VUsMax.Valid {
+			if err := engine.Executor.SetVUsMax(status.VUsMax.Int64); err != nil {
+				apiError(rw, "Couldn't change cap", err.Error(), http.StatusBadRequest)
+				return
+			}
+		}
+		if status.VUs.Valid {
+			if err := engine.Executor.SetVUs(status.VUs.Int64); err != nil {
+				apiError(rw, "Couldn't scale", err.Error(), http.StatusBadRequest)
+				return
+			}
+		}
+	*/
 	data, err := jsonapi.Marshal(NewStatus(engine))
 	if err != nil {
 		apiError(rw, "Encoding error", err.Error(), http.StatusInternalServerError)

api/v1/status_routes_test.go

@@ -21,22 +21,25 @@
 package v1
 
 import (
-	"bytes"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
 	"github.com/loadimpact/k6/core"
+	"github.com/loadimpact/k6/core/local"
 	"github.com/loadimpact/k6/lib"
 	"github.com/manyminds/api2go/jsonapi"
+	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/guregu/null.v3"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetStatus(t *testing.T) {
-	engine, err := core.NewEngine(nil, lib.Options{})
-	assert.NoError(t, err)
+	executor, err := local.New(&lib.MiniRunner{}, logrus.StandardLogger())
+	require.NoError(t, err)
+	engine, err := core.NewEngine(executor, lib.Options{}, logrus.StandardLogger())
+	require.NoError(t, err)
 
 	rw := httptest.NewRecorder()
 	NewHandler().ServeHTTP(rw, newRequestWithEngine(engine, "GET", "/v1/status", nil))
@@ -62,6 +65,8 @@ func TestGetStatus(t *testing.T) {
 	})
 }
 
+//TODO: fix after the manual executor
+/*
 func TestPatchStatus(t *testing.T) {
 	testdata := map[string]struct {
 		StatusCode int
@@ -108,3 +113,4 @@ func TestPatchStatus(t *testing.T) {
 		})
 	}
 }
+*/

cmd/cloud.go

@@ -23,6 +23,7 @@ package cmd
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -33,6 +34,7 @@ import (
 	"github.com/loadimpact/k6/lib"
 	"github.com/loadimpact/k6/stats/cloud"
 	"github.com/loadimpact/k6/ui"
+	"github.com/loadimpact/k6/ui/pb"
 	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
@@ -57,11 +59,9 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 	RunE: func(cmd *cobra.Command, args []string) error {
 		//TODO: disable in quiet mode?
 		_, _ = BannerColor.Fprintf(stdout, "\n%s\n\n", Banner)
-		initBar := ui.ProgressBar{
-			Width: 60,
-			Left:  func() string { return "    uploading script" },
-		}
-		fprintf(stdout, "%s \r", initBar.String())
+
+		progressBar := pb.New(pb.WithConstLeft(" Init"))
+		printBar(progressBar, "Parsing script")
 
 		// Runner
 		pwd, err := os.Getwd()
@@ -81,11 +81,13 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 			return err
 		}
 
+		printBar(progressBar, "Getting script options")
 		r, err := newRunner(src, runType, fs, runtimeOptions)
 		if err != nil {
 			return err
 		}
 
+		printBar(progressBar, "Consolidating options")
 		cliOpts, err := getOptions(cmd.Flags())
 		if err != nil {
 			return err
@@ -99,6 +101,11 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 			return ExitCode{cerr, invalidConfigErrorCode}
 		}
 
+		//TODO: warn about lack of support for --no-setup and --no-teardown in the cloud?
+		//TODO: validate for usage of execution segment
+		//TODO: validate for manual exacution (i.e. schedulers that aren't distributable)
+		//TODO: move those validations to a separate function and reuse validateConfig()?
+
 		err = r.SetOptions(conf.Options)
 		if err != nil {
 			return err
@@ -113,6 +120,7 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 			return errors.New("Not logged in, please use `k6 login cloud`.")
 		}
 
+		printBar(progressBar, "Building the archive")
 		arc := r.MakeArchive()
 		// TODO: Fix this
 		// We reuse cloud.Config for parsing options.ext.loadimpact, but this probably shouldn't be
@@ -161,22 +169,28 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 		}
 
 		// Start cloud test run
+		printBar(progressBar, "Validating script options")
 		client := cloud.NewClient(cloudConfig.Token.String, cloudConfig.Host.String, Version)
 		if err := client.ValidateOptions(arc.Options); err != nil {
 			return err
 		}
 
+		printBar(progressBar, "Uploading archive")
 		refID, err := client.StartCloudTestRun(name, cloudConfig.ProjectID.Int64, arc)
 		if err != nil {
 			return err
 		}
+		progressBar.Modify(pb.WithConstLeft("   Run"))
+		printBar(progressBar, "Initializing the cloud test")
 
 		testURL := cloud.URLForResults(refID, cloudConfig)
 		fprintf(stdout, "\n\n")
-		fprintf(stdout, "     execution: %s\n", ui.ValueColor.Sprint("cloud"))
+		fprintf(stdout, "   executor: %s\n", ui.ValueColor.Sprint("cloud"))
 		fprintf(stdout, "     script: %s\n", ui.ValueColor.Sprint(filename))
 		fprintf(stdout, "     output: %s\n", ui.ValueColor.Sprint(testURL))
+		//TODO: print schedulers information
 		fprintf(stdout, "\n")
+		printBar(progressBar, "Initializing the cloud test")
 
 		// The quiet option hides the progress bar and disallow aborting the test
 		if quiet {
@@ -190,12 +204,15 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 
 		var progressErr error
 		testProgress := &cloud.TestProgressResponse{}
-		progress := ui.ProgressBar{
-			Width: 60,
-			Left: func() string {
-				return "  " + testProgress.RunStatusText
-			},
-		}
+		percentageFmt := "[" + pb.GetFixedLengthFloatFormat(100, 2) + "%%] %s"
+		progressBar.Modify(
+			pb.WithProgress(func() (float64, string) {
+				if testProgress.RunStatus < lib.RunStatusRunning {
+					return 0, testProgress.RunStatusText
+				}
+				return testProgress.Progress, fmt.Sprintf(percentageFmt, testProgress.Progress*100, testProgress.RunStatusText)
+			}),
+		)
 
 		ticker := time.NewTicker(time.Millisecond * 2000)
 		shouldExitLoop := false
@@ -209,8 +226,7 @@ This will execute the test on the Load Impact cloud service. Use "k6 login cloud
 					if (testProgress.RunStatus > lib.RunStatusRunning) || (exitOnRunning && testProgress.RunStatus == lib.RunStatusRunning) {
 						shouldExitLoop = true
 					}
-					progress.Progress = testProgress.Progress
-					fprintf(stdout, "%s\x1b[0K\r", progress.String())
+					printBar(progressBar, "")
 				} else {
 					log.WithError(progressErr).Error("Test progress error")
 				}