* fix(create): let a remote backend mint the --parent child id
`bd create --parent` always called the raw GetNextChildID first, which the
http backend does not serve, so every child create on a remote workspace
refused before writing anything. The Lifecycle role already mints
<parent>.<n> for a create that carries a ParentID and no id of its own, on
every backend and inside the create's own transaction; conformance
RunIssueOperationsCreateUnderAParentMintsTheNextChildID pins it on every leg,
the served one included (and the bd-enterprise postgres leg the MC server
runs). So the create route needs no new capability token: on a registered
Remote backend the client skips the raw reservation and lets the server mint.
The local route keeps its reservation so its Dolt commit staging is
unchanged, and an explicit --id beside --parent is still refused up front.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(mol): molecule reads, auto-close and close --continue over issueops roles
Over the http backend three molecule paths failed, and two of them
silently:
- `bd mol current` / `bd mol progress` without an id answered "no molecules"
because the in_progress listing (a raw SearchIssues shape) and the parent
walk (raw GetDependencyRecordsForIssues) were refused and the refusal was
swallowed; with an id they refused on raw GetMoleculeProgress.
- The molecule auto-close after `bd close` never ran: findParentMolecules
swallowed the same refused edge read into "not part of a molecule".
- `bd close --continue` claimed the next step in a raw RunInTransaction.
The direct route now reads molecules through roleMolStore, which answers
through roles every backend serves: EdgeReader (batched at the wire's 100
anchors) for the parent walk, BatchGetter for the roots (Get per id where a
server does not publish issues.batchGet), Relations for the step rows (full
rows; the raw dependents read over http is getIssue's shallow projection,
which zeroed step assignees) and the progress counts, and Reader.List for the
in_progress/hooked listings. The auto-close closes the root through
Lifecycle.Close, and the --continue claim is one Lifecycle.Update guarded by
ExpectedStatus=open.
No refusal is swallowed any more: findParentMolecules, the molecule finders
and the hooked scan return their errors; `mol current/progress` report them;
the auto-close stays best effort but warns on stderr; AdvanceToNextStep only
moves on to the next ready step when the claim LOST a race (status mismatch,
not claimable, already claimed) and returns anything else. The one heuristic
still skipped is the id-pattern heal in loadDescendants, and only for an
ErrUnsupported backend that cannot express an id-prefix search; other
failures now surface. `mol current`/`mol progress` leave the
types.IssueFilter forbidigo hole, since they no longer build a filter.
gc does not depend on bd's molecule auto-close: it runs its own
(cmd/gc/molecule_autoclose.go, from the bd on_close hook and the
controller's bead-close events). Its worker prompts do run `bd mol current`.
Served e2e (TestE2E_MoleculesOverHTTP): create --parent mints <root>.1/.2,
mol current <id> is non-empty with the full in-progress step, mol progress
counts, close --continue auto-advances, closing the last step auto-closes
the root. `mol current` without an id now refuses out loud on this stack
(asserted: never an empty list); its non-empty assertion is skipped until
S6c (externaldeps reader passthrough) is underneath.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(mol): list molecule candidates with the four wire knobs, drop the S6c skip
On top of S6c the in_progress listing behind 'bd mol current' (no id)
reaches the v0 wire encoder, which refuses ListRequest.IncludeAllTypes.
Ask for templates, gates, infra and ephemeral rows explicitly, which the
wire publishes, and run the 'mol current without an id' served case.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* feat(issueops): one library entry each for molecule auto-close, advance and reads
The molecule rules lived only in cmd/bd, in copies that disagreed: two
auto-close implementations that closed the root through different
library entries outside the step close's transaction, a `close
--continue` claim that set no assignee and could take a step another
agent held on the direct and http routes, and three progress counts.
Every molecule rule now has one implementation in the public issueops
package, composed over three roles every backend serves (BatchGetter,
Relations, EdgeReader): MoleculeRoots, LoadMolecule, AnalyzeMolecule,
ViewMolecule, ReadMoleculeProgress, ActiveMoleculeIDs,
CompletedMolecule. Membership is the parent-child edge.
Auto-close: CloseRequest.AutoCloseMolecule and
CloseBatchRequest.AutoCloseMolecule (opt-in, so gc's own auto-close is
not doubled) close the molecule root a close completed IN THE SAME
TRANSACTION, unforced and guarded on the root revision read there:
storageissueops.CloseCompletedMoleculeInTx on the store backends (the
role bodies bound to the caller's tx, TxMoleculeReader) and
uow.CloseCompletedMoleculeInUOW on the unit of work. It replays on an
idempotent re-close, reports the root on CloseResult/CloseOutcome
.AutoClosedMolecule, and a root its own close policy refuses stays open
and is reported (MoleculeAutoCloseRefusal) without failing the step.
Advance: a new MoleculeStepper role (storage.DoltStorage accessor,
uow.MoleculeStepperSource) whose one implementation,
issueops.NewMoleculeStepper, claims the next ready step through the
Claimer (Lifecycle.Update's Claim for a wisp step): assignee set, a step
another actor holds skipped, never taken.
HTTP: closeIssue/batchCloseIssues carry auto_close_molecule behind the
issues.close.autoCloseMolecule behavior token, and POST
/v0/beads/issues/{id}:advanceMolecule (issues.advanceMolecule) serves
the stepper. Handlers only decode, call the role and encode. The client
sends the member and dials the operation only where advertised; against
an older server it DEGRADES rather than refuses — it runs the same
library rule over its own roles (issueops.CloseCompletedMolecule after
the close, NewMoleculeStepper for the advance), so the outcome is the
same in more round trips. The capability fallbacks that lived in
cmd/bd move into the client: BatchGetter answers one getIssue per id
without issues.batchGet, and EdgeReader splits past the operation's 100
anchors.
Conformance: RunMolecule* on dolt, embedded, uow and http (the http leg
twice: served, and against a server with the tokens struck out).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(cmd/bd): molecule commands and create --parent through the library entries
`bd close`, `bd close --continue`, `bd mol current`, `bd mol progress`,
`bd ready --mol` and `bd create --parent` now call the one library entry
for each rule on every route (direct, proxied server, remote):
- close (batch, --if-revision, proxied) sets CloseRequest/
CloseBatchRequest.AutoCloseMolecule and only reports what the library
closed in the step close's transaction. autoCloseCompletedMolecule,
autoCloseProxiedCompletedMolecule and closeCompletedMoleculeRoot are
gone, and so is the separate post-close write.
- --continue is the route's MoleculeStepper role: a real claim (the
assignee is set) that skips a step another actor holds. Before, the
direct and http routes flipped the status only and could take it.
AdvanceToNextStep, ClaimStepIfOpen and its two implementations are
gone.
- mol current / mol progress / ready --mol read through
issueops.ViewMolecule, ReadMoleculeProgress, ActiveMoleculeIDs and
LoadMolecule/AnalyzeMolecule over the route's roles. Over http this
fixes the missing step assignee on `ready --mol` (corpus mark
mc-ready-mol). The proxied route's SearchIssues fallback, the role
store, the third progress count and the cmd/bd copy of the readiness
analysis are deleted; only presentation stays here.
- create --parent asks the create role to mint the child id on every
route (the local CLI reservation is gone) and to inherit the parent's
labels (InheritLabelsFromParent) inside the create. The dry-run
preview still shows the labels, and a failed label read there is
reported, not swallowed.
TestProxiedServerMoleculeLifecycleAgreesOnEveryRoute runs one molecule
lifecycle through the real binary on the direct, proxied and remote
(`bd connect` to `bd serve`) routes and requires the same rows and the
same JSON on all three. The served e2e now also pins the held-step skip,
the claimed step's assignee and the full rows of `ready --mol`.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(httpclient): refuse molecule auto-close and advance before dialing an older server
The client used to DEGRADE against a server without
issues.close.autoCloseMolecule / issues.advanceMolecule: it closed the step
without the member and ran a second, client-side copy of the auto-close
(issueops.CloseCompletedMolecule) in its own transactions, and composed the
stepper over its own roles. That kept two executions of each rule alive.
Now the rule runs in ONE place, the server's library: a close or batch close
that sets AutoCloseMolecule, and an Advance, refuse before anything is dialed
with the typed capability error (storage.ErrUnsupported, Capability naming the
token). The composed single-item batch leg now carries the member too.
- issueops.CloseCompletedMolecule (the role-composed form) is gone.
MoleculeRootClose is the one root close request (unforced, the auto-close
reason, the session, guarded on the root revision read), and both
in-transaction bodies (storage issueops CloseCompletedMoleculeInTx, uow
CloseCompletedMoleculeInUOW) build from it.
- MoleculeView.Ready is `bd ready --mol`'s list (every analysis-ready node,
hydrated), so ready --mol and mol current derive from ViewMolecule alone.
Tests: unit pre-dial refusal and member pins (httpclient molecule_test.go),
TestServedMoleculeRefusesAgainstAnOlderServer (step stays open, nothing
claimed) replacing the degraded contract arm.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cmd/bd): ask for the molecule auto-close only where the route serves it
The refuse-before-dialing client made every `bd close` over http fail
against a server that does not advertise issues.close.autoCloseMolecule
(an older bd serve, or the MC server shape, whose orchestrator owns the
molecule lifecycle): the CLI always set AutoCloseMolecule.
storage.ServesMoleculeAutoClose answers, through every decorator, whether a
store's closes may carry the flag (MoleculeAutoCloseProber, implemented by
httpclient.Store from its handshake; every local backend serves it). The
direct batch close and the --if-revision close set the flag from it; the
proxied route always serves it. Against a silent server the close goes out
without the member and the server's side owns the auto-close.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(backend/http): scope the advertised-policy check to reads before the close
The close policy check is the client-side policy's last chance: it runs
before the close request, so only the reads up to that request count. A
read after the close (the old-server molecule notice reads the closed
step's edges) is not the external-dependency policy.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* test(backend/http/corpus): drop the six marks S16 and S19 retire
With the molecule library entries underneath, mol current (with and
without an id, json and text), mol progress and ready --mol read through
issueops.LoadMolecule over the roles, and create --parent lets the server
mint the child id. Those six shapes pass on the reference profile.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(cmd/bd): never silent against a server without the molecule tokens
Against a server that advertises neither issues.close.autoCloseMolecule
nor issues.advanceMolecule (an older bd serve, or one whose orchestrator
owns the molecule lifecycle):
- `bd close --continue` closed the step and only then found the advance
refused, leaving the step closed and the next step unclaimed. It now
asks storage.ServesMoleculeAdvance (a MoleculeAdvanceProber the http
store answers from its handshake; local backends always serve it)
BEFORE the close and refuses up front, saying nothing was closed.
- `bd close` went out without auto_close_molecule and said nothing. When
the closed step belongs to a molecule (issueops.MoleculeRoot), a notice
on stderr now names the molecule and the missing token: its auto-close
is the server's to run. The batch and --if-revision closes both say it.
The served e2e masks both tokens out of the handshake and checks the
up-front refusal (the step stays open) and the notice; the httpclient
unit test pins ServesMoleculeAdvance to the handshake.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* refactor(cmd/bd): mol show through issueops.LoadMolecule on every route
`bd mol show` still loaded the molecule through cmd/bd's
loadTemplateSubgraph (raw GetIssue, GetDependentsWithMetadata and
GetDependencyRecords, plus an id-pattern child probe), while mol current,
mol progress and ready --mol read through the library. It now loads
through issueops.LoadMolecule over the route's molecule roles (the direct
store's, or the proxied provider's), so membership is the parent-child
edge everywhere and the http route reads through roles the server serves.
The served e2e checks mol show's root and step count.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs: the molecule auto-close fails the step's close on a non-policy error; stale comments
CloseRequest.AutoCloseMolecule and CloseCompletedMoleculeInTx now say what
changed when the auto-close moved into the close's transaction: a root
close the close policy refuses still leaves the root open and is reported,
but any other failure (a storage error, a lost race on the root's revision)
fails the step's close with it, where the CLI used to close the root
afterwards and only warn.
Stale: the advanceMolecule vocabulary entry said the client composes the
stepper over its own roles when unserved (it refuses before dialing), and
the graph-create collision probe called itself best-effort by transport
(the http GetIssue miss is storage.ErrNotFound like every other store's).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* docs(changelog): the molecule tokens and the S16/S19 behaviours
Entries for issues.close.autoCloseMolecule and issues.advanceMolecule, the
issueops molecule entries, the auto-close inside the step's close (and a
non-policy failure of it failing the close), the real claim behind
close --continue, the molecule reads on every route, the notice and the
up-front --continue refusal against a server without the tokens, and
create --parent / mol reads over http.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(httpclient): regenerate unsupported_gen.go for MoleculeStepper
The PR adds MoleculeStepper() to storage.DoltStorage (200 -> 201
methods). httpclient implements it by hand, but the generated shell's
trailer still counted 200, so
//internal/storage/unsupportedgen:unsupportedgen_test
(TestGeneratedShellIsFresh) failed in Bazel / test and
Bazel / integration, turning CI Gate / Required red.
Regenerated with `go generate ./internal/httpclient`; the only change
is the trailer count (143 of 201 methods generated; 58 left).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(molecule): auto-close refusals, write skew, close --json, docs
Review fixes for #7513, numbered as in each iteration's review
synthesis.
Iteration 1:
F1: a close guard's refusal of the root (TemplateReadOnlyError,
PinnedError, CloseNotAssigneeError) is an auto-close refusal, like the
close policy's: the root stays open and is reported, and the step's
close stands. Pinned by the new conformance case
RunMoleculeGuardedRootKeepsTheStepClose on dolt, embedded, uow and the
served http client.
F2: two closes that finish a molecule's last two steps in concurrent
transactions each read the other's step as open, so neither closed the
root and both committed. Every auto-close now rewrites the root's
coordination cell before it decides the root (local_metadata
molecule-coordination/v1/<shard>, the dependency coordination idiom and
sharding with a FreshRowLock value), in both twins
(CloseCompletedMoleculesInTx and CloseCompletedMoleculesInUOW). Two
deciders of one root now conflict at commit (1213), and the retry reads
the winner's close and closes the root. This is the synthesis's option
(c), applied through a coordination cell instead of the root row; it
needs no post-commit second transaction and no engine lock. The
deterministic two-transaction regression fails without the touch and
passes with it on dolt and uow; the concurrent-close tests end with the
root closed in every round, reported by exactly one close.
F3: the auto-close checks the root's eligibility before walking any
step, MoleculeStepsClosed stops at the first open step, and a batch
decides each root once and reports it on the first item under it.
F4: ErrVersionMismatch on the root is not a refusal; it fails the
step's close with it. The classifier unit test pins this. A conformance
case cannot stage that race deterministically through the public roles.
F5: storage.ServesMoleculeAdvance answers (bool, error), and bd close
--continue refuses before closing anything when the handshake cannot be
read.
F6: the CHANGELOG and the stepper and batch-closer doc comments say
what the code does.
F7: the unserved-auto-close notice fires only when the close left an
auto-closing molecule with every step closed and its root open
(issueops.CompletedMolecule): again on a re-close, once per root in a
batch, never for a step under an ordinary epic or an unfinished
molecule. Proxied mol show, mol current and mol progress again report a
read unit of work that cannot be opened as itself, not as a molecule
that was not found.
F8: the write-ledger comment says the close is refused before dialing.
The dead FirstClosed/LastClosed guards in mol progress pre-exist on main
and are left as they are.
Iteration 2:
F1: on the proxied route, bd ready --mol reported a read unit
of work it could not open twice: once as itself, then as "molecule
'<id>' not found", which under --json is a second error document on
stdout. It now returns moleculeNotResolved, as mol show, mol current and
mol progress do. TestProxiedReadyMolReportsAnUnopenableReadOnce drives
runMoleculeReady with a provider whose NewUOW fails and wants one Error:
line, or one JSON document; both subtests fail with the old return.
F2: the coordination cell serializes every concurrent close of a step
under an open auto-closing root, not only the closes that finish the
molecule. That is the price of deciding the root in the step's
transaction, so it is documented (TouchMoleculeCoordinationInTx, the
UOW twin, CloseRequest.AutoCloseMolecule, the CHANGELOG) and pinned on
dolt and uow: two sibling closes with a third step still open conflict
(both commit when the touch is removed, on either twin), and a six-step
fan-out closes every step through the store's retry, with the root
closed and reported by exactly one close. The synthesis's alternative,
a post-commit recheck by any close that read a step open, is not taken:
it is a second, best-effort transaction after the step's commit, the
shape this PR exists to remove.
F3: MoleculeRootClose's doc no longer promises that a step reopened
between the completion read and the root close fails the step's close.
The guard is the root's RowVersion, which a step reopen never writes;
the doc now says what the guard covers and that this race goes
undetected (it is inherited from the CLI's old post-commit auto-close).
F4: the user docs describe the auto-close. docs/workflows/molecules.md
replaces "Closing the last child does not close the molecule root"
with which roots close and which stay open, the refusal warning, the
unserved-server note and the --json members, and documents the claiming
--continue and parent-child step membership;
docs/reference/json-schema.md gains a bd close --json section. These
are main-only behaviors on pages pinned to v1.2.2 (docs/cli-docs.pin):
a maintainer call against §1 of
engdocs/decisions/2026-07-17-docs-release-pin.md, as in #6508, #5855,
#5997 and #5092. The auto-close itself shipped in v1.2.2
(cmd/bd/close.go autoCloseCompletedMolecule), so the old sentence was
already wrong at the pin. docs/cli-reference/ is generated from the
pinned release and is not hand-edited; the bd close and bd mol show
help texts carry the same facts and reach it at the next pin bump.
F5: bd close --json reports the auto-close. The entry of a close that
completed a molecule gains auto_closed_molecule (the root it closed) or
molecule_auto_close_refusal (why the root stayed open), the HTTP API's
names, on the direct, proxied and --if-revision routes. The members sit
beside the issue's own rather than wrapping the output in an object the
way --suggest-next does: an object would change the output's shape
exactly when a close completes a molecule and break every consumer that
reads an array, while members leave each entry decoding as the closed
issue, compose with `closed` under the flag objects, and leave a plain
close's bytes unchanged. Pinned on the embedded and proxied tiers
(TestEmbeddedCloseJSONReportsMoleculeAutoClose, TestProxiedServerClose2B
json_reports_*, and both --if-revision replay tests), all red without
the change.
F6: cmd/bd's BeadsTemplateLabel is issueops.MoleculeTemplateLabel, so
the template commands and molecule membership cannot drift apart.
F7: the UOW twin's revision probe says that it writes nothing,
and the BatchCloseRequest.auto_close_molecule spec description has its
verb back (apigen regenerated, no drift).
Iteration 3:
F1: on the unit-of-work route (bd serve, the proxied CLI), a refused
root's molecule_auto_close_refusal and warning carried the use case's
and repository's wrapping ("close <id>: db:
IssueSQLRepository.CloseChecked <id>: ...") around the refusal, where
the tx twin and the docs give the refusal alone. Both twins now report
it through RefusedMoleculeAutoClose, which answers the refusing guard's
or policy's own sentence. RunMoleculeRefusedRootKeepsTheStepClose,
RunMoleculeGuardedRootKeepsTheStepClose and the embedded and proxied
close --json tests want that exact sentence; the uow conformance leg
and the proxied test fail without the unwrap.
F2: the docs no longer promise ErrVersionMismatch for a write to the
root that races its auto-close. The root's read and its revision check
share one transaction snapshot, so that write conflicts with the root
close at commit and the retry decides the root again; the close fails
only if it still conflicts when its retry budget runs out
(MoleculeRootClose, IsMoleculeAutoCloseRefusal,
CloseRequest.AutoCloseMolecule, the tx twin's comment, the CHANGELOG
and the OpenAPI description, apigen regenerated).
F3: TestEmbeddedCloseJSONReportsMoleculeAutoClose moves above
TestEmbeddedCloseConcurrent's doc comment, which documents its own test
again.
F4: bd mol progress counting direct steps while the auto-close counts
every descendant predates this PR; it is left for a follow-up.
F5: cmd/bd's molReader drops GetMoleculeProgress, which nothing called
once mol progress read through issueops.ReadMoleculeProgress.
Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Gas City Adopt-PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
598 lines
26 KiB
Go
598 lines
26 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"mime"
|
|
"net/http"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
|
|
"github.com/steveyegge/beads/internal/httpapi/apigen"
|
|
"github.com/steveyegge/beads/internal/storage"
|
|
"github.com/steveyegge/beads/internal/storage/uow"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/issueops"
|
|
"github.com/steveyegge/beads/memoryops"
|
|
)
|
|
|
|
const (
|
|
// claimActorMember is the only member ClaimRequest carries. The schema is
|
|
// additionalProperties: false, so anything else is refused by name.
|
|
claimActorMember = "actor"
|
|
// maxActorBytes is the document's cap on `actor`. The schema's maxLength
|
|
// counts characters; this byte limit is the binding one.
|
|
maxActorBytes = 256
|
|
// maxJSONBodyBytes bounds every request body on this surface. The largest
|
|
// documented one is a handful of short members, so this is pure refusal of
|
|
// the absurd.
|
|
maxJSONBodyBytes = 1 << 20
|
|
// claimContentType is the one media type this surface accepts on a body —
|
|
// requireJSONContent enforces it for every body-carrying operation, not
|
|
// only the claim — and refusing anything else is a CSRF control, not
|
|
// pedantry: a JSON content type is not CORS-"simple", so a cross-origin
|
|
// write always triggers a preflight this server never approves. Accepting
|
|
// text/plain or a form encoding would let an attacker's page skip the
|
|
// preflight and drive a write from any browser on the host.
|
|
claimContentType = "application/json"
|
|
)
|
|
|
|
// handleClaim is v0's compare-and-set claim of a single issue for a
|
|
// caller-named actor, and the write whose posture every later one adopted.
|
|
//
|
|
// ACTOR SEMANTICS, stated because adopting this endpoint depends on them. The
|
|
// actor is caller-ASSERTED provenance for the audit trail and is NOT the
|
|
// authenticated principal, even where a bearer is required: the token a
|
|
// deployment configures is shared and surface-wide, so it names nobody and
|
|
// cannot confirm or contradict the actor a request sends. Any client that
|
|
// reaches this endpoint can claim as any name, exactly as any local process
|
|
// can pass any --actor to the CLI. The CAS is therefore a correctness fence
|
|
// against CONCURRENT claims, not an authorization boundary — it guarantees
|
|
// that two racing claimants cannot both win, and guarantees nothing about who
|
|
// either of them really is. What bounds the blast radius of that posture is
|
|
// the bind: loopback by default, and beyond loopback only with a token file
|
|
// (or the explicit --insecure-no-auth).
|
|
//
|
|
// Two things a CLI claim does that this deliberately does not: hooks do not
|
|
// fire (a user-controlled subprocess per mutation is an unbounded latency
|
|
// multiplier and an orphaned child at shutdown), and the per-command
|
|
// auto-commit machinery never runs. The only durable effect is the single
|
|
// storage commit the claim role makes inside its own transaction — which is
|
|
// exactly what a proxied CLI write does today.
|
|
//
|
|
// Everything above the role here is argument validation: the path split, the
|
|
// media type, the body shape and the actor rules. The claim itself — the CAS,
|
|
// the eligibility rules, the claim pools, the transaction retry and the
|
|
// refusal vocabulary — belongs to issueops.Claimer, reached through the
|
|
// provider's own accessor.
|
|
func (s *Server) handleClaim(w http.ResponseWriter, r *http.Request) {
|
|
// The custom-method dispatcher split the id off the segment and bounded it
|
|
// before this handler was chosen at all; see customMethodTarget.
|
|
id := r.PathValue(customMethodIDValue)
|
|
if !s.requireNoQuery(w, r) {
|
|
return
|
|
}
|
|
if !s.requireJSONContent(w, r) {
|
|
return
|
|
}
|
|
actor, ok := s.claimActor(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
claimer, err := s.claimer(r)
|
|
if err != nil {
|
|
s.failClaim(w, r, err)
|
|
return
|
|
}
|
|
result, err := claimer.Claim(r.Context(), issueops.ClaimRequest{IssueID: id, Actor: actor})
|
|
if err != nil {
|
|
s.failClaim(w, r, err)
|
|
return
|
|
}
|
|
// `already_claimed` is the wire's name for the idempotent re-claim, which
|
|
// is exactly the case the role reports as an unchanged result.
|
|
writeJSON(w, apigen.ClaimResponse{
|
|
Issue: *result.Issue,
|
|
AlreadyClaimed: !result.Changed,
|
|
})
|
|
}
|
|
|
|
// requireJSONContent enforces the request media type. It reports whether the
|
|
// request may proceed.
|
|
//
|
|
// The refusal is 400 invalid_argument naming the header rather than 415:
|
|
// 415 is not in the v0 code vocabulary, and adding a status to that vocabulary
|
|
// for this would be permanent wire surface. `param` is documented as carrying a
|
|
// header name for exactly this kind of refusal — it is what the Host middleware
|
|
// already does.
|
|
//
|
|
// The document states this rule once, at the document level, beside the
|
|
// Host-header and unknown-query-parameter rules, because it holds for every
|
|
// body-carrying operation rather than for this one.
|
|
func (s *Server) requireJSONContent(w http.ResponseWriter, r *http.Request) bool {
|
|
got := r.Header.Get("Content-Type")
|
|
if media, _, err := mime.ParseMediaType(got); err == nil && media == claimContentType {
|
|
return true
|
|
}
|
|
// Attacker-controlled, and quoted by logValue: a cross-origin POST that
|
|
// tried to skip the preflight should leave a trace naming what it sent.
|
|
requestInfo(r.Context()).refuse(got)
|
|
s.fail(w, r, InvalidArgument("Content-Type", ReasonInvalidValue,
|
|
"this operation accepts "+claimContentType+" only"))
|
|
return false
|
|
}
|
|
|
|
// claimActor decodes the request body and validates its one member.
|
|
//
|
|
// Validation happens HERE, at the wire edge, before any database work is done.
|
|
// The domain layer refuses only actor == "" (internal/storage/domain/issue.go),
|
|
// so without this a whitespace-only or megabyte actor would be persisted to the
|
|
// assignee column AND interpolated into the storage commit message — where an
|
|
// unvalidated newline forges audit-trail lines that look like separate commits.
|
|
func (s *Server) claimActor(w http.ResponseWriter, r *http.Request) (string, bool) {
|
|
members, res := decodeJSONObjectBody(w, r)
|
|
if res != nil {
|
|
s.fail(w, r, *res)
|
|
return "", false
|
|
}
|
|
|
|
var unknown []string
|
|
for name := range members {
|
|
if name != claimActorMember {
|
|
unknown = append(unknown, name)
|
|
}
|
|
}
|
|
if len(unknown) > 0 {
|
|
// Same rule as an unknown query parameter, for the same reason, and
|
|
// named the same way: one offender, chosen deterministically so a
|
|
// client dispatching on `param` never sees it depend on map order.
|
|
offender := slices.Min(unknown)
|
|
requestInfo(r.Context()).refuse(offender)
|
|
s.fail(w, r, InvalidArgument(offender, ReasonUnknownParameter,
|
|
"this operation's request body carries `"+claimActorMember+"` and nothing else"))
|
|
return "", false
|
|
}
|
|
|
|
raw, ok := members[claimActorMember]
|
|
if !ok {
|
|
s.fail(w, r, InvalidArgument(claimActorMember, ReasonInvalidValue,
|
|
"`"+claimActorMember+"` is required"))
|
|
return "", false
|
|
}
|
|
// Through a POINTER, so that `null` reaches the type-mismatch branch:
|
|
// unmarshaling JSON null into a string is a no-op, which would have let a
|
|
// null slide down to the actor rules and be reported as "empty after
|
|
// trimming" — the right status, code, param and reason attached to prose
|
|
// that misdescribes what the client sent.
|
|
var actor *string
|
|
if err := json.Unmarshal(raw, &actor); err != nil || actor == nil {
|
|
s.fail(w, r, InvalidArgument(claimActorMember, ReasonInvalidValue,
|
|
"`"+claimActorMember+"` must be a string"))
|
|
return "", false
|
|
}
|
|
trimmed, res := validateActor(*actor)
|
|
if res != nil {
|
|
s.fail(w, r, *res)
|
|
return "", false
|
|
}
|
|
return trimmed, true
|
|
}
|
|
|
|
// decodeJSONObjectBody reads the body as a JSON object of raw members. Decoding
|
|
// the members rather than the generated struct is what makes the schema's
|
|
// additionalProperties: false enforceable by NAME: encoding/json's
|
|
// DisallowUnknownFields reports the offender only inside an error string, and
|
|
// these endpoints exist to let clients stop parsing prose.
|
|
//
|
|
// Shared with the sweep, which has the same posture and the same reason for
|
|
// it; the member vocabulary each operation accepts is its own.
|
|
func decodeJSONObjectBody(w http.ResponseWriter, r *http.Request) (map[string]json.RawMessage, *Result) {
|
|
// A body with no nameable part: `param` is documented absent on exactly
|
|
// this case and present on every other 400.
|
|
unparseable := func(detail string) *Result {
|
|
res := InvalidArgument("", ReasonInvalidValue, detail)
|
|
return &res
|
|
}
|
|
|
|
var members map[string]json.RawMessage
|
|
dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxJSONBodyBytes))
|
|
if err := dec.Decode(&members); err != nil {
|
|
var tooLarge *http.MaxBytesError
|
|
if errors.As(err, &tooLarge) {
|
|
return nil, unparseable(fmt.Sprintf("request body is larger than %d bytes", maxJSONBodyBytes))
|
|
}
|
|
return nil, unparseable("request body must be a JSON object")
|
|
}
|
|
if members == nil {
|
|
// Valid JSON, but `null`: no members to read an actor out of.
|
|
return nil, unparseable("request body must be a JSON object")
|
|
}
|
|
if dec.More() {
|
|
return nil, unparseable("request body must be a single JSON object")
|
|
}
|
|
return members, nil
|
|
}
|
|
|
|
// validateActor applies the document's actor rules in the document's order:
|
|
// trim, then refuse an empty result, an over-long value, and any control
|
|
// character.
|
|
func validateActor(actor string) (string, *Result) {
|
|
return validateNameMember(claimActorMember, actor)
|
|
}
|
|
|
|
// validateNameMember applies the actor rules to any member that NAMES SOMEONE
|
|
// and lands in a 255-character column: `actor` on the mutations, `author` on a
|
|
// comment. The rules are one statement parameterized by the member's spelling,
|
|
// rather than one statement per member — two copies would be two chances for a
|
|
// bound to drift, and the difference between them is a name.
|
|
//
|
|
// It reports the TRIMMED value, which is what reaches the role.
|
|
func validateNameMember(member, value string) (string, *Result) {
|
|
refuse := func(detail string) *Result {
|
|
res := InvalidArgument(member, ReasonInvalidValue, detail)
|
|
return &res
|
|
}
|
|
trimmed := strings.TrimSpace(value)
|
|
switch {
|
|
case trimmed == "":
|
|
return "", refuse("`" + member + "` is empty after trimming")
|
|
|
|
case len(trimmed) > maxActorBytes:
|
|
return "", refuse(fmt.Sprintf("`%s` is %d bytes; the limit is %d",
|
|
member, len(trimmed), maxActorBytes))
|
|
|
|
// The storage column holds types.MaxFieldLen (255) CHARACTERS, one fewer
|
|
// than the document's 256-byte cap allows. Refusing that one-character
|
|
// window here rather than letting it through keeps a documented-looking
|
|
// value from becoming a 500 from the assignee column, and keeps the check
|
|
// keyed on storage's own constant instead of a second copy of the number.
|
|
case types.CheckFieldLen(member, trimmed) != nil:
|
|
return "", refuse(fmt.Sprintf("`%s` is %d characters; storage holds at most %d",
|
|
member, utf8.RuneCountInString(trimmed), types.MaxFieldLen))
|
|
|
|
// Newline above all: the actor is interpolated into the storage commit
|
|
// message, so a multiline value would forge audit-trail lines. A comment's
|
|
// author is not, and is refused anyway — it lands in a column every renderer
|
|
// of the thread prints, where an unfiltered C1 introducer is an
|
|
// escape-sequence payload.
|
|
case strings.ContainsFunc(trimmed, isControlChar):
|
|
return "", refuse("`" + member + "` must not contain control characters")
|
|
}
|
|
return trimmed, nil
|
|
}
|
|
|
|
// isControlChar reports whether a rune is one no actor may carry: every Unicode
|
|
// control character (category Cc — C0, DEL, and the C1 block) plus the
|
|
// U+2028/U+2029 line separators.
|
|
//
|
|
// C1 is refused for the reason C0 is, not for tidiness: U+0085 is NEL, a line
|
|
// break on a VT-conformant terminal, so "alice<U+0085>bd: claim bd-9 by
|
|
// mallory" forges exactly the audit-trail line the C0 check exists to prevent
|
|
// once the actor reaches the storage commit message. U+009B is the one-byte CSI
|
|
// introducer, which makes an unfiltered actor an escape-sequence payload in
|
|
// anything that prints an assignee.
|
|
//
|
|
// The schema's `actor` pattern spells this same set, so what the document
|
|
// advertises and what the server refuses are one statement.
|
|
func isControlChar(r rune) bool {
|
|
return unicode.IsControl(r) || r == '\u2028' || r == '\u2029'
|
|
}
|
|
|
|
// failClaim answers a failed claim, adding the extension members a typed 409
|
|
// carries.
|
|
//
|
|
// The extensions come from issueops.ClaimConflictError, which the role fills
|
|
// from a query inside the transaction that lost the CAS — never from parsing
|
|
// fragments out of the sentinel's message ("already assigned to", "claimed
|
|
// by"). That substring classification is what a client adopting this endpoint
|
|
// gets to delete, and it can only delete it if the server never does it either.
|
|
func (s *Server) failClaim(w http.ResponseWriter, r *http.Request, err error) {
|
|
var conflict *issueops.ClaimConflictError
|
|
if !errors.As(err, &conflict) {
|
|
s.failErr(w, r, err)
|
|
return
|
|
}
|
|
s.fail(w, r, claimRefusal(err))
|
|
}
|
|
|
|
// claimRefusal classifies a refused claim and attaches the extension members
|
|
// the role's typed conflict reports. It is shared with the update's `claim`
|
|
// member, so a claim refused on either operation reads the same.
|
|
func claimRefusal(err error) Result {
|
|
res := ClassifyError(err)
|
|
var conflict *issueops.ClaimConflictError
|
|
if !errors.As(err, &conflict) {
|
|
return res
|
|
}
|
|
// `assignee` is documented with already_claimed only: an issue refused for
|
|
// its STATUS may well carry a stale assignee, and publishing it there would
|
|
// tell a client someone holds work they do not.
|
|
if res.Problem.Code == string(CodeAlreadyClaimed) && conflict.Assignee != "" {
|
|
res = res.WithAssignee(conflict.Assignee)
|
|
}
|
|
if conflict.Status != "" {
|
|
res = res.WithIssueStatus(string(conflict.Status))
|
|
}
|
|
return res
|
|
}
|
|
|
|
// timedProvider records how long a request spent obtaining units of work, so
|
|
// the claim's request line carries the same uow_ms every other route does.
|
|
// RunTxResult owns the unit-of-work lifecycle — that is the point of having one
|
|
// retry/commit implementation — so the measurement wraps the provider rather
|
|
// than the acquisition. Retry attempts ACCUMULATE: two attempts really did
|
|
// spend two acquisitions, and a claim that retried is exactly the case where
|
|
// the number matters.
|
|
type timedProvider struct {
|
|
inner uow.UnitOfWorkProvider
|
|
rec *reqInfo
|
|
}
|
|
|
|
// timedProvider carries the capability accessors, so a handler asks the
|
|
// provider it holds for the role — the same two-step a CLI command performs on
|
|
// a store — instead of reaching past it to a constructor.
|
|
var (
|
|
_ uow.IssueReaderSource = timedProvider{}
|
|
_ uow.IssueClaimerSource = timedProvider{}
|
|
_ uow.MoleculeStepperSource = timedProvider{}
|
|
_ uow.BatchCloserSource = timedProvider{}
|
|
_ uow.ReadyClaimerSource = timedProvider{}
|
|
_ uow.ReleaserSource = timedProvider{}
|
|
_ uow.IssueLifecycleSource = timedProvider{}
|
|
_ uow.WorkspaceConfigSource = timedProvider{}
|
|
_ uow.StatsReporterSource = timedProvider{}
|
|
_ uow.CycleDetectorSource = timedProvider{}
|
|
_ uow.EdgeReaderSource = timedProvider{}
|
|
_ uow.GraphCounterSource = timedProvider{}
|
|
_ uow.BatchGetterSource = timedProvider{}
|
|
_ uow.LeaseReclaimerSource = timedProvider{}
|
|
_ uow.RelationsSource = timedProvider{}
|
|
_ uow.CommenterSource = timedProvider{}
|
|
_ uow.BlockingAnnotatorSource = timedProvider{}
|
|
_ uow.TreeWalkerSource = timedProvider{}
|
|
_ uow.ReadyCounterSource = timedProvider{}
|
|
_ uow.CounterSource = timedProvider{}
|
|
_ uow.QuerierSource = timedProvider{}
|
|
_ uow.SweeperSource = timedProvider{}
|
|
_ uow.DeleterSource = timedProvider{}
|
|
_ uow.BatchCreatorSource = timedProvider{}
|
|
_ uow.DependencyEditorSource = timedProvider{}
|
|
_ uow.MetadataCASSource = timedProvider{}
|
|
_ uow.BatchApplierSource = timedProvider{}
|
|
_ uow.MemoriesSource = timedProvider{}
|
|
_ uow.EventsJournalCursorSource = timedProvider{}
|
|
)
|
|
|
|
// IssueReader builds the reader OVER THIS WRAPPER rather than delegating to the
|
|
// wrapped provider's own accessor. Every accessor on timedProvider does this,
|
|
// and this type is the ONE place in the codebase where a constructor is the
|
|
// right call rather than an accessor: the whole purpose of the wrapper is
|
|
// that every unit of work the reader opens goes through NewUOW below and lands
|
|
// in this request's uow_ms. `p.inner.IssueReader()` would return a reader
|
|
// bound to the untimed provider and the measurement would silently read zero.
|
|
//
|
|
// THAT IS NOT A HYPOTHETICAL, which is why it now has a test. This decorator's
|
|
// layer is on NewUOW, so only a reader holding this wrapper can reach it —
|
|
// unlike telemetry's storage accessor, whose layer is on the RESULT and which
|
|
// therefore recurses and wraps. A reviewer reading the two side by side
|
|
// proposed making this one recurse for symmetry; the whole internal/httpapi
|
|
// suite passes with that change and every read route logs uow_ms=0.000
|
|
// forever. TestAReadRouteTimesTheUnitsOfWorkItsReaderOpens is the assertion
|
|
// that fails instead.
|
|
//
|
|
// That pin is per-route and there are thirteen accessors here, so
|
|
// TestEveryTimedProviderAccessorBindsToTheWrapper covers the rest structurally.
|
|
//
|
|
// The cost is that a provider whose own accessor decorated its reader would be
|
|
// bypassed here. There is one provider (doltSQLProvider) and its accessor is
|
|
// this same construction, so nothing is bypassed today — but if a decorating
|
|
// provider ever appears, this is the line that has to grow a wrap.
|
|
func (p timedProvider) IssueReader() (issueops.Reader, error) {
|
|
return uow.NewIssueReader(p)
|
|
}
|
|
|
|
// IssueClaimer builds the claimer OVER THIS WRAPPER, for the same reason and
|
|
// with the same hazard as IssueReader above: the role's units of work must go
|
|
// through NewUOW below or every claim reports uow_ms=0.000.
|
|
// TestAClaimTimesTheUnitsOfWorkItsClaimerOpens is the assertion that fails
|
|
// instead of the recursion looking correct.
|
|
func (p timedProvider) IssueClaimer() (issueops.Claimer, error) {
|
|
return uow.NewIssueClaimer(p)
|
|
}
|
|
|
|
// BatchCloser builds the many-issue close role OVER THIS WRAPPER, for the same
|
|
// reason as the roles above. Like BatchApplier it opens one of the longest
|
|
// write units of work on this surface — up to a hundred closes plus their
|
|
// blocked-state maintenance in one transaction — so a recursion here would
|
|
// report uow_ms=0.000 for exactly the requests whose timing matters most.
|
|
func (p timedProvider) BatchCloser() (issueops.BatchCloser, error) {
|
|
return uow.NewBatchCloser(p)
|
|
}
|
|
|
|
// ReadyClaimer builds the take-ready-work role OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueClaimer: it opens a write unit of
|
|
// work per call, and its scan is the longest read on this surface — it walks
|
|
// the whole ready order past rows other agents took — so a recursion here would
|
|
// report uow_ms=0.000 for exactly the requests whose timing matters most.
|
|
func (p timedProvider) ReadyClaimer() (issueops.ReadyClaimer, error) {
|
|
return uow.NewReadyClaimer(p)
|
|
}
|
|
|
|
// Releaser builds the claim-release role OVER THIS WRAPPER, for the same reason
|
|
// and with the same hazard as IssueClaimer: a release opens a write transaction
|
|
// per call, so a recursion here would report uow_ms=0.000 for every one of
|
|
// them.
|
|
func (p timedProvider) Releaser() (issueops.Releaser, error) {
|
|
return uow.NewReleaser(p)
|
|
}
|
|
|
|
// IssueLifecycle builds the guarded-mutation role OVER THIS WRAPPER, for the
|
|
// same reason and with the same hazard as IssueClaimer: this role opens the
|
|
// longest write transactions on the surface, so a claimer-style recursion here
|
|
// would report uow_ms=0.000 for exactly the requests whose timing matters most.
|
|
func (p timedProvider) IssueLifecycle() (issueops.Lifecycle, error) {
|
|
return uow.NewIssueOperations(p)
|
|
}
|
|
|
|
// WorkspaceConfig builds the settings role OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as the two above.
|
|
func (p timedProvider) WorkspaceConfig() (issueops.WorkspaceConfig, error) {
|
|
return uow.NewWorkspaceConfig(p)
|
|
}
|
|
|
|
// StatsReporter builds the summary role OVER THIS WRAPPER, for the same reason
|
|
// and with the same hazard as IssueReader.
|
|
func (p timedProvider) StatsReporter() (issueops.StatsReporter, error) {
|
|
return uow.NewStatsReporter(p)
|
|
}
|
|
|
|
// CycleDetector builds the detector OVER THIS WRAPPER, for the same reason and
|
|
// with the same hazard as IssueReader.
|
|
func (p timedProvider) CycleDetector() (issueops.CycleDetector, error) {
|
|
return uow.NewCycleDetector(p)
|
|
}
|
|
|
|
// EdgeReader builds the stored-edge reader OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) EdgeReader() (issueops.EdgeReader, error) {
|
|
return uow.NewEdgeReader(p)
|
|
}
|
|
|
|
// GraphCounter builds the edge-count role OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) GraphCounter() (issueops.GraphCounter, error) {
|
|
return uow.NewGraphCounter(p)
|
|
}
|
|
|
|
// BatchGetter builds the batch-read role OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) BatchGetter() (issueops.BatchGetter, error) {
|
|
return uow.NewBatchGetter(p)
|
|
}
|
|
|
|
// LeaseReclaimer builds the stale-lease sweep OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) LeaseReclaimer() (issueops.LeaseReclaimer, error) {
|
|
return uow.NewLeaseReclaimer(p)
|
|
}
|
|
|
|
// MoleculeStepper builds the advance-a-molecule role OVER THIS WRAPPER, so
|
|
// every read and the claim it composes go through this wrapper's roles.
|
|
func (p timedProvider) MoleculeStepper() (issueops.MoleculeStepper, error) {
|
|
return uow.NewMoleculeStepper(p)
|
|
}
|
|
|
|
// IssueRelations builds the single-anchor neighbor role OVER THIS WRAPPER, for
|
|
// the same reason and with the same hazard as IssueReader. It is the one
|
|
// accessor here whose name is not the role's: the seam spells it IssueRelations
|
|
// on both the store and the provider, and this type implements the seam.
|
|
func (p timedProvider) IssueRelations() (issueops.Relations, error) {
|
|
return uow.NewIssueRelations(p)
|
|
}
|
|
|
|
// Commenter builds the add-comment role OVER THIS WRAPPER, for the same reason
|
|
// and with the same hazard as IssueReader.
|
|
func (p timedProvider) Commenter() (issueops.Commenter, error) {
|
|
return uow.NewCommenter(p)
|
|
}
|
|
|
|
// BlockingAnnotator builds the blocking-decoration role OVER THIS WRAPPER, for
|
|
// the same reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) BlockingAnnotator() (issueops.BlockingAnnotator, error) {
|
|
return uow.NewBlockingAnnotator(p)
|
|
}
|
|
|
|
// TreeWalker builds the dependency-tree walker OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) TreeWalker() (issueops.TreeWalker, error) {
|
|
return uow.NewTreeWalker(p)
|
|
}
|
|
|
|
// ReadyCounter builds the ready counter OVER THIS WRAPPER, for the same reason
|
|
// and with the same hazard as IssueReader.
|
|
func (p timedProvider) ReadyCounter() (issueops.ReadyCounter, error) {
|
|
return uow.NewReadyCounter(p)
|
|
}
|
|
|
|
// Counter builds the issue counter OVER THIS WRAPPER, for ReadyCounter's reason.
|
|
func (p timedProvider) Counter() (issueops.Counter, error) {
|
|
return uow.NewCounter(p)
|
|
}
|
|
|
|
// Querier builds the boolean-query role OVER THIS WRAPPER, for the same reason
|
|
// and with the same hazard as IssueReader.
|
|
func (p timedProvider) Querier() (issueops.Querier, error) {
|
|
return uow.NewQuerier(p)
|
|
}
|
|
|
|
// Sweeper builds the sweeper OVER THIS WRAPPER, for the same reason and with
|
|
// the same hazard as IssueReader.
|
|
func (p timedProvider) Sweeper() (issueops.Sweeper, error) {
|
|
return uow.NewSweeper(p)
|
|
}
|
|
|
|
// Deleter builds the deleter OVER THIS WRAPPER, for the same reason and with
|
|
// the same hazard as IssueReader.
|
|
func (p timedProvider) Deleter() (issueops.Deleter, error) {
|
|
return uow.NewDeleter(p)
|
|
}
|
|
|
|
// BatchCreator builds the batch creator OVER THIS WRAPPER, for the same reason
|
|
// as the roles above. It is the one role here that opens a WRITE unit of work
|
|
// per call.
|
|
func (p timedProvider) BatchCreator() (issueops.BatchCreator, error) {
|
|
return uow.NewBatchCreator(p)
|
|
}
|
|
|
|
// DependencyEditor builds the graph's write role OVER THIS WRAPPER, for the
|
|
// same reason as the roles above. Like BatchCreator and the lifecycle it opens
|
|
// a WRITE unit of work per call.
|
|
func (p timedProvider) DependencyEditor() (issueops.DependencyEditor, error) {
|
|
return uow.NewDependencyEditor(p)
|
|
}
|
|
|
|
// MetadataCAS builds the conditional metadata write OVER THIS WRAPPER, for the
|
|
// same reason and with the same hazard as IssueReader.
|
|
func (p timedProvider) MetadataCAS() (issueops.MetadataCAS, error) {
|
|
return uow.NewMetadataCAS(p)
|
|
}
|
|
|
|
// BatchApplier builds the ordered-plan write role OVER THIS WRAPPER, for the
|
|
// same reason as the roles above. It opens the LONGEST write unit of work on
|
|
// this surface — up to a hundred items in one transaction — so a recursion here
|
|
// would report uow_ms=0.000 for exactly the requests whose timing matters most.
|
|
func (p timedProvider) BatchApplier() (issueops.BatchApplier, error) {
|
|
return uow.NewBatchApplier(p)
|
|
}
|
|
|
|
// Memories builds the persistent-memory role OVER THIS WRAPPER, for the same
|
|
// reason and with the same hazard as IssueReader. It is the one accessor here
|
|
// whose role is not an issueops role; the binding rule is the same.
|
|
func (p timedProvider) Memories() (memoryops.Memories, error) {
|
|
return uow.NewMemories(p)
|
|
}
|
|
|
|
func (p timedProvider) EventsJournalCursor() (storage.EventsJournalCursor, error) {
|
|
return uow.NewEventsJournalCursor(p)
|
|
}
|
|
|
|
func (p timedProvider) NewUOW(ctx context.Context) (uow.UnitOfWork, error) {
|
|
start := time.Now()
|
|
uw, err := p.inner.NewUOW(ctx)
|
|
if p.rec != nil {
|
|
p.rec.uowWait += time.Since(start)
|
|
}
|
|
return uw, err
|
|
}
|
|
|
|
// Close satisfies the provider interface and is never called: RunTxResult
|
|
// closes units of work, not providers. It deliberately does NOT reach the
|
|
// wrapped provider — closing the process-wide pool from inside one request
|
|
// would take the server down with it.
|
|
func (p timedProvider) Close(context.Context) error { return nil }
|