Refactor env loading, appDir resolution, and exec shell

.github/workflows/ci.yml

@@ -13,10 +13,11 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, macos-11.0, ubuntu-latest]
+        os: [macos-latest, ubuntu-latest]
         go-version: [1.17.6]
+        shell: [/bin/bash, /bin/zsh]
 
-    name: ${{ matrix.os }} / go-${{ matrix.go-version }}
+    name: ${{ matrix.os }} / go-${{ matrix.go-version }} / ${{ matrix.shell }}
     steps:
       - uses: actions/setup-go@v1
         with:
@@ -30,6 +31,9 @@ jobs:
 
       - uses: actions/checkout@v2
 
+      - if: contains(matrix.os, 'ubuntu')
+        run: sudo apt install zsh
+
       - if: contains(matrix.os, 'macos')
         run: |
           sw_vers
@@ -40,6 +44,8 @@ jobs:
       - run: go mod download
 
       - run: go test -v -race -coverprofile=coverage.out -covermode=atomic -timeout=300s ./...
+        env:
+          SHELL: ${{ matrix.shell }}
 
   devel-release:
     runs-on: macos-latest

dev/app.go

@@ -24,8 +24,6 @@ import (
 	"gopkg.in/tomb.v2"
 )
 
-const DefaultThreads = 5
-
 var ErrUnexpectedExit = errors.New("unexpected exit")
 
 type App struct {
@@ -49,10 +47,6 @@ type App struct {
 	pool    *AppPool
 	lastUse time.Time
 
-	lock sync.Mutex
-
-	booting bool
-
 	readyChan chan struct{}
 }
 
@@ -133,7 +127,7 @@ func (a *App) watch() error {
 	reason := "detected interval shutdown"
 
 	select {
-	case err = <-c:
+	case <-c:
 		reason = "stdout/stderr closed"
 		err = fmt.Errorf("%s:\n\t%s", ErrUnexpectedExit, a.lastLogLine)
 	case <-a.t.Dying():
@@ -237,64 +231,24 @@ func (a *App) Log() string {
 	return buf.String()
 }
 
-const executionShell = `exec bash -c '
-cd %s
-
-if test -e ~/.powconfig && [ "$PUMADEV_SOURCE_POWCONFIG" != "0" ]; then
-	source ~/.powconfig
-fi
-
-if test -e .env && [ "$PUMADEV_SOURCE_ENV" != "0" ]; then
-	source .env
-fi
-
-if test -e .powrc && [ "$PUMADEV_SOURCE_POWRC" != "0" ]; then
-	source .powrc
-fi
-
-if test -e .powenv && [ "$PUMADEV_SOURCE_POWENV" != "0" ]; then
-	source .powenv
-fi
-
-if test -e .pumaenv && [ "$PUMADEV_SOURCE_PUMAENV" != "0" ]; then
-	source .pumaenv
-fi
-
-if test -e Gemfile && bundle exec puma -V &>/dev/null; then
-	exec bundle exec puma -C $CONFIG --tag puma-dev:%s -w $WORKERS -t 0:$THREADS -b unix:%s
-fi
-
-exec puma -C $CONFIG --tag puma-dev:%s -w $WORKERS -t 0:$THREADS -b unix:%s'
-`
-
 func (pool *AppPool) LaunchApp(name, dir string) (*App, error) {
-	tmpDir := filepath.Join(dir, "tmp")
-	err := os.MkdirAll(tmpDir, 0755)
-	if err != nil {
+	appDir, dirErr := filepath.EvalSymlinks(dir)
+	if dirErr != nil {
+		return nil, dirErr
+	}
+
+	tmpDir := filepath.Join(appDir, "tmp")
+	if err := os.MkdirAll(tmpDir, 0755); err != nil {
 		return nil, err
 	}
 
 	socket := filepath.Join(tmpDir, fmt.Sprintf("puma-dev-%d.sock", os.Getpid()))
 
-	shell := os.Getenv("SHELL")
-
-	if shell == "" {
-		fmt.Printf("! SHELL env var not set, using /bin/bash by default")
-		shell = "/bin/bash"
+	cmd, err := BuildPumaCommand(name, socket, appDir)
+	if err != nil {
+		return nil, err
 	}
 
-	cmd := exec.Command(shell, "-l", "-i", "-c",
-		fmt.Sprintf(executionShell, dir, name, socket, name, socket))
-
-	cmd.Dir = dir
-
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env,
-		fmt.Sprintf("THREADS=%d", DefaultThreads),
-		"WORKERS=0",
-		"CONFIG=-",
-	)
-
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, err
@@ -314,15 +268,15 @@ func (pool *AppPool) LaunchApp(name, dir string) (*App, error) {
 		Command:   cmd,
 		Events:    pool.Events,
 		stdout:    stdout,
-		dir:       dir,
+		dir:       appDir,
 		pool:      pool,
 		readyChan: make(chan struct{}),
 		lastUse:   time.Now(),
 	}
 
 	app.eventAdd("booting_app", "socket", socket)
 
-	stat, err := os.Stat(filepath.Join(dir, "public"))
+	stat, err := os.Stat(filepath.Join(appDir, "public"))
 	if err == nil {
 		app.Public = stat.IsDir()
 	}
@@ -639,3 +593,81 @@ func (a *AppPool) Purge() {
 
 	a.Events.Add("apps_purged")
 }
+
+const pumaShellScriptTemplate = `exec %s -c '
+cd %s
+
+if test -e ~/.powconfig && [ "$PUMADEV_SOURCE_POWCONFIG" != "0" ]; then
+  source ~/.powconfig
+fi
+
+if test -e ~/.pumaenv && [ "$PUMADEV_SOURCE_HOME_PUMAENV" != "0" ]; then
+  source ~/.pumaenv
+fi
+
+if test -e .env && [ "$PUMADEV_SOURCE_ENV" != "0" ]; then
+  source .env
+fi
+
+if test -e .powrc && [ "$PUMADEV_SOURCE_POWRC" != "0" ]; then
+  source .powrc
+fi
+
+if test -e .powenv && [ "$PUMADEV_SOURCE_POWENV" != "0" ]; then
+  source .powenv
+fi
+
+if test -e .pumaenv && [ "$PUMADEV_SOURCE_PUMAENV" != "0" ]; then
+  source .pumaenv
+fi
+
+if test -e Gemfile && bundle exec puma -V &>/dev/null; then
+  exec bundle exec puma %s
+fi
+
+exec puma %s
+'` // <-- don't forget this closing quote
+
+func BuildPumaCommand(appName string, socketPath string, appDir string) (*exec.Cmd, error) {
+
+	osMapEnv := GetMapEnviron()
+
+	// This environment will be fed into the puma exec shell.
+	// However, we _also_ source each supported env file inside the shell to allow for
+	// custom environment grooming.
+	var mapEnv map[string]string
+	mapEnv, err := LoadEnv(osMapEnv, appDir)
+	if err != nil {
+		fmt.Printf("! Falling back to default environment. %v\n", err.Error())
+		mapEnv = osMapEnv
+	}
+
+	pumaArgs := fmt.Sprintf("--tag puma-dev:%s -b unix:%s", appName, socketPath)
+
+	if workers, exist := mapEnv["WORKERS"]; exist {
+		pumaArgs = fmt.Sprintf("-w%s %s", workers, pumaArgs)
+	}
+
+	if threads, exist := mapEnv["THREADS"]; exist {
+		pumaArgs = fmt.Sprintf("-t0:%s %s", threads, pumaArgs)
+	}
+
+	if config, exist := mapEnv["CONFIG"]; exist {
+		pumaArgs = fmt.Sprintf("-C%s %s", config, pumaArgs)
+	}
+
+	// use SHELL from OS env or app env
+	execShell := mapEnv["SHELL"]
+	if execShell == "" {
+		fmt.Printf("! SHELL env var not set, using /bin/bash by default\n")
+		execShell = "/bin/bash"
+	}
+
+	script := fmt.Sprintf(pumaShellScriptTemplate, execShell, appDir, pumaArgs, pumaArgs)
+
+	cmd := exec.Command(execShell, "-l", "-i", "-c", script)
+	cmd.Dir = appDir
+	cmd.Env = ToCmdEnv(mapEnv)
+
+	return cmd, nil
+}

dev/app_test.go

@@ -0,0 +1,27 @@
+package dev
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuildPumaCommand_withEnv(t *testing.T) {
+	t.Setenv("CONFIG", "-")
+	t.Setenv("WORKERS", "4")
+	t.Setenv("THREADS", "5")
+
+	cmd, _ := BuildPumaCommand("foo", "/tmp/tmp/foo.sock", "/tmp")
+
+	assert.Regexp(t, " -w4 ", cmd.Args[4])
+	assert.Regexp(t, " -t0:5 ", cmd.Args[4])
+	assert.Regexp(t, " -C- ", cmd.Args[4])
+}
+
+func TestBuildPumaCommand_withoutEnv(t *testing.T) {
+	cmd, _ := BuildPumaCommand("foo", "/tmp/tmp/foo.sock", "/tmp")
+
+	assert.NotRegexp(t, " -w", cmd.Args[4])
+	assert.NotRegexp(t, " -t", cmd.Args[4])
+	assert.NotRegexp(t, " -C", cmd.Args[4])
+}

dev/env.go

@@ -0,0 +1,74 @@
+package dev
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/joho/godotenv"
+	"github.com/puma/puma-dev/homedir"
+)
+
+// `.pumaenv` has highest priority, `~/.powconfig` has lowest.
+// Be sure to keep these in sync with the pumaShellScriptTemplate in app.go
+var AppEnvPaths = []string{".env", ".powrc", ".powenv", ".pumaenv"}
+var HomeEnvPaths = []string{"~/.powconfig", "~/.pumaenv"}
+
+func LoadEnv(baseEnv map[string]string, dir string) (envMap map[string]string, err error) {
+	// build a list of all the supported env files that exist on the filesystem to load
+	var envPaths []string
+
+	for _, path := range AppEnvPaths {
+		fullPath := filepath.Join(dir, path)
+		if _, err := os.Stat(fullPath); err == nil {
+			envPaths = append(envPaths, fullPath)
+		}
+	}
+
+	for _, path := range HomeEnvPaths {
+		if fullPath, err := homedir.Expand(path); err == nil {
+			if _, err := os.Stat(fullPath); err == nil {
+				envPaths = append(envPaths, fullPath)
+			}
+		}
+	}
+
+	envMap = baseEnv
+
+	// if we have any optional env paths to source, source them
+	if len(envPaths) > 0 {
+		// load the env into a map
+		appEnv, err := godotenv.Read(envPaths...)
+		if err != nil {
+			// if any path fails to load, bail out.
+			return nil, fmt.Errorf("%v in %v", err, envPaths)
+		}
+
+		// merge contents from appEnv into envMap
+		// this way dotenv values will supersede os env values
+		for k, v := range appEnv {
+			envMap[k] = v
+		}
+	}
+
+	return
+}
+
+func ToCmdEnv(envMap map[string]string) (env []string) {
+	for k, v := range envMap {
+		env = append(env, fmt.Sprintf("%s=%s", k, v))
+	}
+	return
+}
+
+func GetMapEnviron() (envMap map[string]string) {
+	envMap = make(map[string]string)
+
+	for _, keyval := range os.Environ() {
+		pair := strings.Split(keyval, "=")
+		envMap[pair[0]] = pair[1]
+	}
+
+	return
+}