replication: simplify parallel replication variables & expose them in config

closes #140

replication/driver/replication_driver.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/go-playground/validator"
 	"github.com/kr/pretty"
 	"github.com/pkg/errors"
 	"google.golang.org/grpc/codes"
@@ -19,7 +20,6 @@ import (
 
 	"github.com/zrepl/zrepl/replication/report"
 	"github.com/zrepl/zrepl/util/chainlock"
-	"github.com/zrepl/zrepl/util/envconst"
 )
 
 type interval struct {
@@ -84,6 +84,7 @@ type Planner interface {
 // an attempt represents a single planning & execution of fs replications
 type attempt struct {
 	planner Planner
+	config  Config
 
 	l *chainlock.L
 
@@ -181,10 +182,25 @@ type step struct {
 type ReportFunc func() *report.Report
 type WaitFunc func(block bool) (done bool)
 
-var maxAttempts = envconst.Int64("ZREPL_REPLICATION_MAX_ATTEMPTS", 3)
-var reconnectHardFailTimeout = envconst.Duration("ZREPL_REPLICATION_RECONNECT_HARD_FAIL_TIMEOUT", 10*time.Minute)
+type Config struct {
+	StepQueueConcurrency     int           `validate:"gte=1"`
+	MaxAttempts              int           `validate:"eq=-1|gt=0"`
+	ReconnectHardFailTimeout time.Duration `validate:"gt=0"`
+}
+
+var validate = validator.New()
+
+func (c Config) Validate() error {
+	return validate.Struct(c)
+}
+
+// caller must ensure config.Validate() == nil
+func Do(ctx context.Context, config Config, planner Planner) (ReportFunc, WaitFunc) {
+
+	if err := config.Validate(); err != nil {
+		panic(err)
+	}
 
-func Do(ctx context.Context, planner Planner) (ReportFunc, WaitFunc) {
 	log := getLog(ctx)
 	l := chainlock.New()
 	run := &run{
@@ -201,7 +217,7 @@ func Do(ctx context.Context, planner Planner) (ReportFunc, WaitFunc) {
 		defer log.Debug("run ended")
 		var prev *attempt
 		mainLog := log
-		for ano := 0; ano < int(maxAttempts) || maxAttempts == 0; ano++ {
+		for ano := 0; ano < int(config.MaxAttempts); ano++ {
 			log := mainLog.WithField("attempt_number", ano)
 			log.Debug("start attempt")
 
@@ -213,6 +229,7 @@ func Do(ctx context.Context, planner Planner) (ReportFunc, WaitFunc) {
 				l:         l,
 				startedAt: time.Now(),
 				planner:   planner,
+				config:    config,
 			}
 			run.attempts = append(run.attempts, cur)
 			run.l.DropWhile(func() {
@@ -248,7 +265,7 @@ func Do(ctx context.Context, planner Planner) (ReportFunc, WaitFunc) {
 			shouldReconnect := mostRecentErrClass == errorClassTemporaryConnectivityRelated
 			log.WithField("reconnect_decision", shouldReconnect).Debug("reconnect decision made")
 			if shouldReconnect {
-				run.waitReconnect.Set(time.Now(), reconnectHardFailTimeout)
+				run.waitReconnect.Set(time.Now(), config.ReconnectHardFailTimeout)
 				log.WithField("deadline", run.waitReconnect.End()).Error("temporary connectivity-related error identified, start waiting for reconnect")
 				var connectErr error
 				var connectErrTime time.Time
@@ -421,7 +438,7 @@ func (a *attempt) doFilesystems(ctx context.Context, prevs map[*fs]*fs) {
 	defer a.l.Lock().Unlock()
 
 	stepQueue := newStepQueue()
-	defer stepQueue.Start(envconst.Int("ZREPL_REPLICATION_EXPERIMENTAL_REPLICATION_CONCURRENCY", 1))() // TODO parallel replication
+	defer stepQueue.Start(a.config.StepQueueConcurrency)()
 	var fssesDone sync.WaitGroup
 	for _, f := range a.fss {
 		fssesDone.Add(1)

replication/driver/replication_driver_test.go

@@ -154,7 +154,12 @@ func TestReplication(t *testing.T) {
 	defer trace.WithTaskFromStackUpdateCtx(&ctx)()
 
 	mp := &mockPlanner{}
-	getReport, wait := Do(ctx, mp)
+	driverConfig := Config{
+		StepQueueConcurrency:     1,
+		MaxAttempts:              1,
+		ReconnectHardFailTimeout: 1 * time.Second,
+	}
+	getReport, wait := Do(ctx, driverConfig, mp)
 	begin := time.Now()
 	fireAt := []time.Duration{
 		// the following values are relative to the start

replication/logic/replication_logic.go

@@ -19,7 +19,6 @@ import (
 	"github.com/zrepl/zrepl/replication/report"
 	"github.com/zrepl/zrepl/util/bytecounter"
 	"github.com/zrepl/zrepl/util/chainlock"
-	"github.com/zrepl/zrepl/util/envconst"
 	"github.com/zrepl/zrepl/util/semaphore"
 	"github.com/zrepl/zrepl/zfs"
 )
@@ -222,7 +221,11 @@ func (s *Step) ReportInfo() *report.StepInfo {
 	}
 }
 
+// caller must ensure policy.Validate() == nil
 func NewPlanner(secsPerState *prometheus.HistogramVec, bytesReplicated *prometheus.CounterVec, sender Sender, receiver Receiver, policy PlannerPolicy) *Planner {
+	if err := policy.Validate(); err != nil {
+		panic(err)
+	}
 	return &Planner{
 		sender:              sender,
 		receiver:            receiver,
@@ -272,7 +275,7 @@ func (p *Planner) doPlanning(ctx context.Context) ([]*Filesystem, error) {
 	}
 	rfss := rlfssres.GetFilesystems()
 
-	sizeEstimateRequestSem := semaphore.New(envconst.Int64("ZREPL_REPLICATION_MAX_CONCURRENT_SIZE_ESTIMATE", 4))
+	sizeEstimateRequestSem := semaphore.New(int64(p.policy.SizeEstimationConcurrency))
 
 	q := make([]*Filesystem, 0, len(sfss))
 	for _, fs := range sfss {

replication/logic/replication_logic_policy.go

@@ -1,6 +1,7 @@
 package logic
 
 import (
+	"github.com/go-playground/validator"
 	"github.com/pkg/errors"
 
 	"github.com/zrepl/zrepl/config"
@@ -8,8 +9,15 @@ import (
 )
 
 type PlannerPolicy struct {
-	EncryptedSend     tri // all sends must be encrypted (send -w, and encryption!=off)
-	ReplicationConfig *pdu.ReplicationConfig
+	EncryptedSend             tri // all sends must be encrypted (send -w, and encryption!=off)
+	ReplicationConfig         *pdu.ReplicationConfig
+	SizeEstimationConcurrency int `validate:"gte=1"`
+}
+
+var validate = validator.New()
+
+func (p PlannerPolicy) Validate() error {
+	return validate.Struct(p)
 }
 
 func ReplicationConfigFromConfig(in *config.Replication) (*pdu.ReplicationConfig, error) {

replication/replication.go

@@ -8,6 +8,6 @@ import (
 	"github.com/zrepl/zrepl/replication/driver"
 )
 
-func Do(ctx context.Context, planner driver.Planner) (driver.ReportFunc, driver.WaitFunc) {
-	return driver.Do(ctx, planner)
+func Do(ctx context.Context, driverConfig driver.Config, planner driver.Planner) (driver.ReportFunc, driver.WaitFunc) {
+	return driver.Do(ctx, driverConfig, planner)
 }