@synopackageland/cli 0.8.0 → 0.9.0

package/dist/templates/_executor/tasks.go

@@ -1,320 +0,0 @@
-package main
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strconv"
-	"synopkgland/executor/internal/taskscript"
-	"time"
-)
-
-type approvedTask struct {
-	Kind         string `json:"kind"`
-	Name         string `json:"name"`
-	ScriptDigest string `json:"script_digest"`
-}
-type taskInventory struct {
-	Package      string         `json:"package"`
-	PolicyDigest string         `json:"policy_digest"`
-	Tasks        []approvedTask `json:"tasks"`
-}
-
-func hashBytes(b []byte) string { h := sha256.Sum256(b); return hex.EncodeToString(h[:]) }
-func validInventory(pkg string, inventory taskInventory) bool {
-	if inventory.Package != pkg || len(inventory.Tasks) != 2 || !idRE.MatchString(inventory.PolicyDigest) {
-		return false
-	}
-	seen := map[string]bool{}
-	for _, t := range inventory.Tasks {
-		if !contains([]string{"boot", "control"}, t.Kind) || seen[t.Kind] || t.Name != pkg+" executor "+t.Kind || !idRE.MatchString(t.ScriptDigest) {
-			return false
-		}
-		seen[t.Kind] = true
-	}
-	return true
-}
-func rootOwner(raw json.RawMessage, boot bool) bool {
-	var owner string
-	if json.Unmarshal(raw, &owner) == nil {
-		return owner == "root"
-	}
-	var owners map[string]string
-	return boot && json.Unmarshal(raw, &owners) == nil && len(owners) == 1 && owners["0"] == "root"
-}
-func taskReference(ctx context.Context, d *liveDSM, task approvedTask, expected string) (string, string, map[string]any, error) {
-	api, version := "SYNO.Core.EventScheduler", "1"
-	ref := map[string]any{"task_name": task.Name}
-	boot := task.Kind == "boot"
-	if !boot {
-		api = "SYNO.Core.TaskScheduler"
-		b, err := listControlTasks(ctx, d)
-		if err != nil {
-			return "", "", nil, err
-		}
-		var list struct {
-			Tasks []struct {
-				Name string      `json:"name"`
-				ID   json.Number `json:"id"`
-			} `json:"tasks"`
-			Total *int `json:"total"`
-		}
-		if json.Unmarshal(b, &list) != nil || list.Total == nil || *list.Total != len(list.Tasks) || len(list.Tasks) > 500 {
-			return "", "", nil, errors.New("incomplete scheduler list")
-		}
-		count := 0
-		var id int
-		for _, t := range list.Tasks {
-			if t.Name == task.Name {
-				count++
-				n, e := strconv.Atoi(string(t.ID))
-				if e != nil || n < 0 {
-					return "", "", nil, errors.New("task id")
-				}
-				id = n
-			}
-		}
-		if count != 1 {
-			return "", "", nil, errors.New("missing or duplicate task")
-		}
-		ref = map[string]any{"id": id, "real_owner": "root"}
-	}
-	var b json.RawMessage
-	var err error
-	if boot {
-		b, err = d.call(ctx, api, "get", version, "", ref)
-	} else {
-		b, err = onUnsupportedVersion(func() (json.RawMessage, error) { return d.call(ctx, api, "get", "4", "", ref) },
-			func() (json.RawMessage, error) { return d.call(ctx, api, "get", "3", "", ref) })
-	}
-	if err != nil {
-		return "", "", nil, err
-	}
-	var got struct {
-		Name          string          `json:"name"`
-		TaskName      string          `json:"task_name"`
-		ID            json.Number     `json:"id"`
-		Owner         json.RawMessage `json:"owner"`
-		RealOwner     string          `json:"real_owner"`
-		Enable        *bool           `json:"enable"`
-		Type          string          `json:"type"`
-		Event         string          `json:"event"`
-		OperationType string          `json:"operation_type"`
-		Operation     string          `json:"operation"`
-		Extra         struct {
-			Script string `json:"script"`
-		} `json:"extra"`
-	}
-	if json.Unmarshal(b, &got) != nil || !rootOwner(got.Owner, boot) || got.Enable == nil {
-		return "", "", nil, errors.New("task owner")
-	}
-	script := got.Operation
-	if boot {
-		if got.TaskName != task.Name || !*got.Enable || got.Event != "bootup" || got.OperationType != "script" {
-			return "", "", nil, errors.New("boot definition")
-		}
-	} else {
-		if got.Name != task.Name || string(got.ID) != strconv.Itoa(ref["id"].(int)) || got.RealOwner != "root" || *got.Enable || got.Type != "script" {
-			return "", "", nil, errors.New("control definition")
-		}
-		script = got.Extra.Script
-	}
-	if script != expected || hashBytes([]byte(script)) != task.ScriptDigest {
-		return "", "", nil, errors.New("task script mismatch")
-	}
-	if !boot {
-		version = "2"
-		ref = map[string]any{"tasks": []map[string]any{ref}}
-	}
-	return api, version, ref, nil
-}
-
-// Setup records are copied into root state only after exact scheduler readback.
-// Package-controlled names can never expand deletion beyond this package's pair.
-func snapshotTasks(ctx context.Context, d *liveDSM, pkg, ed, pd, setupPath, runtime string) error {
-	b, _, err := readLifecycleFile(setupPath, 16384)
-	if err != nil {
-		return err
-	}
-	var setup struct {
-		Package        string          `json:"package"`
-		ExecutorDigest string          `json:"executorDigest"`
-		PolicyDigest   string          `json:"policyDigest"`
-		Policy         json.RawMessage `json:"policy"`
-		Implementation string          `json:"implementation"`
-		Tasks          []struct {
-			Kind   string `json:"kind"`
-			Name   string `json:"name"`
-			Header string `json:"header"`
-			Script string `json:"script"`
-		} `json:"tasks"`
-	}
-	if strictJSON(b, &setup) != nil || setup.Package != pkg || setup.ExecutorDigest != ed || setup.PolicyDigest != pd || setup.Implementation != "executor" {
-		return errors.New("setup pins")
-	}
-	generated, err := taskscript.Generate(pkg, pd)
-	if err != nil || len(setup.Tasks) != len(generated) {
-		return errors.New("setup task inventory")
-	}
-	inv := taskInventory{Package: pkg, PolicyDigest: pd}
-	for i, task := range generated {
-		hint := setup.Tasks[i]
-		if hint.Kind != task.Kind || hint.Name != task.Name || hint.Header != task.Header || hint.Script != task.Script {
-			return errors.New("setup task mismatch")
-		}
-		inv.Tasks = append(inv.Tasks, approvedTask{Kind: task.Kind, Name: task.Name, ScriptDigest: hashBytes([]byte(task.Script))})
-	}
-	if !validInventory(pkg, inv) {
-		return errors.New("setup task inventory")
-	}
-	for i, task := range inv.Tasks {
-		if _, _, _, err = taskReference(ctx, d, task, generated[i].Script); err != nil {
-			return err
-		}
-	}
-	b, err = json.Marshal(inv)
-	if err != nil {
-		return err
-	}
-	f, err := os.CreateTemp(runtime, ".tasks-")
-	if err != nil {
-		return err
-	}
-	defer os.Remove(f.Name())
-	if _, err = f.Write(b); err == nil {
-		err = f.Sync()
-	}
-	closeErr := f.Close()
-	if err != nil {
-		return err
-	}
-	if closeErr != nil {
-		return closeErr
-	}
-	return os.Rename(f.Name(), filepath.Join(runtime, "tasks.json"))
-}
-func readTaskInventory(runtime string) (taskInventory, error) {
-	var inv taskInventory
-	f, err := openRegular(filepath.Join(runtime, "tasks.json"))
-	if err != nil {
-		return inv, err
-	}
-	defer f.Close()
-	info, err := f.Stat()
-	if err != nil || !ownedByRoot(info) || info.Mode().Perm() != 0600 {
-		return inv, errors.New("untrusted task inventory")
-	}
-	b, err := readLimited(f, 16384)
-	if err != nil {
-		return inv, err
-	}
-	err = strictJSON(b, &inv)
-	return inv, err
-}
-func purgeTasks(ctx context.Context, d *liveDSM, pkg string, inv taskInventory, log func(string)) {
-	if !validInventory(pkg, inv) {
-		log("task cleanup skipped: invalid protected inventory")
-		return
-	}
-	generated, err := taskscript.Generate(pkg, inv.PolicyDigest)
-	if err != nil {
-		log("task cleanup skipped: invalid protected pins")
-		return
-	}
-	for _, task := range inv.Tasks {
-		expected := ""
-		for _, canonical := range generated {
-			if canonical.Kind == task.Kind {
-				expected = canonical.Script
-			}
-		}
-		started := time.Now()
-		api, version, ref, err := taskReference(ctx, d, task, expected)
-		if err != nil {
-			log("task cleanup skipped: " + task.Kind + " definition mismatch or unavailable")
-			continue
-		}
-		looked := time.Now()
-		if err = d.mutate(ctx, api, "delete", version, ref); err != nil {
-			log("task cleanup unconfirmed: " + task.Kind)
-		}
-		deleted := time.Now()
-		// The scheduler has no conditional delete. Accept the admin edit window,
-		// delete exactly once, and observe the name afterward without another delete.
-		if taskRemains(ctx, d, task) {
-			log("task cleanup: " + task.Kind + " same-named task remains after delete")
-		}
-		log(fmt.Sprintf("task cleanup timing: package=%s kind=%s lookup_ms=%d delete_ms=%d verify_ms=%d", pkg, task.Kind,
-			looked.Sub(started).Milliseconds(), deleted.Sub(looked).Milliseconds(), time.Since(deleted).Milliseconds()))
-	}
-}
-
-func purgeWithInventory(ctx context.Context, d *liveDSM, pkg string, inv taskInventory, state, runtime, socket string, log func(string)) error {
-	if runtime != filepath.Join(state, "runtime") {
-		return errors.New("runtime outside package protected state")
-	}
-	started := time.Now()
-	purgeTasks(ctx, d, pkg, inv, log)
-	cleaned := time.Now()
-	err := finishControl(state, runtime, socket, true)
-	log(fmt.Sprintf("purge timing: package=%s tasks_ms=%d files_ms=%d", pkg, cleaned.Sub(started).Milliseconds(), time.Since(cleaned).Milliseconds()))
-	return err
-}
-
-func taskRemains(ctx context.Context, d *liveDSM, task approvedTask) bool {
-	if task.Kind == "boot" {
-		b, err := d.call(ctx, "SYNO.Core.EventScheduler", "get", "1", "", map[string]any{"task_name": task.Name})
-		if err != nil {
-			return false
-		}
-		var got struct {
-			Name string `json:"task_name"`
-		}
-		return json.Unmarshal(b, &got) == nil && got.Name == task.Name
-	}
-	b, err := listControlTasks(ctx, d)
-	if err != nil {
-		return false
-	}
-	var list struct {
-		Tasks []struct {
-			Name string `json:"name"`
-		} `json:"tasks"`
-	}
-	if json.Unmarshal(b, &list) != nil {
-		return false
-	}
-	for _, t := range list.Tasks {
-		if t.Name == task.Name {
-			return true
-		}
-	}
-	return false
-}
-
-// DSM 7.1 has TaskScheduler list v2 (offset) and get v3 only. A read falls back
-// solely when DSM reports the method version unsupported; any other refusal stands.
-func onUnsupportedVersion(current, legacy func() (json.RawMessage, error)) (json.RawMessage, error) {
-	b, err := current()
-	var refused *dsmError
-	if errors.As(err, &refused) && versionUnsupported(refused.Code) {
-		return legacy()
-	}
-	return b, err
-}
-
-// DSM 7.1.1 returns 104 for a version above maxVersion (get v4) and 103 for a
-// method absent at an existing version (list v3).
-func versionUnsupported(code int) bool { return code == 103 || code == 104 }
-func listControlTasks(ctx context.Context, d *liveDSM) (json.RawMessage, error) {
-	return onUnsupportedVersion(func() (json.RawMessage, error) {
-		return d.call(ctx, "SYNO.Core.TaskScheduler", "list", "3", "", map[string]any{"start": 0, "limit": 500})
-	}, func() (json.RawMessage, error) {
-		return d.call(ctx, "SYNO.Core.TaskScheduler", "list", "2", "", map[string]any{"offset": 0, "limit": 500})
-	})
-}

package/dist/templates/_executor/tasks_dsm71_test.go

@@ -1,114 +0,0 @@
-package main
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// dsm71Scheduler answers like DSM 7.1.1-42962 (vt-62): TaskScheduler stops at
-// list v2 (offset/limit) and get v3. t-0234 measured the refusals: a version
-// above maxVersion 3 returns 104; a method absent at an existing version, 103.
-type dsm71Scheduler struct {
-	recordingScheduler
-	refusal string
-}
-
-func (s *dsm71Scheduler) Exec(ctx context.Context, path string, args []string) ([]byte, error) {
-	api, method, version := schedulerCall(args)
-	s.calls = append(s.calls, api+" "+method+" v"+version)
-	if api == "SYNO.Core.TaskScheduler" {
-		if method == "list" && version == "3" && s.refusal != "" {
-			return []byte(`{"success":false,"error":{"code":` + s.refusal + `}}`), nil
-		}
-		supported := map[string]string{"list": "2", "get": "3", "delete": "2", "run": "2"}
-		if supported[method] != version {
-			if version > "3" {
-				return []byte(`{"success":false,"error":{"code":104}}`), nil
-			}
-			return []byte(`{"success":false,"error":{"code":103}}`), nil
-		}
-		if method == "list" && (!contains(args, "offset=0") || !contains(args, "limit=500")) {
-			return []byte(`{"success":false,"error":{"code":101}}`), nil
-		}
-	}
-	return s.schedulerFixture.Exec(ctx, path, args)
-}
-
-func purgeWith(t *testing.T, cmd Command) {
-	t.Helper()
-	inventory := taskInventory{Package: "TestApp", PolicyDigest: strings.Repeat("b", 64), Tasks: []approvedTask{{Kind: "boot", Name: "TestApp executor boot", ScriptDigest: canonicalTaskDigest(t, "boot")}, {Kind: "control", Name: "TestApp executor control", ScriptDigest: canonicalTaskDigest(t, "control")}}}
-	state := filepath.Join(t.TempDir(), "state")
-	socket := filepath.Join(t.TempDir(), "socket")
-	os.MkdirAll(filepath.Join(state, "runtime"), 0700)
-	os.MkdirAll(socket, 0700)
-	if err := purgeWithInventory(context.Background(), &liveDSM{Command: cmd}, "TestApp", inventory, state, filepath.Join(state, "runtime"), socket, func(string) {}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestPurgeFindsAndDeletesBothTasksOnDSM71(t *testing.T) {
-	cmd := &dsm71Scheduler{}
-	purgeWith(t, cmd)
-	if strings.Join(cmd.deleted, ",") != "SYNO.Core.EventScheduler,SYNO.Core.TaskScheduler" {
-		t.Fatal("DSM 7.1 tasks left behind", cmd.deleted, cmd.calls)
-	}
-}
-
-func TestSchedulerReadFallsBackOnlyOnUnsupportedVersion(t *testing.T) {
-	for _, code := range []string{"105", "119", "102", "3121"} {
-		t.Run(code, func(t *testing.T) {
-			cmd := &dsm71Scheduler{refusal: code}
-			purgeWith(t, cmd)
-			for _, call := range cmd.calls {
-				if call == "SYNO.Core.TaskScheduler list v2" || call == "SYNO.Core.TaskScheduler get v3" {
-					t.Fatal("fell back after code", code, cmd.calls)
-				}
-			}
-			if contains(cmd.deleted, "SYNO.Core.TaskScheduler") {
-				t.Fatal("deleted without exact readback", cmd.deleted)
-			}
-		})
-	}
-}
-
-func TestModernSchedulerNeverUsesLegacyVersions(t *testing.T) {
-	cmd := &recordingScheduler{}
-	purgeWith(t, cmd)
-	for _, call := range cmd.calls {
-		if call == "SYNO.Core.TaskScheduler list v2" || call == "SYNO.Core.TaskScheduler get v3" {
-			t.Fatal("modern DSM used a legacy version", cmd.calls)
-		}
-	}
-	if len(cmd.deleted) != 2 {
-		t.Fatal(cmd.deleted)
-	}
-}
-
-type recordingScheduler struct {
-	schedulerFixture
-	calls []string
-}
-
-func (s *recordingScheduler) Exec(ctx context.Context, path string, args []string) ([]byte, error) {
-	api, method, version := schedulerCall(args)
-	s.calls = append(s.calls, api+" "+method+" v"+version)
-	return s.schedulerFixture.Exec(ctx, path, args)
-}
-
-func schedulerCall(args []string) (api, method, version string) {
-	for _, a := range args {
-		k, v, _ := strings.Cut(a, "=")
-		switch k {
-		case "api":
-			api = v
-		case "method":
-			method = v
-		case "version":
-			version = v
-		}
-	}
-	return
-}

package/dist/templates/_executor/tasks_review_test.go

@@ -1,43 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestReviewSnapshotRejectsUnrelatedSameNamedRootTasks(t *testing.T) {
-	dir, err := filepath.EvalSymlinks(t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	ed, pd := strings.Repeat("a", 64), strings.Repeat("b", 64)
-	tasks := []map[string]string{}
-	for _, kind := range []string{"boot", "control"} {
-		header := "#!/bin/sh\n# synopkgland executor " + kind + "\n"
-		// Another admin's script merely happens to carry these marker comments.
-		script := header + "# " + ed + " " + pd + "\necho unrelated-backup-task\n"
-		tasks = append(tasks, map[string]string{"kind": kind, "name": "TestApp executor " + kind, "header": header, "script": script})
-	}
-	setup := map[string]any{"package": "TestApp", "executorDigest": ed, "policyDigest": pd, "implementation": "executor", "tasks": tasks}
-	b, _ := json.Marshal(setup)
-	path := filepath.Join(dir, "setup.json")
-	os.WriteFile(path, b, 0600)
-	err = snapshotTasks(context.Background(), &liveDSM{Command: &snapshotFixture{tasks: tasks}}, "TestApp", ed, pd, path, dir)
-	if err == nil {
-		t.Fatal("unrelated root tasks accepted into protected deletion inventory")
-	}
-}
-
-func TestReviewPurgeRejectsUnrelatedSameNamedRootTasks(t *testing.T) {
-	script := "#!/bin/sh\n# synopkgland executor boot\n# " + strings.Repeat("a", 64) + strings.Repeat("b", 64) + "\necho unrelated-backup-task\n"
-	cmd := &schedulerFixture{script: script}
-	inv := taskInventory{Package: "TestApp", PolicyDigest: strings.Repeat("b", 64), Tasks: []approvedTask{{Kind: "boot", Name: "TestApp executor boot", ScriptDigest: hashBytes([]byte(script))}, {Kind: "control", Name: "TestApp executor control", ScriptDigest: hashBytes([]byte(script))}}}
-	purgeTasks(context.Background(), &liveDSM{Command: cmd}, "TestApp", inv, func(string) {})
-	if len(cmd.deleted) != 0 {
-		t.Fatal("deleted unrelated tasks", cmd.deleted)
-	}
-}