fix problem with puma workers, refactoring

Author: prog-supdex

internal/app/caddyrailsapp.go

@@ -5,23 +5,30 @@ import (
 	"github.com/caddyserver/caddy/v2/caddyconfig"
 	"github.com/caddyserver/caddy/v2/caddyconfig/caddyfile"
 	"github.com/caddyserver/caddy/v2/caddyconfig/httpcaddyfile"
-	"github.com/evilmartians/caddy_rails/internal/utils"
+	"github.com/evilmartians/caddy_rails/internal/logger"
+	"github.com/evilmartians/caddy_rails/internal/process"
+	"os"
 )
 
+var caddyLogger = logger.NewCaddyRailsLogger()
+
 func init() {
 	caddy.RegisterModule(CaddyRailsApp{})
-	httpcaddyfile.RegisterGlobalOption("serve-rails", parseGlobalCaddyfileBlock)
+	httpcaddyfile.RegisterGlobalOption("serve", parseGlobalCaddyfileBlock)
 }
 
 type CaddyRailsApp struct {
 	Command []string `json:"command,omitempty"`
 	PidFile string   `json:"pid_file,omitempty"`
 
-	process *utils.UpstreamProcess
-	stopCh  chan struct{}
+	process *process.UpstreamProcess
 }
 
 func (a *CaddyRailsApp) Provision(_ caddy.Context) error {
+	return nil
+}
+
+func (a *CaddyRailsApp) Start() error {
 	var command string
 	var arguments []string
 
@@ -32,64 +39,59 @@ func (a *CaddyRailsApp) Provision(_ caddy.Context) error {
 		arguments = a.Command[1:]
 	}
 
-	process, err := utils.NewUpstreamProcess(command, arguments, false, a.PidFile)
+	proc, err := process.NewUpstreamProcess(command, arguments, false, a.PidFile)
 	if err != nil {
 		return err
 	}
 
-	a.process = process
-	a.stopCh = make(chan struct{})
+	a.process = proc
 
-	return nil
-}
+	caddyLogger.Info("CaddyRails was started")
 
-func (a CaddyRailsApp) Start() error {
-	_, err := a.process.Run()
-
-	return err
+	return a.process.Run()
 }
 
 func (a *CaddyRailsApp) Stop() error {
-	caddy.Log().Info("CaddyRails stopped")
-
-	if a.process != nil {
-		return a.process.Stop()
+	err := a.process.Shutdown(os.Interrupt)
+	if err != nil {
+		return err
 	}
 
-	close(a.stopCh)
+	caddyLogger.Info("CaddyRails stopped")
+
 	return nil
 }
 
 func (a CaddyRailsApp) CaddyModule() caddy.ModuleInfo {
 	return caddy.ModuleInfo{
-		ID:  "serve-rails",
+		ID:  "serve",
 		New: func() caddy.Module { return new(CaddyRailsApp) },
 	}
 }
 
 func parseGlobalCaddyfileBlock(d *caddyfile.Dispenser, _ interface{}) (interface{}, error) {
-	var caddy_rails CaddyRailsApp
+	var caddyRails CaddyRailsApp
 
 	if d.NextArg() && d.NextArg() {
-		caddy_rails.Command = append([]string{d.Val()}, d.RemainingArgs()...)
+		caddyRails.Command = append([]string{d.Val()}, d.RemainingArgs()...)
 	}
 
 	for d.NextBlock(0) {
 		switch d.Val() {
 		case "command":
-			caddy_rails.Command = d.RemainingArgs()
+			caddyRails.Command = d.RemainingArgs()
 		case "pid_file":
 			if d.NextArg() {
-				caddy_rails.PidFile = d.Val()
+				caddyRails.PidFile = d.Val()
 			} else {
 				return nil, d.ArgErr()
 			}
 		}
 	}
 
 	return httpcaddyfile.App{
-		Name:  "serve-rails",
-		Value: caddyconfig.JSON(caddy_rails, nil),
+		Name:  "serve",
+		Value: caddyconfig.JSON(caddyRails, nil),
 	}, nil
 }
 

internal/commands/CaddyfileTemplate

@@ -1,5 +1,5 @@
 {
-  serve-rails bin/rails s -p {{.BackendPort}}
+  serve bin/rails s -p {{.BackendPort}}
   {{if .Debug}}debug{{end}}
   {{if .AccessLog}}log{{end}}
   https_port {{.HttpsPort}}

internal/commands/serve.go

@@ -6,6 +6,8 @@ import (
 	"github.com/caddyserver/caddy/v2"
 	caddycmd "github.com/caddyserver/caddy/v2/cmd"
 	_ "github.com/caddyserver/caddy/v2/modules/standard"
+	"github.com/evilmartians/caddy_rails/internal/logger"
+	"github.com/evilmartians/caddy_rails/internal/process"
 	"github.com/evilmartians/caddy_rails/internal/utils"
 	"github.com/spf13/cobra"
 	"go.uber.org/zap"
@@ -14,48 +16,39 @@ import (
 	"time"
 )
 
-const (
-	errStopUpstream       = "failed to stop upstream process: %v"
-	errPhasedRestart      = "failed to phased restart upstream process: %v"
-	errRunUpstreamProcess = "failed to run upstream process: %v"
-	errLoadCaddyConfig    = "Caddyfile loading error"
-	errAccessCaddyFile    = "Error accessing Caddyfile"
-	infoCaddyFileAbsent   = "Caddyfile does not exist. The server is running direct way"
-	infoCaddyFileLoaded   = "Caddyfile is correct and loaded. The server is running via Caddyfile"
-)
-
-var logger = utils.NewCaddyRailsLogger()
+var caddyLogger = logger.NewCaddyRailsLogger()
 
 func init() {
 	caddycmd.RegisterCommand(caddycmd.Command{
 		Name:  "serve",
 		Short: "Runs an external server and sets up a reverse proxy to it",
-		Long: `
-The serve command runs an external server specified as its argument and
-sets up a reverse proxy to forward requests to it.`,
 		CobraFunc: func(cmd *cobra.Command) {
-			cmd.Flags().String("pid-file", "", "Path to the PID file to control an existing process")
-			cmd.Flags().Bool("stop", false, "Stop the running process")
-			cmd.Flags().Bool("phased-restart", false, "Perform a phased restart of the server")
-			cmd.Flags().Bool("anycable-enabled", false, "Activate AnyCable")
-			cmd.Flags().String("server-type", "puma", "The type of server (puma or unicorn) to control")
-			cmd.Flags().Int("target-port", 3000, "The port that your server should run on. caddy-rails will set this values to the PORT env variable when starting your server.")
-			cmd.Flags().Int("http-port", 80, "The port to listen on for HTTP traffic.")
-			cmd.Flags().Int("https-port", 443, "The port to listen on for HTTPS traffic.")
-			cmd.Flags().StringP("listen", "l", "localhost", "The address to which to bind the listener")
-			cmd.Flags().String("ssl-domain", "", "The domain name to use for SSL provisioning. If not set, SSL will be disabled.")
-			cmd.Flags().StringP("files-path", "f", "", "The domain name to use for SSL provisioning. If not set, SSL will be disabled.")
-			cmd.Flags().BoolP("debug", "v", false, "Enable verbose debug logs")
-			cmd.Flags().Bool("access-log", true, "Enable the access log")
-			cmd.Flags().Bool("no-compress", false, "Disable Zstandard and Gzip compression")
-			cmd.Flags().Duration("http-idle-timeout", 60*time.Second, "The maximum time in seconds that a client can be idle before the connection is closed.")
-			cmd.Flags().Duration("http-read-timeout", 30*time.Second, "The maximum time in seconds that a client can take to send the request headers.")
-			cmd.Flags().Duration("http-write-timeout", 30*time.Second, "The maximum time in seconds during which the client must read the response.")
+			addServeFlags(cmd)
 			cmd.RunE = caddycmd.WrapCommandFuncForCobra(cmdServeRails)
 		},
 	})
 }
 
+func addServeFlags(cmd *cobra.Command) {
+	cmd.Flags().String("pid-file", "", "Path to the PID file to control an existing process")
+	cmd.Flags().Bool("stop", false, "Stop the running process")
+	cmd.Flags().Bool("phased-restart", false, "Perform a phased restart of the server")
+	cmd.Flags().String("server-type", "puma", "The type of server (puma or unicorn) to control")
+	cmd.Flags().Int("target-port", 3000, "The port that your server should run on")
+	cmd.Flags().Int("http-port", 80, "The port to listen on for HTTP traffic.")
+	cmd.Flags().Int("https-port", 443, "The port to listen on for HTTPS traffic.")
+	cmd.Flags().StringP("listen", "l", "localhost", "The address to which to bind the listener")
+	cmd.Flags().String("ssl-domain", "", "The domain name to use for SSL provisioning. If not set, SSL will be disabled.")
+	cmd.Flags().StringP("files-path", "f", "", "The path to the files to serve")
+	cmd.Flags().BoolP("debug", "v", false, "Enable verbose debug logs")
+	cmd.Flags().Bool("access-log", true, "Enable the access log")
+	cmd.Flags().Bool("no-compress", false, "Disable Zstandard and Gzip compression")
+	cmd.Flags().Bool("anycable-enabled", false, "Activate AnyCable")
+	cmd.Flags().Duration("http-idle-timeout", 60*time.Second, "The maximum idle time for HTTP connections.")
+	cmd.Flags().Duration("http-read-timeout", 30*time.Second, "The maximum read timeout for HTTP connections.")
+	cmd.Flags().Duration("http-write-timeout", 30*time.Second, "The maximum write timeout for HTTP connections.")
+}
+
 func cmdServeRails(fs caddycmd.Flags) (int, error) {
 	caddy.TrapSignals()
 
@@ -65,86 +58,75 @@ func cmdServeRails(fs caddycmd.Flags) (int, error) {
 	serverType := fs.String("server-type")
 
 	if stop || phasedRestart {
-		upstream, err := utils.NewUpstreamProcess("", nil, false, pidFile)
-		if err != nil {
-			return 1, err
-		}
-
-		if stop {
-			if err := upstream.Stop(); err != nil {
-				return 1, fmt.Errorf(errStopUpstream, err)
-			}
-			return 0, nil
-		}
-
-		if phasedRestart {
-			if err := upstream.PhasedRestart(serverType); err != nil {
-				return 1, fmt.Errorf(errPhasedRestart, err)
-			}
-			return 0, nil
-		}
+		return handleProcessControl(pidFile, stop, phasedRestart, serverType)
 	}
 
-	if loadConfigIfNeeded() {
+	loaded, err := loadConfigIfNeeded()
+	if err != nil {
+		return 1, err
+	}
+	if loaded {
 		select {}
 	}
 
+	if fs.Int("target-port") != 0 {
+		os.Setenv("PORT", fmt.Sprintf("%d", fs.Int("target-port")))
+	}
+
 	if err := utils.StartCaddyReverseProxy(fs); err != nil {
 		return 1, err
 	}
 
-	return runUpstreamProcess(fs, pidFile)
+	select {}
 }
 
-func loadConfigIfNeeded() bool {
-	curdir, _ := os.Getwd()
-	configFile := filepath.Join(curdir, "Caddyfile")
-
-	if _, err := os.Stat(configFile); err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			logger.Info(infoCaddyFileAbsent)
-		} else {
-			logger.Error(errAccessCaddyFile, zap.Error(err))
-		}
-		return false
-	}
-
-	config, _, err := caddycmd.LoadConfig(configFile, "")
+func handleProcessControl(pidFile string, stop, phasedRestart bool, serverType string) (int, error) {
+	upstream, err := process.NewUpstreamProcess("", nil, false, pidFile)
 	if err != nil {
-		logger.Error(errLoadCaddyConfig, zap.Error(err))
-
-		return false
+		return 1, err
 	}
 
-	err = caddy.Load(config, true)
-	if err != nil {
-		logger.Error(errLoadCaddyConfig, zap.Error(err))
-
-		return false
+	if stop {
+		if err := upstream.Stop(); err != nil {
+			return 1, fmt.Errorf("failed to stop upstream process: %v", err)
+		}
+		return 0, nil
 	}
 
-	logger.Info(infoCaddyFileLoaded)
+	if phasedRestart {
+		if err := upstream.PhasedRestart(serverType); err != nil {
+			return 1, fmt.Errorf("failed to phased restart upstream process: %v", err)
+		}
+		return 0, nil
+	}
 
-	return true
+	return 1, errors.New("invalid process control command")
 }
 
-func runUpstreamProcess(fs caddycmd.Flags, pidFile string) (int, error) {
-	// Set PORT to be inherited by the upstream process.
-	os.Setenv("PORT", fmt.Sprintf("%d", fs.Int("target-port")))
+func loadConfigIfNeeded() (bool, error) {
+	curdir, _ := os.Getwd()
+	configFile := filepath.Join(curdir, "Caddyfile")
 
-	var args []string
-	if len(fs.Args()) > 0 {
-		args = fs.Args()[1:]
+	if _, err := os.Stat(configFile); err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			caddyLogger.Info("Caddyfile does not exist. Running directly")
+		} else {
+			caddyLogger.Error("Error accessing Caddyfile", zap.Error(err))
+		}
+		return false, nil
 	}
 
-	upstream, err := utils.NewUpstreamProcess(fs.Arg(0), args, true, pidFile)
+	config, _, err := caddycmd.LoadConfig(configFile, "")
 	if err != nil {
-		return 1, err
+		caddyLogger.Error("Caddyfile loading error", zap.Error(err))
+		return false, err
 	}
 
-	exitCode, err := upstream.Run()
-	if err != nil {
-		return 1, fmt.Errorf(errRunUpstreamProcess, err)
+	if err := caddy.Load(config, true); err != nil {
+		caddyLogger.Error("Caddyfile loading error", zap.Error(err))
+		return false, err
 	}
-	return exitCode, nil
+
+	caddyLogger.Info("Caddyfile loaded successfully")
+	return true, nil
 }

internal/utils/caddy_rails_logger.go internal/logger/caddyrails_logger.gointernal/utils/caddy_rails_logger.go renamed to internal/logger/caddyrails_logger.go

@@ -1,4 +1,4 @@
-package utils
+package logger
 
 import (
 	"github.com/caddyserver/caddy/v2"