*: fix lint

dm/master/server.go

@@ -1576,6 +1576,7 @@ func (s *Server) getSourceRespsAfterOperation(ctx context.Context, taskName stri
 	return sortCommonWorkerResults(sourceRespCh)
 }
 
+// SetDDLLockMode implements MasterClient.
 func (s *Server) SetDDLLockMode(ctx context.Context, req *pb.SetDDLLockModeRequest) (*pb.CommonWorkerResponse, error) {
 	s.pessimist.SetLockMode(pessimism.LockMode(req.LockMode))
 	return &pb.CommonWorkerResponse{Result: true}, nil

dm/master/shardddl/pessimist.go

@@ -51,6 +51,7 @@ func NewPessimist(pLogger *log.Logger, taskSources func(task string) []string) *
 	}
 }
 
+// SetLockMode dynamically changes the lock mode of all new DDL locks.
 func (p *Pessimist) SetLockMode(mode pessimism.LockMode) {
 	p.mu.Lock()
 	p.lk.SetLockMode(mode)

dm/master/shardddl/pessimist_test.go

@@ -69,11 +69,11 @@ func (t *testPessimist) TestPessimist(c *C) {
 		DDLs          = []string{"ALTER TABLE bar ADD COLUMN c1 INT"}
 		ID1           = "task-1-`foo`.`bar`"
 		ID2           = "task-2-`foo`.`bar`"
-		i11           = pessimism.NewInfo(task1, source1, schema, table, DDLs)
-		i12           = pessimism.NewInfo(task1, source2, schema, table, DDLs)
-		i21           = pessimism.NewInfo(task2, source1, schema, table, DDLs)
-		i22           = pessimism.NewInfo(task2, source2, schema, table, DDLs)
-		i23           = pessimism.NewInfo(task2, source3, schema, table, DDLs)
+		i11           = pessimism.NewInfo(task1, source1, schema, table, DDLs, nil, nil)
+		i12           = pessimism.NewInfo(task1, source2, schema, table, DDLs, nil, nil)
+		i21           = pessimism.NewInfo(task2, source1, schema, table, DDLs, nil, nil)
+		i22           = pessimism.NewInfo(task2, source2, schema, table, DDLs, nil, nil)
+		i23           = pessimism.NewInfo(task2, source3, schema, table, DDLs, nil, nil)
 
 		sources = func(task string) []string {
 			switch task {

pkg/schema/tracker.go

@@ -27,6 +27,7 @@ import (
 	"github.com/pingcap/tidb/meta"
 	"github.com/pingcap/tidb/session"
 	"github.com/pingcap/tidb/store/mockstore"
+	"github.com/pingcap/tidb/util"
 )
 
 const (
@@ -115,8 +116,7 @@ func (tr *Tracker) Reset() error {
 	ddl := tr.dom.DDL()
 	for _, db := range allDBs {
 		dbName := model.NewCIStr(db)
-		switch dbName.L {
-		case "mysql", "performance_schema", "information_schema":
+		if util.IsMemOrSysDB(dbName.L) {
 			continue
 		}
 		if err := ddl.DropSchema(tr.se, dbName); err != nil {

pkg/shardddl/lock.go

@@ -19,6 +19,7 @@ import (
 	"github.com/pingcap/parser/model"
 )
 
+// Lock is a generic DDL lock.
 type Lock struct {
 	mu sync.RWMutex
 
@@ -31,6 +32,7 @@ type Lock struct {
 	impl LockImpl
 }
 
+// LockImpl is an interface describing the resolution algorithm of the lock.
 type LockImpl interface {
 	AddSources(sources []string)
 
@@ -43,6 +45,7 @@ type LockImpl interface {
 	Ready() map[string]bool
 }
 
+// NewLock creates a new generic DDL lock.
 func NewLock(ID, task, owner string, sources []string, impl LockImpl) *Lock {
 	lock := &Lock{
 		ID:    ID,
@@ -58,6 +61,9 @@ func NewLock(ID, task, owner string, sources []string, impl LockImpl) *Lock {
 	return lock
 }
 
+// TrySync tries to sync the lock, does decrease on remain, re-entrant.
+// new upstream sources may join when the DDL lock is in syncing,
+// so we need to merge these new sources.
 func (l *Lock) TrySync(caller string, ddls []string, newTableInfo *model.TableInfo, sources []string) (bool, int, error) {
 	l.mu.Lock()
 	defer l.mu.Unlock()

pkg/shardddl/optimism/lock.go

@@ -26,6 +26,7 @@ type optimisticLockImpl struct {
 	synced bool // whether last call to TrySync() returns true
 }
 
+// NewLock creates a new optimistic DDL lock.
 func NewLock(ID, task, owner string, table *model.TableInfo, sources []string) *shardddl.Lock {
 	return shardddl.NewLock(ID, task, owner, sources, &optimisticLockImpl{
 		tables: make(map[string]schemacmp.Table),

pkg/shardddl/pessimism/keeper.go

@@ -22,10 +22,16 @@ import (
 	"github.com/pingcap/dm/pkg/shardddl/optimism"
 )
 
+// LockMode represents the mode of a DDL lock.
 type LockMode uint32
 
 const (
+	// LockModePessimistic sets the lock mode to be pessimistic. The lock is
+	// held until all sources have executed the same DDL upstream.
 	LockModePessimistic LockMode = iota
+	// LockModeOptimistic sets the lock mode to be optimistic. The lock is
+	// released as soon as the downstream table schema is compatible with all
+	// upstream schemas.
 	LockModeOptimistic
 )
 
@@ -45,12 +51,14 @@ func NewLockKeeper() *LockKeeper {
 	}
 }
 
+// SetLockMode dynamically modify the mode for all new DDL locks.
 func (lk *LockKeeper) SetLockMode(mode LockMode) {
 	lk.mu.Lock()
 	lk.mode = mode
 	lk.mu.Unlock()
 }
 
+// LockMode returns the current mode for new DDL locks.
 func (lk *LockKeeper) LockMode() LockMode {
 	lk.mu.RLock()
 	mode := lk.mode

pkg/shardddl/pessimism/lock.go

@@ -21,6 +21,7 @@ import (
 	"github.com/pingcap/dm/pkg/shardddl"
 )
 
+// Lock is an alias of `shardddl.Lock` for compatibility with existing code.
 type Lock = shardddl.Lock
 
 type pessimisticLockImpl struct {

syncer/shardddl/pessimist_test.go

@@ -66,7 +66,7 @@ func (t *testPessimist) TestPessimist(c *C) {
 
 		logger = log.L()
 		p      = NewPessimist(&logger, etcdTestCli, task, source)
-		info   = p.ConstructInfo(schema, table, DDLs)
+		info   = p.ConstructInfo(schema, table, DDLs, nil, nil)
 	)
 
 	ctx, cancel := context.WithCancel(context.Background())

tests/others_integration.txt

@@ -3,3 +3,4 @@ ha_master
 full_mode
 start_task
 dm_syncer
+sequence_sharding_optimistic