@synopackageland/cli 0.8.0 → 0.9.0

package/templates/_executor/auth_presence_review_test.go

@@ -1,38 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"testing"
-)
-
-func TestReviewEmptyPartialAuthMustNotBecomeWorkerRevoke(t *testing.T) {
-	for _, auth := range []string{`{"dsm_cookie":""}`, `{"dsm_synotoken":""}`, `{"dsm_cookie":"","dsm_synotoken":""}`, `null`} {
-		e, _, _ := setup(t)
-		id := create(t, e)
-		var req Request
-		p, _ := json.Marshal(map[string]string{"delegation_id": id, "job_id": "job1"})
-		raw := []byte(`{"v":1,"op":"delegate.revoke","auth":` + auth + `,"params":` + string(p) + `}`)
-		if err := strictJSON(raw, &req); err != nil {
-			t.Fatal(err)
-		}
-		if r := e.Handle(context.Background(), req); r.Code != "AUTH_DENIED" {
-			t.Errorf("partial auth %s became worker revoke: %+v", auth, r)
-		}
-	}
-}
-
-func TestWorkerRevokeRequiresAbsentOrEmptyAuthObject(t *testing.T) {
-	for _, auth := range []string{"", `,"auth":{}`} {
-		e, _, _ := setup(t)
-		id := create(t, e)
-		p, _ := json.Marshal(map[string]string{"delegation_id": id, "job_id": "job1"})
-		var req Request
-		if err := strictJSON([]byte(`{"v":1,"op":"delegate.revoke"`+auth+`,"params":`+string(p)+`}`), &req); err != nil {
-			t.Fatal(err)
-		}
-		if r := e.Handle(context.Background(), req); !r.OK {
-			t.Fatal("valid worker revoke denied", r)
-		}
-	}
-}

package/templates/_executor/cancel_contract_test.go

@@ -1,236 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-// stubbornMoveWriter keeps copying after its context ends until released, like
-// a slow write syscall, so the canceling window can be observed.
-type stubbornMoveWriter struct {
-	copying, release, published chan struct{}
-	publishing, finishPublish   chan struct{}
-	once                        sync.Once
-}
-
-func (w *stubbornMoveWriter) let() { w.once.Do(func() { close(w.release) }) }
-
-func newStubbornWriter() *stubbornMoveWriter {
-	return &stubbornMoveWriter{copying: make(chan struct{}), release: make(chan struct{}), published: make(chan struct{})}
-}
-func (w *stubbornMoveWriter) Write(context.Context, Subject, string, string, string, string) error {
-	return nil
-}
-func (w *stubbornMoveWriter) Move(_ context.Context, _ Subject, op Operation, d Delegation, guard func(func() (MoveReceipt, error)) (MoveReceipt, error)) (MoveReceipt, error) {
-	close(w.copying)
-	<-w.release
-	return guard(func() (MoveReceipt, error) {
-		if w.publishing != nil {
-			close(w.publishing)
-			<-w.finishPublish
-		}
-		close(w.published)
-		return MoveReceipt{Path: d.Path + "/" + op.Name}, nil
-	})
-}
-
-func operationOf(t *testing.T, r Response) map[string]any {
-	t.Helper()
-	if !r.OK {
-		t.Fatal(r)
-	}
-	b, _ := json.Marshal(r.Result)
-	out := map[string]any{}
-	json.Unmarshal(b, &out)
-	return out
-}
-func wantOperation(t *testing.T, r Response, state, code, reason string) {
-	t.Helper()
-	out := operationOf(t, r)
-	got, _ := out["code"].(string)
-	why, _ := out["reason"].(string)
-	if out["state"] != state || got != code || why != reason {
-		t.Fatalf("want %s/%s/%s, got %v", state, code, reason, out)
-	}
-}
-func startedCopy(t *testing.T, e *Executor, w *stubbornMoveWriter, id, job string) {
-	t.Helper()
-	if err := e.startOperations(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-	// Cleanups run in reverse: release the writer, then stop.
-	t.Cleanup(e.stopOperations)
-	t.Cleanup(w.let)
-	if r := offline(e, "files.moveFromStaging", moveParams(id, job)); !r.OK {
-		t.Fatal(r)
-	}
-	select {
-	case <-w.copying:
-	case <-time.After(2 * time.Second):
-		t.Fatal("copy did not start")
-	}
-}
-
-func TestCancelCopyingAcknowledgesDurablyUntilCanceled(t *testing.T) {
-	e, _, _ := setup(t)
-	id := longGrant(t, e)
-	w := newStubbornWriter()
-	e.Writer = w
-	startedCopy(t, e, w, id, "job")
-	ref := map[string]any{"delegation_id": id, "job_id": "job"}
-	for i := 0; i < 2; i++ {
-		// A repeated cancel after a lost reply returns the same acknowledgement.
-		wantOperation(t, offline(e, "files.cancelOperation", ref), "copying", "CANCEL_REQUESTED", "operation-canceled-by-user")
-	}
-	wantOperation(t, offline(e, "files.operationStatus", ref), "copying", "CANCEL_REQUESTED", "operation-canceled-by-user")
-	e.commitMu.Lock()
-	op, err := e.Store.GetOperation("job")
-	e.commitMu.Unlock()
-	if err != nil || op.CancelRequested != "operation-canceled-by-user" {
-		t.Fatal("cancel intent not durable", op, err)
-	}
-	w.let()
-	waitState(t, e, "job", "canceled")
-	select {
-	case <-w.published:
-		t.Fatal("published after cancel acknowledgement")
-	default:
-	}
-	wantOperation(t, offline(e, "files.cancelOperation", ref), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-	wantOperation(t, offline(e, "files.moveFromStaging", moveParams(id, "job")), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-}
-
-func TestCancelRequestedCopySettlesCanceledAcrossStopAndCrash(t *testing.T) {
-	t.Run("stop-while-canceling", func(t *testing.T) {
-		e, _, _ := setup(t)
-		id := longGrant(t, e)
-		w := newStubbornWriter()
-		e.Writer = w
-		startedCopy(t, e, w, id, "job")
-		ref := map[string]any{"delegation_id": id, "job_id": "job"}
-		wantOperation(t, offline(e, "files.cancelOperation", ref), "copying", "CANCEL_REQUESTED", "operation-canceled-by-user")
-		stopped := make(chan struct{})
-		go func() { e.stopOperations(); close(stopped) }()
-		w.let()
-		<-stopped
-		if err := e.startOperations(context.Background()); err != nil {
-			t.Fatal(err)
-		}
-		defer e.stopOperations()
-		wantOperation(t, offline(e, "files.operationStatus", ref), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-	})
-	for _, intent := range []bool{false, true} {
-		name := map[bool]string{false: "crash-before-publish", true: "crash-after-publish-intent"}[intent]
-		t.Run(name, func(t *testing.T) {
-			e, _, _ := setup(t)
-			id := longGrant(t, e)
-			op := Operation{Version: 1, Package: e.Policy.Package, ID: id, Job: "job", State: "copying", CancelRequested: "operation-canceled-by-user", PublishIntent: intent, Staging: "result", Name: "out.csv", Size: 123}
-			if e.Store.PutOperation(op) != nil {
-				t.Fatal("put")
-			}
-			w := newStubbornWriter()
-			e.Writer = w
-			if err := e.startOperations(context.Background()); err != nil {
-				t.Fatal(err)
-			}
-			defer e.stopOperations()
-			ref := map[string]any{"delegation_id": id, "job_id": "job"}
-			if intent {
-				// A publish that may have happened is never reported as canceled.
-				wantOperation(t, offline(e, "files.operationStatus", ref), "uncertain", "uncertain", "")
-				return
-			}
-			wantOperation(t, offline(e, "files.operationStatus", ref), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-		})
-	}
-}
-
-func TestCancelBeforeAdmissionLeavesTombstoneThatIsNeverAdmitted(t *testing.T) {
-	e, f, _ := setup(t)
-	id := longGrant(t, e)
-	w := newStubbornWriter()
-	e.Writer = w
-	if err := e.startOperations(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-	defer e.stopOperations()
-	ref := map[string]any{"delegation_id": id, "job_id": "job"}
-	if r := offline(e, "files.operationStatus", ref); r.Code != "operation-not-found" {
-		t.Fatal(r)
-	}
-	if r := offline(e, "files.cancelOperation", map[string]any{"delegation_id": strings.Repeat("f", 64), "job_id": "job"}); r.Code != "operation-not-found" {
-		t.Fatal("canceled under an unknown grant", r)
-	}
-	f.user.Username = "bob"
-	if r := request(e, "files.cancelOperation", ref); r.Code != "operation-not-found" {
-		t.Fatal("another owner canceled", r)
-	}
-	f.user.Username = "alice"
-	for i := 0; i < 2; i++ {
-		wantOperation(t, offline(e, "files.cancelOperation", ref), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-	}
-	// The original admission, arriving late or replayed, finds the tombstone.
-	for i := 0; i < 2; i++ {
-		wantOperation(t, offline(e, "files.moveFromStaging", moveParams(id, "job")), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-	}
-	wantOperation(t, offline(e, "files.operationStatus", ref), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-	other := map[string]any{"delegation_id": longGrant(t, e), "job_id": "job"}
-	if r := offline(e, "files.cancelOperation", other); r.Code != "operation-not-found" {
-		t.Fatal("tombstone answered another grant", r)
-	}
-	select {
-	case <-w.copying:
-		t.Fatal("canceled reference was copied")
-	case <-time.After(50 * time.Millisecond):
-	}
-}
-
-func TestCancelQueuedNeverCopies(t *testing.T) {
-	e, _, _ := setup(t)
-	id := longGrant(t, e)
-	w := newStubbornWriter()
-	e.Writer = w
-	startedCopy(t, e, w, id, "active")
-	if r := offline(e, "files.moveFromStaging", moveParams(id, "queued")); !r.OK {
-		t.Fatal(r)
-	}
-	ref := map[string]any{"delegation_id": id, "job_id": "queued"}
-	for i := 0; i < 2; i++ {
-		wantOperation(t, offline(e, "files.cancelOperation", ref), "canceled", "OPERATION_CANCELED", "operation-canceled-by-user")
-	}
-	w.let()
-	waitState(t, e, "active", "committed")
-	if op := waitState(t, e, "queued", "canceled"); op.Part != nil || op.PublishIntent {
-		t.Fatal("canceled queued operation copied", op)
-	}
-}
-
-func TestCancelRacingPublishReturnsCommitted(t *testing.T) {
-	e, _, _ := setup(t)
-	id := longGrant(t, e)
-	w := newStubbornWriter()
-	w.publishing, w.finishPublish = make(chan struct{}), make(chan struct{})
-	e.Writer = w
-	startedCopy(t, e, w, id, "job")
-	w.let()
-	<-w.publishing
-	reply := make(chan Response, 1)
-	go func() {
-		reply <- offline(e, "files.cancelOperation", map[string]any{"delegation_id": id, "job_id": "job"})
-	}()
-	select {
-	case r := <-reply:
-		t.Fatal("cancel answered inside the publish fence", r)
-	case <-time.After(50 * time.Millisecond):
-	}
-	close(w.finishPublish)
-	out := operationOf(t, <-reply)
-	if out["state"] != "committed" || out["receipt"] == nil || out["code"] != nil {
-		t.Fatal("cancel after publish must report committed", out)
-	}
-	waitState(t, e, "job", "committed")
-}

package/templates/_executor/cmd/lifecycle/main.go

@@ -1,42 +0,0 @@
-// This helper runs as the package account, separately from the root executor.
-package main
-
-import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
-	"time"
-
-	"synopkgland/executor/internal/lifecycle"
-)
-
-func main() {
-	if err := run(os.Args[1:]); err != nil {
-		fmt.Fprintln(os.Stderr, "executor lifecycle:", err)
-		os.Exit(1)
-	}
-}
-func run(args []string) error {
-	if len(args) == 0 {
-		return errors.New("start, stop or purge required")
-	}
-	action := args[0]
-	fs := flag.NewFlagSet("lifecycle", flag.ContinueOnError)
-	pkg := fs.String("package", "", "package account")
-	if err := fs.Parse(args[1:]); err != nil {
-		return err
-	}
-	if fs.NArg() != 0 {
-		return errors.New("unexpected arguments")
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Second)
-	defer cancel()
-	data := os.Getenv("SYNOPKG_PKGVAR")
-	if data == "" {
-		data = filepath.Join("/var/packages", *pkg, "var")
-	}
-	return lifecycle.Run(ctx, lifecycle.Config{Package: *pkg, Data: data, Socket: filepath.Join("/run/synopkgland", *pkg, "executor.sock"), Log: func(s string) { fmt.Fprintln(os.Stderr, s) }}, action)
-}

package/templates/_executor/cookie_review_test.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"context"
-	"testing"
-)
-
-func TestReviewCookieControlRejectedBeforeDSM(t *testing.T) {
-	for _, cookie := range []string{"sess\tion", "sess\x7fion", "sess\x01ion"} {
-		e, _, _ := setup(t)
-		if _, code := e.verified(context.Background(), Auth{Cookie: cookie, SynoToken: "token"}); code == "" {
-			t.Errorf("cookie control character accepted: %q", cookie)
-		}
-	}
-}
-
-func TestExecutorCookieRejectsEveryASCIIControl(t *testing.T) {
-	for c := 0; c <= 127; c++ {
-		if c >= 32 && c != 127 {
-			continue
-		}
-		e, _, _ := setup(t)
-		if _, code := e.verified(context.Background(), Auth{Cookie: "sess" + string(rune(c)) + "ion", SynoToken: "token"}); code != "AUTH_DENIED" {
-			t.Errorf("accepted control %d", c)
-		}
-	}
-}

package/templates/_executor/copy.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"errors"
-	"io"
-)
-
-// errParentGone means the move parent closed or broke the control pipe during
-// the copy: it exited or was killed, so no one can ever send publish.
-var errParentGone = errors.New("parent gone")
-
-type controlLine struct {
-	line string
-	err  error
-}
-
-// awaitControl reads the parent's next decision in the background. Pipe EOF
-// is the parent-death signal on every kernel, including 3.10, and unlike
-// PR_SET_PDEATHSIG it survives the child's identity drop and Go's threads.
-func awaitControl(r *bufio.Reader) <-chan controlLine {
-	next := make(chan controlLine, 1)
-	go func() {
-		line, err := r.ReadString('\n')
-		next <- controlLine{line, err}
-	}()
-	return next
-}
-
-// copyUnlessParentGone copies exactly size bytes, checking control between
-// chunks. The parent writes nothing during a copy, so any arrival ends it.
-func copyUnlessParentGone(out io.Writer, src io.Reader, size int64, control <-chan controlLine) error {
-	limited := io.LimitReader(src, size+1)
-	buf := make([]byte, 1<<20)
-	var n int64
-	for {
-		select {
-		case <-control:
-			return errParentGone
-		default:
-		}
-		m, err := limited.Read(buf)
-		if m > 0 {
-			if _, werr := out.Write(buf[:m]); werr != nil {
-				return werr
-			}
-			n += int64(m)
-		}
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-	}
-	if n != size {
-		return errors.New("size mismatch")
-	}
-	return nil
-}
-
-func copyExact(out io.Writer, src io.Reader, size int64) error {
-	return copyUnlessParentGone(out, src, size, nil)
-}

package/templates/_executor/copy_test.go

@@ -1,88 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"io"
-	"os"
-	"testing"
-	"time"
-)
-
-type endlessZeros struct{ read int64 }
-
-func (z *endlessZeros) Read(p []byte) (int, error) {
-	clear(p)
-	z.read += int64(len(p))
-	return len(p), nil
-}
-
-// The move parent holds the child's control pipe open for the whole copy. If
-// the parent dies, the pipe closes and the child must stop copying at once
-// rather than fill a part file nobody can publish.
-func TestCopyStopsWhenParentClosesControl(t *testing.T) {
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-	control := awaitControl(bufio.NewReader(r))
-	src := &endlessZeros{}
-	done := make(chan error, 1)
-	go func() { done <- copyUnlessParentGone(io.Discard, src, 1<<50, control) }()
-	time.Sleep(50 * time.Millisecond)
-	w.Close()
-	select {
-	case err := <-done:
-		if !errors.Is(err, errParentGone) {
-			t.Fatal("want errParentGone, got", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("copy continued after the parent closed control")
-	}
-}
-
-// The parent never writes during the copy; anything arriving there is a
-// protocol violation and stops the copy too.
-func TestCopyStopsOnUnexpectedControlInput(t *testing.T) {
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-	defer w.Close()
-	control := awaitControl(bufio.NewReader(r))
-	done := make(chan error, 1)
-	go func() { done <- copyUnlessParentGone(io.Discard, &endlessZeros{}, 1<<50, control) }()
-	w.Write([]byte("P\n"))
-	select {
-	case err := <-done:
-		if err == nil {
-			t.Fatal("copy accepted early control input")
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("copy ignored control input")
-	}
-}
-
-func TestCopyKeepsExactSizeAndLeavesDecisionForCaller(t *testing.T) {
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer r.Close()
-	control := awaitControl(bufio.NewReader(r))
-	var out bytes.Buffer
-	if err = copyUnlessParentGone(&out, bytes.NewReader(make([]byte, 3<<20)), 3<<20, control); err != nil || out.Len() != 3<<20 {
-		t.Fatal(out.Len(), err)
-	}
-	if copyUnlessParentGone(io.Discard, bytes.NewReader(make([]byte, 4)), 3, control) == nil {
-		t.Fatal("excess bytes accepted")
-	}
-	w.Write([]byte("P\n"))
-	if got := <-control; got.line != "P\n" || got.err != nil {
-		t.Fatal("decision lost", got)
-	}
-	w.Close()
-}

package/templates/_executor/digest_review_test.go

@@ -1,120 +0,0 @@
-package main
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestReviewLargePackageHashDoesNotBlockShutdown(t *testing.T) {
-	dir, err := filepath.EvalSymlinks(t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	exe := filepath.Join(dir, "executor")
-	f, err := os.Create(exe)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err = f.Truncate(1 << 40); err != nil {
-		f.Close()
-		t.Skip(err)
-	}
-	f.Close()
-	os.WriteFile(filepath.Join(dir, "policy.json"), []byte("policy"), 0600)
-	ctx, cancel := context.WithCancel(context.Background())
-	entered := make(chan struct{})
-	done := make(chan error, 1)
-	go func() {
-		done <- manageService(ctx, make(chan string), func() (func(), error) { return func() {}, nil }, func(ctx context.Context) bool {
-			close(entered)
-			return samePackagePins(ctx, dir, strings.Repeat("a", 64), strings.Repeat("b", 64))
-		}, func() error { return nil })
-	}()
-	<-entered
-	time.Sleep(20 * time.Millisecond)
-	cancel()
-	blocked := false
-	select {
-	case <-done:
-	case <-time.After(50 * time.Millisecond):
-		blocked = true
-	}
-	os.Truncate(exe, 0)
-	if blocked {
-		<-done
-		t.Fatal("canceled monitor remains blocked hashing package-controlled file")
-	}
-}
-
-func TestDigestBoundsAndCancellation(t *testing.T) {
-	dir := realTestPath(t, t.TempDir())
-	for _, tc := range []struct {
-		name  string
-		limit int64
-	}{{"executor", maxExecutorBytes}, {"policy.json", maxPolicyBytes}} {
-		path := filepath.Join(dir, tc.name)
-		f, err := os.Create(path)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err = f.Truncate(tc.limit + 1); err != nil {
-			t.Fatal(err)
-		}
-		f.Close()
-		if _, err = digestFile(context.Background(), path, tc.limit); err == nil {
-			t.Fatal("oversize file accepted")
-		}
-		os.WriteFile(path, []byte("valid"), 0600)
-		ctx, cancel := context.WithCancel(context.Background())
-		cancel()
-		if _, err = digestFile(ctx, path, tc.limit); err != context.Canceled {
-			t.Fatal("ignored cancellation", err)
-		}
-	}
-	if _, err := digestFile(context.Background(), dir, maxExecutorBytes); err == nil {
-		t.Fatal("directory accepted")
-	}
-	os.Symlink(filepath.Join(dir, "executor"), filepath.Join(dir, "link"))
-	if _, err := digestFile(context.Background(), filepath.Join(dir, "link"), maxExecutorBytes); err == nil {
-		t.Fatal("symlink accepted")
-	}
-}
-
-func TestLifecycleCancelsPendingPinCheck(t *testing.T) {
-	for _, action := range []string{"stop", "purge", "shutdown"} {
-		t.Run(action, func(t *testing.T) {
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
-			entered, canceled := make(chan struct{}), make(chan struct{})
-			actions := make(chan string)
-			done := make(chan error, 1)
-			go func() {
-				done <- manageService(ctx, actions, func() (func(), error) { t.Error("opened during canceled check"); return func() {}, nil }, func(ctx context.Context) bool { close(entered); <-ctx.Done(); close(canceled); return false }, func() error { return nil })
-			}()
-			<-entered
-			if action == "shutdown" {
-				cancel()
-			} else {
-				actions <- action
-			}
-			select {
-			case <-canceled:
-			case <-time.After(time.Second):
-				t.Fatal("pin check not canceled")
-			}
-			cancel()
-			select {
-			case err := <-done:
-				if err != nil {
-					t.Fatal(err)
-				}
-			case <-time.After(time.Second):
-				t.Fatal("monitor stuck")
-			}
-		})
-	}
-}

package/templates/_executor/directories.go

@@ -1,40 +0,0 @@
-package main
-
-import (
-	"errors"
-	"os"
-	"syscall"
-)
-
-func directoryMatches(info os.FileInfo, mode os.FileMode, uid, gid int) bool {
-	st, ok := info.Sys().(*syscall.Stat_t)
-	return ok && info.IsDir() && info.Mode().Perm() == mode && int(st.Uid) == uid && int(st.Gid) == gid
-}
-
-// Only repair permissions on a directory this invocation created. mkdir's
-// requested mode is reduced by the inherited boot-task umask (normally 0077).
-func createDirectory(path string, mode os.FileMode, uid, gid int) (os.FileInfo, error) {
-	if err := os.Mkdir(path, mode); err != nil {
-		return nil, err
-	}
-	fd, err := syscall.Open(path, syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_NOFOLLOW|syscall.O_CLOEXEC, 0)
-	if err != nil {
-		return nil, err
-	}
-	f := os.NewFile(uintptr(fd), path)
-	defer f.Close()
-	if err = f.Chown(uid, gid); err != nil {
-		return nil, err
-	}
-	if err = f.Chmod(mode); err != nil {
-		return nil, err
-	}
-	info, err := f.Stat()
-	if err != nil {
-		return nil, err
-	}
-	if !directoryMatches(info, mode, uid, gid) {
-		return nil, errors.New("created directory permissions")
-	}
-	return info, nil
-}