ace-assign 0.70.0 → 0.71.0

data/lib/ace/assign/organisms/ordinary_driver.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "tmpdir"
+require "fileutils"
+require_relative "../authority/retained_input"
+require_relative "../authority/prepared_work"
+require_relative "../authority/transfer_codec"
+require_relative "../molecules/journal_mutation"
+require_relative "../models/execution_receipt"
+require_relative "../models/assignment"
+require_relative "../molecules/queue_scanner"
+
+module Ace
+  module Assign
+    module Organisms
+      # Operator protocol over the installed owner supplied by the composition.
+      # Files retain requests only; every observation comes from that owner.
+      class OrdinaryDriver
+        Files = Authority::RetainedInput
+        CONTEXT_KEYS = %w[version project_id assignment_id attempt_id scope pane supervisor_pane cwd head provider].freeze
+        attr_reader :context, :path
+
+        def initialize(path:, project:, transport:)
+          @path = File.expand_path(path)
+          @context = Files.json(@path)
+          unless @context.is_a?(Hash) && @context.keys.sort == CONTEXT_KEYS.sort && @context["version"] == 1 &&
+              @context["project_id"] == project && %w[project_id assignment_id attempt_id].all? { |key|
+                @context[key].is_a?(String) && Molecules::JournalMutation::ID.match?(@context[key]) } &&
+              @context["scope"].is_a?(String) && Authority::PreparedWork::SCOPE.match?(@context["scope"]) &&
+              %w[pane supervisor_pane].all? { |key| @context[key].is_a?(String) && @context[key].match?(/\A[\w.:-]{1,128}\z/) } &&
+              @context["cwd"].is_a?(String) && @context["cwd"].start_with?("/") &&
+              File.expand_path(@context["cwd"]) == @context["cwd"] && @context["head"].is_a?(String) &&
+              @context["head"].match?(/\A[0-9a-f]{40}\z/) && @context["provider"].is_a?(String) &&
+              @context["provider"].bytesize.between?(1, 512)
+            raise ArgumentError, "ordinary driver selection differs; retain the original context"
+          end
+          @root = Authority::PrivateDirectory.verify!(File.dirname(@path))
+          @transport = transport
+        end
+
+        def status
+          reply = read("result_status", selection)
+          data = reply.fetch("data")
+          unless data.values_at("project_id", "assignment_id", "attempt_id") == context.values_at("project_id", "assignment_id", "attempt_id")
+            raise AttemptErrors::EvidenceUnavailable, "canonical status belongs to another execution"
+          end
+          data
+        end
+
+        def start(pane:)
+          worker!(pane)
+          mutate("start", "start_attempt", selection.merge("expected_generation" => 0,
+            "pane" => pane, "scope" => context.fetch("scope"), "head" => context.fetch("head")))
+        end
+
+        def supervisor
+          data = read("supervisor_status", context.slice("assignment_id")).fetch("data")
+          unless data.values_at("project_id", "assignment_id") == context.values_at("project_id", "assignment_id")
+            raise AttemptErrors::EvidenceUnavailable, "canonical supervisor belongs to another assignment"
+          end
+          data
+        end
+
+        def adopt_supervisor(pane:, generation:, previous_binding_sha256:)
+          mutate("supervisor-#{generation}", "adopt_supervisor", context.slice("assignment_id").merge(
+            "pane" => pane, "expected_generation" => generation, "previous_binding_sha256" => previous_binding_sha256))
+        end
+
+        def queue
+          reply, bytes = snapshot("assignment_snapshot", selection.merge("kind" => "queue"))
+          data = reply.fetch("data")
+          unless data.values_at("project_id", "assignment_id", "attempt_id", "scope") ==
+              context.values_at("project_id", "assignment_id", "attempt_id", "scope") &&
+              Digest::SHA256.hexdigest(bytes) == data.fetch("sha256")
+            raise AttemptErrors::EvidenceUnavailable, "canonical queue belongs to another execution"
+          end
+          value = JSON.parse(bytes)
+          assignment = Models::Assignment.new(id: context.fetch("assignment_id"), name: "ordinary",
+            created_at: Time.now.utc, source_config: "canonical", cache_dir: @root)
+          state = Molecules::QueueScanner.new.scan_captured(steps: value.fetch("steps"),
+            reports: value.fetch("reports"), assignment: assignment)
+          scope = context.fetch("scope")
+          current = state.current_in_subtree(scope)
+          next_step = state.next_workable_in_subtree(scope)
+          data.merge("complete" => state.subtree_complete?(scope), "failed" => state.subtree_failed?(scope),
+            "current" => step(current), "next" => step(next_step), "reports" => value.fetch("reports"))
+        end
+
+        def bootstrap(output:)
+          # Accepted task/context bytes are recovered from the canonical owner,
+          # not the worker checkout's possibly older mutable task files.
+          reply, bytes = snapshot("assignment_snapshot", selection.merge("attempt_id" => nil, "kind" => "prepared_work"))
+          data = reply.fetch("data")
+          unless data.values_at("project_id", "assignment_id") == context.values_at("project_id", "assignment_id")
+            raise AttemptErrors::EvidenceUnavailable, "canonical preparation belongs to another assignment"
+          end
+          reference = data.fetch("prepared_work")
+          work = Authority::PreparedWork.admit(bytes: bytes, sha256: data.fetch("sha256"), size: data.fetch("bytes"),
+            head: reference.fetch("prepared_head"), tree: reference.fetch("prepared_tree"), root: @root,
+            deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + 30)
+          unless work.reference(head: reference.fetch("prepared_head"), tree: reference.fetch("prepared_tree")) == reference &&
+              work.manifest.values_at("project_id", "assignment_id", "scope") == context.values_at("project_id", "assignment_id", "scope")
+            raise AttemptErrors::EvidenceUnavailable, "canonical prepared scope differs"
+          end
+          directory = Files.create_output(output)
+          inventory = work.manifest.fetch("context").each_with_index.flat_map do |entry, index|
+            selected = %w[spec text].map { |kind| [kind, entry.fetch(kind)] } +
+              entry.fetch("reports").each_with_index.map { |report, number| ["report-#{number}", report.fetch("file")] }
+            selected.map do |kind, source|
+              content = work.files.fetch(source.fetch("filename"))
+              filename = "context-#{index}-#{kind}.md"
+              Files.write_file(directory, filename, content)
+              {"task_id" => entry.fetch("task_id"), "kind" => kind, "path" => File.join(directory, filename),
+                "sha256" => Digest::SHA256.hexdigest(content), "bytes" => content.bytesize}
+            end
+          end
+          {"project_id" => context.fetch("project_id"), **selection, "scope" => context.fetch("scope"),
+            "manifest_sha256" => work.manifest_sha256, "files" => inventory, "journal_commit" => data.fetch("journal_commit")}
+        end
+
+        def progress(operation:, pane:, generation:, step: nil, report: nil, message: nil)
+          worker!(pane)
+          params = selection.merge("expected_generation" => generation, "pane" => pane)
+          parts = []
+          case operation
+          when "queue_start" then params["step"] = step
+          when "queue_finish"
+            params["step"] = step
+            parts << Files.read_file(report, 65_536)
+          when "queue_fail" then params["message"] = message
+          else raise ArgumentError, "unknown ordinary queue operation"
+          end
+          mutate("progress-#{generation}", operation, params, parts)
+        end
+
+        def submit(pane:, generation:, receipt:, artifacts: [])
+          worker!(pane)
+          bytes = Files.read_file(receipt, 16_384)
+          value = JSON.parse(bytes)
+          unless value.values_at("project_id", "assignment_id", "attempt_id", "scope") ==
+              context.values_at("project_id", "assignment_id", "attempt_id", "scope") &&
+              value.fetch("artifacts").size == artifacts.size
+            raise ArgumentError, "result receipt differs from ordinary selection"
+          end
+          parts = artifacts.each_with_index.map do |file, index|
+            content = Files.read_file(file, Authority::TransferCodec::LIMITS.fetch(:receipt_artifacts).last)
+            unless Digest::SHA256.hexdigest(content) == value.fetch("artifacts").fetch(index).fetch("sha256")
+              raise ArgumentError, "result artifact differs from its receipt"
+            end
+            content
+          end
+          params = selection.merge("expected_generation" => generation,
+            "pane" => pane, "head" => value.fetch("head"), "receipt_sha256" => Digest::SHA256.hexdigest(bytes))
+          verify_result_intent!(params, [bytes] + parts)
+          observed = status
+          if (accepted = observed.fetch("submitted_result"))
+            # An accepted result may have lost its reply. Its generation selects
+            # the original input; never mint a replacement mutation to recover it.
+            original_generation = accepted.fetch("generation") - 1
+            input = File.join(@root, "requests", "result-#{original_generation}", "request.json")
+            original = Files.json(input)
+            expected = document("submit_result", params.merge("expected_generation" => original_generation), nil,
+              inventory([bytes] + parts))
+            unless original.except("mutation_id") == expected.except("mutation_id")
+              raise ArgumentError, "accepted result differs from retained original input"
+            end
+            return replay(input: input).merge("request" => input)
+          end
+          unless observed.fetch("state") == "running" && observed.fetch("generation") == generation
+            raise AttemptErrors::EvidenceUnavailable, "result requires the current canonical generation; retain original inputs"
+          end
+          reply = mutate("result-#{generation}", "submit_result", params, [bytes] + parts)
+          signal_result(reply.fetch("data"))
+          reply
+        end
+
+        def adopt(pane:)
+          owner = supervisor
+          raise ArgumentError, "ordinary result owner pane differs" unless pane == owner.fetch("binding").fetch("pane")
+          observed = status
+          return {"status" => "ok", "data" => observed} if %w[succeeded failed].include?(observed.fetch("state"))
+          result = observed.fetch("submitted_result")
+          raise AttemptErrors::EvidenceUnavailable, "ordinary worker has not submitted a result" unless result
+          mutate("adopt-#{owner.fetch('generation')}-#{observed.fetch('generation')}", "finish", selection.merge("pane" => pane,
+            "expected_generation" => observed.fetch("generation"),
+            **result.slice("result_id", "receipt_digest", "head")))
+        end
+
+        def replay(input:)
+          request = Files.json(input)
+          expected = request["operation"] == "adopt_supervisor" ? context.slice("assignment_id") : selection
+          unless request["project_id"] == context.fetch("project_id") &&
+              request.fetch("params").slice("assignment_id", "attempt_id") == expected &&
+              File.dirname(File.dirname(File.expand_path(input))) == File.join(@root, "requests")
+            raise ArgumentError, "recovery request differs from original execution"
+          end
+          reply = @transport.request(input: input)
+          signal_result(reply.fetch("data")) if request.fetch("operation") == "submit_result"
+          reply
+        end
+
+        private
+
+        def selection = context.slice("assignment_id", "attempt_id")
+
+        # A filesystem watch hint is neither execution state nor a receipt.
+        # Adoption never reads this file, even after restart or forged writes.
+        def signal_result(result)
+          name = "hint-#{SecureRandom.hex(8)}"
+          Files.write_file(@root, name, JSON.generate({"hint_only" => true,
+            "project_id" => context.fetch("project_id"), **selection,
+            "result_id" => result.fetch("result_id")}))
+          File.rename(File.join(@root, name), File.join(@root, "result-hint.json"))
+          File.open(@root) { |file| file.fsync }
+        ensure
+          File.unlink(File.join(@root, name)) if name && File.exist?(File.join(@root, name))
+        end
+
+        def worker!(pane)
+          raise ArgumentError, "ordinary worker pane differs" unless pane == context.fetch("pane")
+        end
+
+        def step(value)
+          value && {"number" => value.number, "name" => value.name, "status" => value.status.to_s,
+            "instructions" => value.instructions, "workflow" => value.workflow, "skill" => value.skill}
+        end
+
+        def read(operation, params)
+          Dir.mktmpdir("ordinary-read-", @root) do |directory|
+            Files.write_file(directory, "request.json", JSON.generate(document(operation, params, nil, [])))
+            @transport.request(input: File.join(directory, "request.json"))
+          end
+        end
+
+        def snapshot(operation, params)
+          Dir.mktmpdir("ordinary-read-", @root) do |directory|
+            Files.write_file(directory, "request.json", JSON.generate(document(operation, params, nil, [])))
+            reply = @transport.request(input: File.join(directory, "request.json"), output: File.join(directory, "snapshot"))
+            entries = reply.fetch("files")
+            raise AttemptErrors::EvidenceUnavailable, "canonical queue snapshot count differs" unless entries.one?
+            [reply, Files.read_file(entries.first.fetch("file"), Authority::PreparedWork::MAX_TOTAL)]
+          end
+        end
+
+        def mutate(key, operation, params, parts = [])
+          request = retain(key, operation, params, parts)
+          @transport.request(input: request).merge("request" => request)
+        rescue StandardError => error
+          raise error.class, "#{error.message}; recover original request #{request || key} before new work"
+        end
+
+        def retain(key, operation, params, parts)
+          directory = File.join(@root, "requests")
+          begin
+            Dir.mkdir(directory, 0o700)
+          rescue Errno::EEXIST
+            Authority::PrivateDirectory.verify!(directory)
+          end
+          raise ArgumentError, "ordinary retained operation key is invalid" unless key.match?(/\A[a-z0-9-]{1,128}\z/)
+          File.open(File.join(directory, ".lock"), File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) do |lock|
+            lock.flock(File::LOCK_EX)
+            target = File.join(directory, key)
+            value = document(operation, params, nil, inventory(parts))
+            if File.exist?(target)
+              Authority::PrivateDirectory.verify!(target)
+              original = Files.json(File.join(target, "request.json"))
+              unless original.except("mutation_id") == value.except("mutation_id")
+                raise ArgumentError, "retained operation changed; replay its exact request or reconcile canonical state"
+              end
+            else
+              scratch = Dir.mktmpdir(".prepare-", directory)
+              begin
+                parts.each_with_index { |bytes, index| Files.write_file(scratch, "part-#{index}", bytes) }
+                value["mutation_id"] = SecureRandom.hex(16)
+                Files.write_file(scratch, "request.json", JSON.generate(value) + "\n")
+                File.rename(scratch, target)
+                File.open(directory) { |handle| handle.fsync }
+              ensure
+                FileUtils.remove_entry(scratch) if File.exist?(scratch)
+              end
+            end
+            File.join(target, "request.json")
+          end
+        end
+
+        def document(operation, params, mutation, parts)
+          {"version" => 1, "project_id" => context.fetch("project_id"), "operation" => operation,
+            "mutation_id" => mutation, "params" => params, "parts" => parts}
+        end
+
+        def inventory(parts)
+          parts.each_with_index.map { |bytes, index|
+            {"file" => "part-#{index}", "bytes" => bytes.bytesize, "sha256" => Digest::SHA256.hexdigest(bytes)} }
+        end
+
+        def verify_result_intent!(params, parts)
+          expected = document("submit_result", params.except("expected_generation"), nil, inventory(parts))
+          Dir.glob(File.join(@root, "requests", "result-*", "request.json")).each do |input|
+            original = Files.json(input)
+            original = original.merge("params" => original.fetch("params").except("expected_generation"))
+            unless original.except("mutation_id") == expected.except("mutation_id")
+              raise ArgumentError, "result retry changed the retained original intent"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Assign
-    VERSION = "0.70.0"
+    VERSION = "0.71.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ace-assign
 version: !ruby/object:Gem::Version
-  version: 0.70.0
+  version: 0.71.0
 platform: ruby
 authors:
 - Michal Czyz
@@ -175,14 +175,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.60.3
+        version: 0.61.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.60.3
+        version: 0.61.0
 - !ruby/object:Gem::Dependency
   name: ace-task
   requirement: !ruby/object:Gem::Requirement
@@ -405,11 +405,13 @@ files:
 - lib/ace/assign/atoms/assign_frontmatter_parser.rb
 - lib/ace/assign/atoms/assignment_scope.rb
 - lib/ace/assign/atoms/attempt_state_machine.rb
+- lib/ace/assign/atoms/candidate_limits.rb
 - lib/ace/assign/atoms/catalog_loader.rb
 - lib/ace/assign/atoms/composition_rules.rb
 - lib/ace/assign/atoms/delivery_parameters.rb
 - lib/ace/assign/atoms/evidence_digest.rb
 - lib/ace/assign/atoms/fixed_merge_schemas.rb
+- lib/ace/assign/atoms/git_blob_batch.rb
 - lib/ace/assign/atoms/number_generator.rb
 - lib/ace/assign/atoms/preset_expander.rb
 - lib/ace/assign/atoms/preset_loader.rb
@@ -423,9 +425,12 @@ files:
 - lib/ace/assign/authority/campaign_consumer_policy.rb
 - lib/ace/assign/authority/campaign_execution.rb
 - lib/ace/assign/authority/campaign_round_transfer.rb
+- lib/ace/assign/authority/candidate_blob_batch.rb
+- lib/ace/assign/authority/candidate_head_comparison.rb
 - lib/ace/assign/authority/candidate_transfer.rb
 - lib/ace/assign/authority/cleanup_result_protection.rb
 - lib/ace/assign/authority/client.rb
+- lib/ace/assign/authority/command_execution.rb
 - lib/ace/assign/authority/deployment.rb
 - lib/ace/assign/authority/deployment_history.rb
 - lib/ace/assign/authority/endcap.rb
@@ -439,10 +444,12 @@ files:
 - lib/ace/assign/authority/endcap_results.rb
 - lib/ace/assign/authority/endcap_review_requests.rb
 - lib/ace/assign/authority/endcap_reviews.rb
+- lib/ace/assign/authority/endcap_service_context.rb
 - lib/ace/assign/authority/endcap_service_settlement.rb
-- lib/ace/assign/authority/endcap_services.rb
 - lib/ace/assign/authority/evidence_transfer.rb
 - lib/ace/assign/authority/execution_scope_observation.rb
+- lib/ace/assign/authority/fixed_publication_lifecycle.rb
+- lib/ace/assign/authority/fixed_service_lifecycle.rb
 - lib/ace/assign/authority/inbox_context_original.rb
 - lib/ace/assign/authority/launch_attempt_consumers.rb
 - lib/ace/assign/authority/launch_campaign_registration.rb
@@ -466,11 +473,16 @@ files:
 - lib/ace/assign/authority/ordinary_completion.rb
 - lib/ace/assign/authority/ordinary_effect_settlement.rb
 - lib/ace/assign/authority/ordinary_lifecycle.rb
+- lib/ace/assign/authority/ordinary_merge_evidence.rb
 - lib/ace/assign/authority/ordinary_peer.rb
 - lib/ace/assign/authority/ordinary_progress.rb
 - lib/ace/assign/authority/ordinary_queue.rb
+- lib/ace/assign/authority/ordinary_release_artifacts.rb
 - lib/ace/assign/authority/ordinary_results.rb
+- lib/ace/assign/authority/ordinary_review_evidence.rb
+- lib/ace/assign/authority/ordinary_reviews.rb
 - lib/ace/assign/authority/ordinary_server.rb
+- lib/ace/assign/authority/ordinary_supervisor.rb
 - lib/ace/assign/authority/original_inbox_selection.rb
 - lib/ace/assign/authority/posix_acl.rb
 - lib/ace/assign/authority/prepared_input.rb
@@ -482,6 +494,8 @@ files:
 - lib/ace/assign/authority/protected_assignment_context.rb
 - lib/ace/assign/authority/readiness_hook.rb
 - lib/ace/assign/authority/receipt_transfer.rb
+- lib/ace/assign/authority/release_artifact_manifest.rb
+- lib/ace/assign/authority/retained_input.rb
 - lib/ace/assign/authority/router.rb
 - lib/ace/assign/authority/server.rb
 - lib/ace/assign/authority/service_cleanup_dispatch.rb
@@ -576,6 +590,7 @@ files:
 - lib/ace/assign/organisms/assignment_executor.rb
 - lib/ace/assign/organisms/attempt_coordinator.rb
 - lib/ace/assign/organisms/delivery_coordinator.rb
+- lib/ace/assign/organisms/ordinary_driver.rb
 - lib/ace/assign/organisms/ordinary_merge_consumer.rb
 - lib/ace/assign/organisms/prepared_work_builder.rb
 - lib/ace/assign/organisms/protected_delivery_coordinator.rb