Use go-sql-driver for connecting to mysql

Author: calind

Gopkg.lock

@@ -44,41 +44,48 @@ func RunRunCommand(stopCh <-chan struct{}) error {
 		return fmt.Errorf("mysql is not ready, err: %s", err)
 	}
 
-	// deactivate read only
-	if _, err := tb.RunQuery("SET GLOBAL READ_ONLY = 0"); err != nil {
+	// deactivate super read only
+	if err := tb.RunQuery("SET GLOBAL READ_ONLY = 1; SET GLOBAL SUPER_READ_ONLY = 0;"); err != nil {
 		return fmt.Errorf("failed to configure master node, err: %s", err)
 	}
+	glog.V(2).Info("Temporary disabled SUPER_READ_ONLY...")
 
 	// update orchestrator user and password if orchestrator is configured
 	if len(tb.GetOrcUser()) > 0 {
-		if err := tb.UpdateOrcUserPass(); err != nil {
+		if err := configureOrchestratorUser(); err != nil {
 			return err
 		}
 	}
+	glog.V(2).Info("Configured orchestrator user...")
 
 	// update replication user and password
 	if err := configureReplicationUser(); err != nil {
 		return err
 	}
+	glog.V(2).Info("Configured replication user...")
 
 	// update metrics exporter user and password
 	if err := configureExporterUser(); err != nil {
 		return err
 	}
+	glog.V(2).Info("Configured metrics exporter user...")
 
 	// if it's slave set replication source (master host)
 	if err := configTopology(); err != nil {
 		return err
 	}
+	glog.V(2).Info("Configured topology...")
 
 	if err := markConfigurationDone(); err != nil {
 		return err
 	}
+	glog.V(2).Info("Flag setup as complete...")
 
 	// if it's master node then make it writtable else make it read only
 	if err := configReadOnly(); err != nil {
 		return err
 	}
+	glog.V(2).Info("Configured read only flag...")
 
 	// start http server for readiness probe
 	// here the server is ready to accept traffic
@@ -88,12 +95,27 @@ func RunRunCommand(stopCh <-chan struct{}) error {
 	return startServeBackups()
 }
 
+func configureOrchestratorUser() error {
+	query := fmt.Sprintf(`
+    SET @@SESSION.SQL_LOG_BIN = 0;
+    GRANT SUPER, PROCESS, REPLICATION SLAVE, REPLICATION CLIENT, RELOAD ON *.* TO '%[1]s'@'%%' IDENTIFIED BY '%[2]s';
+    GRANT SELECT ON meta.* TO '%[1]s'@'%%';
+    GRANT SELECT ON mysql.slave_master_info TO '%[1]s'@'%%';
+    `, tb.GetOrcUser(), tb.GetOrcPass())
+
+	if err := tb.RunQuery(query); err != nil {
+		return fmt.Errorf("failed to configure orchestrator (user/pass/access), err: %s", err)
+	}
+
+	return nil
+}
+
 func configureReplicationUser() error {
 	query := fmt.Sprintf(`
     SET @@SESSION.SQL_LOG_BIN = 0;
     GRANT SELECT, PROCESS, RELOAD, LOCK TABLES, REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO '%s'@'%%' IDENTIFIED BY '%s';
     `, tb.GetReplUser(), tb.GetReplPass())
-	if _, err := tb.RunQuery(query); err != nil {
+	if err := tb.RunQuery(query); err != nil {
 		return fmt.Errorf("failed to configure replication user: %s", err)
 	}
 
@@ -105,7 +127,7 @@ func configureExporterUser() error {
     SET @@SESSION.SQL_LOG_BIN = 0;
     GRANT SELECT, PROCESS, REPLICATION CLIENT ON *.* TO '%s'@'%%' IDENTIFIED BY '%s' WITH MAX_USER_CONNECTIONS 3;
     `, tb.GetExporterUser(), tb.GetExporterPass())
-	if _, err := tb.RunQuery(query); err != nil {
+	if err := tb.RunQuery(query); err != nil {
 		return fmt.Errorf("failed to metrics exporter user: %s", err)
 	}
 
@@ -158,11 +180,11 @@ func waitForMysqlReady() error {
 
 	for i := 0; i < timeOut; i++ {
 		time.Sleep(1 * time.Second)
-		if _, err := tb.RunQuery("SELECT 1"); err == nil {
+		if err := tb.RunQuery("SELECT 1"); err == nil {
 			break
 		}
 	}
-	if _, err := tb.RunQuery("SELECT 1"); err != nil {
+	if err := tb.RunQuery("SELECT 1"); err != nil {
 		glog.V(2).Info("Mysql is not ready.")
 		return err
 	}
@@ -179,7 +201,7 @@ func configReadOnly() error {
 	} else {
 		query = "SET GLOBAL SUPER_READ_ONLY = 1"
 	}
-	if _, err := tb.RunQuery(query); err != nil {
+	if err := tb.RunQuery(query); err != nil {
 		return fmt.Errorf("failed to set read_only config, err: %s", err)
 	}
 	return nil
@@ -189,21 +211,22 @@ func configTopology() error {
 	if tb.NodeRole() == "slave" {
 		// slave node
 		query := fmt.Sprintf(`
+			STOP SLAVE;
             CHANGE MASTER TO MASTER_AUTO_POSITION=1,
 			  MASTER_HOST='%s',
 			  MASTER_USER='%s',
 			  MASTER_PASSWORD='%s',
 			  MASTER_CONNECT_RETRY=%d;
          `, tb.GetMasterHost(), tb.GetReplUser(), tb.GetReplPass(), connRetry)
 
-		if _, err := tb.RunQuery(query); err != nil {
+		if err := tb.RunQuery(query); err != nil {
 			return fmt.Errorf("failed to configure slave node, err: %s", err)
 		}
 
 		query = `
         START SLAVE;
         `
-		if _, err := tb.RunQuery(query); err != nil {
+		if err := tb.RunQuery(query); err != nil {
 			glog.Warning("Failed to start slave simple, err: %s, try second method.")
 			// TODO: https://bugs.mysql.com/bug.php?id=83713
 			query2 := `
@@ -213,7 +236,7 @@ func configTopology() error {
 			reset slave;
 			start slave;
             `
-			if _, err := tb.RunQuery(query2); err != nil {
+			if err := tb.RunQuery(query2); err != nil {
 				return fmt.Errorf("failed to start slave node, err: %s", err)
 			}
 		}
@@ -237,8 +260,8 @@ func markConfigurationDone() error {
     COMMIT;
     `, tb.ToolsDbName, tb.ToolsInitTableName, tb.GetHostname())
 
-	if _, err := tb.RunQuery(query); err != nil {
-		return fmt.Errorf("to mark configuration done, err: %s", err)
+	if err := tb.RunQuery(query); err != nil {
+		return fmt.Errorf("failed to mark configuration done, err: %s", err)
 	}
 
 	return nil

cmd/mysql-helper/apphelper/apphelper.go

@@ -18,14 +18,16 @@ package util
 
 import (
 	"bufio"
-	"bytes"
+	"database/sql"
 	"fmt"
 	"io"
 	"os"
-	"os/exec"
+	"path"
 	"strconv"
 	"strings"
 
+	"github.com/go-ini/ini"
+	_ "github.com/go-sql-driver/mysql"
 	"github.com/golang/glog"
 
 	api "github.com/presslabs/mysql-operator/pkg/apis/mysql/v1alpha1"
@@ -215,47 +217,68 @@ func readFileContent(fileName string) string {
 	return scanner.Text()
 }
 
-func UpdateOrcUserPass() error {
-	glog.V(2).Info("Creating orchestrator user, password and privileges...")
-	query := fmt.Sprintf(`
-    SET @@SESSION.SQL_LOG_BIN = 0;
-    GRANT SUPER, PROCESS, REPLICATION SLAVE, REPLICATION CLIENT, RELOAD ON *.* TO '%[1]s'@'%%' IDENTIFIED BY '%[2]s';
-    GRANT SELECT ON meta.* TO '%[1]s'@'%%';
-    GRANT SELECT ON mysql.slave_master_info TO '%[1]s'@'%%';
-    `, GetOrcUser(), GetOrcPass())
-
-	if _, err := RunQuery(query); err != nil {
-		return fmt.Errorf("failed to configure orchestrator (user/pass/access), err: %s", err)
+func GetMySQLConnectionString() (dsn string, err error) {
+	cnfPath := path.Join(ConfigDir, "client.cnf")
+	cfg, err := ini.Load(cnfPath)
+	if err != nil {
+		return "", fmt.Errorf("Could not open %s: %s", cnfPath, err)
 	}
-	glog.V(2).Info("Orchestrator user configured!")
-
-	return nil
+	client := cfg.Section("client")
+	host := client.Key("host").String()
+	user := client.Key("user").String()
+	passowrd := client.Key("password").String()
+	port, err := client.Key("port").Int()
+	if err != nil {
+		return "", fmt.Errorf("Invalid port in %s: %s", cnfPath, err)
+	}
+	dsn = fmt.Sprintf("%s:%s@tcp(%s:%d)/?timeout=5s&multiStatements=true", user, passowrd, host, port)
+	return
 }
 
-func RunQuery(q string) (string, error) {
-	glog.V(3).Infof("QUERY: %s", q)
-
-	mysql := exec.Command("mysql",
-		fmt.Sprintf("--defaults-file=%s/%s", ConfigDir, "client.cnf"),
-	)
+func RunQuery(q string) (err error) {
+	dsn, err := GetMySQLConnectionString()
+	if err != nil {
+		glog.Warningf("Could not get mysql connection dsn: %s", err)
+		return
+	}
 
-	// write query through pipe to mysql
-	rq := strings.NewReader(q)
-	mysql.Stdin = rq
-	var bufOUT, bufERR bytes.Buffer
-	mysql.Stdout = &bufOUT
-	mysql.Stderr = &bufERR
+	db, err := sql.Open("mysql", dsn)
+	if err != nil {
+		glog.Warningf("Could not open mysql connection: %s", err)
+		return
+	}
 
-	if err := mysql.Run(); err != nil {
-		glog.Errorf("Failed to run query, err: %s", err)
-		glog.V(2).Infof("Mysql STDOUT: %s, STDERR: %s", bufOUT.String(), bufERR.String())
-		return "", err
+	if _, err := db.Query(q); err != nil {
+		glog.V(2).Infof("QUERY: %s", q)
+		glog.Warningf("Could not query mysql: %s", err)
+		return err
 	}
 
-	glog.V(2).Infof("Mysql STDOUT: %s, STDERR: %s", bufOUT.String(), bufERR.String())
-	glog.V(3).Infof("Mysql output for query %s is: %s", q, bufOUT.String())
+	return
+
+	// 	glog.V(3).Infof("QUERY: %s", q)
+
+	// 	mysql := exec.Command("mysql",
+	// 		fmt.Sprintf("--defaults-file=%s/%s", ConfigDir, "client.cnf"),
+	// 	)
+
+	// 	// write query through pipe to mysql
+	// 	rq := strings.NewReader(q)
+	// 	mysql.Stdin = rq
+	// 	var bufOUT, bufERR bytes.Buffer
+	// 	mysql.Stdout = &bufOUT
+	// 	mysql.Stderr = &bufERR
+
+	// 	if err := mysql.Run(); err != nil {
+	// 		glog.Errorf("Failed to run query, err: %s", err)
+	// 		glog.V(2).Infof("Mysql STDOUT: %s, STDERR: %s", bufOUT.String(), bufERR.String())
+	// 		return "", err
+	// 	}
+
+	// 	glog.V(2).Infof("Mysql STDOUT: %s, STDERR: %s", bufOUT.String(), bufERR.String())
+	// 	glog.V(3).Infof("Mysql output for query %s is: %s", q, bufOUT.String())
 
-	return bufOUT.String(), nil
+	// 	return bufOUT.String(), nil
 }
 
 func getOrcUri() string {