New executors

lib/scheduler/base_config.go

@@ -22,39 +22,34 @@ package scheduler
 
 import (
 	"fmt"
+	"regexp"
+	"strings"
 	"time"
 
 	"github.com/loadimpact/k6/lib/types"
 	null "gopkg.in/guregu/null.v3"
 )
 
-const minPercentage = 0.01
-
-// The maximum time k6 will wait after an iteration is supposed to be done
-const maxIterationTimeout = 300 * time.Second
+var schedulerNameWhitelist = regexp.MustCompile(`^[0-9a-zA-Z_-]+$`) //nolint:gochecknoglobals
 
 // BaseConfig contains the common config fields for all schedulers
 type BaseConfig struct {
-	Name             string             `json:"-"` // set via the JS object key
-	Type             string             `json:"type"`
-	StartTime        types.NullDuration `json:"startTime"`
-	Interruptible    null.Bool          `json:"interruptible"`
-	IterationTimeout types.NullDuration `json:"iterationTimeout"`
-	Env              map[string]string  `json:"env"`
-	Exec             null.String        `json:"exec"` // function name, externally validated
-	Percentage       float64            `json:"-"`    // 100, unless Split() was called
+	Name         string             `json:"-"` // set via the JS object key
+	Type         string             `json:"type"`
+	StartTime    types.NullDuration `json:"startTime"`
+	GracefulStop types.NullDuration `json:"gracefulStop"`
+	Env          map[string]string  `json:"env"`
+	Exec         null.String        `json:"exec"` // function name, externally validated
 
 	//TODO: future extensions like tags, distribution, others?
 }
 
 // NewBaseConfig returns a default base config with the default values
-func NewBaseConfig(name, configType string, interruptible bool) BaseConfig {
+func NewBaseConfig(name, configType string) BaseConfig {
 	return BaseConfig{
-		Name:             name,
-		Type:             configType,
-		Interruptible:    null.NewBool(interruptible, false),
-		IterationTimeout: types.NewNullDuration(30*time.Second, false),
-		Percentage:       100,
+		Name:         name,
+		Type:         configType,
+		GracefulStop: types.NewNullDuration(30*time.Second, false),
 	}
 }
 
@@ -65,39 +60,83 @@ func (bc BaseConfig) Validate() (errors []error) {
 	if bc.Name == "" {
 		errors = append(errors, fmt.Errorf("scheduler name shouldn't be empty"))
 	}
-	if bc.Type == "" {
-		errors = append(errors, fmt.Errorf("missing or empty type field"))
-	}
-	if bc.Percentage < minPercentage || bc.Percentage > 100 {
+	if !schedulerNameWhitelist.MatchString(bc.Name) {
 		errors = append(errors, fmt.Errorf(
-			"percentage should be between %f and 100, but is %f", minPercentage, bc.Percentage,
+			"the scheduler name should contain only numbers, latin letters, underscores, and dashes",
 		))
 	}
 	if bc.Exec.Valid && bc.Exec.String == "" {
 		errors = append(errors, fmt.Errorf("exec value cannot be empty"))
 	}
+	if bc.Type == "" {
+		errors = append(errors, fmt.Errorf("missing or empty type field"))
+	}
 	// The actually reasonable checks:
 	if bc.StartTime.Duration < 0 {
-		errors = append(errors, fmt.Errorf("scheduler start time can't be negative"))
+		errors = append(errors, fmt.Errorf("the startTime can't be negative"))
 	}
-	iterTimeout := time.Duration(bc.IterationTimeout.Duration)
-	if iterTimeout < 0 || iterTimeout > maxIterationTimeout {
-		errors = append(errors, fmt.Errorf(
-			"the iteration timeout should be between 0 and %s, but is %s", maxIterationTimeout, iterTimeout,
-		))
+	if bc.GracefulStop.Duration < 0 {
+		errors = append(errors, fmt.Errorf("the gracefulStop timeout can't be negative"))
 	}
 	return errors
 }
 
-// GetBaseConfig just returns itself
-func (bc BaseConfig) GetBaseConfig() BaseConfig {
-	return bc
+// GetName returns the name of the scheduler.
+func (bc BaseConfig) GetName() string {
+	return bc.Name
+}
+
+// GetType returns the scheduler's type as a string ID.
+func (bc BaseConfig) GetType() string {
+	return bc.Type
+}
+
+// GetStartTime returns the starting time, relative to the beginning of the
+// actual test, that this scheduler is supposed to execute.
+func (bc BaseConfig) GetStartTime() time.Duration {
+	return time.Duration(bc.StartTime.Duration)
 }
 
-// CopyWithPercentage is a helper function that just sets the percentage to
-// the specified amount.
-func (bc BaseConfig) CopyWithPercentage(percentage float64) *BaseConfig {
-	c := bc
-	c.Percentage = percentage
-	return &c
+// GetGracefulStop returns how long k6 is supposed to wait for any still
+// running iterations to finish executing at the end of the normal scheduler
+// duration, before it actually kills them.
+//
+// Of course, that doesn't count when the user manually interrupts the test,
+// then iterations are immediately stopped.
+func (bc BaseConfig) GetGracefulStop() time.Duration {
+	return time.Duration(bc.GracefulStop.Duration)
+}
+
+// GetEnv returns any specific environment key=value pairs that
+// are configured for the scheduler.
+func (bc BaseConfig) GetEnv() map[string]string {
+	return bc.Env
+}
+
+// GetExec returns the configured custom exec value, if any.
+func (bc BaseConfig) GetExec() null.String {
+	return bc.Exec
+}
+
+// IsDistributable returns true since by default all schedulers could be run in
+// a distributed manner.
+func (bc BaseConfig) IsDistributable() bool {
+	return true
+}
+
+// getBaseInfo is a helper method for the the "parent" String methods.
+func (bc BaseConfig) getBaseInfo(facts ...string) string {
+	if bc.Exec.Valid {
+		facts = append(facts, fmt.Sprintf("exec: %s", bc.Exec.String))
+	}
+	if bc.StartTime.Duration > 0 {
+		facts = append(facts, fmt.Sprintf("startTime: %s", bc.StartTime.Duration))
+	}
+	if bc.GracefulStop.Duration > 0 {
+		facts = append(facts, fmt.Sprintf("gracefulStop: %s", bc.GracefulStop.Duration))
+	}
+	if len(facts) == 0 {
+		return ""
+	}
+	return " (" + strings.Join(facts, ", ") + ")"
 }

lib/scheduler/base_scheduler.go

@@ -0,0 +1,89 @@
+/*
+ *
+ * k6 - a next-generation load testing tool
+ * Copyright (C) 2019 Load Impact
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+package scheduler
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/loadimpact/k6/lib"
+	"github.com/loadimpact/k6/ui/pb"
+	"github.com/sirupsen/logrus"
+)
+
+// BaseScheduler is a helper struct that contains common properties and methods
+// between most schedulers. It is intended to be used as an anonymous struct
+// inside of most of the schedulers, for the purpose of reducing boilerplate
+// code.
+type BaseScheduler struct {
+	config        lib.SchedulerConfig
+	executorState *lib.ExecutorState
+	logger        *logrus.Entry
+	progress      *pb.ProgressBar
+}
+
+// NewBaseScheduler just returns an initialized BaseScheduler
+func NewBaseScheduler(config lib.SchedulerConfig, es *lib.ExecutorState, logger *logrus.Entry) *BaseScheduler {
+	return &BaseScheduler{
+		config:        config,
+		executorState: es,
+		logger:        logger,
+		progress: pb.New(
+			pb.WithLeft(config.GetName),
+		),
+	}
+}
+
+// Init doesn't do anything for most schedulers, since initialization of all
+// planned VUs is handled by the executor.
+func (bs *BaseScheduler) Init(_ context.Context) error {
+	return nil
+}
+
+// GetConfig returns the configuration with which this scheduler was launched.
+func (bs BaseScheduler) GetConfig() lib.SchedulerConfig {
+	return bs.config
+}
+
+// GetLogger returns the scheduler logger entry.
+func (bs BaseScheduler) GetLogger() *logrus.Entry {
+	return bs.logger
+}
+
+// GetProgress just returns the progressbar pointer.
+func (bs BaseScheduler) GetProgress() *pb.ProgressBar {
+	return bs.progress
+}
+
+// IsPausable just returns false, since most schedulers are not pausable after
+// they have been started...
+func (BaseScheduler) IsPausable() bool {
+	return false
+}
+
+// LiveUpdate just returns false, since most schedulers' configs cannot be
+// updated in-flight.
+func (bs BaseScheduler) LiveUpdate(_ bool, _ lib.SchedulerConfig) error {
+	return fmt.Errorf(
+		"%s scheduler '%s' doesn't support pausing or live configuration updates",
+		bs.config.GetType(), bs.config.GetName(),
+	)
+}