[Fixes #197] Gracefully shutdown HTTP server

src/api/server.go

@@ -5,34 +5,56 @@ import (
 	"github.com/f1bonacc1/process-compose/src/app"
 	"github.com/gin-gonic/gin"
 	"github.com/rs/zerolog/log"
+	"net"
+	"net/http"
 	"os"
 )
 
 const EnvDebugMode = "PC_DEBUG_MODE"
 
-func StartHttpServerWithUnixSocket(useLogger bool, unixSocket string, project app.IProject) {
+func StartHttpServerWithUnixSocket(useLogger bool, unixSocket string, project app.IProject) (*http.Server, error) {
 	router := getRouter(useLogger, project)
 	log.Info().Msgf("start UDS http server listening %s", unixSocket)
+
+	os.Remove(unixSocket)
+	server := &http.Server{
+		Handler: router.Handler(),
+	}
+
+	listener, err := net.Listen("unix", unixSocket)
+	if err != nil {
+		return server, err
+	}
+
 	go func() {
-		os.Remove(unixSocket)
-		err := router.RunUnix(unixSocket)
-		if err != nil {
+		defer listener.Close()
+		defer os.Remove(unixSocket)
+
+		if err := server.Serve(listener); err != nil && err != http.ErrServerClosed {
 			log.Fatal().Err(err).Msgf("start UDS http server on %s failed", unixSocket)
 		}
 	}()
+
+	return server, nil
 }
 
-func StartHttpServerWithTCP(useLogger bool, port int, project app.IProject) {
+func StartHttpServerWithTCP(useLogger bool, port int, project app.IProject) (*http.Server, error) {
 	router := getRouter(useLogger, project)
 	endPoint := fmt.Sprintf(":%d", port)
 	log.Info().Msgf("start http server listening %s", endPoint)
+
+	server := &http.Server{
+		Addr:    endPoint,
+		Handler: router.Handler(),
+	}
+
 	go func() {
-		err := router.Run(endPoint)
-		if err != nil {
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			log.Fatal().Err(err).Msgf("start http server on %s failed", endPoint)
 		}
 	}()
 
+	return server, nil
 }
 
 func getRouter(useLogger bool, project app.IProject) *gin.Engine {

src/app/project_runner.go

@@ -15,6 +15,14 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+type ExitError struct {
+	Code int
+}
+
+func (e *ExitError) Error() string {
+	return fmt.Sprintf("project non-zero exit code: %d", e.Code)
+}
+
 type ProjectRunner struct {
 	procConfMutex     sync.Mutex
 	project           *types.Project
@@ -47,15 +55,15 @@ func (p *ProjectRunner) init() {
 	p.initProcessLogs()
 }
 
-func (p *ProjectRunner) Run() int {
+func (p *ProjectRunner) Run() error {
 	p.runningProcesses = make(map[string]*Process)
 	runOrder := []types.ProcessConfig{}
 	err := p.project.WithProcesses([]string{}, func(process types.ProcessConfig) error {
 		runOrder = append(runOrder, process)
 		return nil
 	})
 	if err != nil {
-		log.Error().Msgf("Failed to build project run order: %s", err.Error())
+		return fmt.Errorf("failed to build project run order: %e", err)
 	}
 	var nameOrder []string
 	for _, v := range runOrder {
@@ -75,7 +83,10 @@ func (p *ProjectRunner) Run() int {
 	}
 	p.waitGroup.Wait()
 	log.Info().Msg("Project completed")
-	return p.exitCode
+	if p.exitCode != 0 {
+		err = &ExitError{p.exitCode}
+	}
+	return err
 }
 
 func (p *ProjectRunner) runProcess(config *types.ProcessConfig) {

src/app/system_test.go

@@ -146,10 +146,10 @@ func TestSystem_TestComposeChainExit(t *testing.T) {
 			t.Errorf(err.Error())
 			return
 		}
-		exitCode := runner.Run()
-		want := 42
-		if want != exitCode {
-			t.Errorf("Project.Run() = %v, want %v", exitCode, want)
+		err = runner.Run()
+		want := "project non-zero exit code: 42"
+		if want != err.Error() {
+			t.Errorf("Project.Run() = %v, want %v", err, want)
 		}
 	})
 }

src/cmd/project_runner.go

@@ -38,16 +38,16 @@ func getProjectRunner(process []string, noDeps bool, mainProcess string, mainPro
 	return runner
 }
 
-func runProject(runner *app.ProjectRunner) {
-	exitCode := 0
+func runProject(runner *app.ProjectRunner) error {
+	var err error
 	if *pcFlags.IsTuiEnabled {
-		exitCode = runTui(runner)
+		err = runTui(runner)
 	} else {
-		exitCode = runHeadless(runner)
+		err = runHeadless(runner)
 	}
 	os.Remove(*pcFlags.UnixSocketPath)
 	log.Info().Msg("Thank you for using process-compose")
-	os.Exit(exitCode)
+	return err
 }
 
 func setSignal(signalHandler func()) {
@@ -60,23 +60,22 @@ func setSignal(signalHandler func()) {
 	}()
 }
 
-func runHeadless(project *app.ProjectRunner) int {
+func runHeadless(project *app.ProjectRunner) error {
 	setSignal(func() {
 		_ = project.ShutDownProject()
 	})
-	exitCode := project.Run()
-	return exitCode
+	return project.Run()
 }
 
-func runTui(project *app.ProjectRunner) int {
+func runTui(project *app.ProjectRunner) error {
 	go startTui(project)
-	exitCode := project.Run()
+	err := project.Run()
 	if !*pcFlags.KeepTuiOn {
 		tui.Stop()
 	} else {
 		tui.Wait()
 	}
-	return exitCode
+	return err
 }
 
 func startTui(runner app.IProject) {

src/cmd/root.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"github.com/f1bonacc1/process-compose/src/admitter"
 	"github.com/f1bonacc1/process-compose/src/api"
@@ -12,6 +13,7 @@ import (
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 	"io"
+	"net/http"
 	"os"
 	"path"
 	"runtime"
@@ -36,18 +38,17 @@ var (
 			pcFlags.PcThemeChanged = cmd.Flags().Changed(flagTheme)
 			pcFlags.SortColumnChanged = cmd.Flags().Changed(flagSort)
 		},
-		RunE: run,
+		Run: run,
 	}
 )
 
-func run(cmd *cobra.Command, args []string) error {
+func run(cmd *cobra.Command, args []string) {
 	defer func() {
 		_ = logFile.Close()
 	}()
 	runner := getProjectRunner([]string{}, false, "", []string{})
-	startHttpServerIfEnabled(!*pcFlags.IsTuiEnabled, runner)
-	runProject(runner)
-	return nil
+	err := waitForProjectAndServer(!*pcFlags.IsTuiEnabled, runner)
+	handleErrorAndExit(err)
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -137,14 +138,47 @@ func setupLogger() *os.File {
 	return file
 }
 
-func startHttpServerIfEnabled(useLogger bool, runner *app.ProjectRunner) {
+// Logs and exits with a non-zero code if there are any errors.
+func handleErrorAndExit(err error) {
+	if err != nil {
+		log.Error().Err(err)
+		if exitErr, ok := err.(*app.ExitError); ok {
+			os.Exit(exitErr.Code)
+		}
+		os.Exit(1)
+	}
+}
+
+func startHttpServerIfEnabled(useLogger bool, runner *app.ProjectRunner) (*http.Server, error) {
 	if !*pcFlags.NoServer {
 		if *pcFlags.IsUnixSocket {
-			api.StartHttpServerWithUnixSocket(useLogger, *pcFlags.UnixSocketPath, runner)
-			return
+			return api.StartHttpServerWithUnixSocket(useLogger, *pcFlags.UnixSocketPath, runner)
 		}
-		api.StartHttpServerWithTCP(useLogger, *pcFlags.PortNum, runner)
+		return api.StartHttpServerWithTCP(useLogger, *pcFlags.PortNum, runner)
 	}
+
+	return nil, nil
+}
+
+func waitForProjectAndServer(useLogger bool, runner *app.ProjectRunner) error {
+	server, err := startHttpServerIfEnabled(useLogger, runner)
+	if err != nil {
+		return err
+	}
+	// Blocks until shutdown.
+	if err = runProject(runner); err != nil {
+		return err
+	}
+	if server != nil {
+		shutdownTimeout := 5 * time.Second
+		ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
+		defer cancel()
+		if err := server.Shutdown(ctx); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 func getClient() *client.PcClient {

src/cmd/run.go

@@ -39,8 +39,8 @@ Command line arguments, provided after --, are passed to the PROCESS.`,
 			args,
 		)
 
-		startHttpServerIfEnabled(false, runner)
-		runProject(runner)
+		err := waitForProjectAndServer(!*pcFlags.IsTuiEnabled, runner)
+		handleErrorAndExit(err)
 	},
 }
 

src/cmd/up.go

@@ -14,8 +14,8 @@ If one or more process names are passed as arguments,
 will start them and their dependencies only`,
 	Run: func(cmd *cobra.Command, args []string) {
 		runner := getProjectRunner(args, *pcFlags.NoDependencies, "", []string{})
-		startHttpServerIfEnabled(!*pcFlags.IsTuiEnabled, runner)
-		runProject(runner)
+		err := waitForProjectAndServer(!*pcFlags.IsTuiEnabled, runner)
+		handleErrorAndExit(err)
 	},
 }