feat: support query and path params passthrough

Author: Gabriel-Ladzaretti

endpoint.go

@@ -9,31 +9,33 @@ import (
 	"net/http"
 	"os"
 	"os/exec"
+	"regexp"
 	"slices"
 	"strings"
 	"syscall"
 	"time"
 )
 
 type resolvedEndpoint struct {
-	method  string
-	command string
-	args    []string
-	env     []string
-	timeout time.Duration
+	method     string
+	command    string
+	args       []string
+	env        []string
+	timeout    time.Duration
+	pathParams []string
 }
 
 type Endpoint struct {
-	Path     string   `json:"path,omitempty"     toml:"path,commented"`
-	Token    string   `json:"token,omitempty"    toml:"token,commented"`
-	Method   string   `json:"method,omitempty"   toml:"method,commented"`
-	Cmd      []string `json:"cmd,omitempty"      toml:"cmd,commented"`
-	Env      []string `json:"env,omitempty"      toml:"env,commented"`
-	Detached bool     `json:"detached,omitempty" toml:"detached,commented"`
-	UID      uint32   `json:"uid,omitempty"      toml:"uid,commented"`
-	GID      uint32   `json:"gid,omitempty"      toml:"gid,commented"`
-	Timeout  string   `json:"timeout,omitempty"  toml:"timeout,commented"`
-	NoAuth   bool     `json:"no_auth,omitempty"  toml:"no_auth,commented"`
+	Path         string   `json:"path,omitempty"          toml:"path,commented"`
+	Token        string   `json:"token,omitempty"         toml:"token,commented"`
+	Method       string   `json:"method,omitempty"        toml:"method,commented"`
+	Cmd          []string `json:"cmd,omitempty"           toml:"cmd,commented"`
+	EnvAllowlist []string `json:"env_allowlist,omitempty" toml:"env_allowlist,commented"`
+	Detached     bool     `json:"detached,omitempty"      toml:"detached,commented"`
+	UID          uint32   `json:"uid,omitempty"           toml:"uid,commented"`
+	GID          uint32   `json:"gid,omitempty"           toml:"gid,commented"`
+	Timeout      string   `json:"timeout,omitempty"       toml:"timeout,commented"`
+	NoAuth       bool     `json:"no_auth,omitempty"       toml:"no_auth,commented"`
 
 	resolvedEndpoint
 }
@@ -72,19 +74,28 @@ func (e *Endpoint) validate() error {
 	return nil
 }
 
+var re = regexp.MustCompile(`{([^{}]*)}`)
+
 func (e *Endpoint) resolve() {
 	e.method = cmp.Or(e.Method, http.MethodPost)
 	e.command, e.args = e.Cmd[0], e.Cmd[1:]
 
-	e.env = make([]string, 0, len(e.Env))
-	for _, key := range e.Env {
-		e.env = append(e.env, key, os.Getenv(key))
+	e.env = make([]string, 0, len(e.EnvAllowlist))
+	for _, key := range e.EnvAllowlist {
+		e.env = append(e.env, key+"="+os.Getenv(key))
 	}
 
 	if e.Timeout != "" {
 		t, _ := time.ParseDuration(e.Timeout) // validated at [Endpoint.validate]
 		e.timeout = t
 	}
+
+	e.pathParams = make([]string, 0, 4)
+
+	matches := re.FindAllStringSubmatch(e.Path, -1)
+	for _, v := range matches {
+		e.pathParams = append(e.pathParams, v[1])
+	}
 }
 
 func (e *Endpoint) redact() Endpoint {
@@ -107,15 +118,15 @@ type ExecResult struct {
 	Error    string `json:"error,omitempty"`
 }
 
-func (e *Endpoint) run(ctx context.Context) *ExecResult {
+func (e *Endpoint) run(ctx context.Context, env []string) *ExecResult {
 	if e.Detached {
-		return e.runDetached()
+		return e.runDetached(env)
 	}
 
-	return e.runWait(ctx)
+	return e.runWait(ctx, env)
 }
 
-func (e *Endpoint) runWait(ctx context.Context) *ExecResult {
+func (e *Endpoint) runWait(ctx context.Context, env []string) *ExecResult {
 	if e.timeout != 0 {
 		c, cancel := context.WithTimeout(ctx, e.timeout)
 		ctx = c
@@ -131,7 +142,7 @@ func (e *Endpoint) runWait(ctx context.Context) *ExecResult {
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 
-	cmd.Env = e.env
+	cmd.Env = slices.Concat(e.env, env)
 
 	if e.UID != 0 || e.GID != 0 {
 		cmd.SysProcAttr = &syscall.SysProcAttr{}
@@ -162,9 +173,9 @@ func (e *Endpoint) runWait(ctx context.Context) *ExecResult {
 	return &execResult
 }
 
-func (e *Endpoint) runDetached() *ExecResult {
+func (e *Endpoint) runDetached(env []string) *ExecResult {
 	cmd := exec.Command(e.command, e.args...) //nolint:gosec,noctx // command and args come from trusted config // noctx is intentional
-	cmd.Env = e.env
+	cmd.Env = slices.Concat(e.env, env)
 
 	if f, err := os.OpenFile("/dev/null", os.O_WRONLY, 0); err == nil {
 		cmd.Stdout, cmd.Stderr, cmd.Stdin = f, f, nil

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"bytes"
 	"cmp"
 	"context"
 	"crypto/subtle"
@@ -16,45 +17,23 @@ import (
 	"strings"
 	"syscall"
 	"time"
+	"unicode"
 
 	"github.com/google/uuid"
 )
 
 var Version = "v0.0.0"
 
-type execState int
+type execState string
 
 const (
-	_ execState = iota
-	execStateRunning
-	execStateQueued
-	execStateCompleted
-	execStateFailed
-	execStateCanceled
+	execStateRunning   execState = "running"
+	execStateQueued    execState = "queued"
+	execStateCompleted execState = "completed"
+	execStateFailed    execState = "failed"
+	execStateCanceled  execState = "canceled"
 )
 
-func (s execState) String() string {
-	switch s {
-	case execStateQueued:
-		return "queued"
-	case execStateRunning:
-		return "running"
-	case execStateCompleted:
-		return "completed"
-	case execStateFailed:
-		return "failed"
-	case execStateCanceled:
-		return "canceled"
-	default:
-		return "unknown"
-	}
-}
-
-//nolint:unparam
-func (s execState) MarshalText() ([]byte, error) {
-	return []byte(s.String()), nil
-}
-
 const (
 	defaultConfigName = ".execd.toml"
 	defaultListenAddr = ":8081"
@@ -131,22 +110,6 @@ func newJobsHandler(jobs *safeMap[string, RequestState]) http.Handler {
 		CompletedAt time.Time `json:"completed_at,omitzero"`
 	}
 
-	compare := func(a, b JobsSummary) int {
-		if a.State != b.State {
-			return cmp.Compare(int(a.State), int(b.State))
-		}
-
-		// descending order
-		switch {
-		case a.StartedAt.After(b.StartedAt):
-			return -1
-		case a.StartedAt.Before(b.StartedAt):
-			return 1
-		default:
-			return 0
-		}
-	}
-
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodGet {
 			w.Header().Set("Allow", http.MethodGet)
@@ -171,7 +134,9 @@ func newJobsHandler(jobs *safeMap[string, RequestState]) http.Handler {
 			})
 		})
 
-		slices.SortFunc(summary, compare)
+		slices.SortFunc(summary, func(a, b JobsSummary) int {
+			return a.StartedAt.Compare(b.StartedAt)
+		})
 
 		writeJSON(w, http.StatusOK, summary)
 	})
@@ -212,6 +177,35 @@ func newJobHandler(jobs *safeMap[string, RequestState]) http.Handler {
 	})
 }
 
+func toEnvKey(s string) (key string) {
+	buf := &bytes.Buffer{}
+
+	for i, r := range s {
+		if unicode.IsUpper(r) && i > 0 {
+			buf.WriteRune('_')
+		}
+
+		buf.WriteRune(unicode.ToUpper(r))
+	}
+
+	return buf.String()
+}
+
+func paramsToEnv(r *http.Request, pathParams []string) []string {
+	params := r.URL.Query()
+	env := make([]string, 0, len(params)+len(pathParams))
+
+	for k, v := range params {
+		env = append(env, toEnvKey(k)+"="+strings.Join(v, " "))
+	}
+
+	for _, k := range pathParams {
+		env = append(env, toEnvKey(k)+"="+r.PathValue(k))
+	}
+
+	return env
+}
+
 func newExecHandler(appCtx context.Context, e Endpoint, jobs *safeMap[string, RequestState]) http.Handler {
 	method := strings.ToUpper(e.method)
 
@@ -241,11 +235,11 @@ func newExecHandler(appCtx context.Context, e Endpoint, jobs *safeMap[string, Re
 			ID string `json:"id,omitempty"`
 		}{ID: id})
 
-		go runRequest(appCtx, e, jobs, id)
+		go runRequest(appCtx, e, jobs, id, paramsToEnv(r, e.pathParams))
 	})
 }
 
-func runRequest(ctx context.Context, e Endpoint, jobs *safeMap[string, RequestState], id string) {
+func runRequest(ctx context.Context, e Endpoint, jobs *safeMap[string, RequestState], id string, env []string) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
@@ -254,7 +248,7 @@ func runRequest(ctx context.Context, e Endpoint, jobs *safeMap[string, RequestSt
 		return old
 	})
 
-	execResult := e.run(ctx)
+	execResult := e.run(ctx, env)
 
 	completed := RequestState{
 		State:       execStateCompleted,