system: remove tmpfiles

This is no longer used.

Signed-off-by: Ophestra <cat@gensokyo.uk>

system/system_test.go

@@ -149,7 +149,7 @@ func TestEqual(t *testing.T) {
 		{"op type mismatch",
 			New(t.Context(), message.NewMsg(nil), 150).
 				ChangeHosts("chronos").
-				CopyFile(new([]byte), m("/home/ophestra/xdg/config/pulse/cookie"), 0, 256),
+				Wayland(m("/proc/nonexistent/dst"), m("/proc/nonexistent/src"), "\x00", "\x00"),
 			New(t.Context(), message.NewMsg(nil), 150).
 				ChangeHosts("chronos").
 				Ensure(m("/run"), 0755),

system/tmpfiles.go

@@ -1,81 +0,0 @@
-package system
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"syscall"
-
-	"hakurei.app/container/check"
-	"hakurei.app/hst"
-)
-
-// CopyFile reads up to n bytes from src and writes the resulting byte slice to payloadP.
-func (sys *I) CopyFile(payloadP *[]byte, src *check.Absolute, cap int, n int64) *I {
-	buf := new(bytes.Buffer)
-	buf.Grow(cap)
-	sys.ops = append(sys.ops, &tmpfileOp{payloadP, src.String(), n, buf})
-	return sys
-}
-
-// tmpfileOp implements [I.CopyFile].
-type tmpfileOp struct {
-	payload *[]byte
-	src     string
-
-	n   int64
-	buf *bytes.Buffer
-}
-
-func (t *tmpfileOp) Type() hst.Enablement { return Process }
-
-func (t *tmpfileOp) apply(sys *I) error {
-	if t.payload == nil {
-		// this is a misuse of the API; do not return a wrapped error
-		return errors.New("invalid payload")
-	}
-
-	sys.msg.Verbose("copying", t)
-
-	if b, err := sys.stat(t.src); err != nil {
-		return newOpError("tmpfile", err, false)
-	} else {
-		if b.IsDir() {
-			return newOpError("tmpfile", &os.PathError{Op: "stat", Path: t.src, Err: syscall.EISDIR}, false)
-		}
-		if s := b.Size(); s > t.n {
-			return newOpError("tmpfile", &os.PathError{Op: "stat", Path: t.src, Err: syscall.ENOMEM}, false)
-		}
-	}
-
-	var r io.ReadCloser
-	if f, err := sys.open(t.src); err != nil {
-		return newOpError("tmpfile", err, false)
-	} else {
-		r = f
-	}
-	if n, err := io.CopyN(t.buf, r, t.n); err != nil {
-		if !errors.Is(err, io.EOF) {
-			_ = r.Close()
-			return newOpError("tmpfile", err, false)
-		}
-		sys.msg.Verbosef("copied %d bytes from %q", n, t.src)
-	}
-	if err := r.Close(); err != nil {
-		return newOpError("tmpfile", err, false)
-	}
-
-	*t.payload = t.buf.Bytes()
-	return nil
-}
-func (t *tmpfileOp) revert(*I, *Criteria) error { t.buf.Reset(); return nil }
-
-func (t *tmpfileOp) Is(o Op) bool {
-	target, ok := o.(*tmpfileOp)
-	return ok && t != nil && target != nil &&
-		t.src == target.src && t.n == target.n
-}
-func (t *tmpfileOp) Path() string   { return t.src }
-func (t *tmpfileOp) String() string { return fmt.Sprintf("up to %d bytes from %q", t.n, t.src) }

system/tmpfiles_test.go

@@ -1,142 +0,0 @@
-package system
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"strings"
-	"syscall"
-	"testing"
-
-	"hakurei.app/container/stub"
-)
-
-type errorReader struct{}
-
-func (errorReader) Read([]byte) (int, error) { return 0, stub.UniqueError(0xdeadbeef) }
-
-func TestTmpfileOp(t *testing.T) {
-	// 255 bytes
-	const paSample = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
-
-	checkOpBehaviour(t, []opBehaviourTestCase{
-		{"payload", 0xdead, 0xff, &tmpfileOp{
-			nil, "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, nil, errors.New("invalid payload"), nil, nil},
-
-		{"stat", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, nil, stub.UniqueError(1)),
-		}, &OpError{Op: "tmpfile", Err: stub.UniqueError(1)}, nil, nil},
-
-		{"stat EISDIR", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1 << 8, true}, nil),
-		}, &OpError{Op: "tmpfile", Err: &os.PathError{Op: "stat", Path: "/home/ophestra/xdg/config/pulse/cookie", Err: syscall.EISDIR}}, nil, nil},
-
-		{"stat ENOMEM", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1<<8 + 1, false}, nil),
-		}, &OpError{Op: "tmpfile", Err: &os.PathError{Op: "stat", Path: "/home/ophestra/xdg/config/pulse/cookie", Err: syscall.ENOMEM}}, nil, nil},
-
-		{"open", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1 << 8, false}, nil),
-			call("open", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, nil, stub.UniqueError(0)),
-		}, &OpError{Op: "tmpfile", Err: stub.UniqueError(0)}, nil, nil},
-
-		{"reader", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1 << 8, false}, nil),
-			call("open", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, &readerOsFile{true, errorReader{}}, nil),
-		}, &OpError{Op: "tmpfile", Err: stub.UniqueError(0xdeadbeef)}, nil, nil},
-
-		{"closed", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1 << 8, false}, nil),
-			call("open", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, &readerOsFile{true, strings.NewReader(paSample + "=")}, nil),
-		}, &OpError{Op: "tmpfile", Err: os.ErrClosed}, nil, nil},
-
-		{"success full", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1 << 8, false}, nil),
-			call("open", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, &readerOsFile{false, strings.NewReader(paSample + "=")}, nil),
-		}, nil, nil, nil},
-
-		{"success", 0xdead, 0xff, &tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}, []stub.Call{
-			call("verbose", stub.ExpectArgs{[]any{"copying", &tmpfileOp{new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }()}}}, nil, nil),
-			call("stat", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, stubFi{1 << 8, false}, nil),
-			call("open", stub.ExpectArgs{"/home/ophestra/xdg/config/pulse/cookie"}, &readerOsFile{false, strings.NewReader(paSample)}, nil),
-			call("verbosef", stub.ExpectArgs{"copied %d bytes from %q", []any{int64(1<<8 - 1), "/home/ophestra/xdg/config/pulse/cookie"}}, nil, nil),
-		}, nil, nil, nil},
-	})
-
-	checkOpsBuilder(t, "CopyFile", []opsBuilderTestCase{
-		{"pulse", 0xcafebabe, func(_ *testing.T, sys *I) {
-			sys.CopyFile(new([]byte), m("/home/ophestra/xdg/config/pulse/cookie"), 1<<8, 1<<8)
-		}, []Op{&tmpfileOp{
-			new([]byte), "/home/ophestra/xdg/config/pulse/cookie", 1 << 8,
-			func() *bytes.Buffer { buf := new(bytes.Buffer); buf.Grow(1 << 8); return buf }(),
-		}}, stub.Expect{}},
-	})
-
-	checkOpIs(t, []opIsTestCase{
-		{"nil", (*tmpfileOp)(nil), (*tmpfileOp)(nil), false},
-		{"zero", new(tmpfileOp), new(tmpfileOp), true},
-
-		{"n differs", &tmpfileOp{
-			src: "/home/ophestra/xdg/config/pulse/cookie",
-			n:   1 << 7,
-		}, &tmpfileOp{
-			src: "/home/ophestra/xdg/config/pulse/cookie",
-			n:   1 << 8,
-		}, false},
-
-		{"src differs", &tmpfileOp{
-			src: "/home/ophestra/xdg/config/pulse",
-			n:   1 << 8,
-		}, &tmpfileOp{
-			src: "/home/ophestra/xdg/config/pulse/cookie",
-			n:   1 << 8,
-		}, false},
-
-		{"equals", &tmpfileOp{
-			src: "/home/ophestra/xdg/config/pulse/cookie",
-			n:   1 << 8,
-		}, &tmpfileOp{
-			src: "/home/ophestra/xdg/config/pulse/cookie",
-			n:   1 << 8,
-		}, true},
-	})
-
-	checkOpMeta(t, []opMetaTestCase{
-		{"pulse", &tmpfileOp{nil, "/home/ophestra/xdg/config/pulse/cookie", 1 << 8, nil},
-			Process, "/home/ophestra/xdg/config/pulse/cookie",
-			`up to 256 bytes from "/home/ophestra/xdg/config/pulse/cookie"`},
-	})
-}