Use config flags

src/cmd/0-init.go

@@ -0,0 +1,9 @@
+package cmd
+
+import "github.com/f1bonacc1/process-compose/src/config"
+
+var pcFlags *config.Flags
+
+func init() {
+	pcFlags = config.NewFlags()
+}

src/cmd/attach.go

@@ -6,22 +6,18 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var (
-	logLength = 1000
-)
-
 // attachCmd represents the attach command
 var attachCmd = &cobra.Command{
 	Use:   "attach",
 	Short: "Attach the Process Compose TUI Remotely to a Running Process Compose Server",
 	Run: func(cmd *cobra.Command, args []string) {
-		pcClient := client.NewClient(pcAddress, port, logLength)
+		pcClient := client.NewClient(*pcFlags.Address, *pcFlags.PortNum, *pcFlags.LogLength)
 		tui.SetupTui(pcClient)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(attachCmd)
-	attachCmd.Flags().StringVarP(&pcAddress, "address", "a", "localhost", "address of a running process compose server")
-	attachCmd.Flags().IntVarP(&logLength, "log-length", "l", logLength, "log length to display in TUI")
+	attachCmd.Flags().StringVarP(pcFlags.Address, "address", "a", *pcFlags.Address, "address of a running process compose server")
+	attachCmd.Flags().IntVarP(pcFlags.LogLength, "log-length", "l", *pcFlags.LogLength, "log length to display in TUI")
 }

src/cmd/list.go

@@ -13,7 +13,7 @@ var listCmd = &cobra.Command{
 	Short:   "List available processes",
 	Aliases: []string{"ls"},
 	Run: func(cmd *cobra.Command, args []string) {
-		processNames, err := client.GetProcessesName(pcAddress, port)
+		processNames, err := client.GetProcessesName(*pcFlags.Address, *pcFlags.PortNum)
 		if err != nil {
 			logFatal(err, "failed to list processes")
 		}

src/cmd/logs.go

@@ -5,17 +5,11 @@ import (
 	"github.com/f1bonacc1/process-compose/src/client"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
-	"math"
 	"os"
 	"os/signal"
 	"time"
 )
 
-var (
-	follow     bool
-	tailLength int
-)
-
 // logsCmd represents the logs command
 var logsCmd = &cobra.Command{
 	Use:   "logs [PROCESS]",
@@ -26,7 +20,7 @@ var logsCmd = &cobra.Command{
 		logger := client.LogClient{
 			Format: "%s\n",
 		}
-		err := logger.ReadProcessLogs(pcAddress, port, name, tailLength, follow, os.Stdout)
+		err := logger.ReadProcessLogs(*pcFlags.Address, *pcFlags.PortNum, name, *pcFlags.LogTailLength, *pcFlags.LogFollow, os.Stdout)
 		if err != nil {
 			log.Error().Msgf("Failed to fetch logs for process %s: %v", name, err)
 			return
@@ -46,6 +40,6 @@ var logsCmd = &cobra.Command{
 func init() {
 	processCmd.AddCommand(logsCmd)
 
-	logsCmd.Flags().BoolVarP(&follow, "follow", "f", false, "Follow log output")
-	logsCmd.Flags().IntVarP(&tailLength, "tail", "n", math.MaxInt, "Number of lines to show from the end of the logs")
+	logsCmd.Flags().BoolVarP(pcFlags.LogFollow, "follow", "f", *pcFlags.LogFollow, "Follow log output")
+	logsCmd.Flags().IntVarP(pcFlags.LogTailLength, "tail", "n", *pcFlags.LogTailLength, "Number of lines to show from the end of the logs")
 }

src/cmd/ports.go

@@ -15,7 +15,7 @@ var portsCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		name := args[0]
-		ports, err := client.GetProcessPorts(pcAddress, port, name)
+		ports, err := client.GetProcessPorts(*pcFlags.Address, *pcFlags.PortNum, name)
 		if err != nil {
 			logFatal(err, "failed to get process %s ports", name)
 			return

src/cmd/process.go

@@ -13,5 +13,5 @@ var processCmd = &cobra.Command{
 
 func init() {
 	rootCmd.AddCommand(processCmd)
-	processCmd.PersistentFlags().StringVarP(&pcAddress, "address", "a", "localhost", "address of a running process compose server")
+	processCmd.PersistentFlags().StringVarP(pcFlags.Address, "address", "a", *pcFlags.Address, "address of a running process compose server")
 }

src/cmd/project_runner.go

@@ -28,7 +28,7 @@ func getProjectRunner(process []string, noDeps bool) *app.ProjectRunner {
 
 func runProject(runner *app.ProjectRunner) {
 	exitCode := 0
-	if isTui {
+	if *pcFlags.Headless {
 		exitCode = runTui(runner)
 	} else {
 		exitCode = runHeadless(runner)

src/cmd/restart.go

@@ -13,7 +13,7 @@ var restartCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		name := args[0]
-		err := client.RestartProcess(pcAddress, port, name)
+		err := client.RestartProcess(*pcFlags.Address, *pcFlags.PortNum, name)
 		if err != nil {
 			logFatal(err, "failed to restart process %s", name)
 		}

src/cmd/root.go

@@ -10,18 +10,12 @@ import (
 	"github.com/spf13/cobra"
 	"os"
 	"path"
-	"strconv"
-	"strings"
 	"time"
 )
 
 var (
-	port      int
-	isTui     bool
-	opts      *loader.LoaderOptions
-	pcAddress string
-	logPath   string
-	logFile   *os.File
+	opts    *loader.LoaderOptions
+	logFile *os.File
 
 	// rootCmd represents the base command when called without any subcommands
 	rootCmd = &cobra.Command{
@@ -35,23 +29,12 @@ var (
 	}
 )
 
-const (
-	defaultPortNum   = 8080
-	portEnvVarName   = "PC_PORT_NUM"
-	tuiEnvVarName    = "PC_DISABLE_TUI"
-	configEnvVarName = "PC_CONFIG_FILES"
-)
-
 func run(cmd *cobra.Command, args []string) {
-
-	if !cmd.Flags().Changed("tui") {
-		isTui = getTuiDefault()
-	}
 	defer func() {
 		_ = logFile.Close()
 	}()
 	runner := getProjectRunner([]string{}, false)
-	api.StartHttpServer(!isTui, port, runner)
+	api.StartHttpServer(!*pcFlags.Headless, *pcFlags.PortNum, runner)
 	runProject(runner)
 }
 
@@ -70,36 +53,10 @@ func init() {
 		FileNames: []string{},
 	}
 
-	rootCmd.Flags().BoolVarP(&isTui, "tui", "t", true, "enable tui (-t=false) (env: "+tuiEnvVarName+")")
-	rootCmd.PersistentFlags().IntVarP(&port, "port", "p", getPortDefault(), "port number (env: "+portEnvVarName+")")
-	rootCmd.Flags().StringArrayVarP(&opts.FileNames, "config", "f", getConfigDefault(), "path to config files to load (env: "+configEnvVarName+")")
-	rootCmd.PersistentFlags().StringVarP(&logPath, "log-file", "L", config.GetLogFilePath(), "Specify the log file path (env: "+config.LogPathEnvVarName+")")
-}
-
-func getTuiDefault() bool {
-	_, found := os.LookupEnv(tuiEnvVarName)
-	return !found
-}
-
-func getPortDefault() int {
-	val, found := os.LookupEnv(portEnvVarName)
-	if found {
-		port, err := strconv.Atoi(val)
-		if err != nil {
-			log.Fatal().Msgf("Invalid port number: %s", val)
-			return defaultPortNum
-		}
-		return port
-	}
-	return defaultPortNum
-}
-
-func getConfigDefault() []string {
-	val, found := os.LookupEnv(configEnvVarName)
-	if found {
-		return strings.Split(val, ",")
-	}
-	return []string{}
+	rootCmd.Flags().BoolVarP(pcFlags.Headless, "tui", "t", true, "enable tui (-t=false) (env: "+config.TuiEnvVarName+")")
+	rootCmd.PersistentFlags().IntVarP(pcFlags.PortNum, "port", "p", *pcFlags.PortNum, "port number (env: "+config.PortEnvVarName+")")
+	rootCmd.Flags().StringArrayVarP(&opts.FileNames, "config", "f", config.GetConfigDefault(), "path to config files to load (env: "+config.ConfigEnvVarName+")")
+	rootCmd.PersistentFlags().StringVarP(pcFlags.LogFile, "log-file", "L", *pcFlags.LogFile, "Specify the log file path (env: "+config.LogPathEnvVarName+")")
 }
 
 func logFatal(err error, format string, args ...interface{}) {
@@ -109,14 +66,14 @@ func logFatal(err error, format string, args ...interface{}) {
 }
 
 func setupLogger() *os.File {
-	dirName := path.Dir(logPath)
+	dirName := path.Dir(*pcFlags.LogFile)
 	if err := os.MkdirAll(dirName, 0700); err != nil && !os.IsExist(err) {
 		fmt.Printf("Failed to create log directory: %s - %v\n", dirName, err)
 		os.Exit(1)
 	}
-	file, err := os.OpenFile(logPath, config.LogFileFlags, config.LogFileMode)
+	file, err := os.OpenFile(*pcFlags.LogFile, config.LogFileFlags, config.LogFileMode)
 	if err != nil {
-		logFatal(err, "Failed to open log file: %s", logPath)
+		logFatal(err, "Failed to open log file: %s", *pcFlags.LogFile)
 	}
 	log.Logger = log.Output(zerolog.ConsoleWriter{
 		Out:        file,

src/cmd/scale.go

@@ -19,7 +19,7 @@ var scaleCmd = &cobra.Command{
 		if err != nil {
 			logFatal(err, "second argument must be an integer")
 		}
-		err = client.ScaleProcess(pcAddress, port, name, count)
+		err = client.ScaleProcess(*pcFlags.Address, *pcFlags.PortNum, name, count)
 		if err != nil {
 			logFatal(err, "failed to scale process %s", name)
 		}

src/cmd/start.go

@@ -16,7 +16,7 @@ var startCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		name := args[0]
-		err := client.StartProcess(pcAddress, port, name)
+		err := client.StartProcess(*pcFlags.Address, *pcFlags.PortNum, name)
 		if err != nil {
 			logFatal(err, "failed to start process %s", name)
 		}

src/cmd/stop.go

@@ -11,7 +11,7 @@ var stopCmd = &cobra.Command{
 	Use:   "stop [PROCESS...]",
 	Short: "Stop a running process",
 	Run: func(cmd *cobra.Command, args []string) {
-		stopped, err := client.StopProcesses(pcAddress, port, args)
+		stopped, err := client.StopProcesses(*pcFlags.Address, *pcFlags.PortNum, args)
 		if err != nil {
 			logFatal(err, "failed to stop processes %v", args)
 		}

src/cmd/up.go

@@ -2,13 +2,10 @@ package cmd
 
 import (
 	"github.com/f1bonacc1/process-compose/src/api"
+	"github.com/f1bonacc1/process-compose/src/config"
 	"github.com/spf13/cobra"
 )
 
-var (
-	noDeps = false
-)
-
 // upCmd represents the up command
 var upCmd = &cobra.Command{
 	Use:   "up [PROCESS...]",
@@ -17,20 +14,17 @@ var upCmd = &cobra.Command{
 If one or more process names are passed as arguments,
 will start them and their dependencies only`,
 	Run: func(cmd *cobra.Command, args []string) {
-		if !cmd.Flags().Changed("tui") {
-			isTui = getTuiDefault()
-		}
-		runner := getProjectRunner(args, noDeps)
-		api.StartHttpServer(!isTui, port, runner)
+		runner := getProjectRunner(args, *pcFlags.NoDependencies)
+		api.StartHttpServer(!*pcFlags.Headless, *pcFlags.PortNum, runner)
 		runProject(runner)
 	},
 }
 
 func init() {
 	rootCmd.AddCommand(upCmd)
 
-	upCmd.Flags().BoolVarP(&isTui, "tui", "t", true, "disable tui (-t=false) (env: PC_DISABLE_TUI)")
-	upCmd.Flags().BoolVarP(&noDeps, "no-deps", "", false, "don't start dependent processes")
-	upCmd.Flags().StringArrayVarP(&opts.FileNames, "config", "f", getConfigDefault(), "path to config files to load (env: PC_CONFIG_FILES)")
+	upCmd.Flags().BoolVarP(pcFlags.Headless, "tui", "t", *pcFlags.Headless, "disable tui (-t=false) (env: PC_DISABLE_TUI)")
+	upCmd.Flags().BoolVarP(pcFlags.NoDependencies, "no-deps", "", *pcFlags.NoDependencies, "don't start dependent processes")
+	upCmd.Flags().StringArrayVarP(&opts.FileNames, "config", "f", config.GetConfigDefault(), "path to config files to load (env: PC_CONFIG_FILES)")
 
 }

src/config/Flags.go

@@ -0,0 +1,74 @@
+package config
+
+import "math"
+
+const (
+	// DefaultRefreshRate represents the refresh interval.
+	DefaultRefreshRate = 2 // secs
+
+	// DefaultLogLevel represents the default log level.
+	DefaultLogLevel = "info"
+
+	// DefaultPortNum represents the default port number.
+	DefaultPortNum = 8080
+
+	// DefaultAddress represents the default address.
+	DefaultAddress = "localhost"
+
+	// DefaultLogLength represents the default log length.
+	DefaultLogLength = 1000
+)
+
+const (
+	PortEnvVarName   = "PC_PORT_NUM"
+	TuiEnvVarName    = "PC_DISABLE_TUI"
+	ConfigEnvVarName = "PC_CONFIG_FILES"
+)
+
+// Flags represents PC configuration flags.
+type Flags struct {
+	RefreshRate    *int
+	PortNum        *int
+	Address        *string
+	LogLevel       *string
+	LogFile        *string
+	LogLength      *int
+	LogFollow      *bool
+	LogTailLength  *int
+	Headless       *bool
+	Command        *string
+	AllNamespaces  *bool
+	ReadOnly       *bool
+	Write          *bool
+	NoDependencies *bool
+}
+
+// NewFlags returns new configuration flags.
+func NewFlags() *Flags {
+	return &Flags{
+		RefreshRate:    intPtr(DefaultRefreshRate),
+		Headless:       boolPtr(GetTuiDefault()),
+		PortNum:        intPtr(getPortDefault()),
+		Address:        strPtr(DefaultAddress),
+		LogLength:      intPtr(DefaultLogLength),
+		LogLevel:       strPtr(DefaultLogLevel),
+		LogFile:        strPtr(GetLogFilePath()),
+		LogFollow:      boolPtr(false),
+		LogTailLength:  intPtr(math.MaxInt),
+		AllNamespaces:  boolPtr(false),
+		ReadOnly:       boolPtr(false),
+		NoDependencies: boolPtr(false),
+	}
+}
+
+func boolPtr(b bool) *bool {
+	return &b
+}
+
+func intPtr(i int) *int {
+	return &i
+}
+
+func strPtr(s string) *string {
+	return &s
+}