Route native service commands and configure fresh authoring role

Select native installs only via explicit PIPELINES_PREFIX or the matching owned prefix/bin/pipelines executable. Route enable/status/disable to the existing native supervisor; validate registration ownership, label and command, keep preview read-only, and disable login registration before stopping. Never fall back to a standalone service for an invalid explicit prefix.

Fresh native installs explicitly enable authoring, while reinstalls preserve false or missing legacy role settings. Add explicit --allow-authoring/--no-authoring overrides and pass the server flag only for manifest true. Print a copyable native enable command and update installation help/docs. No Docker configuration changes.

Checks: 54 mocked native installer/lifecycle tests; 8 entrypoint tests; offline Go installation/CLI tests and vet; gofmt clean; shell syntax and diff checks. No live install, restart, deployment, permission/config changes, or native Linux verification.
This commit is contained in:
2026-10-20 21:41:05 +01:00
parent d58b3f49fc
commit bb32383bbe
11 changed files with 508 additions and 18 deletions
+31 -10
View File
@@ -49,6 +49,19 @@ a private 0600 file there with `password` and a cookie-signing `secret`; read it
non-private existing file stops setup instead of resetting credentials. The
service never inherits the test-only `PIPELINES_WEB_AUTH=disabled` bypass.
A **fresh** native installation records `allow_authoring: true` in its manifest
and explicitly starts Go with `-allow-authoring`, so the single-user web workflow
can create and publish pipelines. `./install --no-authoring` instead selects an
execution-only role. Reinstalls preserve the recorded role; an older manifest
without this field stays execution-only. To deliberately enable authoring for
such an installation, use `./install --allow-authoring`. The installer prints the
selected role. This is a server permission, not a browser authentication bypass;
the authenticated proxy and loopback API defaults still apply. Docker's role and
startup flags are unchanged.
Role changes apply on the supervisor's next start. A reinstall does not forcibly
restart an already-running supervisor; if reconfiguring an active installation,
use its `pipelines restart` only when no work is active.
Setup resolves `PIPELINES_PREFIX` or defaults to `~/.local/share/pipelines`,
creates `bin/`, `lib/`, `data/`, `logs/` and `secrets/` (`secrets` and `data` at
0700), copies `scripts/manage.py` to `<prefix>/lib/manage.py`, builds exactly
@@ -107,12 +120,17 @@ present but its volumes cannot be inspected (for example a stopped daemon), setu
fails clearly instead of silently skipping migration, so an existing Docker
database is never shadowed by an empty native start.
Setup already starts it and enables login autostart. Optional CLI management
requires the prefix selector (the executable path alone does not select it):
Setup already starts it and enables login autostart, and prints a copyable
`<prefix>/bin/pipelines service enable` command. That installed executable safely
selects its own native manifest; an unrelated CLI never guesses a default prefix.
Optional terminal use needs only the installed binary on PATH:
```sh
export PIPELINES_PREFIX="$HOME/.local/share/pipelines"
export PATH="$PIPELINES_PREFIX/bin:$PATH"
export PATH="$HOME/.local/share/pipelines/bin:$PATH"
pipelines service enable # idempotently enable/start this native install
pipelines service enable --print # read-only existing definition preview
pipelines service status # login registration state; no credentials
pipelines service disable # disable login autostart AND stop its supervisor
pipelines doctor
# pipelines stop / start / restart / logs
```
@@ -130,9 +148,12 @@ first; the migration still needs its volumes and image). ntfy runs from
`$XDG_CONFIG_HOME/systemd/user/net.a-wan.pipelines.service` (default `~/.config`)
and runs `systemctl --user daemon-reload` then `enable --now
net.a-wan.pipelines.service`. This is login autostart, not boot-without-login;
Linux lingering is an explicit administrator decision. Do **not** run the separate
`pipelines service enable` for this installation: it configures a standalone
developer server, not the manifest database/ntfy/web supervisor. Logs are in
Linux lingering is an explicit administrator decision. `pipelines service` uses
this existing supervisor and database, never a second developer server. An
explicit `PIPELINES_PREFIX` can also select it from another CLI. Native service
commands reject standalone `--db`/`--addr` options; use installer flags to change
the manifest. Definitions belonging to a developer service or another native
prefix are never overwritten by these commands. Logs are in
`<prefix>/logs/{server,ntfy,web,supervisor}.log` (Linux supervisor output also goes
to `journalctl --user -u net.a-wan.pipelines.service`).
@@ -370,8 +391,8 @@ Drafts use the OS user cache; `PIPELINES_DRAFT_DIR` overrides that location.
## Developer/legacy autostart (unsupported)
Stop any existing foreground or legacy server first, then explicitly configure
the OS user service:
For a standalone developer binary (not the CLI inside a native install), stop any
existing foreground or legacy server first, then explicitly configure the OS user service:
```sh
pipelines service enable
@@ -482,7 +503,7 @@ does not purge data.
The previous Python-supervised setup is retained only for explicit legacy use.
Set `PIPELINES_PREFIX` to its existing directory for its lifecycle commands;
no command infers that directory from an executable location. The old
legacy manifests are never inferred from an executable location. The old
`--system-command`, provisioning, and autostart installer flags have been removed.
To migrate, stop the old server first, install normal Go binaries, and start with
+29 -3
View File
@@ -17,13 +17,22 @@ type Config struct {
OpenCode string `json:"opencode"`
OpenCodeEnv map[string]string `json:"opencode_env"`
Path string `json:"path"`
Ntfy struct {
Mode string `json:"mode"`
} `json:"ntfy"`
}
// Load selects a legacy managed installation only via an explicit PIPELINES_PREFIX.
// Load selects an explicit prefix, or a native installation containing this exact
// executable. It never guesses a default prefix for an unrelated Go-installed CLI.
func Load(executable string) (*Config, error) {
prefix := os.Getenv("PIPELINES_PREFIX")
inferred := prefix == ""
if prefix == "" {
return nil, nil
resolved, err := filepath.EvalSymlinks(executable)
if err != nil || filepath.Base(resolved) != "pipelines" || filepath.Base(filepath.Dir(resolved)) != "bin" {
return nil, nil
}
prefix = filepath.Dir(filepath.Dir(resolved))
}
prefix, err := filepath.Abs(prefix)
if err != nil {
@@ -35,13 +44,21 @@ func Load(executable string) (*Config, error) {
if resolved, err := filepath.EvalSymlinks(prefix); err == nil {
prefix = resolved
}
data, err := os.ReadFile(filepath.Join(prefix, "pipelines-install.json"))
manifest := filepath.Join(prefix, "pipelines-install.json")
info, err := os.Lstat(manifest)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
if !info.Mode().IsRegular() || !ownedByUser(info) {
return nil, fmt.Errorf("refusing installation manifest not a regular file owned by this user")
}
data, err := os.ReadFile(manifest)
if err != nil {
return nil, err
}
var config Config
if err = json.Unmarshal(data, &config); err != nil {
return nil, err
@@ -49,6 +66,15 @@ func Load(executable string) (*Config, error) {
if config.Format != 1 || config.Prefix != prefix || config.ServerPort < 1024 || config.ServerPort > 65535 {
return nil, fmt.Errorf("invalid managed installation manifest")
}
if inferred && config.Ntfy.Mode != "native" {
return nil, nil
}
if inferred {
binary, err := os.Stat(filepath.Join(prefix, "bin", "pipelines"))
if err != nil || !binary.Mode().IsRegular() || binary.Mode().Perm()&0111 == 0 || !ownedByUser(binary) {
return nil, fmt.Errorf("native installation executable must be owned by this user")
}
}
return &config, nil
}
@@ -48,3 +48,100 @@ func TestStandaloneGoInstalledCommandHasNoServiceDependency(t *testing.T) {
t.Fatal(config, err)
}
}
func nativeFixture(t *testing.T) (string, string) {
t.Helper()
root, err := filepath.EvalSymlinks(t.TempDir())
if err != nil {
t.Fatal(err)
}
if err = os.Mkdir(filepath.Join(root, "bin"), 0700); err != nil {
t.Fatal(err)
}
binary := filepath.Join(root, "bin", "pipelines")
if err = os.WriteFile(binary, []byte("binary"), 0700); err != nil {
t.Fatal(err)
}
config := Config{Format: 1, Prefix: root, ServerPort: 18080, Python: filepath.Join(root, "python3")}
config.Ntfy.Mode = "native"
data, _ := json.Marshal(config)
if err = os.WriteFile(filepath.Join(root, "pipelines-install.json"), data, 0600); err != nil {
t.Fatal(err)
}
return root, binary
}
func TestNativeExecutableDiscoveryAndExplicitPrefixPrecedence(t *testing.T) {
t.Setenv("PIPELINES_PREFIX", "")
root, binary := nativeFixture(t)
link := filepath.Join(t.TempDir(), "pipelines")
if err := os.Symlink(binary, link); err != nil {
t.Fatal(err)
}
loaded, err := Load(link)
if err != nil || loaded == nil || loaded.Prefix != root {
t.Fatal("native executable not selected", loaded, err)
}
other, _ := nativeFixture(t)
t.Setenv("PIPELINES_PREFIX", other)
loaded, err = Load(link)
if err != nil || loaded == nil || loaded.Prefix != other {
t.Fatal("explicit selection lost precedence", loaded, err)
}
}
func TestDiscoveryNeverGuessesHomeOrLegacyInstallation(t *testing.T) {
t.Setenv("PIPELINES_PREFIX", "")
root, binary := nativeFixture(t)
home := t.TempDir()
t.Setenv("HOME", home)
if err := os.MkdirAll(filepath.Join(home, ".local", "share"), 0700); err != nil {
t.Fatal(err)
}
if err := os.Symlink(root, filepath.Join(home, ".local", "share", "pipelines")); err != nil {
t.Fatal(err)
}
unrelated := filepath.Join(t.TempDir(), "pipelines")
if err := os.WriteFile(unrelated, []byte("binary"), 0700); err != nil {
t.Fatal(err)
}
loaded, err := Load(unrelated)
if err != nil || loaded != nil {
t.Fatal("unrelated executable selected installation", loaded, err)
}
config := Config{Format: 1, Prefix: root, ServerPort: 18080}
data, _ := json.Marshal(config)
os.WriteFile(filepath.Join(root, "pipelines-install.json"), data, 0600)
loaded, err = Load(binary)
if err != nil || loaded != nil {
t.Fatal("legacy manifest was inferred", loaded, err)
}
t.Setenv("PIPELINES_PREFIX", root)
loaded, err = Load(binary)
if err != nil || loaded == nil {
t.Fatal("explicit legacy selection stopped working", loaded, err)
}
}
func TestNativeDiscoveryRejectsSymlinkManifestAndMismatchedPrefix(t *testing.T) {
for _, test := range []string{"symlink", "mismatch"} {
t.Run(test, func(t *testing.T) {
t.Setenv("PIPELINES_PREFIX", "")
root, binary := nativeFixture(t)
manifest := filepath.Join(root, "pipelines-install.json")
if test == "symlink" {
target := filepath.Join(root, "other.json")
os.Rename(manifest, target)
os.Symlink(target, manifest)
} else {
config := Config{Format: 1, Prefix: "/another/prefix", ServerPort: 18080}
config.Ntfy.Mode = "native"
data, _ := json.Marshal(config)
os.WriteFile(manifest, data, 0600)
}
if _, err := Load(binary); err == nil {
t.Fatal("unsafe manifest was accepted")
}
})
}
}
+8
View File
@@ -0,0 +1,8 @@
//go:build !darwin && !linux
package installation
import "os"
// Native managed installations are supported only on macOS and Linux.
func ownedByUser(info os.FileInfo) bool { return false }
+13
View File
@@ -0,0 +1,13 @@
//go:build darwin || linux
package installation
import (
"os"
"syscall"
)
func ownedByUser(info os.FileInfo) bool {
stat, ok := info.Sys().(*syscall.Stat_t)
return ok && int(stat.Uid) == os.Getuid()
}
+20 -2
View File
@@ -162,9 +162,27 @@ func ServerExecutable(executable string) (string, error) {
return server, nil
}
// ServiceCommand uses the OS service manager directly, without a second supervisor.
// ServiceCommand manages the selected native supervisor, or a standalone
// developer service when no native installation was selected.
func ServiceCommand(ctx context.Context, executable string, args []string, out, stderr io.Writer) error {
help := "Usage: pipelines service enable [--db FILE] [--addr HOST:PORT] [--print]\n pipelines service disable | status\nAutostart is per-user, at login. enable starts the server now; --print only previews.\nRuns use the directory you invoke pipelines run from.\n"
config, err := Load(executable)
if err != nil {
return err
}
if config != nil && config.Ntfy.Mode == "native" {
// Use an internal verb so an older manager fails instead of forwarding
// "service" back into this CLI recursively. Reinstall refreshes manage.py.
command := exec.CommandContext(ctx, config.Python, append([]string{filepath.Join(config.Prefix, "lib/manage.py"), "--prefix", config.Prefix, "native-service"}, args...)...)
command.Stdout, command.Stderr = out, stderr
if err := command.Run(); err != nil {
return fmt.Errorf("native service command failed (rerun ./install if the manager is outdated): %w", err)
}
return nil
}
if config == nil && os.Getenv("PIPELINES_PREFIX") != "" {
return fmt.Errorf("PIPELINES_PREFIX does not select an existing installation; refusing to configure a standalone service")
}
help := "Usage: pipelines service enable [--print]\n pipelines service disable | status\nNative installs manage the existing server/web/ntfy supervisor, selected by PIPELINES_PREFIX or the installed CLI path.\nAutostart is per-user, at login. enable starts now; --print only previews.\nStandalone developer binaries also support enable --db FILE --addr HOST:PORT.\nRuns use the directory you invoke pipelines run from.\n"
if len(args) == 0 || args[0] == "--help" || args[0] == "help" {
_, err := io.WriteString(out, help)
return err
+40
View File
@@ -4,6 +4,7 @@ import (
"bytes"
"context"
"encoding/xml"
"fmt"
"io"
"os"
"os/exec"
@@ -111,6 +112,7 @@ func TestServiceWritesRefuseUnmanagedFilesAndSymlinks(t *testing.T) {
}
func TestServiceConfigurationPreviewAndLifecycleWithMockOSManager(t *testing.T) {
t.Setenv("PIPELINES_PREFIX", "")
if runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
t.Skip("no supported OS manager")
}
@@ -184,3 +186,41 @@ func TestServiceConfigurationPreviewAndLifecycleWithMockOSManager(t *testing.T)
}
}
}
func TestNativeServiceRoutesToManifestSupervisor(t *testing.T) {
for _, explicit := range []bool{false, true} {
t.Run(fmt.Sprint(explicit), func(t *testing.T) {
t.Setenv("PIPELINES_PREFIX", "")
root, binary := nativeFixture(t)
capture := filepath.Join(root, "arguments")
t.Setenv("TEST_MANAGED_ARGS", capture)
if err := os.WriteFile(filepath.Join(root, "python3"), []byte("#!/bin/sh\nprintf '%s\\n' \"$@\" > \"$TEST_MANAGED_ARGS\"\n"), 0700); err != nil {
t.Fatal(err)
}
if explicit {
t.Setenv("PIPELINES_PREFIX", root)
binary = filepath.Join(t.TempDir(), "unrelated-cli")
}
var out bytes.Buffer
for _, args := range [][]string{{"enable"}, {"enable", "--print"}, {"status"}, {"disable"}} {
if err := ServiceCommand(context.Background(), binary, args, &out, &out); err != nil {
t.Fatal(err)
}
data, err := os.ReadFile(capture)
want := append([]string{filepath.Join(root, "lib/manage.py"), "--prefix", root, "native-service"}, args...)
if err != nil || string(data) != strings.Join(want, "\n")+"\n" {
t.Fatal("wrong managed dispatch", string(data), err)
}
}
})
}
}
func TestInvalidExplicitPrefixCannotCreateStandaloneService(t *testing.T) {
t.Setenv("PIPELINES_PREFIX", t.TempDir())
var out bytes.Buffer
err := ServiceCommand(context.Background(), "/unrelated/pipelines", []string{"enable"}, &out, &out)
if err == nil || !strings.Contains(err.Error(), "refusing to configure a standalone service") {
t.Fatal(err)
}
}
+79 -3
View File
@@ -6,6 +6,8 @@ import json
import os
from pathlib import Path
import platform
import plistlib
import re
import shutil
import signal
import subprocess
@@ -15,6 +17,7 @@ import urllib.request
DEFAULT_PREFIX = Path.home() / ".local/share/pipelines"
MARKER = "pipelines-install.json"
SERVICE_MARKER = "Managed by Pipelines native installer"
def ntfy_mode(config):
@@ -105,6 +108,74 @@ def registration(config):
return config.get("registration")
def service_command(config, arguments):
parser = argparse.ArgumentParser(prog="pipelines service",
description="Manage this native installation's server, authenticated web and ntfy login service.")
parser.add_argument("action", choices=("enable", "disable", "status"))
parser.add_argument("--print", dest="preview", action="store_true",
help="Preview enable's existing service definition without changing or starting anything")
if not arguments or arguments == ["help"]:
parser.print_help()
return
args = parser.parse_args(arguments)
if args.preview and args.action != "enable":
parser.error("--print is only supported with enable")
if ntfy_mode(config) != "native" or config.get("label") != "net.a-wan.pipelines" or not registration(config):
raise ValueError("No native installer login service is recorded; rerun ./install")
path = Path(registration(config))
if platform.system() == "Darwin":
expected = Path.home() / "Library/LaunchAgents/net.a-wan.pipelines.plist"
elif platform.system() == "Linux":
root = Path(config.get("opencode_env", {}).get("XDG_CONFIG_HOME") or Path.home() / ".config")
expected = root / "systemd/user/net.a-wan.pipelines.service"
else:
raise ValueError("Native login services require macOS launchd or Linux systemd --user")
if (path != expected or path.is_symlink() or not path.is_file()
or path.stat().st_uid != os.getuid()):
raise ValueError("Refusing an unexpected native service definition path or owner")
content = path.read_text()
if SERVICE_MARKER not in content:
raise ValueError("Refusing an unmanaged or standalone developer service definition")
if platform.system() == "Darwin":
definition = plistlib.loads(content.encode())
command = [config["python"], str(Path(config["prefix"]) / "lib/manage.py"),
"supervise", "--prefix", config["prefix"]]
if definition.get("Label") != config["label"] or definition.get("ProgramArguments") != command:
raise ValueError("Native service definition does not match this installation")
else:
def quote(value):
return '"' + value.replace('\\', '\\\\').replace('"', '\\"').replace('%', '%%').replace('$', '$$') + '"'
command = [config["python"], str(Path(config["prefix"]) / "lib/manage.py"),
"supervise", "--prefix", config["prefix"]]
if "ExecStart=" + " ".join(map(quote, command)) not in content.splitlines():
raise ValueError("Native service definition does not match this installation")
if args.preview:
print(content, end="")
elif args.action == "enable":
start(config)
print("Native login autostart enabled: server, authenticated web and ntfy.")
elif args.action == "disable":
if platform.system() == "Darwin":
run(["launchctl", "disable", f"gui/{os.getuid()}/{config['label']}"], quiet=True)
else:
run(["systemctl", "--user", "disable", config["label"] + ".service"], quiet=True)
stop(config)
print("Native login autostart disabled; supervisor stopped. Data and credentials retained.")
elif platform.system() == "Darwin":
domain = f"gui/{os.getuid()}"
disabled = run(["launchctl", "print-disabled", domain], quiet=True)
enabled = not re.search(r'"' + re.escape(config["label"]) + r'"\s*=>\s*true', disabled.stdout)
active = run(["launchctl", "print", domain + "/" + config["label"]], quiet=True, check=False).returncode == 0
print("Autostart:", "enabled" if enabled else "disabled")
print("Supervisor:", "loaded" if active else "not loaded")
else:
enabled = run(["systemctl", "--user", "is-enabled", config["label"] + ".service"], quiet=True, check=False)
active = run(["systemctl", "--user", "is-active", config["label"] + ".service"], quiet=True, check=False)
print("Autostart:", "enabled" if enabled.returncode == 0 else "disabled")
print("Supervisor:", "active" if active.returncode == 0 else "inactive")
def start(config):
root = Path(config["prefix"])
if registration(config):
@@ -235,10 +306,12 @@ def supervise(config):
PIPELINES_NTFY_PUBLIC_URL=config["public_url"],
PIPELINES_NTFY_TOKEN_FILE=str(root / "secrets/publisher-token"))
env.pop("PIPELINES_NTFY_TOKEN", None)
server_command = [str(root / "bin/pipelines-server"), "-addr",
server_address(config), "-db", str(root / "data/pipelines.db")]
if config.get("allow_authoring") is True:
server_command.append("-allow-authoring")
with (root / "logs/server.log").open("a") as log:
child = subprocess.Popen([str(root / "bin/pipelines-server"), "-addr",
server_address(config), "-db", str(root / "data/pipelines.db")],
cwd=config["workspace"], env=env, stdout=log, stderr=log)
child = subprocess.Popen(server_command, cwd=config["workspace"], env=env, stdout=log, stderr=log)
if config.get("web"):
web = config["web"]
web_env = dict(env)
@@ -325,6 +398,9 @@ def main():
selector.add_argument("--prefix", type=Path, default=DEFAULT_PREFIX)
selected, forwarded = selector.parse_known_args()
config = load(selected.prefix)
if forwarded and forwarded[0] in ("service", "native-service"):
service_command(config, forwarded[1:])
return
if not forwarded or forwarded[0] not in lifecycle:
binary = str(Path(config["prefix"]) / "bin/pipelines")
env = dict(os.environ)
+26
View File
@@ -19,6 +19,7 @@ import os
import platform
import plistlib
import secrets
import shlex
import shutil
import subprocess
import sys
@@ -227,6 +228,20 @@ class Setup:
raw = self.prefix_argument or self.environ.get("PIPELINES_PREFIX") or default
return Path(raw).expanduser().resolve()
def authoring_role(self, prefix, requested):
"""Fresh single-user installs author; never widen an existing server's role."""
if requested is not None:
return requested
path = prefix / MARKER
if not path.exists() and not path.is_symlink():
return True
if path.is_symlink() or not path.is_file():
raise ValueError("Refusing to read authoring role from a non-regular installation manifest")
existing = json.loads(path.read_text())
if not isinstance(existing, dict) or not isinstance(existing.get("allow_authoring", False), bool):
raise ValueError("Invalid existing authoring role; no permission changes were made")
return existing.get("allow_authoring", False)
# --- prefix layout ---------------------------------------------------
def prepare_layout(self, prefix):
@@ -581,6 +596,7 @@ class Setup:
except ValueError:
raise ValueError("Invalid API/web bind address; use an IPv4 address such as 0.0.0.0 or 127.0.0.1") from None
prefix = self.resolve_prefix()
allow_authoring = self.authoring_role(prefix, args.allow_authoring)
harness = self.harness()
service_path = self.service_path()
# Reuse an already built ntfy binary and skip the release lookup, so a
@@ -625,6 +641,7 @@ class Setup:
path_value = str(prefix / "bin") + os.pathsep + self.environ.get("PATH", "")
manifest = {
"format": 1,
"allow_authoring": allow_authoring,
"prefix": str(prefix),
"python": python,
"server_port": args.port,
@@ -673,6 +690,10 @@ class Setup:
print(f"ntfy is configured for {base_url}; server, web proxy and ntfy have login autostart ({service_path}).")
print(f"Web: http://{lan_ip if args.web_host == '0.0.0.0' else args.web_host}:{args.web_port}/ "
f"(sign-in password in {web['auth_file']}; existing credentials retained).")
print("Login autostart is already enabled. To enable/start it again, run:\n "
+ shlex.join([str(prefix / "bin/pipelines"), "service", "enable"]))
print("Configured server role: " + ("single-user authoring enabled (web pipeline creation/publication allowed)."
if allow_authoring else "execution-only (pipeline publication disabled)."))
if args.bind_address == "0.0.0.0":
print(f"Phone client server URL: ws://{lan_ip}:{args.port}/connect "
"(use a workspace path that exists on this server).")
@@ -692,6 +713,11 @@ def arguments(argv=None):
help="Unauthenticated server bind address (default 127.0.0.1; expose only the web proxy)")
parser.add_argument("--ntfy-port", type=int, default=DEFAULT_NTFY_PORT, help="ntfy listen port")
parser.add_argument("--model", help="Record an explicit default model; otherwise host OpenCode configuration is reused")
role = parser.add_mutually_exclusive_group()
role.add_argument("--allow-authoring", dest="allow_authoring", action="store_true", default=None,
help="Explicitly enable pipeline publication; fresh native installs default to enabled")
role.add_argument("--no-authoring", dest="allow_authoring", action="store_false",
help="Execution-only server; disable pipeline publication (reinstalls otherwise preserve the recorded role)")
parser.add_argument("--replace-data", action="store_true",
help="Allow Docker migration to replace an existing native database/auth store")
return parser.parse_args(argv)
+124
View File
@@ -1,14 +1,20 @@
import importlib.util
import io
import os
from pathlib import Path
import signal
import subprocess
import tempfile
import unittest
from contextlib import redirect_stdout
from unittest.mock import MagicMock, patch
spec = importlib.util.spec_from_file_location("manage_native", Path(__file__).with_name("manage.py"))
manage = importlib.util.module_from_spec(spec)
spec.loader.exec_module(manage)
setup_spec = importlib.util.spec_from_file_location("setup_native_service", Path(__file__).with_name("setup-native.py"))
setup_native = importlib.util.module_from_spec(setup_spec)
setup_spec.loader.exec_module(setup_native)
class FakeProcess:
@@ -20,6 +26,124 @@ class FakeProcess:
class ManageNativeTests(unittest.TestCase):
def service_config(self, home, system):
config = self.config(home / "prefix")
config["opencode_env"] = {"XDG_CONFIG_HOME": str(home / ".config")}
path = (home / "Library/LaunchAgents/net.a-wan.pipelines.plist" if system == "Darwin"
else home / ".config/systemd/user/net.a-wan.pipelines.service")
setup_native.Setup(home, environ={}).register_service(path, config)
return config
def test_native_service_preview_is_read_only_on_both_platforms(self):
for system in ("Darwin", "Linux"):
with self.subTest(system=system), tempfile.TemporaryDirectory() as directory, \
patch.object(manage.Path, "home", return_value=Path(directory)), \
patch.object(manage.platform, "system", return_value=system):
config = self.service_config(Path(directory), system)
path = Path(config["registration"])
before = path.read_bytes()
with patch.object(manage, "run", side_effect=AssertionError("preview invoked OS manager")), \
patch.object(manage, "start", side_effect=AssertionError("preview started services")), \
redirect_stdout(io.StringIO()) as output:
manage.service_command(config, ["enable", "--print"])
self.assertEqual(path.read_bytes(), before)
self.assertEqual(output.getvalue(), before.decode())
self.assertNotIn("publisher-token", output.getvalue())
def test_native_service_enable_and_disable_use_existing_registration(self):
for system in ("Darwin", "Linux"):
with self.subTest(system=system), tempfile.TemporaryDirectory() as directory, \
patch.object(manage.Path, "home", return_value=Path(directory)), \
patch.object(manage.platform, "system", return_value=system):
config = self.service_config(Path(directory), system)
before = Path(config["registration"]).read_bytes()
with patch.object(manage, "start") as start, redirect_stdout(io.StringIO()):
manage.service_command(config, ["enable"])
start.assert_called_once_with(config)
calls = []
with patch.object(manage, "run", side_effect=lambda args, **kw: calls.append(args)), \
patch.object(manage, "stop", side_effect=lambda cfg: calls.append("stop")), \
redirect_stdout(io.StringIO()):
manage.service_command(config, ["disable"])
expected = (["launchctl", "disable", f"gui/{os.getuid()}/net.a-wan.pipelines"] if system == "Darwin"
else ["systemctl", "--user", "disable", "net.a-wan.pipelines.service"])
self.assertEqual(calls, [expected, "stop"])
self.assertEqual(Path(config["registration"]).read_bytes(), before)
def test_native_service_status_does_not_print_raw_manager_output(self):
for system in ("Darwin", "Linux"):
with self.subTest(system=system), tempfile.TemporaryDirectory() as directory, \
patch.object(manage.Path, "home", return_value=Path(directory)), \
patch.object(manage.platform, "system", return_value=system):
config = self.service_config(Path(directory), system)
def manager(args, **kwargs):
self.assertTrue(kwargs["quiet"])
return subprocess.CompletedProcess(args, 0, stdout='"net.a-wan.pipelines" => true\nprivate-output')
with patch.object(manage, "run", side_effect=manager), redirect_stdout(io.StringIO()) as output:
manage.service_command(config, ["status"])
self.assertNotIn("private-output", output.getvalue())
self.assertIn("Autostart: " + ("disabled" if system == "Darwin" else "enabled"), output.getvalue())
def test_native_service_rejects_unmanaged_symlink_and_wrong_prefix_definitions(self):
for variant in ("unmanaged", "symlink", "wrong-prefix", "wrong-label"):
with self.subTest(variant=variant), tempfile.TemporaryDirectory() as directory, \
patch.object(manage.Path, "home", return_value=Path(directory)), \
patch.object(manage.platform, "system", return_value="Linux"):
config = self.service_config(Path(directory), "Linux")
path = Path(config["registration"])
if variant == "unmanaged":
path.write_text("Managed by pipelines service\nExecStart=developer-server")
elif variant == "symlink":
target = path.with_suffix(".other")
path.rename(target)
path.symlink_to(target)
elif variant == "wrong-prefix":
config["prefix"] += "-other"
else:
config["label"] = "pipelines"
with patch.object(manage, "run", side_effect=AssertionError("unsafe OS manager invocation")), \
patch.object(manage, "start", side_effect=AssertionError("unsafe startup")):
with self.assertRaises(ValueError):
manage.service_command(config, ["enable"])
def test_native_service_rejects_standalone_database_flags(self):
with redirect_stdout(io.StringIO()), patch("sys.stderr", new_callable=io.StringIO):
with self.assertRaises(SystemExit) as raised:
manage.service_command({}, ["enable", "--db", "/other.db"])
self.assertEqual(raised.exception.code, 2)
def test_manager_dispatches_internal_service_verb_without_forwarding_to_go(self):
config = {"prefix": "/scratch/native"}
with patch("sys.argv", ["manage.py", "--prefix", "/scratch/native", "native-service", "enable", "--print"]), \
patch.object(manage, "load", return_value=config), \
patch.object(manage, "service_command") as service, \
patch.object(manage.os, "execve", side_effect=AssertionError("recursive Go dispatch")):
manage.main()
service.assert_called_once_with(config, ["enable", "--print"])
def test_supervisor_authoring_flag_requires_explicit_manifest_true(self):
for role in (True, False, None, "true"):
with self.subTest(role=role), tempfile.TemporaryDirectory() as directory:
root = Path(directory)
(root / "logs").mkdir()
config = self.config(root)
if role is not None:
config["allow_authoring"] = role
ntfy, server = MagicMock(), MagicMock()
ntfy.poll.return_value = None
server.poll.return_value = 0
server.returncode = 0
with patch.object(manage, "ntfy_start", return_value=ntfy), \
patch.object(manage, "wait_health"), patch.object(manage.signal, "signal"), \
patch.object(manage.subprocess, "Popen", return_value=server) as popen:
manage.supervise(config)
command = popen.call_args.args[0]
self.assertEqual(command[:5], [str(root / "bin/pipelines-server"), "-addr", "127.0.0.1:8080",
"-db", str(root / "data/pipelines.db")])
self.assertEqual("-allow-authoring" in command, role is True)
def config(self, root, mode="native"):
return {
"format": 1, "prefix": str(root), "python": "python3", "server_port": 8080,
+41
View File
@@ -250,6 +250,46 @@ class SetupNativeTests(unittest.TestCase):
installer = setup_native.Setup(directory, runner=Recorder(), environ={"PIPELINES_PREFIX": str(custom)})
self.assertEqual(installer.resolve_prefix(), custom.resolve())
def test_authoring_role_defaults_only_fresh_install_to_enabled(self):
with tempfile.TemporaryDirectory() as directory:
installer = self.installer(directory, Recorder())
prefix = Path(directory) / "prefix"
self.assertTrue(installer.authoring_role(prefix, None))
prefix.mkdir()
for previous, expected in (({}, False), ({"allow_authoring": False}, False),
({"allow_authoring": True}, True)):
with self.subTest(previous=previous):
manifest = prefix / setup_native.MARKER
manifest.write_text(json.dumps(previous))
before = manifest.read_bytes()
self.assertIs(installer.authoring_role(prefix, None), expected)
self.assertTrue(installer.authoring_role(prefix, True))
self.assertFalse(installer.authoring_role(prefix, False))
self.assertEqual(manifest.read_bytes(), before)
manifest.write_text('{"allow_authoring":"true"}')
with self.assertRaisesRegex(ValueError, "Invalid existing authoring role"):
installer.authoring_role(prefix, None)
def test_authoring_flags_are_explicit_optional_overrides(self):
self.assertIsNone(setup_native.arguments([]).allow_authoring)
self.assertTrue(setup_native.arguments(["--allow-authoring"]).allow_authoring)
self.assertFalse(setup_native.arguments(["--no-authoring"]).allow_authoring)
def test_full_run_keeps_existing_execution_only_and_accepts_fresh_opt_out(self):
for previous, arguments in (({}, []), ({"allow_authoring": False}, []), (None, ["--no-authoring"])):
with self.subTest(previous=previous), tempfile.TemporaryDirectory() as directory:
installer = self.installer(directory, Recorder())
prefix = Path(directory) / "prefix"
if previous is not None:
prefix.mkdir()
(prefix / setup_native.MARKER).write_text(json.dumps(previous))
with patch.object(setup_native.shutil, "which", side_effect=self.which_all()), \
patch.object(setup_native.lan, "detect_lan", return_value="192.168.1.20"), \
patch.object(setup_native.configure, "host_timezone", return_value="UTC"), \
redirect_stdout(io.StringIO()):
installer.run(setup_native.arguments(arguments))
self.assertFalse(manage.load(prefix)["allow_authoring"])
def test_missing_opencode_fails_actionably(self):
with tempfile.TemporaryDirectory() as directory:
installer = self.installer(directory, Recorder())
@@ -268,6 +308,7 @@ class SetupNativeTests(unittest.TestCase):
installer.run(setup_native.arguments([]))
config = manage.load(prefix)
self.assertEqual(config["format"], 1)
self.assertTrue(config["allow_authoring"])
self.assertEqual(config["prefix"], str(prefix.resolve()))
self.assertEqual(config["server_port"], 8080)
self.assertEqual(config["bind_address"], "127.0.0.1")