feat: add process-compose command to CLI (#6)

- Add `process-compose` command to start a `process-compose` easily which was configured in a devenv Nix shell by doing `quitsh process-compose start ./tools/nix#mynamespace.shells.test-db`.

Author: gabyx

justfile

@@ -38,6 +38,10 @@ format *args:
 package-nix:
     nix build -L "{{flake_dir}}#cli" -o "{{out_dir}}/package/cli"
 
+# Clean the output folder.
+clean:
+    rm -rf "{{out_dir}}"
+
 ## CI =========================================================================
 ci *args:
     just nix-develop "ci" "$@"

pkg/cli/cmd/process-compose/process-compose.go

@@ -0,0 +1,26 @@
+package processcompose
+
+import (
+	"errors"
+
+	"github.com/sdsc-ordes/quitsh/pkg/cli"
+	processcomposestart "github.com/sdsc-ordes/quitsh/pkg/cli/cmd/process-compose/start"
+
+	"github.com/spf13/cobra"
+)
+
+func AddCmd(cl cli.ICLI, parent *cobra.Command, flakeDirDefault string) *cobra.Command {
+	configCmd := &cobra.Command{
+		Use:   "process-compose",
+		Short: "Start process-compose services defined in Nix 'devenv.sh' shells.",
+		RunE: func(_cmd *cobra.Command, _args []string) error {
+			return errors.New("no subcommand given")
+		},
+	}
+
+	processcomposestart.AddCmd(cl, configCmd, flakeDirDefault)
+
+	parent.AddCommand(configCmd)
+
+	return configCmd
+}

pkg/cli/cmd/process-compose/start/start.go

@@ -0,0 +1,115 @@
+package processcomposestart
+
+import (
+	"context"
+	"os"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/sdsc-ordes/quitsh/pkg/cli"
+	"github.com/sdsc-ordes/quitsh/pkg/errors"
+	processcompose "github.com/sdsc-ordes/quitsh/pkg/exec/process-compose"
+	fs "github.com/sdsc-ordes/quitsh/pkg/filesystem"
+	"github.com/sdsc-ordes/quitsh/pkg/log"
+	"github.com/spf13/cobra"
+)
+
+const longDesc = `Start a process-compose definition from a 'devenv.sh' Nix shell
+specified by an attribute path (e.g. 'mynamespace.shells.test-dbs') or installable
+(e.g. './tools/nix#mynamespace.shells.test-dbs')
+in a 'flake.nix' file.`
+
+const timeoutContainers = 100 * time.Second
+
+type startArgs struct {
+	attrPath string
+	flakeDir string
+	waitFor  []string
+
+	socketPathFile string
+}
+
+func AddCmd(cl cli.ICLI, parent *cobra.Command, defaultFlakeDir string) {
+	var stArgs startArgs
+
+	startCmd := &cobra.Command{
+		Use:     "start [devenv-attr-path or devenv-installable]",
+		Short:   "Start a process-compose definition from a 'devenv.sh' Nix shell.",
+		Long:    longDesc,
+		PreRunE: cobra.MinimumNArgs(1),
+		RunE: func(_cmd *cobra.Command, args []string) error {
+			stArgs.attrPath = args[0]
+
+			_, err := StartServices(
+				cl.RootDir(),
+				stArgs.flakeDir,
+				stArgs.attrPath,
+				stArgs.waitFor,
+				stArgs.socketPathFile)
+
+			return err
+		},
+	}
+
+	startCmd.Flags().
+		StringVarP(&stArgs.flakeDir,
+			"flake-dir", "f", defaultFlakeDir, "The flake directory which contains a `flake.nix` file.")
+
+	startCmd.Flags().
+		StringArrayVarP(&stArgs.waitFor,
+			"wait-for", "w", nil, "Wait for this processes to be running.")
+
+	startCmd.Flags().
+		StringVarP(&stArgs.socketPathFile,
+			"socketPathFile", "s", ".pc-socket-path", "The file (JSON) where the process-compose socket path is written to.")
+
+	parent.AddCommand(startCmd)
+}
+
+// StartServices starts the process-compose services from `flake.nix` in `flakeDir`
+// defined in the installable `devenvShellInstallable`.
+// You can wait for the processes names to be running with `waitFor`.
+func StartServices(
+	rootDir string,
+	flakeDir string,
+	devenvShellAttrPath string,
+	waitFor []string,
+	socketPathFile string) (
+	pcCtx processcompose.ProcessComposeCtx,
+	err error,
+) {
+	dir, err := os.MkdirTemp(os.TempDir(), "process-compose-*")
+	if err != nil {
+		return pcCtx, errors.AddContext(err, "could not create process-compose log file.")
+	}
+
+	logFile := path.Join(dir, "process-compose.log")
+	if strings.Contains(devenvShellAttrPath, "#") {
+		pcCtx, err = processcompose.StartFromInstallable(rootDir, devenvShellAttrPath, logFile)
+	} else {
+		pcCtx, err = processcompose.Start(rootDir, flakeDir, devenvShellAttrPath, logFile)
+	}
+
+	if err != nil {
+		return pcCtx, errors.AddContext(err, "could not start process-compose")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeoutContainers)
+	defer cancel()
+
+	isRunning, err := pcCtx.WaitTillRunning(ctx, waitFor...)
+	if err != nil || !isRunning {
+		return pcCtx, errors.AddContext(err, "failed to wait for processes '%q'.", waitFor)
+	}
+
+	err = os.WriteFile(socketPathFile, []byte(pcCtx.Socket()), fs.DefaultPermissionsFile)
+	if err != nil {
+		log.WarnE(err, "Could not write socket path to file '%s'.", socketPathFile)
+	}
+
+	log.Info("Inspect processes with 'process-compose attach -u '%s'.", pcCtx.Socket())
+	log.Info("Stop processes with 'process-compose down -u '%s'.", pcCtx.Socket())
+
+	return pcCtx, nil
+}

pkg/cli/cmd/root/root.go

@@ -126,7 +126,7 @@ func New(
 		StringVar(&rootArgs.ConfigUser, "config-user", "", "The global user configuration file (overlay), can not exist.")
 	rootCmd.PersistentFlags().
 		StringVarP(&rootArgs.Cwd,
-			"cwd", "C", "",
+			"cwd", "C", ".",
 			"Set the current working directory "+
 				"(note: '--root-dir' = Git root dir evaluated from `--cwd`).")
 	rootCmd.PersistentFlags().

pkg/exec/nix/attr-paths.go

@@ -7,6 +7,10 @@ import (
 
 // FlakeInstallable returns the attribute path `<flakePath>#<attrPath>`.
 func FlakeInstallable(flakePath string, attrPath string) string {
+	if flakePath == "" {
+		flakePath = "."
+	}
+
 	return fmt.Sprintf("%s#%s", flakePath, attrPath)
 }
 

pkg/exec/nix/context.go

@@ -92,6 +92,8 @@ func addDefaultArgs(rootDir string, b exec.CmdContextBuilder) exec.CmdContextBui
 	// mode while still being able to run processes & services and modify
 	// (some parts) of the active shell.mkdir -p .devenv/state
 	// See: https://github.com/cachix/devenv/issues/1461
+	// NOTE: This will also work if no input matches the override which is important
+	//       for users not using this.
 	return b.
 		Cwd(rootDir).
 		BaseArgs(

pkg/exec/process-compose/compose.go

@@ -23,18 +23,34 @@ type ProcessComposeCtx struct {
 }
 
 // Start starts the process compose from a
-// `devShellInstallable` (e.g. `./tools/nix#custodian.shells.test-dbs`
-// which must be a `devenv` shell) in the flake located
+// `devShellAttrPath` (e.g. `custodian.shells.test-dbs`
+// which must be a `devenv` shell) in the flake `flake.nix` located
 // at `flakeDir`. The `rootDir` is the working directory and
 // where the `.devenv/state/pwd` file is for `nonPureEval == false`.
+// Note: You also call [StartFromInstallable] and directly pass an
+// installable, e.g. a flake output attribute path like
+// `./a/b/c#mynamespace.shells.test-dbs`.
 func Start(
 	rootDir string,
 	flakeDir string,
-	devShellInstallable string,
+	devShellAttrPath string,
 	logFile string,
 ) (pc ProcessComposeCtx, err error) {
-	devShellInstallable = nix.FlakeInstallable(flakeDir, devShellInstallable)
+	devShellAttrPath = nix.FlakeInstallable(flakeDir, devShellAttrPath)
+
+	return StartFromInstallable(rootDir, devShellAttrPath, logFile)
+}
 
+// Start starts the process compose from a Nix
+// `devShellInstallable` (e.g. `./tools/nix#custodian.shells.test-dbs`
+// which must be a `devenv` shell).
+// The `rootDir` is the working directory and
+// where the `.devenv/state/pwd` file is for `nonPureEval == false`.
+func StartFromInstallable(
+	rootDir string,
+	devShellInstallable string,
+	logFile string,
+) (pc ProcessComposeCtx, err error) {
 	procCompExe, socketPath, err := getSocketPath(devShellInstallable, rootDir)
 	if err != nil {
 		return pc, err
@@ -66,6 +82,8 @@ func Start(
 		devShellInstallable,
 		"socket",
 		socketPath,
+		"logFile",
+		logFile,
 	)
 
 	b = exec.NewCmdCtxBuilder().
@@ -94,6 +112,10 @@ func (pc *ProcessComposeCtx) Stop() error {
 func (pc *ProcessComposeCtx) WaitTillRunning(
 	ctx context.Context,
 	procs ...string) (isRunning bool, err error) {
+	if len(procs) == 0 {
+		return true, nil
+	}
+
 	err = pc.waitForSocket()
 	if err != nil {
 		return false, err

pkg/exec/process-compose/test/.gitignore

@@ -0,0 +1,4 @@
+.devenv
+
+# Generated in test.
+.pc-socket-path

pkg/log/log.go

@@ -107,7 +107,12 @@ func createRecord(skipFns int, level slog.Level, msg string, args ...any) slog.R
 	return r
 }
 
-// Trace will log an trace if trace is enabled.
+// Trace will log a trace info with formatting.
+func Tracef(msg string, args ...any) {
+	Trace(fmt.Sprintf(msg, args...))
+}
+
+// Trace will log a trace info.
 func Trace(msg string, args ...any) {
 	msg = fmt.Sprintf(msg, args...)
 	ctx := context.Background()
@@ -120,7 +125,12 @@ func Trace(msg string, args ...any) {
 	_ = slog.Default().Handler().Handle(ctx, r)
 }
 
-// Debug will log an info if debug is enabled.
+// Debug will log a debug info with formatting.
+func Debugf(msg string, args ...any) {
+	Debug(fmt.Sprintf(msg, args...))
+}
+
+// Debug will log a debug info.
 func Debug(msg string, args ...any) {
 	ctx := context.Background()
 	const level = slog.LevelDebug
@@ -132,6 +142,11 @@ func Debug(msg string, args ...any) {
 	_ = slog.Default().Handler().Handle(ctx, r)
 }
 
+// Info will log an info with formatting.
+func Infof(msg string, args ...any) {
+	Info(fmt.Sprintf(msg, args...))
+}
+
 // Info will log an info.
 func Info(msg string, args ...any) {
 	ctx := context.Background()
@@ -144,35 +159,65 @@ func Info(msg string, args ...any) {
 	_ = slog.Default().Handler().Handle(ctx, r)
 }
 
-// Warn will log an info.
+// Warn will log a warning info with formatting.
+func Warnf(msg string, args ...any) {
+	Warn(fmt.Sprintf(msg, args...))
+}
+
+// Warn will log an warning info.
 func Warn(msg string, args ...any) {
 	warnS(0, msg, args...)
 }
 
+// Warn will log a warning for an error `err` with formatting.
+func WarnEf(err error, msg string, args ...any) {
+	WarnE(err, fmt.Sprintf(msg, args...))
+}
+
 // Warn will log a warning for an error `err`.
 func WarnE(err error, msg string, args ...any) {
-	a := make([]interface{}, 0, 2+len(args)) //nolint: mnd
+	a := make([]any, 0, 2+len(args)) //nolint: mnd
 	a = append(a, "error", err)
 	a = append(a, args...)
 	warnS(0, msg, a...)
 }
 
+// Error will log an error with formatting.
+func Errorf(msg string, args ...any) {
+	Error(fmt.Sprintf(msg, args...))
+}
+
 // Error will log an error.
 func Error(msg string, args ...any) {
 	errorS(0, msg, args...)
 }
 
+// Error will log an error for `err` with formatting.
+func ErrorEf(err error, msg string, args ...any) {
+	ErrorE(err, fmt.Sprintf(msg, args...))
+}
+
 // Error will log an error for `err`.
 func ErrorE(err error, msg string, args ...any) {
 	errorES(0, err, msg, args...)
 }
 
+// Panic will log and panic with formatting.
+func Panicf(msg string, args ...any) {
+	Panic(fmt.Sprintf(msg, args...))
+}
+
 // Panic will log and panic.
 func Panic(msg string, args ...any) {
 	errorS(0, msg, args...)
 	panic(msg)
 }
 
+// Panic will log and panic with formatting.
+func PanicEf(err error, msg string, args ...any) {
+	PanicE(err, fmt.Sprintf(msg, args...))
+}
+
 // PanicE will log and panic if `err` is not `nil`.
 func PanicE(err error, msg string, args ...any) {
 	if err != nil {
@@ -204,7 +249,7 @@ func errorS(skipFns int, msg string, args ...any) {
 }
 
 func errorES(skipFns int, err error, msg string, args ...any) {
-	a := make([]interface{}, 0, 2+len(args)) //nolint: mnd
+	a := make([]any, 0, 2+len(args)) //nolint: mnd
 	a = append(a, args...)
 	a = append(a, "error", err)
 	errorS(skipFns+1, msg, a...)