Refactor connection handling

mblaschke · mblaschke · commit 966bb85ad14b · 2017-09-30T19:41:37.000+02:00
Setting connection if connection is empty and not passign server around
diff --git a/sync/config.go b/sync/config.go
@@ -19,6 +19,7 @@ type Filesystem struct {
 	Path string
 	Local string
 	Filter Filter
+	Connection commandbuilder.Connection
 	Options struct {
 		GenerateStubs bool `yaml:"generate-stubs"`
 	}
@@ -52,7 +53,7 @@ type Database struct {
 	cacheRemoteTableList []string
 	cacheLocalTableList []string
 
-	remoteConnection commandbuilder.Connection
+	Connection commandbuilder.Connection
 }
 
 type Execution struct {
diff --git a/sync/database.go b/sync/database.go
@@ -7,6 +7,12 @@ import (
 	"github.com/webdevops/go-shell/commandbuilder"
 )
 
+func (database *Database) ApplyDefaults(server *Server) {
+	// set default connection if not set
+	if (commandbuilder.Connection{}) == database.Connection {
+		database.Connection = server.Connection
+	}
+}
 
 func (database *Database) mysqlTableFilter(connection *commandbuilder.Connection, connectionType string) ([]string, []string) {
 	var exclude []string
diff --git a/sync/database_remote.go b/sync/database_remote.go
@@ -29,7 +29,7 @@ func (database *Database) remoteMysqldumpCmdBuilder(additionalArgs []string, use
 	}
 
 	// exclude
-	excludeArgs, includeArgs := database.mysqlTableFilter(&database.remoteConnection, "remote");
+	excludeArgs, includeArgs := database.mysqlTableFilter(&database.Connection, "remote");
 	if useFilter && len(excludeArgs) > 0 {
 		args = append(args, excludeArgs...)
 	}
@@ -46,7 +46,7 @@ func (database *Database) remoteMysqldumpCmdBuilder(additionalArgs []string, use
 	cmd = append(cmd, shell.QuoteValues(args...)...)
 	cmd = append(cmd, "|", "gzip", "--stdout")
 
-	return database.remoteConnection.RawShellCommandBuilder(cmd...)
+	return database.Connection.RawShellCommandBuilder(cmd...)
 }
 
 func (database *Database) remoteMysqlCmdBuilder(args ...string) []interface{} {
@@ -72,7 +72,7 @@ func (database *Database) remoteMysqlCmdBuilder(args ...string) []interface{} {
 		args = append(args, database.Schema)
 	}
 
-	return database.remoteConnection.CommandBuilder("mysql", args...)
+	return database.Connection.CommandBuilder("mysql", args...)
 }
 
 
@@ -101,5 +101,5 @@ func (database *Database) remoteMysqlCmdBuilderUncompress(args ...string) []inte
 
 	cmd := []string{"gunzip", "--stdout", "|", "mysql", strings.Join(shell.QuoteValues(args...), " ")}
 
-	return database.remoteConnection.RawShellCommandBuilder(cmd...)
+	return database.Connection.RawShellCommandBuilder(cmd...)
 }
diff --git a/sync/filesystem.go b/sync/filesystem.go
@@ -3,26 +3,35 @@ package sync
 import (
 	"fmt"
 	"strings"
+	"github.com/webdevops/go-shell/commandbuilder"
 )
 
-func (filesystem *Filesystem) localPath(server *Server) string {
-	if filesystem.Local != "" {
-		return filesystem.Local
-	} else {
-		return server.GetLocalPath()
+func (filesystem *Filesystem) ApplyDefaults(server *Server) {
+	// set default connection if not set
+	if (commandbuilder.Connection{}) == filesystem.Connection {
+		filesystem.Connection = server.Connection
 	}
+
+	// set default path
+	if filesystem.Local == "" {
+		filesystem.Local = server.GetLocalPath()
+	}
+}
+
+func (filesystem *Filesystem) localPath() string {
+	return filesystem.Local
 }
 
-func (filesystem *Filesystem) String(server *Server, direction string) string {
+func (filesystem *Filesystem) String(direction string) string {
 	var parts []string
 
 	switch direction {
 	case "sync":
 		parts = append(parts, fmt.Sprintf("Path:%s", filesystem.Path))
 		parts = append(parts, "->")
-		parts = append(parts, fmt.Sprintf("Local:%s", filesystem.localPath(server)))
+		parts = append(parts, fmt.Sprintf("Local:%s", filesystem.localPath()))
 	case "deploy":
-		parts = append(parts, fmt.Sprintf("Local:%s", filesystem.localPath(server)))
+		parts = append(parts, fmt.Sprintf("Local:%s", filesystem.localPath()))
 		parts = append(parts, "->")
 		parts = append(parts, fmt.Sprintf("Path:%s", filesystem.Path))
 	}
diff --git a/sync/server_deploy.go b/sync/server_deploy.go
@@ -23,14 +23,17 @@ func (server *Server) DeployFilesystem() {
 	}
 
 	for _, filesystem := range server.Filesystem {
-		Logger.Main("Starting deploy of %s", filesystem.String(server, "deploy"))
-		filesystem.Deploy(server)
+		filesystem.ApplyDefaults(server)
+
+		Logger.Main("Starting deploy of %s", filesystem.String( "deploy"))
+		filesystem.Deploy()
 	}
 }
 
 func (server *Server) DeployDatabases() {
 	for _, database := range server.Database {
+		database.ApplyDefaults(server)
 		Logger.Main("Starting deploy of %s", database.String("deploy"))
-		database.Deploy(server)
+		database.Deploy()
 	}
 }
diff --git a/sync/server_deploy_database.go b/sync/server_deploy_database.go
@@ -5,19 +5,17 @@ import (
 	"fmt"
 )
 
-func (database *Database) Deploy(server *Server) {
-	database.remoteConnection = server.Connection
-
+func (database *Database) Deploy() {
 	if database.Options.ClearDatabase {
-		database.deployClearDatabase(server)
+		database.deployClearDatabase()
 	}
 
-	database.deployStructure(server)
-	database.deployData(server)
+	database.deployStructure()
+	database.deployData()
 }
 
 // Deploy database structure
-func (database *Database) deployClearDatabase(server *Server) {
+func (database *Database) deployClearDatabase() {
 
 	// don't use database which we're trying to drop, instead use "mysql"
 	schema := database.Schema
@@ -37,7 +35,7 @@ func (database *Database) deployClearDatabase(server *Server) {
 }
 
 // Deploy database structure
-func (database *Database) deployStructure(server *Server) {
+func (database *Database) deployStructure() {
 	Logger.Step("deploy database structure")
 
 	// Deploy structure only
@@ -49,7 +47,7 @@ func (database *Database) deployStructure(server *Server) {
 }
 
 // Deploy database data
-func (database *Database) deployData(server *Server) {
+func (database *Database) deployData() {
 	Logger.Step("deploy database data")
 
 	// Deploy data only
diff --git a/sync/server_deploy_filesystem.go b/sync/server_deploy_filesystem.go
@@ -8,17 +8,19 @@ import (
 )
 
 // General sync
-func (filesystem *Filesystem) Deploy(server *Server) {
-	switch server.Connection.GetType() {
+func (filesystem *Filesystem) Deploy() {
+	switch filesystem.Connection.GetType() {
+	case "local":
+		fallthrough
 	case "ssh":
-		filesystem.deployRsync(server)
+		filesystem.deployRsync()
 	case "docker":
 		errors.New("Docker not supported")
 	}
 }
 
 // Sync filesystem using rsync
-func (filesystem *Filesystem) deployRsync(server *Server) {
+func (filesystem *Filesystem) deployRsync() {
 	args := []string{"-rlptD", "--delete-after", "--progress", "--human-readable"}
 
 	// include filter
@@ -40,8 +42,14 @@ func (filesystem *Filesystem) deployRsync(server *Server) {
 	}
 
 	// build source and target paths
-	sourcePath := filesystem.localPath(server)
-	targetPath := fmt.Sprintf("%s:%s", server.Connection.SshConnectionHostnameString(), filesystem.Path)
+	sourcePath := filesystem.localPath()
+	targetPath := ""
+	switch filesystem.Connection.GetType() {
+	case "ssh":
+		targetPath = fmt.Sprintf("%s:%s", filesystem.Connection.SshConnectionHostnameString(), filesystem.Path)
+	case "local":
+		targetPath = filesystem.Path
+	}
 
 	// make sure source/target paths are using suffix slash
 	args = append(args, RsyncPath(sourcePath), RsyncPath(targetPath))
diff --git a/sync/server_sync.go b/sync/server_sync.go
@@ -16,19 +16,22 @@ func (server *Server) Sync() {
 
 func (server *Server) SyncFilesystem() {
 	for _, filesystem := range server.Filesystem {
+		filesystem.ApplyDefaults(server)
+
 		if filesystem.Options.GenerateStubs {
-			Logger.Main("Starting stub generator for %s", filesystem.String(server, "sync"))
-			filesystem.SyncStubs(server)
+			Logger.Main("Starting stub generator for %s", filesystem.String( "sync"))
+			filesystem.SyncStubs()
 		} else {
-			Logger.Main("Starting sync of %s", filesystem.String(server, "sync"))
-			filesystem.Sync(server)
+			Logger.Main("Starting sync of %s", filesystem.String("sync"))
+			filesystem.Sync()
 		}
 	}
 }
 
 func (server *Server) SyncDatabases() {
 	for _, database := range server.Database {
+		database.ApplyDefaults(server)
 		Logger.Main("Starting sync of %s", database.String("sync"))
-		database.Sync(server)
+		database.Sync()
 	}
 }
diff --git a/sync/server_sync_database.go b/sync/server_sync_database.go
@@ -7,19 +7,17 @@ import (
 	"os"
 )
 
-func (database *Database) Sync(server *Server) {
-	database.remoteConnection = server.Connection
-
+func (database *Database) Sync() {
 	if database.Options.ClearDatabase {
-		database.syncClearDatabase(server)
+		database.syncClearDatabase()
 	}
 
-	database.syncStructure(server)
-	database.syncData(server)
+	database.syncStructure()
+	database.syncData()
 }
 
 // Sync database structure
-func (database *Database) syncClearDatabase(server *Server) {
+func (database *Database) syncClearDatabase() {
 
 	// don't use database which we're trying to drop, instead use "mysql"
 	schema := database.Local.Schema
@@ -39,7 +37,7 @@ func (database *Database) syncClearDatabase(server *Server) {
 }
 
 // Sync database structure
-func (database *Database) syncStructure(server *Server) {
+func (database *Database) syncStructure() {
 	Logger.Step("syncing database structure")
 
 	tmpfile, err := ioutil.TempFile("", "dump")
@@ -58,7 +56,7 @@ func (database *Database) syncStructure(server *Server) {
 }
 
 // Sync database data
-func (database *Database) syncData(server *Server) {
+func (database *Database) syncData() {
 	Logger.Step("syncing database data")
 
 	tmpfile, err := ioutil.TempFile("", "dump")
diff --git a/sync/server_sync_filesystem.go b/sync/server_sync_filesystem.go
@@ -8,17 +8,19 @@ import (
 )
 
 // General sync
-func (filesystem *Filesystem) Sync(server *Server) {
-	switch server.Connection.GetType() {
+func (filesystem *Filesystem) Sync() {
+	switch filesystem.Connection.GetType() {
+	case "local":
+		fallthrough
 	case "ssh":
-		filesystem.syncRsync(server)
+		filesystem.syncRsync()
 	case "docker":
 		errors.New("Docker not supported")
 	}
 }
 
 // Sync filesystem using rsync
-func (filesystem *Filesystem) syncRsync(server *Server) {
+func (filesystem *Filesystem) syncRsync() {
 	args := []string{"-rlptD", "--delete-after", "--progress", "--human-readable"}
 
 	// include filter
@@ -40,8 +42,15 @@ func (filesystem *Filesystem) syncRsync(server *Server) {
 	}
 
 	// build source and target paths
-	sourcePath := fmt.Sprintf("%s:%s", server.Connection.SshConnectionHostnameString(), filesystem.Path)
-	targetPath := filesystem.localPath(server)
+	sourcePath := ""
+	switch filesystem.Connection.GetType() {
+	case "ssh":
+		sourcePath = fmt.Sprintf("%s:%s", filesystem.Connection.SshConnectionHostnameString(), filesystem.Path)
+	case "local":
+		sourcePath = filesystem.Path
+	}
+
+	targetPath := filesystem.localPath()
 
 	// make sure source/target paths are using suffix slash
 	args = append(args, RsyncPath(sourcePath), RsyncPath(targetPath))
diff --git a/sync/server_sync_filesystem_stubs.go b/sync/server_sync_filesystem_stubs.go
@@ -11,22 +11,24 @@ import (
 )
 
 // General sync
-func (filesystem *Filesystem) SyncStubs(server *Server) {
-	switch server.Connection.GetType() {
+func (filesystem *Filesystem) SyncStubs() {
+	switch filesystem.Connection.GetType() {
+	case "local":
+		fallthrough
 	case "ssh":
-		filesystem.generateStubs(server)
+		filesystem.generateStubs()
 	case "docker":
 		errors.New("Docker not supported")
 	}
 }
 
 // Sync filesystem using rsync
-func (filesystem *Filesystem) generateStubs(server *Server) {
-	cmd := shell.Cmd(server.Connection.CommandBuilder("find", filesystem.Path, "-type f")...)
+func (filesystem *Filesystem) generateStubs() {
+	cmd := shell.Cmd(filesystem.Connection.CommandBuilder("find", filesystem.Path, "-type f")...)
 	output := cmd.Run().Stdout.String()
 
 	removeBasePath := filesystem.Path
-	localBasePath := filesystem.localPath(server)
+	localBasePath := filesystem.localPath()
 
 	// build list and filter it by user filter list
 	fileList := []string{}
@@ -36,14 +38,13 @@ func (filesystem *Filesystem) generateStubs(server *Server) {
 	}
 	fileList = filesystem.Filter.ApplyFilter(fileList)
 
-
 	// generate stubs
 	stubGen := stubfilegenerator.StubGenerator()
 	for _, filePath := range fileList {
 		localPath := path.Join(localBasePath, filePath)
+		localAbsPath, _ := filepath.Abs(localPath)
 
 		stubGen.TemplateVariables["PATH"] = localPath
-		localAbsPath, _ := filepath.Abs(localPath)
 		stubGen.GenerateStub(localAbsPath)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ type Filesystem struct {`
`19`	`19`	`Path string`
`20`	`20`	`Local string`
`21`	`21`	`Filter Filter`
	`22`	`+ Connection commandbuilder.Connection`
`22`	`23`	`Options struct {`
`23`	`24`	GenerateStubs bool `yaml:"generate-stubs"`
`24`	`25`	`}`
`@@ -52,7 +53,7 @@ type Database struct {`
`52`	`53`	`cacheRemoteTableList []string`
`53`	`54`	`cacheLocalTableList []string`
`54`	`55`
`55`		`- remoteConnection commandbuilder.Connection`
	`56`	`+ Connection commandbuilder.Connection`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`type Execution struct {`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ func (database *Database) remoteMysqldumpCmdBuilder(additionalArgs []string, use`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// exclude`
`32`		`- excludeArgs, includeArgs := database.mysqlTableFilter(&database.remoteConnection, "remote");`
	`32`	`+ excludeArgs, includeArgs := database.mysqlTableFilter(&database.Connection, "remote");`
`33`	`33`	`if useFilter && len(excludeArgs) > 0 {`
`34`	`34`	`args = append(args, excludeArgs...)`
`35`	`35`	`}`
`@@ -46,7 +46,7 @@ func (database *Database) remoteMysqldumpCmdBuilder(additionalArgs []string, use`
`46`	`46`	`cmd = append(cmd, shell.QuoteValues(args...)...)`
`47`	`47`	`cmd = append(cmd, "\|", "gzip", "--stdout")`
`48`	`48`
`49`		`- return database.remoteConnection.RawShellCommandBuilder(cmd...)`
	`49`	`+ return database.Connection.RawShellCommandBuilder(cmd...)`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`func (database *Database) remoteMysqlCmdBuilder(args ...string) []interface{} {`
`@@ -72,7 +72,7 @@ func (database *Database) remoteMysqlCmdBuilder(args ...string) []interface{} {`
`72`	`72`	`args = append(args, database.Schema)`
`73`	`73`	`}`
`74`	`74`
`75`		`- return database.remoteConnection.CommandBuilder("mysql", args...)`
	`75`	`+ return database.Connection.CommandBuilder("mysql", args...)`
`76`	`76`	`}`
`77`	`77`
`78`	`78`
`@@ -101,5 +101,5 @@ func (database *Database) remoteMysqlCmdBuilderUncompress(args ...string) []inte`
`101`	`101`
`102`	`102`	`cmd := []string{"gunzip", "--stdout", "\|", "mysql", strings.Join(shell.QuoteValues(args...), " ")}`
`103`	`103`
`104`		`- return database.remoteConnection.RawShellCommandBuilder(cmd...)`
	`104`	`+ return database.Connection.RawShellCommandBuilder(cmd...)`
`105`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,14 +23,17 @@ func (server *Server) DeployFilesystem() {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`for _, filesystem := range server.Filesystem {`
`26`		`- Logger.Main("Starting deploy of %s", filesystem.String(server, "deploy"))`
`27`		`- filesystem.Deploy(server)`
	`26`	`+ filesystem.ApplyDefaults(server)`
	`27`	`+`
	`28`	`+ Logger.Main("Starting deploy of %s", filesystem.String( "deploy"))`
	`29`	`+ filesystem.Deploy()`
`28`	`30`	`}`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`func (server *Server) DeployDatabases() {`
`32`	`34`	`for _, database := range server.Database {`
	`35`	`+ database.ApplyDefaults(server)`
`33`	`36`	`Logger.Main("Starting deploy of %s", database.String("deploy"))`
`34`		`- database.Deploy(server)`
	`37`	`+ database.Deploy()`
`35`	`38`	`}`
`36`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,19 +16,22 @@ func (server *Server) Sync() {`
`16`	`16`
`17`	`17`	`func (server *Server) SyncFilesystem() {`
`18`	`18`	`for _, filesystem := range server.Filesystem {`
	`19`	`+ filesystem.ApplyDefaults(server)`
	`20`	`+`
`19`	`21`	`if filesystem.Options.GenerateStubs {`
`20`		`- Logger.Main("Starting stub generator for %s", filesystem.String(server, "sync"))`
`21`		`- filesystem.SyncStubs(server)`
	`22`	`+ Logger.Main("Starting stub generator for %s", filesystem.String( "sync"))`
	`23`	`+ filesystem.SyncStubs()`
`22`	`24`	`} else {`
`23`		`- Logger.Main("Starting sync of %s", filesystem.String(server, "sync"))`
`24`		`- filesystem.Sync(server)`
	`25`	`+ Logger.Main("Starting sync of %s", filesystem.String("sync"))`
	`26`	`+ filesystem.Sync()`
`25`	`27`	`}`
`26`	`28`	`}`
`27`	`29`	`}`
`28`	`30`
`29`	`31`	`func (server *Server) SyncDatabases() {`
`30`	`32`	`for _, database := range server.Database {`
	`33`	`+ database.ApplyDefaults(server)`
`31`	`34`	`Logger.Main("Starting sync of %s", database.String("sync"))`
`32`		`- database.Sync(server)`
	`35`	`+ database.Sync()`
`33`	`36`	`}`
`34`	`37`	`}`