samagotchi 0.128.0 → 0.129.0

data/lib/samagotchi/terminal_ui/local_link.rb

@@ -57,7 +57,7 @@ module Samagotchi
         id = @session_id
         return [:gone, "stopped"] if Session.stopped_marker?(id, state_dir: @state_dir)
 
-        link = WorkerLink.resolve(session_dir, unlink: true, host: @host)
+        link = WorkerLink.resolve(session_dir, unlink: true)
         if link.is_a?(WorkerLink::Skew)
           @failure = link.message(id)
           return [:gone, "worker_newer"]
@@ -79,7 +79,7 @@ module Samagotchi
         candidate = if found&.port == port
                       found
                     else
-                      link = WorkerLink.resolve(session_dir, unlink: true, host: @host)
+                      link = WorkerLink.resolve(session_dir, unlink: true)
                       link.live? && link.port == port ? link.client(@session_id, host: @host) : nil
                     end
         @client = candidate if candidate

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.128.0"
+  VERSION = "0.129.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -118,6 +118,9 @@ module Samagotchi
       # Seconds GET /api/models waits for the hosts' lists before answering
       # with what it has (the listing goes on and fills the registry's cache).
       MODELS_WAIT_TIMEOUT = 4.0
+      # The one refusal for an update operation (an install, a workers
+      # restart, a chi web restart) asked while another one runs: 409 update_running.
+      UPDATE_RUNNING = "a chi update operation is already running; try again when it ends"
       EVENTS_POLL = 1.0
 
       # A callable the event loops ask whether the server still runs;
@@ -702,7 +705,7 @@ module Samagotchi
             false
           end
         end
-        return error_response(409, "update_running", "an update is already running") if already_running
+        return error_response(409, "update_running", UPDATE_RUNNING) if already_running
 
         @hub.publish_update(state: "running", rows: [], operation: "install", version: version)
         Thread.new { perform_update(version) }
@@ -774,7 +777,7 @@ module Samagotchi
             false
           end
         end
-        return error_response(409, "update_running", "a chi update operation is already running") if already_running
+        return error_response(409, "update_running", UPDATE_RUNNING) if already_running
 
         @hub.publish_update(state: "running", rows: [], operation: "workers")
         Thread.new { perform_worker_restarts }
@@ -834,7 +837,7 @@ module Samagotchi
           @update_running = true # held for good once restarting: the exec ends this process
           false
         end
-        return error_response(409, "update_running", "a chi update operation is running; restart chi web when it ends") if busy
+        return error_response(409, "update_running", UPDATE_RUNNING) if busy
 
         case @restart_web.call
         when true then return json_response(202, { state: "restarting" })
@@ -1721,8 +1724,7 @@ module Samagotchi
                            outcome.is_a?(WorkerLink::Leaving) || outcome.is_a?(WorkerLink::Stale) ||
                              outcome.is_a?(WorkerLink::Skew) ||
                              (outcome.is_a?(WorkerLink::Starting) && outcome.stuck)
-                         end,
-                         host: DEFAULT_HOST)
+                         end)
       end
 
       def stream_link_error(id, link)
@@ -1741,7 +1743,7 @@ module Samagotchi
       def stream_open_error(id, outcome)
         return error_response(503, "not_live", WorkerLink.unanswered(id)) if outcome.is_a?(BridgeClient::StreamOpen::Unreachable)
         return error_response(503, "not_live", WorkerLink.not_live(id)) if outcome.reason == :unknown_session
-        return error_response(502, "bridge_secret", BridgeSecret.refused(id)) if outcome.reason == :bridge_secret
+        return error_response(502, BridgeSecret::ERROR, BridgeSecret.refused(id)) if outcome.reason == :bridge_secret
 
         error_response(502, "bridge_error", outcome.detail || "the session's worker answered #{outcome.status}")
       end
@@ -1752,7 +1754,7 @@ module Samagotchi
       # @return [WorkerLink::Live, WorkerLink::None, WorkerLink::Stale]
       def worker_link(session_id)
         dir = @session_class.session_dir(session_id, state_dir: default_state_dir)
-        WorkerLink.resolve(dir, unlink: true, host: DEFAULT_HOST)
+        WorkerLink.resolve(dir, unlink: true)
       rescue StandardError
         WorkerLink::None.new
       end

data/lib/samagotchi/web/public/app.js

@@ -60,7 +60,7 @@ import { createSystemOneWrongAction } from "./system_one_wrong.js";
 import { appendQuote } from "./annotations.js";
 import { applyComposerText, applyRowTemplate, fetchApply } from "./review_apply.js";
 import { CHECK_NOT_ON_PAGE, nameVerdictCards, ownerCheckHash } from "./verdict_card.js";
-import { freshURL, placeVerdictWithFresh, settleRunning } from "./verdict_fresh.js";
+import { freshURL, placeVerdictWithFresh, redrawFresh, settleRunning } from "./verdict_fresh.js";
 import { authorBadge, nameUnnamedBadges } from "./participant_names.js";
 import { parsePresets } from "./annotate_presets.js";
 import { createAnnotateBar } from "./annotate_bar.js";
@@ -590,8 +590,13 @@ function copyUpdateCommand(command) {
 function followSelectedSession(sess) {
   current.owner = sess.owner || null;
   current.workerVersion = sess.worker_version || null;
+  const verifyWas = verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp);
   current.workerFeatures = Array.isArray(sess.worker_features) ? sess.worker_features : [];
   current.bridgeUp = sess.bridge_up === true;
+  // The Verify gate flipped (a restart brought the feature): the cards' Verify fresh part follows.
+  if (verifyWas !== verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp)) {
+    redrawFresh(historyEl, verifyFreshState());
+  }
   const streaming = !!(streamControl && streamControl.live);
   if (!streaming) current.status = sess.status;
   updateInfoBar();
@@ -1356,6 +1361,7 @@ function placeVerdict(record) {
 
 // The owner's Verify fresh on an unclear verdict's card (verdict_fresh.js):
 // always theirs to start; its running check links to the child's session.
+const verifyFreshErrors = {};
 function verifyFreshState() {
   const id = selected;
   const unavailable = verifyWorkerUnavailable(current.workerFeatures, current.bridgeUp);
@@ -1363,6 +1369,7 @@ function verifyFreshState() {
   return {
     verdicts: current.verdicts || [],
     running: current.verifyFresh,
+    errors: verifyFreshErrors,
     canStart: !!id && !unavailable,
     unavailableReason: unavailable ? VERIFY_UNAVAILABLE : null,
     start: async (of) => {

data/lib/samagotchi/web/public/participant.js

@@ -434,12 +434,14 @@ function renderThread() {
 // participant starts one while their grant could run a turn now
 // (can_comment); the owner looking through the participant view never
 // does, and no one here gets a link to the child's session.
+const freshErrors = {};
 function verifyFreshState() {
   if (!Array.isArray(data.fresh_running)) data.fresh_running = [];
   const unavailable = data.session?.verify_unavailable === true;
   return {
     verdicts: data.verdicts || [],
     running: data.fresh_running,
+    errors: freshErrors,
     canStart: !unavailable && !ownerView && !ended && !!data.viewer?.can_comment,
     unavailableReason: unavailable ? VERIFY_UNAVAILABLE : null,
     start: async (of) => {

data/lib/samagotchi/web/public/verdict_fresh.js

@@ -29,7 +29,8 @@ export function settleRunning(running, record) {
 // Places a session verdict as the pages draw them: an original verdict's
 // card (verdict_card.js) with its Verify fresh part, or a fresh verdict on
 // its original's card. +fresh+: {verdicts (all of the session's), running
-// (the page's own array; a start adds to it), canStart, start(of) → Promise
+// (the page's own array; a start adds to it), errors (the page's own
+// object, check id → the last start error, so a redraw shows it again), canStart, start(of) → Promise
 // of {ok, child_id, error}, childHref(id) → a link to the child or null}.
 export function placeVerdictWithFresh(root, record, opts = {}, fresh = {}) {
   if (record?.fresh) {
@@ -43,6 +44,11 @@ export function placeVerdictWithFresh(root, record, opts = {}, fresh = {}) {
   return card;
 }
 
+// Every verdict card under +root+ drawn again from +fresh+ (the gate changed).
+export function redrawFresh(root, fresh = {}) {
+  for (const card of root?.querySelectorAll?.(".verify-verdict") || []) renderFresh(card, fresh);
+}
+
 // The card's Verify fresh part, drawn again from +fresh+: the fresh
 // verdicts, the running check, else the button (an unclear verdict, and a
 // viewer who could run a turn now).
@@ -100,10 +106,11 @@ export function renderFresh(card, fresh = {}) {
     part.append(button);
   }
 
-  if (card.dataset.freshError) {
+  const error = (fresh.errors ||= {})[of];
+  if (error) {
     const line = doc.createElement("p");
     line.className = "verify-fresh-error";
-    line.textContent = card.dataset.freshError;
+    line.textContent = error;
     part.append(line);
   }
   if (part.childNodes.length) card.append(part);
@@ -120,12 +127,12 @@ async function startFresh(card, button, fresh) {
     result = { ok: false, error: error?.message };
   }
   if (result?.ok) {
-    delete card.dataset.freshError;
+    if (fresh.errors) delete fresh.errors[of];
     if (fresh.running && !fresh.running.some((entry) => runningOf(entry) === of)) {
       fresh.running.push(result.child_id ? { of, child_id: result.child_id } : of);
     }
   } else {
-    card.dataset.freshError = result?.error || "Couldn't start a fresh check.";
+    (fresh.errors ||= {})[of] = result?.error || "Couldn't start a fresh check.";
   }
   renderFresh(card, fresh);
 }

data/lib/samagotchi/worker.rb

@@ -168,6 +168,10 @@ module Samagotchi
       @loop_started = false
       @left_loop = false
       @signal_mutex = Mutex.new
+      # The exit being taken or taken (:exit, :delete, :restart), claimed
+      # under its own lock before #exit_request's slow stop-all (#claim_exit).
+      @exit_claim = nil
+      @exit_claim_mutex = Mutex.new
       @grace_expired = false
       # The running turn has ended (its end event) and its after_turn hooks
       # run: a signal's grace waits for them (#signalled).
@@ -1583,41 +1587,89 @@ module Samagotchi
     def exit_request(client_id, delete: false, restart: false, stop: false, ask: true)
       # The Bridge serves before the idle-exit policy exists.
       return WorkerIdleExit::Hold.new(reason: :starting) unless @idle_exit
-      # One exit is already taken: the first one decides how the worker
-      # leaves (a later stop-all can't turn a restart, whose reminders go to
-      # the next worker, into a plain exit). Held at the leave, it is
-      # forgotten and the next request counts again.
-      return nil if @exit_requested
 
-      if restart
-        hold = @idle_exit.hold_for_restart
-        return WorkerIdleExit::Hold.new(reason: hold) if hold
-      else
-        # /exit names the tasks it waits for (D3), from the one look that found them.
-        # The ask covers the delegate children too, but only for a plain /exit: an
-        # exit that deletes the session, or one a UI won't ask about, ignores them.
-        hold = @idle_exit.request_hold(requester: client_id, hint: TASK_STOP_HINT, ask: ask && !delete)
-        if hold
-          # A hold the user can't stop here: no ask, today's refusal.
-          return hold unless hold.ask?
-          # The ask's 409: the list, for the terminal to ask with.
-          return hold unless stop
-
-          @stopped_holds = @hold_stop.stop_all
-          # An unstoppable hold may have arrived while stopping (a child stopped
-          # here is no longer counted).
-          recheck = @idle_exit.request_hold(requester: client_id, hint: TASK_STOP_HINT)
-          return recheck if recheck
-        end
+      kind = if restart then :restart
+             elsif delete then :delete
+             else :exit
+             end
+      # One exit at a time, and the first one taken decides how the worker
+      # leaves (a later stop-all can't turn a restart, whose reminders go to
+      # the next worker, into a plain exit): claimed before the slow
+      # stop-all, so a request of another kind meanwhile is refused (409),
+      # not told it went through. Held at the leave, it is forgotten and the
+      # next request counts again.
+      refused = claim_exit(kind)
+      return refused.value if refused
+
+      hold = exit_hold(client_id, kind: kind, stop: stop, ask: ask)
+      if hold
+        forget_exit
+        return hold
       end
 
       @stopped_holds = nil unless stop
-      @exit_requested = true
       @exit_requested_by = client_id
-      @exit_deletes = delete && !restart
-      @exit_restart = restart
+      @exit_deletes = kind == :delete
+      @exit_restart = kind == :restart
+      @exit_requested = true
       @waker.wake
       nil
+    rescue StandardError
+      # A look or a stop that raised lets the claim go (the Bridge answers 500).
+      forget_exit unless @exit_requested
+      raise
+    end
+
+    # One answer for an exit request that doesn't get the claim, boxed so a
+    # nil (accepted) is told apart from "claimed".
+    ExitRefused = Data.define(:value)
+
+    # @return [ExitRefused, nil] nil when this request now holds the claim;
+    #   else its answer: nil (accepted: an exit of the same kind is already
+    #   taken) or WorkerIdleExit.leaving (one of another kind is, or is still
+    #   being taken)
+    def claim_exit(kind)
+      @exit_claim_mutex.synchronize do
+        next ExitRefused.new(value: nil) if @exit_claim == kind && @exit_requested
+        next ExitRefused.new(value: WorkerIdleExit.leaving(@exit_claim)) if @exit_claim
+
+        @exit_claim = kind
+        nil
+      end
+    end
+
+    # The taken exit is let go: held at the leave, or its hand-off failed.
+    def forget_exit
+      @exit_claim_mutex.synchronize do
+        @exit_requested = nil
+        @exit_restart = false
+        @exit_claim = nil
+      end
+    end
+
+    # What keeps the worker up for this request, nil when nothing does; a
+    # stop request stops what the user can stop first (#exit_request).
+    # @return [WorkerIdleExit::Hold, nil]
+    def exit_hold(client_id, kind:, stop:, ask:)
+      if kind == :restart
+        hold = @idle_exit.hold_for_restart
+        return hold && WorkerIdleExit::Hold.new(reason: hold)
+      end
+
+      # /exit names the tasks it waits for (D3), from the one look that found them.
+      # The ask covers the delegate children too, but only for a plain /exit: an
+      # exit that deletes the session, or one a UI won't ask about, ignores them.
+      hold = @idle_exit.request_hold(requester: client_id, hint: TASK_STOP_HINT, ask: ask && kind != :delete)
+      return nil unless hold
+      # A hold the user can't stop here: no ask, today's refusal.
+      return hold unless hold.ask?
+      # The ask's 409: the list, for the terminal to ask with.
+      return hold unless stop
+
+      @stopped_holds = @hold_stop.stop_all
+      # An unstoppable hold may have arrived while stopping (a child stopped
+      # here is no longer counted).
+      @idle_exit.request_hold(requester: client_id, hint: TASK_STOP_HINT)
     end
 
     # #leave_idle for an exit a client asked for: check again with the event
@@ -1636,8 +1688,7 @@ module Samagotchi
                    @idle_exit.hold_for_request(requester: @exit_requested_by, streams: false)
                  end
           if hold
-            @exit_requested = nil
-            @exit_restart = false
+            forget_exit
             Log.info(:worker, "exit_held", reason: hold)
             next false
           end
@@ -1666,8 +1717,7 @@ module Samagotchi
       end
       true
     rescue StandardError => e
-      @exit_requested = nil
-      @exit_restart = false
+      forget_exit
       Log.warn(:worker, "reminders_carry_failed", error: e.class.name, msg: e.message)
       false
     end

data/lib/samagotchi/worker_idle_exit.rb

@@ -39,6 +39,23 @@ module Samagotchi
       def ask? = !holds.empty?
     end
 
+    # The 409 reason for an exit request when another client's exit, of
+    # another kind, is already taken (Worker#exit_request): the first one
+    # decides how the worker leaves, so a restart asked after a plain /exit
+    # is refused rather than told "restarting".
+    LEAVING = { exit: :leaving_exit, delete: :leaving_delete, restart: :leaving_restart }.freeze
+    # What each of those says, for every client's refusal line
+    # (TerminalUI::ExitLines, SessionManager::RestartRefused).
+    LEAVING_WORDS = {
+      leaving_exit: "the worker is already leaving as a plain exit",
+      leaving_delete: "the worker is already leaving as an exit that deletes the session",
+      leaving_restart: "the worker is already leaving as a restart"
+    }.freeze
+
+    # @param kind [Symbol] the exit already taken (:exit, :delete or :restart)
+    # @return [Hold] the refusal for a request of another kind
+    def self.leaving(kind) = Hold.new(reason: LEAVING.fetch(kind))
+
     # One kind of hold the exit ask offers to stop: +kind+ (:reminders,
     # :background_tasks or :delegates) and its +items+ (#HoldItem). The 409's
     # +holds+ is this in JSON: `{kind:, items: [{id:, label:, detail:}]}`.

data/lib/samagotchi/worker_link.rb

@@ -121,7 +121,7 @@ module Samagotchi
     # @param owner [OwnerLock::Owner, nil, :read] the lock's holder as the
     #   caller already read it (nil: free); :read reads it here
     # @return [Live, Starting, Leaving, None, Stale, Skew]
-    def resolve(session_dir, unlink:, owner: :read, host: BridgeClient::HOST)
+    def resolve(session_dir, unlink:, owner: :read)
       owner = OwnerLock.owner(session_dir) if owner == :read
       stamp = file_stamp(session_dir)
       sidecar = WorkerSidecar.read(session_dir)
@@ -136,7 +136,7 @@ module Samagotchi
 
     # @return [BridgeClient, nil] a client for the session's Live worker
     def client(session_id, session_dir:, unlink: true, host: BridgeClient::HOST, read_timeout: BridgeClient::READ_TIMEOUT)
-      link = resolve(session_dir, unlink: unlink, host: host)
+      link = resolve(session_dir, unlink: unlink)
       link.live? ? link.client(session_id, host: host, read_timeout: read_timeout) : nil
     end
 
@@ -152,11 +152,11 @@ module Samagotchi
     # @return [Live, Starting, Leaving, None, Stale, Skew] the outcome it
     #   stopped at, else the last one seen
     def await(_session_id, session_dir:, timeout:, unlink: true, interval: BridgeClient::SPAWN_POLL_INTERVAL,
-              until: nil, give_up: nil, host: BridgeClient::HOST)
+              until: nil, give_up: nil)
       wanted = binding.local_variable_get(:until) # a keyword: no plain read
       last = nil
       found = BridgeClient.poll(timeout, interval: interval) do
-        last = resolve(session_dir, unlink: unlink, host: host)
+        last = resolve(session_dir, unlink: unlink)
         last if (last.live? && (wanted.nil? || wanted.call(last))) || give_up&.call(last)
       end
       found || last
@@ -189,7 +189,15 @@ module Samagotchi
     def unowned(session_dir, sidecar, owner, stamp, unlink)
       return None.new(owner: owner) unless sidecar
 
-      unlink_unchanged(session_dir, stamp) if unlink
+      if unlink
+        # A worker that took the lock and wrote its sidecar since the lock
+        # was read (before the stamp): its fresh file is the one stamped, so
+        # read the lock again just before the unlink, and take that worker.
+        fresh = OwnerLock.owner(session_dir)
+        return resolve(session_dir, unlink: false, owner: fresh) if fresh&.worker?
+
+        unlink_unchanged(session_dir, stamp)
+      end
       Stale.new(sidecar: sidecar, reason: :lock_free, owner: owner)
     end
     private_class_method :unowned

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.128.0
+  version: 0.129.0
 platform: ruby
 authors:
 - Dmitry Dedov