// RunMysqlUpgrade will run the mysql_upgrade program on the current install. // Will not be called when mysqld is running. func (mysqld *Mysqld) RunMysqlUpgrade() error { // Execute as remote action on mysqlctld if requested. if *socketFile != "" { log.Infof("executing Mysqld.RunMysqlUpgrade() remotely via mysqlctld server: %v", *socketFile) client, err := mysqlctlclient.New("unix", *socketFile) if err != nil { return fmt.Errorf("can't dial mysqlctld: %v", err) } defer client.Close() return client.RunMysqlUpgrade(context.TODO()) } // find mysql_upgrade. If not there, we do nothing. dir, err := vtenv.VtMysqlRoot() if err != nil { log.Warningf("VT_MYSQL_ROOT not set, skipping mysql_upgrade step: %v", err) return nil } name := path.Join(dir, "bin/mysql_upgrade") if _, err := os.Stat(name); err != nil { log.Warningf("mysql_upgrade binary not present, skipping it: %v", err) return nil } // run the program, if it fails, we fail args := []string{ // --defaults-file=* must be the first arg. "--defaults-file=" + mysqld.config.path, "--socket", mysqld.config.SocketFile, "--user", mysqld.dba.Uname, "--force", // Don't complain if it's already been upgraded. } if mysqld.dba.Pass != "" { // --password must be omitted entirely if empty, or else it will prompt. args = append(args, "--password", mysqld.dba.Pass) } cmd := exec.Command(name, args...) cmd.Env = []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")} out, err := cmd.CombinedOutput() log.Infof("mysql_upgrade output: %s", out) return err }
// ReinitConfig updates the config file as if Mysqld is initializing. At the // moment it only randomizes ServerID because it's not safe to restore a replica // from a backup and then give it the same ServerID as before, MySQL can then // skip transactions in the replication stream with the same server_id. func (mysqld *Mysqld) ReinitConfig(ctx context.Context) error { log.Infof("Mysqld.ReinitConfig") // Execute as remote action on mysqlctld if requested. if *socketFile != "" { log.Infof("executing Mysqld.ReinitConfig() remotely via mysqlctld server: %v", *socketFile) client, err := mysqlctlclient.New("unix", *socketFile) if err != nil { return fmt.Errorf("can't dial mysqlctld: %v", err) } defer client.Close() return client.ReinitConfig(ctx) } if err := mysqld.config.RandomizeMysqlServerID(); err != nil { return err } root, err := vtenv.VtRoot() if err != nil { return err } return mysqld.initConfig(root) }
// Shutdown will stop the mysqld daemon that is running in the background. // // waitForMysqld: should the function block until mysqld has stopped? // This can actually take a *long* time if the buffer cache needs to be fully // flushed - on the order of 20-30 minutes. // // If a mysqlctld address is provided in a flag, Shutdown will run remotely. func (mysqld *Mysqld) Shutdown(ctx context.Context, waitForMysqld bool) error { log.Infof("Mysqld.Shutdown") // Execute as remote action on mysqlctld if requested. if *socketFile != "" { log.Infof("executing Mysqld.Shutdown() remotely via mysqlctld server: %v", *socketFile) client, err := mysqlctlclient.New("unix", *socketFile) if err != nil { return fmt.Errorf("can't dial mysqlctld: %v", err) } defer client.Close() return client.Shutdown(ctx, waitForMysqld) } // We're shutting down on purpose. We no longer want to be notified when // mysqld terminates. mysqld.mutex.Lock() if mysqld.cancelWaitCmd != nil { close(mysqld.cancelWaitCmd) mysqld.cancelWaitCmd = nil } mysqld.mutex.Unlock() // possibly mysql is already shutdown, check for a few files first _, socketPathErr := os.Stat(mysqld.config.SocketFile) _, pidPathErr := os.Stat(mysqld.config.PidFile) if socketPathErr != nil && pidPathErr != nil { log.Warningf("assuming mysqld already shut down - no socket, no pid file found") return nil } // try the mysqld shutdown hook, if any h := hook.NewSimpleHook("mysqld_shutdown") hr := h.Execute() switch hr.ExitStatus { case hook.HOOK_SUCCESS: // hook exists and worked, we can keep going case hook.HOOK_DOES_NOT_EXIST: // hook doesn't exist, try mysqladmin log.Infof("No mysqld_shutdown hook, running mysqladmin directly") dir, err := vtenv.VtMysqlRoot() if err != nil { return err } name := path.Join(dir, "bin/mysqladmin") arg := []string{ "-u", "vt_dba", "-S", mysqld.config.SocketFile, "shutdown"} env := []string{ os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql"), } _, err = execCmd(name, arg, env, dir) if err != nil { return err } default: // hook failed, we report error return fmt.Errorf("mysqld_shutdown hook failed: %v", hr.String()) } // Wait for mysqld to really stop. Use the sock file as a // proxy for that since we can't call wait() in a process we // didn't start. if waitForMysqld { for { select { case <-ctx.Done(): return errors.New("gave up waiting for mysqld to stop") default: } _, statErr := os.Stat(mysqld.config.SocketFile) if statErr != nil && os.IsNotExist(statErr) { return nil } log.Infof("Mysqld.Shutdown: sleeping for 1s waiting for socket file %v", mysqld.config.SocketFile) time.Sleep(time.Second) } } return nil }
// Start will start the mysql daemon, either by running the 'mysqld_start' // hook, or by running mysqld_safe in the background. // If a mysqlctld address is provided in a flag, Start will run remotely. func (mysqld *Mysqld) Start(ctx context.Context) error { // Execute as remote action on mysqlctld if requested. if *socketFile != "" { log.Infof("executing Mysqld.Start() remotely via mysqlctld server: %v", *socketFile) client, err := mysqlctlclient.New("unix", *socketFile) if err != nil { return fmt.Errorf("can't dial mysqlctld: %v", err) } defer client.Close() return client.Start(ctx) } var name string ts := fmt.Sprintf("Mysqld.Start(%v)", time.Now().Unix()) // try the mysqld start hook, if any switch hr := hook.NewSimpleHook("mysqld_start").Execute(); hr.ExitStatus { case hook.HOOK_SUCCESS: // hook exists and worked, we can keep going name = "mysqld_start hook" case hook.HOOK_DOES_NOT_EXIST: // hook doesn't exist, run mysqld_safe ourselves log.Infof("%v: No mysqld_start hook, running mysqld_safe directly", ts) dir, err := vtenv.VtMysqlRoot() if err != nil { return err } name = path.Join(dir, "bin/mysqld_safe") arg := []string{ "--defaults-file=" + mysqld.config.path} env := []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")} cmd := exec.Command(name, arg...) cmd.Dir = dir cmd.Env = env log.Infof("%v %#v", ts, cmd) stderr, err := cmd.StderrPipe() if err != nil { return nil } stdout, err := cmd.StdoutPipe() if err != nil { return nil } go func() { scanner := bufio.NewScanner(stderr) for scanner.Scan() { log.Infof("%v stderr: %v", ts, scanner.Text()) } }() go func() { scanner := bufio.NewScanner(stdout) for scanner.Scan() { log.Infof("%v stdout: %v", ts, scanner.Text()) } }() err = cmd.Start() if err != nil { return nil } mysqld.mutex.Lock() mysqld.cancelWaitCmd = make(chan struct{}) go func(cancel <-chan struct{}) { // Wait regardless of cancel, so we don't generate defunct processes. err := cmd.Wait() log.Infof("%v exit: %v", ts, err) // The process exited. Trigger OnTerm callbacks, unless we were cancelled. select { case <-cancel: default: mysqld.mutex.Lock() for _, callback := range mysqld.onTermFuncs { go callback() } mysqld.mutex.Unlock() } }(mysqld.cancelWaitCmd) mysqld.mutex.Unlock() default: // hook failed, we report error return fmt.Errorf("mysqld_start hook failed: %v", hr.String()) } // give it some time to succeed - usually by the time the socket emerges // we are in good shape for { select { case <-ctx.Done(): return errors.New(name + ": deadline exceeded waiting for " + mysqld.config.SocketFile) default: } _, statErr := os.Stat(mysqld.config.SocketFile) if statErr == nil { // Make sure the socket file isn't stale. conn, connErr := mysqld.dbaPool.Get(0) if connErr == nil { conn.Recycle() return nil } } else if !os.IsNotExist(statErr) { return statErr } log.Infof("%v: sleeping for 1s waiting for socket file %v", ts, mysqld.config.SocketFile) time.Sleep(time.Second) } }
// Start will start the mysql daemon, either by running the 'mysqld_start' // hook, or by running mysqld_safe in the background. // If a mysqlctld address is provided in a flag, Start will run remotely. func (mysqld *Mysqld) Start(ctx context.Context, mysqldArgs ...string) error { // Execute as remote action on mysqlctld if requested. if *socketFile != "" { log.Infof("executing Mysqld.Start() remotely via mysqlctld server: %v", *socketFile) client, err := mysqlctlclient.New("unix", *socketFile) if err != nil { return fmt.Errorf("can't dial mysqlctld: %v", err) } defer client.Close() return client.Start(ctx, mysqldArgs...) } var name string ts := fmt.Sprintf("Mysqld.Start(%v)", time.Now().Unix()) // try the mysqld start hook, if any switch hr := hook.NewHook("mysqld_start", mysqldArgs).Execute(); hr.ExitStatus { case hook.HOOK_SUCCESS: // hook exists and worked, we can keep going name = "mysqld_start hook" case hook.HOOK_DOES_NOT_EXIST: // hook doesn't exist, run mysqld_safe ourselves log.Infof("%v: No mysqld_start hook, running mysqld_safe directly", ts) dir, err := vtenv.VtMysqlRoot() if err != nil { return err } name, err = binaryPath(dir, "mysqld_safe") if err != nil { return err } arg := []string{ "--defaults-file=" + mysqld.config.path} arg = append(arg, mysqldArgs...) env := []string{os.ExpandEnv("LD_LIBRARY_PATH=$VT_MYSQL_ROOT/lib/mysql")} cmd := exec.Command(name, arg...) cmd.Dir = dir cmd.Env = env log.Infof("%v %#v", ts, cmd) stderr, err := cmd.StderrPipe() if err != nil { return nil } stdout, err := cmd.StdoutPipe() if err != nil { return nil } go func() { scanner := bufio.NewScanner(stderr) for scanner.Scan() { log.Infof("%v stderr: %v", ts, scanner.Text()) } }() go func() { scanner := bufio.NewScanner(stdout) for scanner.Scan() { log.Infof("%v stdout: %v", ts, scanner.Text()) } }() err = cmd.Start() if err != nil { return nil } mysqld.mutex.Lock() mysqld.cancelWaitCmd = make(chan struct{}) go func(cancel <-chan struct{}) { // Wait regardless of cancel, so we don't generate defunct processes. err := cmd.Wait() log.Infof("%v exit: %v", ts, err) // The process exited. Trigger OnTerm callbacks, unless we were cancelled. select { case <-cancel: default: mysqld.mutex.Lock() for _, callback := range mysqld.onTermFuncs { go callback() } mysqld.mutex.Unlock() } }(mysqld.cancelWaitCmd) mysqld.mutex.Unlock() default: // hook failed, we report error return fmt.Errorf("mysqld_start hook failed: %v", hr.String()) } return mysqld.Wait(ctx) }