diff --git a/go/base/context.go b/go/base/context.go index 089d22f..a45f5c3 100644 --- a/go/base/context.go +++ b/go/base/context.go @@ -51,6 +51,7 @@ type MigrationContext struct { AllowedRunningOnMaster bool AllowedMasterMaster bool SwitchToRowBinlogFormat bool + TrustRBR bool NullableUniqueKeyAllowed bool ApproveRenamedColumns bool SkipRenamedColumns bool @@ -92,6 +93,7 @@ type MigrationContext struct { TableEngine string RowsEstimate int64 UsedRowsEstimateMethod RowsEstimateMethod + HasSuperPrivilege bool OriginalBinlogFormat string OriginalBinlogRowImage string InspectorConnectionConfig *mysql.ConnectionConfig diff --git a/go/cmd/gh-ost/main.go b/go/cmd/gh-ost/main.go index f3a887d..fd35f2b 100644 --- a/go/cmd/gh-ost/main.go +++ b/go/cmd/gh-ost/main.go @@ -69,6 +69,7 @@ func main() { cutOver := flag.String("cut-over", "atomic", "choose cut-over type (default|atomic, two-step)") flag.BoolVar(&migrationContext.SwitchToRowBinlogFormat, "switch-to-rbr", false, "let this tool automatically switch binary log format to 'ROW' on the replica, if needed. The format will NOT be switched back. I'm too scared to do that, and wish to protect you if you happen to execute another migration while this one is running") + flag.BoolVar(&migrationContext.TrustRBR, "trust-rbr", false, "set to 'true' when you know for certain your server uses 'ROW' binlog_format. gh-ost is unable to tell, event after reading binlog_format, whether the replication process does indeed use 'ROW', and restarts replication to be certain RBR setting is applied. Such operation requires SUPER privileges which you might not have. Setting this flag avoids restarting replication and you can proceed to use gh-ost without SUPER privileges") chunkSize := flag.Int64("chunk-size", 1000, "amount of rows to handle in each iteration (allowed range: 100-100,000)") defaultRetries := flag.Int64("default-retries", 60, "Default number of retries for various operations before panicking") cutOverLockTimeoutSeconds := flag.Int64("cut-over-lock-timeout-seconds", 3, "Max number of seconds to hold locks on tables while attempting to cut-over (retry attempted when lock exceeds timeout)") @@ -145,7 +146,9 @@ func main() { if migrationContext.MigrateOnReplica && migrationContext.TestOnReplica { log.Fatalf("--migrate-on-replica and --test-on-replica are mutually exclusive") } - + if migrationContext.SwitchToRowBinlogFormat && migrationContext.TrustRBR { + log.Fatalf("--switch-to-rbr and --trust-rbr are mutually exclusive") + } switch *cutOver { case "atomic", "default", "": migrationContext.CutOverType = base.CutOverAtomic diff --git a/go/logic/inspect.go b/go/logic/inspect.go index ae56719..09c4021 100644 --- a/go/logic/inspect.go +++ b/go/logic/inspect.go @@ -50,9 +50,6 @@ func (this *Inspector) InitDBConnections() (err error) { if err := this.validateGrants(); err != nil { return err } - // if err := this.restartReplication(); err != nil { - // return err - // } if err := this.validateBinlogs(); err != nil { return err } @@ -157,6 +154,7 @@ func (this *Inspector) validateGrants() error { query := `show /* gh-ost */ grants for current_user()` foundAll := false foundSuper := false + foundReplicationClient := false foundReplicationSlave := false foundDBAll := false @@ -169,6 +167,9 @@ func (this *Inspector) validateGrants() error { if strings.Contains(grant, `SUPER`) && strings.Contains(grant, ` ON *.*`) { foundSuper = true } + if strings.Contains(grant, `REPLICATION CLIENT`) && strings.Contains(grant, ` ON *.*`) { + foundReplicationClient = true + } if strings.Contains(grant, `REPLICATION SLAVE`) && strings.Contains(grant, ` ON *.*`) { foundReplicationSlave = true } @@ -187,6 +188,7 @@ func (this *Inspector) validateGrants() error { if err != nil { return err } + this.migrationContext.HasSuperPrivilege = foundSuper if foundAll { log.Infof("User has ALL privileges") @@ -196,7 +198,11 @@ func (this *Inspector) validateGrants() error { log.Infof("User has SUPER, REPLICATION SLAVE privileges, and has ALL privileges on %s.*", sql.EscapeName(this.migrationContext.DatabaseName)) return nil } - log.Debugf("Privileges: Super: %t, REPLICATION SLAVE: %t, ALL on *.*: %t, ALL on %s.*: %t", foundSuper, foundReplicationSlave, foundAll, sql.EscapeName(this.migrationContext.DatabaseName), foundDBAll) + if foundReplicationClient && foundReplicationSlave && foundDBAll { + log.Infof("User has REPLICATION CLIENT, REPLICATION SLAVE privileges, and has ALL privileges on %s.*", sql.EscapeName(this.migrationContext.DatabaseName)) + return nil + } + log.Debugf("Privileges: Super: %t, REPLICATION CLIENT: %t, REPLICATION SLAVE: %t, ALL on *.*: %t, ALL on %s.*: %t", foundSuper, foundReplicationClient, foundReplicationSlave, foundAll, sql.EscapeName(this.migrationContext.DatabaseName), foundDBAll) return log.Errorf("User has insufficient privileges for migration. Needed: SUPER, REPLICATION SLAVE and ALL on %s.*", sql.EscapeName(this.migrationContext.DatabaseName)) } @@ -230,16 +236,26 @@ func (this *Inspector) restartReplication() error { // the replication thread apply it. func (this *Inspector) applyBinlogFormat() error { if this.migrationContext.RequiresBinlogFormatChange() { + if !this.migrationContext.SwitchToRowBinlogFormat { + return fmt.Errorf("Existing binlog_format is %s. Am not switching it to ROW unless you specify --switch-to-rbr", this.migrationContext.OriginalBinlogFormat) + } if _, err := sqlutils.ExecNoPrepare(this.db, `set global binlog_format='ROW'`); err != nil { return err } if _, err := sqlutils.ExecNoPrepare(this.db, `set session binlog_format='ROW'`); err != nil { return err } + if err := this.restartReplication(); err != nil { + return err + } log.Debugf("'ROW' binlog format applied") + return nil } - if err := this.restartReplication(); err != nil { - return err + // We already have RBR, no explicit switch + if !this.migrationContext.TrustRBR { + if err := this.restartReplication(); err != nil { + return err + } } return nil }