samagotchi 0.128.0 → 0.130.0

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).
@@ -1241,7 +1245,8 @@ module Samagotchi
         # status, its rings and every save from here on say so.
         @session.parent_id = Session.parent_override(@session_id, state_dir: @state_dir) || @session.parent_id
         save_session
-        result = @engine.run_turn(@session, prompt, pending_input: pending_input_drain, **turn_args)
+        result = @engine.run_turn(@session, prompt, pending_input: pending_input_drain, input_waiting: method(:input_waiting?),
+                                                    **turn_args)
       rescue StandardError => e
         error = e
         # Still running: no turn of the Engine's ended (it never began).
@@ -1464,6 +1469,13 @@ module Samagotchi
       end
     end
 
+    # Whether a person's message waits that the next boundary merges
+    # (SessionInbox.steer_waiting?): a running task_wait ends on it. Never
+    # in a participant's turn, whose drain merges none.
+    def input_waiting?
+      !@participant_turn && SessionInbox.steer_waiting?(@session_dir)
+    end
+
     # A participant's author fields (Engine#author_fields), {} for the owner.
     def turn_author_fields(origin)
       origin.participant? ? @engine.author_fields(origin.author, session: @session) : {}
@@ -1583,41 +1595,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 +1696,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 +1725,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.130.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -342,6 +342,7 @@ files:
 - lib/samagotchi/guardrails.rb
 - lib/samagotchi/guardrails/approval.rb
 - lib/samagotchi/guardrails/approvals.rb
+- lib/samagotchi/guardrails/chi_dirs.rb
 - lib/samagotchi/guardrails/child_boundary.rb
 - lib/samagotchi/guardrails/context.rb
 - lib/samagotchi/guardrails/data_readers.rb
@@ -354,6 +355,7 @@ files:
 - lib/samagotchi/guardrails/parent_approvals.rb
 - lib/samagotchi/guardrails/parent_levels.rb
 - lib/samagotchi/guardrails/parent_policy.rb
+- lib/samagotchi/guardrails/path_resolve.rb
 - lib/samagotchi/guardrails/protected_paths.rb
 - lib/samagotchi/guardrails/read_only_shell.rb
 - lib/samagotchi/guardrails/review_boundary.rb