Modules refactor

cmd/configure.go

@@ -5,7 +5,6 @@ package cmd
 
 import (
 	"github.com/goodylabs/tug/internal/app"
-	"github.com/goodylabs/tug/pkg/dependecies"
 	"github.com/spf13/cobra"
 )
 
@@ -14,10 +13,8 @@ var configureCmd = &cobra.Command{
 	Use:   "configure",
 	Short: "Configure tug",
 	Run: func(cmd *cobra.Command, args []string) {
-		container := dependecies.InitDependencyContainer()
-		err := container.Invoke(func(configureUseCase *app.ConfigureUseCase) error {
-			return configureUseCase.Execute()
-		})
+		configureUseCase := app.NewConfigureUseCase()
+		err := configureUseCase.Execute()
 		if err != nil {
 			cmd.PrintErrf("%v\n", err)
 		}

cmd/constants.go

@@ -0,0 +1,7 @@
+package cmd
+
+const (
+	checkHint      = "Check are you able to establish SSH connection hosts in project"
+	customHostHint = "Manually input host - won't use project config"
+	customUserHint = "Manually input user (only to use with '--host' flag)"
+)

cmd/docker.go

@@ -2,35 +2,42 @@ package cmd
 
 import (
 	"github.com/goodylabs/tug/internal/app"
-	"github.com/goodylabs/tug/pkg/dependecies"
+	"github.com/goodylabs/tug/internal/modules/action"
+	"github.com/goodylabs/tug/internal/modules/loadproject"
 	"github.com/spf13/cobra"
 )
 
 var dockerCmd = &cobra.Command{
 	Use:   "docker",
 	Short: "Abstraction layer for docker operations related to project repo",
 	Run: func(cmd *cobra.Command, args []string) {
-		check, err := cmd.Flags().GetBool("check")
+		checkConnectionUseCase := app.NewCheckConnectionUseCase()
+		useModuleUseCase := app.NewUseModuleV2UseCase()
 
-		container := dependecies.InitDependencyContainer(
-			dependecies.WithDockerHandler,
-		)
-		if check {
-			err = container.Invoke(func(checkConnectionUseCase *app.CheckConnectionUseCase) error {
-				return checkConnectionUseCase.Execute()
-			})
-		} else {
-			err = container.Invoke(func(useModuleUseCase *app.UseModuleUseCase) error {
-				return useModuleUseCase.Execute()
-			})
+		if check, _ := cmd.Flags().GetBool("check"); check == true {
+			if err := checkConnectionUseCase.Execute(loadproject.DockerStrategy); err != nil {
+				cmd.PrintErrf("%v\n", err)
+			}
+			return
 		}
-		if err != nil {
+
+		if host, _ := cmd.Flags().GetString("host"); host != "" {
+			user, _ := cmd.Flags().GetString("user")
+			if err := useModuleUseCase.ExecuteDirect(user, host, action.Docker); err != nil {
+				cmd.PrintErrf("%v\n", err)
+			}
+			return
+		}
+
+		if err := useModuleUseCase.Execute(loadproject.DockerStrategy, action.Docker); err != nil {
 			cmd.PrintErrf("%v\n", err)
 		}
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(dockerCmd)
-	dockerCmd.Flags().Bool("check", false, "Check SSH connections before running Docker commands")
+	dockerCmd.Flags().Bool("check", false, checkHint)
+	dockerCmd.Flags().String("host", "", customHostHint)
+	dockerCmd.Flags().String("user", "root", customUserHint)
 }

cmd/pm2.go

@@ -2,35 +2,43 @@ package cmd
 
 import (
 	"github.com/goodylabs/tug/internal/app"
-	"github.com/goodylabs/tug/pkg/dependecies"
+	"github.com/goodylabs/tug/internal/modules/action"
+	"github.com/goodylabs/tug/internal/modules/loadproject"
 	"github.com/spf13/cobra"
 )
 
 var pm2Cmd = &cobra.Command{
 	Use:   "pm2",
 	Short: "Abstraction layer for pm2 operations related to project repo",
 	Run: func(cmd *cobra.Command, args []string) {
-		check, err := cmd.Flags().GetBool("check")
+		checkConnectionUseCase := app.NewCheckConnectionUseCase()
+		useModuleUseCase := app.NewUseModuleV2UseCase()
 
-		container := dependecies.InitDependencyContainer(
-			dependecies.WithPm2Handler,
-		)
-		if check {
-			err = container.Invoke(func(checkConnectionUseCase *app.CheckConnectionUseCase) error {
-				return checkConnectionUseCase.Execute()
-			})
-		} else {
-			err = container.Invoke(func(useModuleUseCase *app.UseModuleUseCase) error {
-				return useModuleUseCase.Execute()
-			})
+		if check, _ := cmd.Flags().GetBool("check"); check == true {
+			if err := checkConnectionUseCase.Execute(loadproject.Pm2Strategy); err != nil {
+				cmd.PrintErrf("%v\n", err)
+			}
+			return
 		}
-		if err != nil {
+
+		if host, _ := cmd.Flags().GetString("host"); host != "" {
+			user, _ := cmd.Flags().GetString("user")
+			if err := useModuleUseCase.ExecuteDirect(user, host, action.Pm2); err != nil {
+				cmd.PrintErrf("%v\n", err)
+			}
+			return
+		}
+
+		if err := useModuleUseCase.Execute(loadproject.Pm2Strategy, action.Pm2); err != nil {
 			cmd.PrintErrf("%v\n", err)
 		}
+
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(pm2Cmd)
-	pm2Cmd.Flags().Bool("check", false, "Check SSH connections before running Docker commands")
+	pm2Cmd.Flags().Bool("check", false, checkHint)
+	pm2Cmd.Flags().String("host", "", customHostHint)
+	pm2Cmd.Flags().String("user", "root", customUserHint)
 }

cmd/pystrano.go

@@ -5,7 +5,8 @@ package cmd
 
 import (
 	"github.com/goodylabs/tug/internal/app"
-	"github.com/goodylabs/tug/pkg/dependecies"
+	"github.com/goodylabs/tug/internal/modules/action"
+	"github.com/goodylabs/tug/internal/modules/loadproject"
 	"github.com/spf13/cobra"
 )
 
@@ -14,20 +15,18 @@ var pystranoCmd = &cobra.Command{
 	Use:   "pystrano",
 	Short: "Abstraction layer for pm2 operations related to project repo",
 	Run: func(cmd *cobra.Command, args []string) {
-		check, err := cmd.Flags().GetBool("check")
 
-		container := dependecies.InitDependencyContainer(
-			dependecies.WithPystranoHandler,
-		)
-		if check {
-			err = container.Invoke(func(checkConnectionUseCase *app.CheckConnectionUseCase) error {
-				return checkConnectionUseCase.Execute()
-			})
-		} else {
-			err = container.Invoke(func(useModuleUseCase *app.UseModuleUseCase) error {
-				return useModuleUseCase.Execute()
-			})
+		if check, _ := cmd.Flags().GetBool("check"); check == true {
+			checkConnectionUseCase := app.NewCheckConnectionUseCase()
+			if err := checkConnectionUseCase.Execute(loadproject.PystranoStrategy); err != nil {
+				cmd.PrintErrf("%v\n", err)
+			}
+			return
 		}
+
+		useCase := app.NewUseModuleV2UseCase()
+		err := useCase.Execute(loadproject.PystranoStrategy, action.Pystrano)
+
 		if err != nil {
 			cmd.PrintErrf("%v\n", err)
 		}
@@ -36,14 +35,5 @@ var pystranoCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(pystranoCmd)
-
-	// Here you will define your flags and configuration settings.
-
-	// Cobra supports Persistent Flags which will work for this command
-	// and all subcommands, e.g.:
-	// pystranoCmd.PersistentFlags().String("foo", "", "A help for foo")
-
-	// Cobra supports local flags which will only run when this command
-	// is called directly, e.g.:
-	// pystranoCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+	pystranoCmd.Flags().Bool("check", false, "Check SSH connections before running Docker commands")
 }

cmd/swarm.go

@@ -2,31 +2,31 @@ package cmd
 
 import (
 	"github.com/goodylabs/tug/internal/app"
-	"github.com/goodylabs/tug/pkg/dependecies"
+	"github.com/goodylabs/tug/internal/modules/action"
+	"github.com/goodylabs/tug/internal/modules/loadproject"
 	"github.com/spf13/cobra"
 )
 
 var swarmCmd = &cobra.Command{
 	Use:   "swarm",
 	Short: "Abstraction layer for docker swarm operations related to project repo",
 	Run: func(cmd *cobra.Command, args []string) {
-		check, err := cmd.Flags().GetBool("check")
 
-		container := dependecies.InitDependencyContainer(
-			dependecies.WithSwarmHandler,
-		)
-		if check {
-			err = container.Invoke(func(checkConnectionUseCase *app.CheckConnectionUseCase) error {
-				return checkConnectionUseCase.Execute()
-			})
-		} else {
-			err = container.Invoke(func(useModuleUseCase *app.UseModuleUseCase) error {
-				return useModuleUseCase.Execute()
-			})
+		if check, _ := cmd.Flags().GetBool("check"); check == true {
+			checkConnectionUseCase := app.NewCheckConnectionUseCase()
+			if err := checkConnectionUseCase.Execute(loadproject.DockerStrategy); err != nil {
+				cmd.PrintErrf("%v\n", err)
+			}
+			return
 		}
+
+		useCase := app.NewUseModuleV2UseCase()
+		err := useCase.Execute(loadproject.DockerStrategy, action.Swarm)
+
 		if err != nil {
 			cmd.PrintErrf("%v\n", err)
 		}
+
 	},
 }
 

internal/adapters/prompter.go

@@ -127,3 +127,17 @@ func (p *prompter) runPrompter(options []ports.DisplayValueOpts, label string) (
 func (p *prompter) ChooseFromListWithDisplayValue(options []ports.DisplayValueOpts, label string) (string, error) {
 	return p.runPrompter(options, label)
 }
+
+func (p *prompter) AskUserForInput(prompt string) (string, error) {
+	input := promptui.Prompt{
+		Label:  prompt,
+		Stdout: noBellWriter{os.Stdout},
+	}
+
+	value, err := input.Run()
+	if err != nil {
+		return "", err
+	}
+
+	return value, nil
+}

internal/adapters/sshconnector.go

@@ -15,7 +15,8 @@ import (
 )
 
 type sshConnector struct {
-	client *ssh.Client
+	client     *ssh.Client
+	passphrase []byte
 }
 
 func NewSSHConnector() ports.SSHConnector {
@@ -69,16 +70,22 @@ func (s *sshConnector) loadSSHKeysFromDir() ([]ssh.AuthMethod, error) {
 	if err != nil {
 		if _, ok := err.(*ssh.PassphraseMissingError); ok {
 			fmt.Print("Enter passphrase for SSH key: ")
-			passphrase, perr := term.ReadPassword(int(os.Stdin.Fd()))
-			fmt.Println()
-			if perr != nil {
-				return nil, perr
+
+			if "" == string(s.passphrase) {
+				passphraseInput, perr := term.ReadPassword(int(os.Stdin.Fd()))
+				fmt.Println()
+				if perr != nil {
+					return nil, perr
+				}
+
+				s.passphrase = passphraseInput
 			}
 
-			signer, err = ssh.ParsePrivateKeyWithPassphrase(keyData, passphrase)
+			signer, err = ssh.ParsePrivateKeyWithPassphrase(keyData, s.passphrase)
 			if err != nil {
 				return nil, err
 			}
+
 		} else {
 			return nil, err
 		}