summercms/cmd/summer/runtime.go

package main

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"

	"git.golem15.com/golem15/summercms/internal/build"
	"git.golem15.com/golem15/summercms/modules/bonfire"
)

// appRunner runs the app binary with argv; tests replace it.
var appRunner = runAppBinary

// delegateCommands returns every command summer runs on the app binary. One
// table is the single source: name, base description and a hint naming the
// common flags or arguments the app binary accepts.
func delegateCommands() []bonfire.Command {
	rows := []struct{ name, description, hint string }{
		{"migrate", "Run plugin migrations in the app binary", ""},
		{"migrate:rollback", "Roll back the last migration of a plugin in the app binary", "--plugin <id>"},
		{"migrate:status", "Show per-plugin migration history in the app binary", ""},
		{"serve", "Run the app HTTP server", "--addr <host:port> (default :8080)"},
		{"queue:work", "Run background job workers in the app binary", "--queue <name> (repeatable)"},
		{"queue:clear", "Clear pending queued jobs in the app binary", `[queue] argument (default "default")`},
		{"schedule:run", "Run the scheduler in the app binary (or once for system cron)", "--once"},
		{"route:list", "List the app's routes from the app binary", ""},
		{"key:generate", "Print a fresh application key from the app binary", ""},
		{"admin:create", "Create a backend administrator in the app binary", "--email <email> (required), --login, --role <code>, --superuser; the password is prompted or read from stdin"},
		{"admin:reset-password", "Reset a backend administrator's password in the app binary", "<identifier> (login or email); the password is prompted or read from stdin"},
	}
	cmds := make([]bonfire.Command, 0, len(rows))
	for _, r := range rows {
		cmds = append(cmds, delegateCommand(r.name, r.description, r.hint))
	}
	return cmds
}

// delegateCommand returns a passthrough command that runs name on the app
// binary with every argument summer was given.
func delegateCommand(name, description, hint string) bonfire.Command {
	long := description + ".\n\nsummer runs bin/<binary> " + name +
		" in the application directory, building the binary first when it is missing. Every flag and argument after " +
		name + ", including --help, is passed to the app binary unchanged."
	if hint != "" {
		long += "\n\nCommon flags: " + hint + "."
	}
	long += "\n\nRun summer " + name + " --help inside an application to list all of them."
	return bonfire.Command{
		Name:        name,
		Description: description + " (flags pass to the app binary)",
		Long:        long,
		Passthrough: true,
		Run: func(ctx context.Context, in bonfire.Input, out bonfire.Output) error {
			args := in.Args()
			// One leading "--" is dropped so the older
			// `summer serve -- --addr :8123` form keeps working.
			if len(args) > 0 && args[0] == "--" {
				args = args[1:]
			}
			argv := append([]string{name}, args...)
			return appRunner(ctx, argv, out)
		},
	}
}

func runAppBinary(ctx context.Context, argv []string, out bonfire.Output) error {
	if len(argv) == 0 {
		return fmt.Errorf("summer: missing app command")
	}
	dir, err := os.Getwd()
	if err != nil {
		return err
	}
	appDir, err := build.FindAppDir(dir)
	if err != nil {
		return err
	}
	m, err := build.LoadManifest(filepath.Join(appDir, "summer.yaml"))
	if err != nil {
		return err
	}
	bin := filepath.Join(appDir, "bin", m.Binary)
	if _, err := os.Stat(bin); err != nil {
		if err := build.App(ctx, appDir, out); err != nil {
			return err
		}
	}
	self, err := os.Executable()
	if err == nil {
		if same, _ := sameFile(self, bin); same {
			return fmt.Errorf("summer: refusing to recurse into %s", bin)
		}
	}
	cmd := exec.CommandContext(ctx, bin, argv...)
	cmd.Dir = appDir
	cmd.Stdout = out
	cmd.Stderr = out
	cmd.Stdin = os.Stdin
	cmd.Env = os.Environ()
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("summer: %s: %w", strings.Join(argv, " "), err)
	}
	return nil
}

func sameFile(a, b string) (bool, error) {
	ai, err := os.Stat(a)
	if err != nil {
		return false, err
	}
	bi, err := os.Stat(b)
	if err != nil {
		return false, err
	}
	return os.SameFile(ai, bi), nil
}