//go:build linux

package host

import (
	"github.com/carlosframework/platform/internal/release"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"testing"
)

func TestPlan14GenerationKernelRunningExecutable(t *testing.T) {
	for _, change := range []string{"running", "deleted", "parent-renamed"} {
		t.Run(change, func(t *testing.T) {
			f := generationProc(t)
			b := f.reservation.Binding
			body, err := os.ReadFile("/bin/sleep")
			if err != nil {
				t.Fatal(err)
			}
			if err := os.WriteFile(b.Path, body, 0700); err != nil {
				t.Fatal(err)
			}
			if err := os.Chmod(b.Path, 0700); err != nil {
				t.Fatal(err)
			}
			cmd := exec.Command(b.Path, "60")
			cmd.Dir = t.TempDir()
			if err := cmd.Start(); err != nil {
				t.Fatal(err)
			}
			joined := false
			defer func() {
				if !joined {
					_ = cmd.Process.Kill()
					_ = cmd.Wait()
				}
			}()
			proc := filepath.Join("/proc", strconv.Itoa(cmd.Process.Pid))
			raw, err := generationRead(proc + "/stat")
			if err != nil {
				t.Fatal(err)
			}
			start, err := generationStart(raw)
			if err != nil {
				t.Fatal(err)
			}
			// The copied binary kept the staged inode. Read the real proc link, not
			// the fake launch fixture's claim that it observed a process.
			generationRelink(t, proc+"/exe", f.task+"/exe")
			switch change {
			case "deleted":
				if err := os.Remove(b.Path); err != nil {
					t.Fatal(err)
				}
			case "parent-renamed":
				if err := os.Rename(b.Tree, b.Tree+".old"); err != nil {
					t.Fatal(err)
				}
			}
			if err := generationLinkRef(proc+"/exe", b); err == nil {
				t.Fatal("running executable not found")
			}
			if _, err := (generationKernel{proc: f.proc}).absent(t.Context(), f.reservation); err == nil {
				t.Fatal("running tenant released")
			}
			actual := b
			actual.ControllerPID = cmd.Process.Pid
			actual.ControllerStart = start
			actual.Target.BootID, err = (generationKernel{proc: "/proc"}).boot()
			if err != nil {
				t.Fatal(err)
			}
			if err := (generationKernel{proc: "/proc"}).controllerGone(t.Context(), actual); err == nil {
				t.Fatal("live process reported joined")
			}
			if err := cmd.Process.Kill(); err != nil {
				t.Fatal(err)
			}
			_ = cmd.Wait()
			joined = true
			if err := (generationKernel{proc: "/proc"}).controllerGone(t.Context(), actual); err != nil {
				t.Fatal(err)
			}
			generationRelink(t, f.unrelated, f.task+"/exe")
			_, err = (generationKernel{proc: f.proc}).absent(t.Context(), f.reservation)
			if (err == nil) != (change != "parent-renamed") {
				t.Fatalf("after join: %v", err)
			}
		})
	}
}

func TestPlan14GenerationKernelCgroup(t *testing.T) {
	for _, attack := range []string{"absent", "empty", "populated", "replaced", "unknown-child", "pending-present", "unreadable"} {
		t.Run(attack, func(t *testing.T) {
			f, d, _ := generationLaunchFixture(t)
			if _, err := f.root.Serve(t.Context(), f.peer, f.req); err != nil {
				t.Fatal(err)
			}
			r := readGenerationLaunch(t, d)
			boot, err := os.ReadFile("/proc/sys/kernel/random/boot_id")
			if err != nil {
				t.Fatal(err)
			}
			r.Binding.Target.BootID = strings.TrimSpace(string(boot))
			root := t.TempDir()
			group := filepath.Join(root, r.Process.Group)
			if attack != "absent" {
				if err := os.MkdirAll(group, 0700); err != nil {
					t.Fatal(err)
				}
				id, err := stopIdentity(group)
				if err != nil {
					t.Fatal(err)
				}
				r.Process.GroupIdentity.Device, r.Process.GroupIdentity.Inode = id.Device, id.Inode
				generationWrite(t, group+"/cgroup.events", "populated 0\n")
			}
			switch attack {
			case "populated":
				generationWrite(t, group+"/cgroup.events", "populated 1\n")
			case "replaced":
				r.Process.GroupIdentity.Inode++
			case "unknown-child":
				if err := os.Mkdir(group+"/child", 0700); err != nil {
					t.Fatal(err)
				}
			case "pending-present":
				r.Process = release.GenerationProcess{}
			case "unreadable":
				if err := os.Remove(group + "/cgroup.events"); err != nil {
					t.Fatal(err)
				}
			}
			err = generationGroupGone(t.Context(), root, r)
			allow := attack == "absent" || attack == "empty"
			if (err == nil) != allow {
				t.Fatalf("group check=%v allow=%t", err, allow)
			}
		})
	}
}