ace-assign 0.63.1 → 0.66.0

data/lib/ace/assign/authority/launch_scope_close.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module Authority
+      class LaunchLifecycle
+        # Source-owned close core. Its first accepted mutation seals admission
+        # and caches the retained running reply before any manager stop. A
+        # subsequent fresh mutation may record positive observation; replay of
+        # the first mutation always keeps its original reply and performs no I/O.
+        def close_execution_scope!(params:, peer:, role:)
+          strict!(params, %w[mapping_id assignment_id attempt_id mutation_id expected_generation])
+          %w[assignment_id attempt_id mutation_id].each { |key| token!(params.fetch(key)) }
+          generation!(params.fetch("expected_generation"))
+          @kernel.live!(peer)
+          map = @deployment.mapping(params.fetch("mapping_id"))
+          journal = journal_for(map)
+          input = params.reject { |key, _| key == "mutation_id" }
+          digest = Digest::SHA256.hexdigest(JSON.generate(canonical(input)))
+          stop_after_commit = false
+          inhibit_after_commit = false
+          result = with_containment_exclusion(params, map, journal) do
+            result = @mutex.synchronize do
+              current = journal.read_events(params.fetch("assignment_id")).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+              scope_close_owner!(params, map, current, peer, role)
+              journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"),
+                mutation_id: params.fetch("mutation_id"), operation: "close_execution_scope", parameters_digest: digest,
+                expected_generation: params.fetch("expected_generation"), with_replay: true) do |events, _commit, _generation|
+                lineage = scope_close_owner!(params, map, events, peer, role)
+                closure = scope_closure_plan!(lineage: lineage, params: params, map: map, events: events, journal: journal, commit: _commit)
+                stop_after_commit = closure.fetch(:stop_required)
+                inhibit_after_commit = closure.fetch(:inhibit_required)
+                closure.fetch(:plan)
+              end
+            end
+            result
+          end
+          if !result.fetch(:replayed) && inhibit_after_commit
+            request_original_input_inhibition!(params, map, journal)
+          end
+          if !result.fetch(:replayed) && stop_after_commit
+            with_containment_exclusion(params, map, journal) do
+              @mutex.synchronize do
+                current = journal.read_events(params.fetch("assignment_id")).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+                scope_close_owner!(params, map, current, peer, role)
+              end
+              scope_observer_for(params.fetch("mapping_id")).stop_sealed_service!
+            end
+          end
+          result
+        end
+
+        def observe_execution_scope!(params:, peer:, role:)
+          strict!(params, %w[mapping_id assignment_id attempt_id])
+          %w[assignment_id attempt_id].each { |key| token!(params.fetch(key)) }
+          @kernel.live!(peer)
+          map = @deployment.mapping(params.fetch("mapping_id"))
+          journal = journal_for(map)
+          with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              commit = journal.ref_value
+              events = journal.read_events(params.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+              lineage = scope_close_owner!(params, map, events, peer, role)
+              projection = {"attempt_id" => params.fetch("attempt_id"), "scope_generation" => lineage.binding&.fetch("scope_generation"),
+                "state" => "unverifiable", "proof_id" => nil, "required_action" => "inspect_exact_scope",
+                "generation" => journal.authority_generation(events), "journal_commit" => commit}
+              return projection unless lineage.binding
+              begin
+                observation = scope_observer_for(params.fetch("mapping_id")).observe(lineage)
+                if pending_prompt_issuers?(events, journal, commit)
+                  projection.merge("required_action" => "drain_original_prompt_issuer")
+                elsif lineage.proof_event
+                  scope_observer_for(params.fetch("mapping_id")).verify_closed!(lineage)
+                  projection.merge("state" => "closed_no_writers", "proof_id" => lineage.proof_id, "required_action" => nil)
+                elsif lineage.sealed? && observation.fetch("populated").zero?
+                  projection.merge("required_action" => "close_scope")
+                else
+                  projection.merge("state" => "running", "required_action" => "close_scope")
+                end
+              rescue Ace::Runtime::RuntimeUnavailableError, AttemptErrors::EvidenceUnavailable
+                projection
+              end
+            end
+          end
+        end
+
+        private
+
+        # Shared source-only plan for close and public stop. It does not issue
+        # manager/native control, mutate canonical state or acquire exclusions.
+        # Each CAS invocation derives its own post-commit work flags anew.
+        def scope_closure_plan!(lineage:, params:, map:, events:, journal:, commit:)
+          stop_required = false
+          inhibit_required = false
+          binding = lineage.binding
+          raise AttemptErrors::EvidenceUnavailable, "original parent binding is missing" unless binding
+          projection = {"attempt_id" => params.fetch("attempt_id"), "scope_generation" => binding.fetch("scope_generation"),
+            "state" => "running", "proof_id" => nil, "required_action" => "close_scope"}
+          plan = if !lineage.sealed?
+            stop_required = true
+            inhibit_required = true
+            payload = {"scope_generation" => binding.fetch("scope_generation"), "scope_binding_event_id" => lineage.binding_event.fetch("digest")}
+            {events: [{type: "scope_sealed", payload: payload}], blobs: {}, data: projection}
+          elsif @native_issuers.key?(native_issuer_key(params, map)) || pending_prompt_issuers?(events, journal, commit)
+            # A live issuer may still start after this inactive snapshot.
+            inhibit_required = true
+            {events: [], blobs: {}, data: projection}
+          elsif lineage.proof_event
+            scope_observer_for(params.fetch("mapping_id")).verify_closed!(lineage)
+            {events: [], blobs: {}, data: projection.merge("state" => "closed_no_writers", "proof_id" => lineage.proof_id, "required_action" => nil)}
+          elsif scope_observer_for(params.fetch("mapping_id")).sealed_service_stop_required?(lineage)
+            # A fresh canonical close resumes a stop lost after the seal.
+            # Replaying either mutation performs no manager I/O.
+            stop_required = true
+            {events: [], blobs: {}, data: projection}
+          else
+            # This call must return a fresh validated observation, never
+            # a cached population, caller JSON or a manifest boolean.
+            payload = scope_observer_for(params.fetch("mapping_id")).closed_observation_for_proof!(lineage, events: events)
+            expected = binding.slice("scope_generation", "boot_id", "slice_invocation_id", "cgroup_identity").merge(
+              "scope_binding_event_id" => lineage.binding_event.fetch("digest"), "seal_event_id" => lineage.seal_event.fetch("digest"), "populated" => 0)
+            unless payload == expected
+              raise AttemptErrors::EvidenceUnavailable, "fresh observation does not name the retained sealed parent"
+            end
+            at = Time.now.utc
+            event = Models::EvidenceEvent.build(type: "scope_closed_no_writers", attempt_id: params.fetch("attempt_id"),
+              payload: payload, previous_digest: events.last&.fetch("digest"), recorded_at: at)
+            {events: [{type: "scope_closed_no_writers", payload: payload, recorded_at: at}], blobs: {},
+              data: projection.merge("state" => "closed_no_writers", "proof_id" => event.fetch("digest"), "required_action" => nil)}
+          end
+          {plan: plan, stop_required: stop_required, inhibit_required: inhibit_required}
+        end
+
+        def scope_close_owner!(params, map, events, peer, role)
+          state = states(events)[params.fetch("attempt_id")]
+          unless state && state["mapping_id"] == params.fetch("mapping_id") &&
+              (role == :supervisor || role == :launcher && @kernel.same?(state.fetch("launcher_identity"), peer))
+            raise AttemptErrors::UnauthorizedIdentity, "scope closure requires the original launch owner"
+          end
+          Molecules::ExecutionScopeLineage.new(events: events, project_id: map.fetch("project_id"),
+            assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"), mapping_id: params.fetch("mapping_id"))
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/authority/launch_scope_parent.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module Authority
+      class LaunchLifecycle
+        private
+
+        # Called inside the existing slot/assignment exclusion, after the fresh
+        # reservation CAS and outside its authority mutex/journal ref lock.
+        # Mutation replay and restart never call this activation path.
+        def provision_reserved_parent_held!(reservation, map, journal)
+          params = reservation.slice("mapping_id", "assignment_id", "attempt_id")
+          context = params.merge("project_id" => map.fetch("project_id"),
+            "reservation_generation" => reservation.fetch("reservation_generation"),
+            "scope_generation" => reservation.fetch("generation") + 1)
+          observer = scope_observer_for(params.fetch("mapping_id"))
+          binding = observer.activate_parent!(context)
+          @mutex.synchronize do
+            journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"),
+              mutation_id: "scope-parent-#{Digest::SHA256.hexdigest(params.fetch('attempt_id'))[0, 48]}",
+              operation: "scope_parent_binding", parameters_digest: Digest::SHA256.hexdigest(JSON.generate(canonical(context))),
+              expected_generation: reservation.fetch("generation"), with_replay: true) do |events, _commit, _generation|
+              state = states(events)[params.fetch("attempt_id")]
+              unless state && state["phase"] == "reserved" && state["launch_ticket"] == reservation.fetch("launch_ticket") &&
+                  events.none? { |event| %w[scope_bound scope_native_bound scope_child_bound scope_sealed].include?(event["type"]) ||
+                    event["type"] == "authority_mutation" && event.dig("payload", "operation") == "scope_service_admission" }
+                raise AttemptErrors::Conflict, "parent activation cannot replace or reopen an existing generation"
+              end
+              at = Time.now.utc
+              event = Models::EvidenceEvent.build(type: "scope_bound", attempt_id: params.fetch("attempt_id"),
+                payload: binding, previous_digest: events.last&.fetch("digest"), recorded_at: at)
+              lineage = Molecules::ExecutionScopeLineage.new(events: events + [event], project_id: map.fetch("project_id"),
+                assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"), mapping_id: params.fetch("mapping_id"))
+              observer.observe(lineage)
+              {events: [{type: "scope_bound", payload: binding, recorded_at: at}], blobs: {}, data: state.merge(
+                "scope_generation" => binding.fetch("scope_generation"), "scope_binding_event_id" => event.fetch("digest"))}
+            end
+          end
+        end
+      end
+    end
+  end
+end