ddl: set tidb_super_read_only=ON when do flashback cluster

ddl/cluster.go

@@ -60,12 +60,15 @@ var pdScheduleKey = []string{
 const (
 	flashbackMaxBackoff = 1800000         // 1800s
 	flashbackTimeout    = 3 * time.Minute // 3min
+)
 
-	pdScheduleArgsOffset     = 1
-	gcEnabledArgsOffset      = 2
-	autoAnalyzeOffset        = 3
-	totalLockedRegionsOffset = 4
-	commitTSOffset           = 5
+const (
+	pdScheduleArgsOffset = 1 + iota
+	gcEnabledOffset
+	autoAnalyzeOffset
+	readOnlyOffset
+	totalLockedRegionsOffset
+	commitTSOffset
 )
 
 func closePDSchedule() error {
@@ -134,6 +137,18 @@ func getTiDBEnableAutoAnalyze(sess sessionctx.Context) (string, error) {
 	return val, nil
 }
 
+func setTiDBSuperReadOnly(sess sessionctx.Context, value string) error {
+	return sess.GetSessionVars().GlobalVarsAccessor.SetGlobalSysVar(context.Background(), variable.TiDBSuperReadOnly, value)
+}
+
+func getTiDBSuperReadOnly(sess sessionctx.Context) (string, error) {
+	val, err := sess.GetSessionVars().GlobalVarsAccessor.GetGlobalSysVar(variable.TiDBSuperReadOnly)
+	if err != nil {
+		return "", errors.Trace(err)
+	}
+	return val, nil
+}
+
 func checkAndSetFlashbackClusterInfo(sess sessionctx.Context, d *ddlCtx, t *meta.Meta, job *model.Job, flashbackTS uint64) (err error) {
 	if err = ValidateFlashbackTS(d.ctx, sess, flashbackTS); err != nil {
 		return err
@@ -148,6 +163,9 @@ func checkAndSetFlashbackClusterInfo(sess sessionctx.Context, d *ddlCtx, t *meta
 	if err = setTiDBEnableAutoAnalyze(sess, variable.Off); err != nil {
 		return err
 	}
+	if err = setTiDBSuperReadOnly(sess, variable.On); err != nil {
+		return err
+	}
 
 	nowSchemaVersion, err := t.GetSchemaVersion()
 	if err != nil {
@@ -465,9 +483,9 @@ func (w *worker) onFlashbackCluster(d *ddlCtx, t *meta.Meta, job *model.Job) (ve
 
 	var flashbackTS, lockedRegions, commitTS uint64
 	var pdScheduleValue map[string]interface{}
-	var autoAnalyzeValue string
+	var autoAnalyzeValue, readOnlyValue string
 	var gcEnabledValue bool
-	if err := job.DecodeArgs(&flashbackTS, &pdScheduleValue, &gcEnabledValue, &autoAnalyzeValue, &lockedRegions, &commitTS); err != nil {
+	if err := job.DecodeArgs(&flashbackTS, &pdScheduleValue, &gcEnabledValue, &autoAnalyzeValue, &readOnlyValue, &lockedRegions, &commitTS); err != nil {
 		job.State = model.JobStateCancelled
 		return ver, errors.Trace(err)
 	}
@@ -494,13 +512,19 @@ func (w *worker) onFlashbackCluster(d *ddlCtx, t *meta.Meta, job *model.Job) (ve
 			job.State = model.JobStateCancelled
 			return ver, errors.Trace(err)
 		}
-		job.Args[gcEnabledArgsOffset] = &gcEnableValue
+		job.Args[gcEnabledOffset] = &gcEnableValue
 		autoAnalyzeValue, err = getTiDBEnableAutoAnalyze(sess)
 		if err != nil {
 			job.State = model.JobStateCancelled
 			return ver, errors.Trace(err)
 		}
 		job.Args[autoAnalyzeOffset] = &autoAnalyzeValue
+		readOnlyValue, err = getTiDBSuperReadOnly(sess)
+		if err != nil {
+			job.State = model.JobStateCancelled
+			return ver, errors.Trace(err)
+		}
+		job.Args[readOnlyOffset] = &readOnlyValue
 		job.SchemaState = model.StateDeleteOnly
 		return ver, nil
 	// Stage 2, check flashbackTS, close GC and PD schedule.
@@ -593,10 +617,10 @@ func finishFlashbackCluster(w *worker, job *model.Job) error {
 
 	var flashbackTS, lockedRegions, commitTS uint64
 	var pdScheduleValue map[string]interface{}
-	var autoAnalyzeValue string
+	var autoAnalyzeValue, readOnlyValue string
 	var gcEnabled bool
 
-	if err := job.DecodeArgs(&flashbackTS, &pdScheduleValue, &gcEnabled, &autoAnalyzeValue, &lockedRegions, &commitTS); err != nil {
+	if err := job.DecodeArgs(&flashbackTS, &pdScheduleValue, &gcEnabled, &autoAnalyzeValue, &readOnlyValue, &lockedRegions, &commitTS); err != nil {
 		return errors.Trace(err)
 	}
 	sess, err := w.sessPool.get()
@@ -614,6 +638,9 @@ func finishFlashbackCluster(w *worker, job *model.Job) error {
 				return err
 			}
 		}
+		if err = setTiDBSuperReadOnly(sess, readOnlyValue); err != nil {
+			return err
+		}
 		return setTiDBEnableAutoAnalyze(sess, autoAnalyzeValue)
 	})
 	if err != nil {

ddl/cluster_test.go

@@ -202,23 +202,35 @@ func TestGlobalVariablesOnFlashback(t *testing.T) {
 			rs, err = tk.Exec("show variables like 'tidb_enable_auto_analyze'")
 			assert.NoError(t, err)
 			assert.Equal(t, tk.ResultSetToResult(rs, "").Rows()[0][1], variable.Off)
+			rs, err = tk.Exec("show variables like 'tidb_super_read_only'")
+			assert.NoError(t, err)
+			assert.Equal(t, tk.ResultSetToResult(rs, "").Rows()[0][1], variable.On)
 		}
 	}
 	dom.DDL().SetHook(hook)
-	// first try with `tidb_gc_enable` = on
+	// first try with `tidb_gc_enable` = on and `tidb_super_read_only` = off
 	tk.MustExec("set global tidb_gc_enable = on")
+	tk.MustExec("set global tidb_super_read_only = off")
 
 	tk.MustExec(fmt.Sprintf("flashback cluster to timestamp '%s'", oracle.GetTimeFromTS(ts)))
-	rs, err := tk.Exec("show variables like 'tidb_gc_enable'")
+
+	rs, err := tk.Exec("show variables like 'tidb_super_read_only'")
+	require.NoError(t, err)
+	require.Equal(t, tk.ResultSetToResult(rs, "").Rows()[0][1], variable.Off)
+	rs, err = tk.Exec("show variables like 'tidb_gc_enable'")
 	require.NoError(t, err)
 	require.Equal(t, tk.ResultSetToResult(rs, "").Rows()[0][1], variable.On)
 
-	// second try with `tidb_gc_enable` = off
+	// second try with `tidb_gc_enable` = off and `tidb_super_read_only` = on
 	tk.MustExec("set global tidb_gc_enable = off")
+	tk.MustExec("set global tidb_super_read_only = on")
 
 	ts, err = tk.Session().GetStore().GetOracle().GetTimestamp(context.Background(), &oracle.Option{})
 	require.NoError(t, err)
 	tk.MustExec(fmt.Sprintf("flashback cluster to timestamp '%s'", oracle.GetTimeFromTS(ts)))
+	rs, err = tk.Exec("show variables like 'tidb_super_read_only'")
+	require.NoError(t, err)
+	require.Equal(t, tk.ResultSetToResult(rs, "").Rows()[0][1], variable.On)
 	rs, err = tk.Exec("show variables like 'tidb_gc_enable'")
 	require.NoError(t, err)
 	require.Equal(t, tk.ResultSetToResult(rs, "").Rows()[0][1], variable.Off)

ddl/ddl_api.go

@@ -2716,9 +2716,10 @@ func (d *ddl) FlashbackCluster(ctx sessionctx.Context, flashbackTS uint64) error
 		Args: []interface{}{
 			flashbackTS,
 			map[string]interface{}{},
-			true,        /* tidb_gc_enable */
-			variable.On, /* tidb_enable_auto_analyze */
-			0,           /* totalRegions */
+			true,         /* tidb_gc_enable */
+			variable.On,  /* tidb_enable_auto_analyze */
+			variable.Off, /* tidb_super_read_only */
+			0,            /* totalRegions */
 			0 /* newCommitTS */},
 	}
 	err := d.DoDDLJob(ctx, job)

tests/readonlytest/readonly_test.go

@@ -158,6 +158,11 @@ func TestRestriction(t *testing.T) {
 	require.Error(t, err)
 	require.Equal(t, err.Error(), PriviledgedErrMsg)
 
+	// can't do flashback cluster
+	_, err = s.udb.Exec("flashback cluster to timestamp ''")
+	require.Error(t, err)
+	require.Equal(t, err.Error(), ReadOnlyErrMsg)
+
 	// can do some Admin stmts
 	_, err = s.udb.Exec("admin show ddl jobs")
 	require.NoError(t, err)