*: introduce pkg/migrations

pkg/kv/batch.go

@@ -754,3 +754,27 @@ func (b *Batch) addSSTable(
 	b.appendReqs(req)
 	b.initResult(1, 0, notRaw, nil)
 }
+
+// migrate is only exported on DB.
+//lint:ignore U1001 unused
+func (b *Batch) migrate(s, e interface{}, targetVersion roachpb.Version) {
+	begin, err := marshalKey(s)
+	if err != nil {
+		b.initResult(0, 0, notRaw, err)
+		return
+	}
+	end, err := marshalKey(e)
+	if err != nil {
+		b.initResult(0, 0, notRaw, err)
+		return
+	}
+	req := &roachpb.MigrateRequest{
+		RequestHeader: roachpb.RequestHeader{
+			Key:    begin,
+			EndKey: end,
+		},
+		TargetVersion: targetVersion,
+	}
+	b.appendReqs(req)
+	b.initResult(1, 0, notRaw, nil)
+}

pkg/kv/db.go

@@ -639,6 +639,18 @@ func (db *DB) AddSSTable(
 	return getOneErr(db.Run(ctx, b), b)
 }
 
+// Migrate proactively forces ranges overlapping with the provided keyspace to
+// transition out of any legacy modes of operation (as defined by the target
+// version).
+//lint:ignore U1001 unused
+func (db *DB) Migrate(
+	ctx context.Context, begin, end interface{}, targetVersion roachpb.Version,
+) error {
+	b := &Batch{}
+	b.migrate(begin, end, targetVersion)
+	return getOneErr(db.Run(ctx, b), b)
+}
+
 // sendAndFill is a helper which sends the given batch and fills its results,
 // returning the appropriate error which is either from the first failing call,
 // or an "internal" error.

pkg/kv/kvserver/batcheval/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "cmd_lease_request.go",
         "cmd_lease_transfer.go",
         "cmd_merge.go",
+        "cmd_migrate.go",
         "cmd_push_txn.go",
         "cmd_put.go",
         "cmd_query_intent.go",

pkg/kv/kvserver/batcheval/cmd_migrate.go

@@ -0,0 +1,46 @@
+// Copyright 2020 The Cockroach Authors.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package batcheval
+
+import (
+	"context"
+
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/batcheval/result"
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/spanset"
+	"github.com/cockroachdb/cockroach/pkg/roachpb"
+	"github.com/cockroachdb/cockroach/pkg/storage"
+	"github.com/cockroachdb/cockroach/pkg/util/log"
+)
+
+func init() {
+	RegisterReadWriteCommand(roachpb.Migrate, declareKeysMigrate, Migrate)
+}
+
+func declareKeysMigrate(
+	_ *roachpb.RangeDescriptor, _ roachpb.Header, _ roachpb.Request, _, _ *spanset.SpanSet,
+) {
+}
+
+// Migrate ensures that the range proactively carries out any outstanding
+// below-Raft migrations.
+//
+// TODO(irfansharif): Do something real here. It's not currently wired up to
+// anything. We'll eventually want a `map[roachpb.Version]Fn` mapping here that
+// lets us define specific migrations for specific target versions.
+func Migrate(
+	ctx context.Context, _ storage.ReadWriter, cArgs CommandArgs, _ roachpb.Response,
+) (result.Result, error) {
+	args := cArgs.Args.(*roachpb.MigrateRequest)
+	h := cArgs.Header
+
+	log.Infof(ctx, "evaluating Migrate command for r%d@%s [%s, %s)", h.RangeID, args.TargetVersion, args.Key, args.EndKey)
+	return result.Result{}, nil
+}

pkg/kv/kvserver/replica_write.go

@@ -214,6 +214,30 @@ func (r *Replica) executeWriteBatch(
 					log.Warningf(ctx, "%v", err)
 				}
 			}
+			if ba.Requests[0].GetMigrate() != nil && propResult.Err == nil {
+				// Migrate is special since it wants commands to be durably
+				// applied on all peers, which we achieve via waitForApplication.
+				//
+				// TODO(tbg,irfansharif): Could a snapshot below maxLeaseIndex
+				// be in-flight to a follower that's not in `desc` (but will be
+				// in it soon)? This seems to be in the realm of what's possible
+				// in theory: we'll only ever proactively send a snap when the
+				// peer is a learner, but an old snapshot that precedes
+				// maxLeaseIndex may be in flight for no good reason and once
+				// that peer is added to desc (after this code has done its
+				// work) and receives said zombie snap, it'll be initialized
+				// without having caught up past the migration. What's the
+				// safeguard needed here? I'm not sure. If we force a log
+				// truncation right after this proposal, would that force all
+				// to-be replicas to first catch up? Does that provide the
+				// invariants we want?
+				desc := r.Desc()
+				// NB: waitForApplication already has a timeout.
+				applicationErr := waitForApplication(
+					ctx, r.store.cfg.NodeDialer, desc.RangeID, desc.Replicas().All(),
+					uint64(maxLeaseIndex))
+				propResult.Err = roachpb.NewError(applicationErr)
+			}
 			return propResult.Reply, nil, propResult.Err
 		case <-slowTimer.C:
 			slowTimer.Read = true

pkg/roachpb/api.go

@@ -727,6 +727,9 @@ func (*ImportRequest) Method() Method { return Import }
 // Method implements the Request interface.
 func (*AdminScatterRequest) Method() Method { return AdminScatter }
 
+// Method implements the Request interface.
+func (*MigrateRequest) Method() Method { return Migrate }
+
 // Method implements the Request interface.
 func (*AddSSTableRequest) Method() Method { return AddSSTable }
 
@@ -970,6 +973,12 @@ func (r *AdminScatterRequest) ShallowCopy() Request {
 	return &shallowCopy
 }
 
+// ShallowCopy implements the Request interface.
+func (r *MigrateRequest) ShallowCopy() Request {
+	shallowCopy := *r
+	return &shallowCopy
+}
+
 // ShallowCopy implements the Request interface.
 func (r *AddSSTableRequest) ShallowCopy() Request {
 	shallowCopy := *r
@@ -1301,6 +1310,7 @@ func (*ExportRequest) flags() int                        { return isRead | isRan
 func (*ImportRequest) flags() int                        { return isAdmin | isAlone }
 func (*AdminScatterRequest) flags() int                  { return isAdmin | isRange | isAlone }
 func (*AdminVerifyProtectedTimestampRequest) flags() int { return isAdmin | isRange | isAlone }
+func (*MigrateRequest) flags() int                       { return isWrite | isRange | isAlone }
 func (*AddSSTableRequest) flags() int {
 	return isWrite | isRange | isAlone | isUnsplittable | canBackpressure
 }