@synopackageland/cli 0.8.0 → 0.9.0

package/templates/native-go-delegate/backend/internal/delegate/admission_recovery_test.go

@@ -1,410 +0,0 @@
-package delegate
-
-import (
-	"context"
-	"dsmapp/internal/background"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"sync"
-	"testing"
-	"time"
-)
-
-// dedupExecutor models the protected receiver: one operation per job, and an
-// exact repeated admission returns that operation instead of writing again.
-type dedupExecutor struct {
-	mu      sync.Mutex
-	ops     map[string]OperationResult
-	params  map[string]MoveParams
-	moves   int
-	created int
-	cancels int
-	// admit runs outside the lock before validation completes. It returns
-	// whether the operation is created and the reply the caller observes.
-	admit func(context.Context, MoveParams) (bool, error)
-}
-
-func newDedupExecutor() *dedupExecutor {
-	return &dedupExecutor{ops: map[string]OperationResult{}, params: map[string]MoveParams{}}
-}
-
-func (e *dedupExecutor) Call(ctx context.Context, op string, _ map[string]string, in, out any) error {
-	if ctx.Err() != nil {
-		return fail("canceled")
-	}
-	switch op {
-	case "files.moveFromStaging":
-		p := in.(MoveParams)
-		e.mu.Lock()
-		e.moves++
-		old, ok := e.ops[p.JobID]
-		original, admit := e.params[p.JobID], e.admit
-		e.mu.Unlock()
-		if ok {
-			if old.State == "canceled" && original == (MoveParams{}) {
-				return encodeOperation(old, out) // canceled before admission
-			}
-			if original != p {
-				return fail("operation-conflict")
-			}
-			return encodeOperation(old, out)
-		}
-		create, reply := true, error(nil)
-		if admit != nil {
-			create, reply = admit(ctx, p)
-		}
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		result, ok := e.ops[p.JobID]
-		if create && !ok {
-			result = OperationResult{JobID: p.JobID, State: "queued"}
-			e.ops[p.JobID], e.params[p.JobID] = result, p
-			e.created++
-		}
-		if reply != nil {
-			return reply
-		}
-		return encodeOperation(result, out)
-	case "files.operationStatus":
-		ref := in.(OperationRef)
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		result, ok := e.ops[ref.JobID]
-		if !ok {
-			return fail("operation-not-found")
-		}
-		return encodeOperation(result, out)
-	case "files.cancelOperation":
-		ref := in.(OperationRef)
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		e.cancels++
-		result, ok := e.ops[ref.JobID]
-		switch {
-		case !ok:
-			result = OperationResult{JobID: ref.JobID, State: "canceled", Code: "OPERATION_CANCELED", Reason: "operation-canceled-by-user"}
-		case result.State == "queued":
-			result.State, result.Code, result.Reason = "canceled", "OPERATION_CANCELED", "operation-canceled-by-user"
-		}
-		e.ops[ref.JobID] = result
-		return encodeOperation(result, out)
-	}
-	return fail("unsupported")
-}
-
-func (e *dedupExecutor) counts() (int, int) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	return e.moves, e.created
-}
-
-func encodeOperation(result OperationResult, out any) error {
-	data, _ := json.Marshal(result)
-	return json.Unmarshal(data, out)
-}
-
-type testClock struct{ at time.Time }
-
-func (c *testClock) now() time.Time { return c.at }
-
-func recoveringService(t *testing.T) (*Service, MoveParams, *dedupExecutor, *testClock) {
-	t.Helper()
-	s, in := stagedService(t)
-	e := newDedupExecutor()
-	clock := &testClock{at: time.Unix(1_800_000_000, 0)}
-	s.Client, s.now = e, clock.now
-	return s, in, e, clock
-}
-
-// restarted models a new process over the same durable mirror directory.
-func restarted(s *Service, client ExecutorClient, clock *testClock) *Service {
-	return &Service{Client: client, Store: background.NewStore(filepath.Dir(s.StagingDir) + "/background"), StagingDir: s.StagingDir, Lifetime: s.Lifetime, Operations: s.Operations, now: clock.now}
-}
-
-// reserveWithoutSending leaves the durable mirror a crash before transport
-// would leave: reserved with the original params and pinned source.
-func reserveWithoutSending(t *testing.T, s *Service, in MoveParams) {
-	t.Helper()
-	source, err := pinSource(s.StagingDir, in.Staging, in.Size)
-	if err != nil {
-		t.Fatal(err)
-	}
-	params, _ := json.Marshal(in)
-	if _, fresh, err := s.Store.ReserveMove(context.Background(), background.MoveBinding{JobID: in.JobID, DelegationID: in.DelegationID, Params: params, Source: source, Phase: background.MoveReserved}); err != nil || !fresh {
-		t.Fatal(fresh, err)
-	}
-}
-
-func TestUnconnectedAdmissionIsSentByTheNextSameRefCall(t *testing.T) {
-	s, in, e, _ := recoveringService(t)
-	dir, err := os.MkdirTemp("/tmp", "t0203-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	s.Client = &Client{Socket: filepath.Join(dir, "absent.sock"), Timeout: time.Second}
-	_, err = s.MoveFromStaging(context.Background(), in)
-	code(t, err, "EXECUTOR_UNAVAILABLE")
-	s.Client = e
-	for i := 0; i < 3; i++ {
-		out, err := s.MoveFromStaging(context.Background(), in)
-		if err != nil || out.JobID != in.JobID || out.State != "queued" {
-			t.Fatal(i, out, err)
-		}
-	}
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal("admission not recovered exactly once", moves, created)
-	}
-}
-
-func TestCrashBeforeTransportIsAdmittedAfterRestart(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	reserveWithoutSending(t, s, in)
-	out, err := restarted(s, e, clock).MoveFromStaging(context.Background(), in)
-	if err != nil || out.State != "queued" {
-		t.Fatal(out, err)
-	}
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal(moves, created)
-	}
-}
-
-func TestCrashDuringTransportResendsOnlyAfterBackoff(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	s.Client = fakeExecutor(func(_ context.Context, op string, _ map[string]string, _, _ any) error {
-		panic("injected process exit inside transport")
-	})
-	func() {
-		defer func() {
-			if recover() == nil {
-				t.Fatal("missing crash injection")
-			}
-		}()
-		_, _ = s.MoveFromStaging(context.Background(), in)
-	}()
-	next := restarted(s, e, clock)
-	_, err := next.MoveFromStaging(context.Background(), in)
-	code(t, err, "ADMISSION_PENDING")
-	if moves, _ := e.counts(); moves != 0 {
-		t.Fatal("resent before backoff", moves)
-	}
-	clock.at = clock.at.Add(admissionBackoff(1))
-	if out, err := next.MoveFromStaging(context.Background(), in); err != nil || out.State != "queued" {
-		t.Fatal(out, err)
-	}
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal(moves, created)
-	}
-}
-
-func TestAdmissionAbortedDuringValidation(t *testing.T) {
-	for _, admitted := range []bool{true, false} {
-		t.Run(map[bool]string{true: "executor-admitted-after-caller-timeout", false: "never-admitted"}[admitted], func(t *testing.T) {
-			s, in, e, clock := recoveringService(t)
-			// The caller's own deadline ends while the executor is validating.
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
-			e.admit = func(ctx context.Context, _ MoveParams) (bool, error) {
-				cancel()
-				<-ctx.Done()
-				return admitted, fail("EXECUTOR_TIMEOUT")
-			}
-			_, err := s.MoveFromStaging(ctx, in)
-			if err == nil {
-				t.Fatal("aborted admission reported success")
-			}
-			e.admit = nil
-			clock.at = clock.at.Add(admissionBackoff(1))
-			out, err := s.MoveFromStaging(context.Background(), in)
-			if err != nil || out.State != "queued" {
-				t.Fatal(out, err)
-			}
-			moves, created := e.counts()
-			if created != 1 || (admitted && moves != 1) || (!admitted && moves != 2) {
-				t.Fatal(moves, created)
-			}
-		})
-	}
-}
-
-func TestLostAdmissionResponseFindsTheOriginalOperation(t *testing.T) {
-	s, in, e, _ := recoveringService(t)
-	e.admit = func(context.Context, MoveParams) (bool, error) { return true, fail("EXECUTOR_PROTOCOL") }
-	out, err := s.MoveFromStaging(context.Background(), in)
-	if err != nil || out.State != "queued" {
-		t.Fatal(out, err)
-	}
-	e.admit = nil
-	for i := 0; i < 2; i++ {
-		if out, err = s.MoveFromStaging(context.Background(), in); err != nil || out.State != "queued" {
-			t.Fatal(out, err)
-		}
-	}
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal(moves, created)
-	}
-	binding, err := s.Store.MoveBinding(context.Background(), in.JobID)
-	if err != nil || binding.Phase != background.MoveAccepted {
-		t.Fatal("found operation not recorded as accepted", binding, err)
-	}
-}
-
-func TestCompetingRecoveryCallsSendOneAdmission(t *testing.T) {
-	s, in, e, _ := recoveringService(t)
-	reserveWithoutSending(t, s, in)
-	var wg sync.WaitGroup
-	for i := 0; i < 8; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			_, err := s.MoveFromStaging(context.Background(), in)
-			if err != nil && errorCode(err) != "ADMISSION_PENDING" {
-				t.Error(err)
-			}
-		}()
-	}
-	wg.Wait()
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal(moves, created)
-	}
-}
-
-func TestCommittedOperationIsNeverAdmittedAgain(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	e.ops[in.JobID] = OperationResult{JobID: in.JobID, State: "committed", Receipt: &Receipt{Path: "/home/a", Size: 3}}
-	e.params[in.JobID] = in
-	reserveWithoutSending(t, s, in)
-	// A sent-phase mirror queries first; the committed original is returned.
-	sent := restarted(s, e, clock)
-	if _, _, err := sent.Store.ClaimAdmission(context.Background(), in.JobID, clock.now(), maxMoveAdmissions, admissionBackoff); err != nil {
-		t.Fatal(err)
-	}
-	out, err := sent.MoveFromStaging(context.Background(), in)
-	if err != nil || out.State != "committed" {
-		t.Fatal(out, err)
-	}
-	if _, err = os.Stat(filepath.Join(s.StagingDir, in.Staging)); !os.IsNotExist(err) {
-		t.Fatal("committed source not cleaned", err)
-	}
-	// Even if executor history were lost, a cleaned committed mirror is final.
-	delete(e.ops, in.JobID)
-	clock.at = clock.at.Add(time.Hour)
-	_, err = sent.MoveFromStaging(context.Background(), in)
-	code(t, err, "operation-not-found")
-	if moves, _ := e.counts(); moves != 0 {
-		t.Fatal("committed operation admitted again", moves)
-	}
-}
-
-func TestAcceptedOperationMissingIsNotReadmitted(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	if _, err := s.MoveFromStaging(context.Background(), in); err != nil {
-		t.Fatal(err)
-	}
-	delete(e.ops, in.JobID)
-	clock.at = clock.at.Add(time.Hour)
-	_, err := s.MoveFromStaging(context.Background(), in)
-	code(t, err, "operation-not-found")
-	if moves, _ := e.counts(); moves != 1 {
-		t.Fatal("accepted operation admitted again", moves)
-	}
-}
-
-func TestTerminalRefusalsAreNeverRevived(t *testing.T) {
-	for _, refusal := range []string{"APP_DENIED", "DELEGATION_DENIED", "operation-conflict", "disabled", "SCOPE_DENIED"} {
-		t.Run(refusal, func(t *testing.T) {
-			s, in, e, clock := recoveringService(t)
-			reserveWithoutSending(t, s, in)
-			e.admit = func(context.Context, MoveParams) (bool, error) { return false, fail(refusal) }
-			_, err := s.MoveFromStaging(context.Background(), in)
-			code(t, err, refusal)
-			e.admit = nil
-			clock.at = clock.at.Add(time.Hour)
-			for i := 0; i < 2; i++ {
-				_, err = restarted(s, e, clock).MoveFromStaging(context.Background(), in)
-				code(t, err, refusal)
-			}
-			if moves, created := e.counts(); moves != 1 || created != 0 {
-				t.Fatal(moves, created)
-			}
-		})
-	}
-}
-
-func TestTransientRefusalsKeepTheReferenceRecoverable(t *testing.T) {
-	for _, refusal := range []string{"EXECUTOR_PAUSED", "queue-full"} {
-		t.Run(refusal, func(t *testing.T) {
-			s, in, e, clock := recoveringService(t)
-			e.admit = func(context.Context, MoveParams) (bool, error) { return false, fail(refusal) }
-			for i := 0; i < maxMoveAdmissions+2; i++ {
-				_, err := s.MoveFromStaging(context.Background(), in)
-				code(t, err, refusal)
-				clock.at = clock.at.Add(maxAdmissionBackoff)
-			}
-			e.admit = nil
-			if out, err := s.MoveFromStaging(context.Background(), in); err != nil || out.State != "queued" {
-				t.Fatal("proven refusal spent the resend bound", out, err)
-			}
-			if _, created := e.counts(); created != 1 {
-				t.Fatal(created)
-			}
-		})
-	}
-}
-
-func TestAmbiguousResendsAreBoundedWithBackoff(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	e.admit = func(context.Context, MoveParams) (bool, error) { return false, fail("EXECUTOR_TIMEOUT") }
-	for attempt := 1; attempt <= maxMoveAdmissions; attempt++ {
-		_, err := s.MoveFromStaging(context.Background(), in)
-		code(t, err, "ADMISSION_PENDING")
-		if moves, _ := e.counts(); moves != attempt {
-			t.Fatal("attempt", attempt, moves)
-		}
-		clock.at = clock.at.Add(admissionBackoff(attempt) - time.Nanosecond)
-		_, err = s.MoveFromStaging(context.Background(), in)
-		if attempt < maxMoveAdmissions {
-			code(t, err, "ADMISSION_PENDING")
-		} else {
-			code(t, err, "ADMISSION_EXHAUSTED")
-		}
-		if moves, _ := e.counts(); moves != attempt {
-			t.Fatal("resent inside backoff", attempt, moves)
-		}
-		clock.at = clock.at.Add(time.Nanosecond)
-	}
-	clock.at = clock.at.Add(24 * time.Hour)
-	_, err := s.MoveFromStaging(context.Background(), in)
-	code(t, err, "ADMISSION_EXHAUSTED")
-	if moves, _ := e.counts(); moves != maxMoveAdmissions {
-		t.Fatal(moves)
-	}
-	if admissionBackoff(maxMoveAdmissions) != maxAdmissionBackoff || admissionBackoff(1) != 2*time.Second {
-		t.Fatal(admissionBackoff(1), admissionBackoff(maxMoveAdmissions))
-	}
-}
-
-func TestReplacedSourceIsNeverResent(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	reserveWithoutSending(t, s, in)
-	source := filepath.Join(s.StagingDir, in.Staging)
-	os.Rename(source, source+".old")
-	os.WriteFile(source, []byte("new"), 0600)
-	_, err := restarted(s, e, clock).MoveFromStaging(context.Background(), in)
-	code(t, err, "STAGING_CHANGED")
-	if moves, _ := e.counts(); moves != 0 {
-		t.Fatal("replaced source admitted", moves)
-	}
-}
-
-func TestSweepAdmitsAnUnsentReservedMove(t *testing.T) {
-	s, in, e, _ := recoveringService(t)
-	reserveWithoutSending(t, s, in)
-	if err := s.SweepMoves(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal(moves, created)
-	}
-}

package/templates/native-go-delegate/backend/internal/delegate/busy_review_test.go

@@ -1,15 +0,0 @@
-package delegate
-
-import (
-	"dsmapp/internal/api"
-	"dsmapp/internal/background"
-	"errors"
-	"testing"
-)
-
-func TestReviewBusyJournalHasRetryableStableCode(t *testing.T) {
-	var out *api.Error
-	if !errors.As(jobError(background.ErrBusy), &out) || out.Code != "jobs_busy" {
-		t.Fatalf("bounded lock timeout mapped to generic error: %+v", out)
-	}
-}

package/templates/native-go-delegate/backend/internal/delegate/cancel_contract_test.go

@@ -1,95 +0,0 @@
-package delegate
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func wantCanceled(t *testing.T, out OperationResult, err error) {
-	t.Helper()
-	if err != nil || out.State != "canceled" || out.Code != "OPERATION_CANCELED" || out.Reason != "operation-canceled-by-user" {
-		t.Fatal("want canceled", out, err)
-	}
-}
-
-// A cancel of a reference that was reserved but never admitted must stop the
-// SDK's own admission recovery from sending it later.
-func TestCancelOfUnadmittedReferenceIsNeverSentByRecovery(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	reserveWithoutSending(t, s, in)
-	ref := OperationRef{in.DelegationID, in.JobID}
-	out, err := s.CancelOperation(context.Background(), nil, ref)
-	wantCanceled(t, out, err)
-	clock.at = clock.at.Add(time.Hour)
-	for i := 0; i < 2; i++ {
-		out, err := s.MoveFromStaging(context.Background(), in)
-		if err != nil || out.State != "canceled" {
-			t.Fatal("same-ref call after cancel", out, err)
-		}
-		if err = restarted(s, e, clock).SweepMoves(context.Background()); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if moves, created := e.counts(); moves != 0 || created != 0 {
-		t.Fatal("canceled reference was admitted", moves, created)
-	}
-	if _, err = os.Stat(filepath.Join(s.StagingDir, in.Staging)); err != nil {
-		t.Fatal("canceled source removed", err)
-	}
-}
-
-// The intent survives an executor that cannot be reached at cancel time: the
-// package's next same-ref call or sweep forwards the cancel, never admission.
-func TestCancelIntentSurvivesUnavailableExecutorAndRestart(t *testing.T) {
-	s, in, e, clock := recoveringService(t)
-	reserveWithoutSending(t, s, in)
-	dir, err := os.MkdirTemp("/tmp", "t0205-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	s.Client = &Client{Socket: filepath.Join(dir, "absent.sock"), Timeout: time.Second}
-	_, err = s.CancelOperation(context.Background(), nil, OperationRef{in.DelegationID, in.JobID})
-	code(t, err, "EXECUTOR_UNAVAILABLE")
-	next := restarted(s, e, clock)
-	if err = next.SweepMoves(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-	if moves, created := e.counts(); moves != 0 || created != 0 || e.cancels != 1 {
-		t.Fatal("sweep admitted a canceled reference", moves, created, e.cancels)
-	}
-	if out, err := next.MoveFromStaging(context.Background(), in); err != nil || out.State != "canceled" {
-		t.Fatal(out, err)
-	}
-	if pending, err := next.Store.PendingMoves(context.Background()); err != nil || len(pending) != 0 {
-		t.Fatal("canceled mirror still swept", pending, err)
-	}
-}
-
-// A cancel whose reply was lost is repeated with the same reference.
-func TestRepeatedCancelAfterLostReplyIsIdempotent(t *testing.T) {
-	s, in, e, _ := recoveringService(t)
-	if _, err := s.MoveFromStaging(context.Background(), in); err != nil {
-		t.Fatal(err)
-	}
-	ref := OperationRef{in.DelegationID, in.JobID}
-	s.Client = fakeExecutor(func(ctx context.Context, op string, auth map[string]string, p, out any) error {
-		if err := e.Call(ctx, op, auth, p, out); err != nil || op != "files.cancelOperation" {
-			return err
-		}
-		return fail("EXECUTOR_TIMEOUT")
-	})
-	_, err := s.CancelOperation(context.Background(), nil, ref)
-	code(t, err, "EXECUTOR_TIMEOUT")
-	s.Client = e
-	for i := 0; i < 2; i++ {
-		out, err := s.CancelOperation(context.Background(), nil, ref)
-		wantCanceled(t, out, err)
-	}
-	if moves, created := e.counts(); moves != 1 || created != 1 {
-		t.Fatal(moves, created)
-	}
-}

package/templates/native-go-delegate/backend/internal/delegate/client.go

@@ -1,151 +0,0 @@
-// Package delegate provides the fixed v1 executor protocol. Credentials exist
-// only in a live request; workers carry a delegation and job binding instead.
-package delegate
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"dsmapp/internal/api"
-	"encoding/json"
-	"errors"
-	"io"
-	"net"
-	"regexp"
-	"time"
-	"unicode/utf8"
-)
-
-const MaxFrame = 64 * 1024
-
-var stableCode = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_-]{0,127}$`)
-
-type Request struct {
-	V      int               `json:"v"`
-	Op     string            `json:"op"`
-	Auth   map[string]string `json:"auth,omitempty"`
-	Params json.RawMessage   `json:"params"`
-}
-type Client struct {
-	Socket  string
-	Timeout time.Duration
-}
-
-// ExecutorClient keeps the session/staging bridge independent of transport.
-// The production client still uses the existing bounded v1 Unix socket.
-type ExecutorClient interface {
-	Call(context.Context, string, map[string]string, any, any) error
-}
-
-var _ ExecutorClient = (*Client)(nil)
-
-func Local(packageID string) *Client {
-	return &Client{Socket: "/run/synopkgland/" + packageID + "/executor.sock", Timeout: 20 * time.Second}
-}
-func fail(code string) error {
-	return &api.Error{Code: code, Message: "Executor operation refused (" + code + ")"}
-}
-
-// dialFailure means no connection was established and no request bytes were
-// sent. Unwrap preserves the public API code without exposing socket details.
-type dialFailure struct{ error }
-
-func (e *dialFailure) Unwrap() error { return e.error }
-
-// Call uses one connection per request, including its newline in the size
-// budget. Refusal codes survive unchanged; executor messages never expose
-// cookie values or internal paths through the CGI response.
-func (c *Client) Call(parent context.Context, op string, auth map[string]string, params any, result any) error {
-	if parent.Err() != nil {
-		return fail("canceled")
-	}
-	if c == nil || c.Socket == "" {
-		return fail("EXECUTOR_UNAVAILABLE")
-	}
-	p, e := json.Marshal(params)
-	if e != nil {
-		return fail("invalid-request")
-	}
-	if params == nil {
-		p = []byte("{}")
-	}
-	b, e := json.Marshal(Request{V: 1, Op: op, Auth: auth, Params: p})
-	if e != nil {
-		return fail("invalid-request")
-	}
-	b = append(b, '\n')
-	if len(b) > MaxFrame {
-		return fail("EXECUTOR_TOO_LARGE")
-	}
-	timeout := c.Timeout
-	if timeout <= 0 {
-		timeout = 20 * time.Second
-	}
-	ctx, cancel := context.WithTimeout(parent, timeout)
-	defer cancel()
-	transport := func(err error) error {
-		if parent.Err() != nil {
-			return fail("canceled")
-		}
-		if ctx.Err() != nil {
-			return fail("EXECUTOR_TIMEOUT")
-		}
-		var ne net.Error
-		if errors.As(err, &ne) && ne.Timeout() {
-			return fail("EXECUTOR_TIMEOUT")
-		}
-		return fail("EXECUTOR_UNAVAILABLE")
-	}
-	conn, e := (&net.Dialer{}).DialContext(ctx, "unix", c.Socket)
-	if e != nil {
-		if parent.Err() != nil {
-			return fail("canceled")
-		}
-		return &dialFailure{transport(e)}
-	}
-	defer conn.Close()
-	stop := context.AfterFunc(ctx, func() { conn.Close() })
-	defer stop()
-	deadline, _ := ctx.Deadline()
-	if e = conn.SetDeadline(deadline); e != nil {
-		return transport(e)
-	}
-	if _, e = io.Copy(conn, bytes.NewReader(b)); e != nil {
-		return transport(e)
-	}
-	line, e := bufio.NewReader(io.LimitReader(conn, MaxFrame+1)).ReadBytes('\n')
-	if len(line) > MaxFrame {
-		return fail("EXECUTOR_TOO_LARGE")
-	}
-	if e != nil {
-		if !errors.Is(e, io.EOF) {
-			return transport(e)
-		}
-		return fail("EXECUTOR_PROTOCOL")
-	}
-	if !utf8.Valid(line) {
-		return fail("EXECUTOR_PROTOCOL")
-	}
-	var reply struct {
-		OK      *bool           `json:"ok"`
-		Result  json.RawMessage `json:"result"`
-		Code    string          `json:"code"`
-		Message string          `json:"message"`
-	}
-	if json.Unmarshal(line, &reply) != nil || reply.OK == nil {
-		return fail("EXECUTOR_PROTOCOL")
-	}
-	if !*reply.OK {
-		if !stableCode.MatchString(reply.Code) {
-			return fail("EXECUTOR_PROTOCOL")
-		}
-		return fail(reply.Code)
-	}
-	if len(reply.Result) == 0 || string(reply.Result) == "null" || reply.Result[0] != '{' {
-		return fail("EXECUTOR_PROTOCOL")
-	}
-	if result != nil && json.Unmarshal(reply.Result, result) != nil {
-		return fail("EXECUTOR_PROTOCOL")
-	}
-	return nil
-}