atris 3.74.29 → 3.76.0

package/lib/release-kind.js

@@ -2,16 +2,33 @@
 
 // Why a claim was let go, as a field the rating can read without reading words.
 //
-// One kind exists. The work is done and its pull request is open for a person to
+// Two kinds exist. Both ride on the release event as fields; the reason text is
+// only for people, and nothing ever parses it.
+//
+// proof_not_saved. The work is done and its pull request is open for a person to
 // land, but the proof that says so could not be saved. The builder did its part,
-// so the release is neither a landing nor a drop. The kind and the pull request
-// ride on the release event as fields; the reason text is only for people, and
-// nothing ever parses it.
+// so the release is neither a landing nor a drop. A release says this by passing
+// the kind and the pull request together. The task db refuses half of a marker,
+// and the rating reads a release as this kind only when both are there.
+//
+// could_not_start. The flight let the claim go before the engine ran, because the
+// build machine could not start the job (no room on the disk, a build copy that
+// would not open, a lease that would not set, a brief that would not save). The
+// builder never touched the work, so the release is neither a drop nor a finished
+// job. The kind goes alone, with no pull request, and only the flights pass it.
 //
-// A release says this by passing both fields. The task db refuses half of a
-// marker, and the rating reads a release as this kind only when both are there.
+// The kind checks itself. A builder shares the task store with the flight, so
+// the store and the rating take it only for a claim whose engine was never
+// asked. Right before it asks the assigned engine, the flight writes a
+// build_started event on the claim (see markBuildStarted in task-db.js). A
+// release that carries could_not_start on a claim with that event is an
+// ordinary release, and the rating reads it as a drop. Scout and prep passes
+// run before the mark, so they never count as the build starting.
 
 const PROOF_NOT_SAVED = 'proof_not_saved';
+const COULD_NOT_START = 'could_not_start';
+// The event type of that mark.
+const BUILD_STARTED = 'build_started';
 
 // True for a release event payload that carries the kind and an open pull
 // request it can point at. Anything less is an ordinary release.
@@ -24,4 +41,11 @@ function isProofNotSaved(payload) {
   return (Number.isInteger(pr.number) && pr.number > 0) || /^https?:\/\//i.test(String(pr.url || '').trim());
 }
 
-module.exports = { PROOF_NOT_SAVED, isProofNotSaved };
+// True for a release event payload that carries the could-not-start kind.
+// Anything else, including the same words with no field, is an ordinary release.
+function isCouldNotStart(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
+  return payload.kind === COULD_NOT_START;
+}
+
+module.exports = { PROOF_NOT_SAVED, COULD_NOT_START, BUILD_STARTED, isProofNotSaved, isCouldNotStart };

package/lib/review-integrity.js

@@ -59,20 +59,65 @@ function reviewEventActors(task) {
   return actors;
 }
 
-// Actors who reviewed the task and are not its builder.
+// Everyone who ever built the task: the stamped builder, the current claimant, whoever any claim
+// event on file names, and whoever handed work in on it (the proof_ready events that carry a
+// handed_in_by mark; a review pass leaves none) together with the others that hand-in names as
+// having built the work with it (its built_with list: a flight that ran for a member hands in under
+// the member's name, and the engines that ran are named there). Authorship is cumulative and nothing clears it, so
+// sending a job back, letting the claim go or reopening it never makes a past builder look
+// independent again. The system's own names (RESERVED_ACTORS) record passes and checks, never
+// builds, so an event under one of them makes no author. `task.events` is whatever the caller has
+// of the job's history; a caller with the whole history (the store's authorsOfTask) gets the whole
+// answer.
+function taskAuthors(task) {
+  const authors = new Set();
+  if (!task || typeof task !== 'object') return authors;
+  const add = (value, { fromEvent = false } = {}) => {
+    const name = normalizeActor(value);
+    if (name && !(fromEvent && RESERVED_ACTORS.has(name))) authors.add(name);
+  };
+  const metadata = task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  add(metadata.built_by);
+  add(task.claimed_by);
+  const events = Array.isArray(task.events) ? task.events : [];
+  for (const event of events) {
+    if (!event || typeof event !== 'object') continue;
+    const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
+    if (event.event_type === 'claimed') add(payload.claimed_by || event.actor, { fromEvent: true });
+    else if (event.event_type === 'proof_ready') {
+      add(payload.handed_in_by, { fromEvent: true });
+      // A list of names, not a string to split; anything in it that is not a name is no author.
+      if (Array.isArray(payload.built_with)) {
+        for (const name of payload.built_with) if (typeof name === 'string') add(name, { fromEvent: true });
+      }
+    }
+  }
+  return authors;
+}
+
+// Whether this actor ever built the task (see taskAuthors), or is the builder the older rules
+// resolve for a row with no other record (taskBuilder).
+function isTaskAuthor(task, actor) {
+  const name = normalizeActor(actor);
+  if (!name || !task || typeof task !== 'object') return false;
+  return taskAuthors(task).has(name) || taskBuilder(task) === name;
+}
+
+// Actors who reviewed the task and never built any of it.
 function independentReviewActors(task) {
   const builder = taskBuilder(task);
   const actors = reviewEventActors(task);
   if (builder) actors.delete(builder);
+  for (const author of taskAuthors(task)) actors.delete(author);
   return actors;
 }
 
-// True when at least one review pass came from someone other than the
-// builder. When the builder cannot be resolved at all, fall back to
-// requiring two distinct actors. Independence cannot be proven from one.
+// True when at least one review pass came from someone who never built any of the task. When
+// nobody can be resolved as its builder at all, fall back to requiring two distinct actors.
+// Independence cannot be proven from one.
 function hasIndependentReview(task) {
   const builder = taskBuilder(task);
-  if (!builder) return reviewEventActors(task).size >= 2;
+  if (!builder && taskAuthors(task).size === 0) return reviewEventActors(task).size >= 2;
   return independentReviewActors(task).size >= 1;
 }
 
@@ -138,6 +183,8 @@ module.exports = {
   normalizeActor,
   isFleetEngineActor,
   taskBuilder,
+  taskAuthors,
+  isTaskAuthor,
   reviewEventActors,
   independentReviewActors,
   hasIndependentReview,