ace-assign 0.71.0 → 0.73.0

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

@@ -1,146 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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