igniter 0.5.0 → 0.5.2

data/packages/igniter-application/lib/igniter/application/application_host_activation_ledger_commit.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationHostActivationLedgerCommit
+      SCHEMA_VERSION = "activation-ledger-v1"
+      REQUIRED_PACKET_FIELDS = %i[
+        packet_id
+        schema_version
+        transfer_receipt_id
+        activation_readiness_id
+        activation_plan_id
+        activation_plan_verification_id
+        activation_dry_run_id
+        commit_readiness_id
+        operation_digest
+        commit_decision
+        idempotency_key
+        caller_metadata
+        receipt_sink
+        application_host_adapter
+        dry_run
+        commit_readiness
+      ].freeze
+
+      attr_reader :packet, :adapter, :metadata
+
+      def self.commit(evidence_packet, adapter:, metadata: {})
+        new(evidence_packet: evidence_packet, adapter: adapter, metadata: metadata)
+      end
+
+      def initialize(evidence_packet:, adapter:, metadata: {})
+        @packet = normalize_hash(evidence_packet).freeze
+        @adapter = adapter
+        @metadata = metadata.dup.freeze
+        @validation_refusals = (packet_refusals + evidence_refusals + adapter_refusals).freeze
+        @acknowledgements = acknowledge_operations.freeze
+        @refusals = (@validation_refusals + acknowledgement_refusals).freeze
+        freeze
+      end
+
+      def committed?
+        refusals.empty?
+      end
+
+      def to_h
+        {
+          result_id: result_id,
+          packet_id: value(packet, :packet_id),
+          operation_digest: operation_digest,
+          committed: committed?,
+          dry_run: false,
+          applied_operations: applied_operations,
+          skipped_operations: skipped_operations,
+          refusals: refusals,
+          warnings: [],
+          adapter_receipts: adapter_receipts,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      attr_reader :acknowledgements, :refusals, :validation_refusals
+
+      def result_id
+        "activation-ledger-result:#{value(packet, :packet_id)}"
+      end
+
+      def applied_operations
+        return [] unless committed?
+
+        acknowledgements.map do |entry|
+          record = entry.fetch(:record)
+          {
+            type: operation_type(value(record, :operation)),
+            status: :acknowledged,
+            receipt_id: value(record, :receipt_id),
+            adapter: adapter.to_h
+          }
+        end
+      end
+
+      def skipped_operations
+        dry_run_skipped.map(&:dup)
+      end
+
+      def adapter_receipts
+        return [] unless committed?
+
+        acknowledgements.map { |entry| entry.fetch(:record) }
+      end
+
+      def acknowledge_operations
+        return [] unless validation_refusals.empty?
+
+        dry_run_would_apply.map do |operation|
+          adapter.acknowledge(
+            packet_id: value(packet, :packet_id),
+            operation: operation,
+            operation_digest: operation_digest,
+            idempotency_key: value(packet, :idempotency_key),
+            caller_metadata: value(packet, :caller_metadata)
+          )
+        end
+      end
+
+      def acknowledgement_refusals
+        acknowledgements.filter_map do |entry|
+          entry.fetch(:refusal) if entry.fetch(:status) == :refused
+        end
+      end
+
+      def packet_refusals
+        [].tap do |items|
+          missing_packet_fields.each do |field|
+            items << refusal(:missing_evidence_field, "Activation evidence packet is missing a required field.", field)
+          end
+          items << refusal(:unsupported_schema_version, "Activation evidence packet schema version is not supported.", value(packet, :schema_version)) unless
+            value(packet, :schema_version) == SCHEMA_VERSION
+          items << refusal(:commit_not_explicit, "Activation ledger commit requires explicit commit_decision: true.", value(packet, :commit_decision)) unless
+            value(packet, :commit_decision) == true
+          items << refusal(:receipt_sink_missing, "Activation ledger commit requires an explicit receipt sink.", value(packet, :receipt_sink)) if
+            value(packet, :receipt_sink).to_s.empty?
+          identity_refusals.each do |entry|
+            items << entry
+          end
+          forbidden_fields.each do |field|
+            items << refusal(:forbidden_evidence_field, "Activation evidence packet contains a forbidden live/runtime field.", field)
+          end
+        end
+      end
+
+      def evidence_refusals
+        [].tap do |items|
+          items << refusal(:operation_digest_mismatch, "Activation evidence operation digest does not match dry-run evidence.", operation_digest) unless
+            operation_digest == computed_operation_digest
+          items << refusal(:dry_run_missing, "Activation ledger commit requires dry-run evidence.", dry_run_payload) unless
+            value(dry_run_payload, :dry_run) == true
+          items << refusal(:dry_run_committed, "Activation ledger commit cannot consume committed dry-run evidence.", dry_run_payload) if
+            value(dry_run_payload, :committed) == true
+          items << refusal(:dry_run_not_executable, "Activation dry-run evidence is not executable.", dry_run_payload) unless
+            value(dry_run_payload, :executable) == true
+          dry_run_refusals.each do |entry|
+            items << refusal(:dry_run_refusal, "Activation dry-run has unresolved refusals.", entry)
+          end
+          readiness_blockers.each do |entry|
+            items << refusal(:commit_readiness_blocker, "Activation commit readiness has unresolved blockers.", entry)
+          end
+        end
+      end
+
+      def adapter_refusals
+        [].tap do |items|
+          missing_adapter_methods.each do |method_name|
+            items << refusal(:missing_adapter_capability, "Activation ledger adapter is missing a required capability.", method_name)
+          end
+          next unless missing_adapter_methods.empty?
+
+          dry_run_would_apply.each do |operation|
+            type = operation_type(operation)
+            items << refusal(:unsupported_operation_type, "Activation ledger adapter does not support operation type.", operation) unless
+              adapter.supports?(type)
+          end
+        end
+      end
+
+      def missing_adapter_methods
+        %i[supports? acknowledge readback to_h].reject { |method_name| adapter.respond_to?(method_name) }
+      end
+
+      def identity_refusals
+        {
+          activation_dry_run_id: dry_run_payload,
+          commit_readiness_id: commit_readiness_payload
+        }.filter_map do |field, payload|
+          evidence_id = evidence_identity(payload, field)
+          next if evidence_id.nil? || evidence_id == value(packet, field)
+
+          refusal(:stale_evidence_identity, "Activation evidence identity does not match packet identity.", {
+                    field: field,
+                    packet_value: value(packet, field),
+                    evidence_value: evidence_id
+                  })
+        end
+      end
+
+      def missing_packet_fields
+        REQUIRED_PACKET_FIELDS.select { |field| missing?(value(packet, field)) }
+      end
+
+      def forbidden_fields
+        %i[
+          live_host
+          constants
+          loaded_classes
+          rack_app
+          route_table
+          rendered_output
+          contract_results
+          cluster_placement
+          discovery_results
+          discovery
+          discover
+          adapter_registry
+          lookup
+          destination
+          destination_root
+          host_target
+          target
+        ].reject { |field| missing?(value(packet, field)) }
+      end
+
+      def missing?(item)
+        item.nil? || (item.respond_to?(:empty?) && item.empty?)
+      end
+
+      def dry_run_payload
+        normalize_hash(value(packet, :dry_run))
+      end
+
+      def commit_readiness_payload
+        normalize_hash(value(packet, :commit_readiness))
+      end
+
+      def dry_run_would_apply
+        Array(value(dry_run_payload, :would_apply)).map { |entry| normalize_hash(entry) }
+      end
+
+      def dry_run_skipped
+        Array(value(dry_run_payload, :skipped)).map { |entry| normalize_hash(entry) }
+      end
+
+      def dry_run_refusals
+        Array(value(dry_run_payload, :refusals)).map { |entry| normalize_hash(entry) }
+      end
+
+      def readiness_blockers
+        Array(value(commit_readiness_payload, :blockers)).map { |entry| normalize_hash(entry) }
+      end
+
+      def operation_digest
+        value(packet, :operation_digest)
+      end
+
+      def computed_operation_digest
+        ApplicationHostActivationOperationDigest.compute(dry_run_payload)
+      end
+
+      def evidence_identity(payload, field)
+        candidates = [field, :id, :result_id, :evidence_id]
+        candidates.each do |candidate|
+          candidate_value = value(payload, candidate)
+          return candidate_value unless missing?(candidate_value)
+        end
+        nil
+      end
+
+      def operation_type(operation)
+        type = value(operation, :type)
+        type.respond_to?(:to_sym) ? type.to_sym : type
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : {}
+        source.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+
+      def value(hash, key)
+        return nil unless hash.respond_to?(:key?)
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_s]
+      end
+
+      def refusal(code, message, entry)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/application_host_activation_ledger_verification.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Igniter
+  module Application
+    class ApplicationHostActivationLedgerVerification
+      attr_reader :packet, :commit_result, :adapter, :metadata
+
+      def self.verify(evidence_packet, commit_result:, adapter:, metadata: {})
+        new(
+          evidence_packet: evidence_packet,
+          commit_result: commit_result,
+          adapter: adapter,
+          metadata: metadata
+        )
+      end
+
+      def initialize(evidence_packet:, commit_result:, adapter:, metadata: {})
+        @packet = normalize_hash(evidence_packet).freeze
+        @commit_result = normalize_hash(commit_result.respond_to?(:to_h) ? commit_result.to_h : commit_result).freeze
+        @adapter = adapter
+        @metadata = metadata.dup.freeze
+        @readbacks = readback_records.freeze
+        @findings = build_findings.freeze
+        freeze
+      end
+
+      def valid?
+        findings.empty?
+      end
+
+      def complete?
+        valid? && committed? && verified_operations.length == expected_operations.length
+      end
+
+      def to_h
+        {
+          verification_id: verification_id,
+          packet_id: packet_id,
+          result_id: result_id,
+          operation_digest: operation_digest,
+          idempotency_key: idempotency_key,
+          valid: valid?,
+          complete: complete?,
+          committed: committed?,
+          findings: findings,
+          verified_operations: verified_operations,
+          unexpected_operations: unexpected_operations,
+          adapter_readbacks: readbacks,
+          counts: counts,
+          skipped_operations: skipped_operations,
+          verified_at: Time.now.utc.iso8601,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      attr_reader :readbacks, :findings
+
+      def verification_id
+        "activation-ledger-verification:#{packet_id}:#{operation_digest}"
+      end
+
+      def packet_id
+        value(packet, :packet_id)
+      end
+
+      def result_id
+        value(commit_result, :result_id)
+      end
+
+      def operation_digest
+        value(packet, :operation_digest)
+      end
+
+      def idempotency_key
+        value(packet, :idempotency_key)
+      end
+
+      def committed?
+        value(commit_result, :committed) == true
+      end
+
+      def build_findings
+        [].tap do |items|
+          items << finding(:commit_not_committed, "Activation commit result is not committed.", commit_result) unless
+            committed?
+          items.concat(result_identity_findings)
+          items.concat(applied_operation_findings)
+          items.concat(identity_findings)
+          items.concat(missing_findings)
+          items.concat(unexpected_findings)
+          items.concat(duplicate_findings)
+          items.concat(commit_receipt_findings)
+        end
+      end
+
+      def result_identity_findings
+        [
+          [:result_packet_id_mismatch, :packet_id, packet_id],
+          [:result_operation_digest_mismatch, :operation_digest, operation_digest]
+        ].filter_map do |code, field, expected|
+          actual = value(commit_result, field)
+          next if actual == expected
+
+          finding(code, "Activation commit result identity does not match evidence packet.", {
+                    field: field,
+                    expected: expected,
+                    actual: actual
+                  })
+        end
+      end
+
+      def applied_operation_findings
+        return [] if applied_operation_types.sort == expected_operation_types.sort
+
+        [
+          finding(:applied_operation_mismatch, "Activation commit result applied operations do not match packet.", {
+                    expected_types: expected_operation_types,
+                    actual_types: applied_operation_types
+                  })
+        ]
+      end
+
+      def identity_findings
+        [
+          [:packet_id_mismatch, :packet_id, packet_id],
+          [:operation_digest_mismatch, :operation_digest, operation_digest],
+          [:idempotency_key_mismatch, :idempotency_key, idempotency_key]
+        ].flat_map do |code, field, expected|
+          readbacks.filter_map do |record|
+            actual = value(record, field)
+            next if actual == expected
+
+            finding(code, "Activation ledger readback identity does not match evidence packet.", {
+                      field: field,
+                      expected: expected,
+                      actual: actual,
+                      receipt_id: value(record, :receipt_id)
+                    })
+          end
+        end
+      end
+
+      def missing_findings
+        expected_operation_keys.filter_map do |operation_key|
+          next if readback_by_operation.key?(operation_key)
+
+          finding(:missing_ledger_record, "Activation ledger readback is missing an expected operation.", {
+                    operation_key: operation_key
+                  })
+        end
+      end
+
+      def unexpected_findings
+        unexpected_operations.map do |record|
+          finding(:unexpected_ledger_record, "Activation ledger readback contains an unplanned operation.", record)
+        end
+      end
+
+      def duplicate_findings
+        readback_by_operation.filter_map do |operation_key, records|
+          next unless records.length > 1
+
+          finding(:duplicate_ledger_record, "Activation ledger readback contains duplicate operation records.", {
+                    operation_key: operation_key,
+                    receipt_ids: records.map { |record| value(record, :receipt_id) }
+                  })
+        end
+      end
+
+      def commit_receipt_findings
+        commit_receipts.filter_map do |record|
+          receipt_id = value(record, :receipt_id)
+          next if readbacks.any? { |readback| value(readback, :receipt_id) == receipt_id }
+
+          finding(:commit_receipt_missing_from_readback, "Commit receipt was not returned by adapter readback.", record)
+        end
+      end
+
+      def verified_operations
+        expected_operations.filter_map do |operation|
+          records = readback_by_operation.fetch(operation_key(operation), [])
+          next unless records.length == 1 && record_matches_expected?(records.first)
+
+          {
+            type: operation_type(operation),
+            operation_key: operation_key(operation),
+            receipt_id: value(records.first, :receipt_id),
+            status: :verified
+          }
+        end
+      end
+
+      def unexpected_operations
+        readbacks.reject { |record| expected_operation_keys.include?(record_operation_key(record)) }
+      end
+
+      def readback_by_operation
+        @readback_by_operation ||= readbacks.group_by { |record| record_operation_key(record) }
+      end
+
+      def readback_records
+        return [] unless adapter.respond_to?(:readback)
+
+        adapter.readback(idempotency_key: idempotency_key, operation_digest: operation_digest).map do |record|
+          normalize_hash(record)
+        end
+      end
+
+      def record_matches_expected?(record)
+        value(record, :packet_id) == packet_id &&
+          value(record, :operation_digest) == operation_digest &&
+          value(record, :idempotency_key) == idempotency_key
+      end
+
+      def expected_operations
+        Array(value(dry_run_payload, :would_apply)).map { |entry| normalize_hash(entry) }
+      end
+
+      def expected_operation_keys
+        @expected_operation_keys ||= expected_operations.map { |operation| operation_key(operation) }
+      end
+
+      def commit_receipts
+        Array(value(commit_result, :adapter_receipts)).map { |entry| normalize_hash(entry) }
+      end
+
+      def applied_operations
+        Array(value(commit_result, :applied_operations)).map { |entry| normalize_hash(entry) }
+      end
+
+      def applied_operation_types
+        applied_operations.map { |entry| operation_type(entry) }
+      end
+
+      def expected_operation_types
+        expected_operations.map { |entry| operation_type(entry) }
+      end
+
+      def skipped_operations
+        Array(value(commit_result, :skipped_operations)).map { |entry| normalize_hash(entry) }
+      end
+
+      def counts
+        {
+          expected: expected_operations.length,
+          readback: readbacks.length,
+          verified: verified_operations.length,
+          unexpected: unexpected_operations.length,
+          findings: findings.length,
+          skipped: skipped_operations.length
+        }
+      end
+
+      def dry_run_payload
+        normalize_hash(value(packet, :dry_run))
+      end
+
+      def record_operation_key(record)
+        operation = normalize_hash(value(record, :operation))
+        value(operation, :operation_key) || operation_key(operation)
+      end
+
+      def operation_key(operation)
+        [
+          value(operation, :type),
+          value(operation, :destination),
+          value(operation, :source)
+        ].join(":")
+      end
+
+      def operation_type(operation)
+        type = value(operation, :type)
+        type.respond_to?(:to_sym) ? type.to_sym : type
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : {}
+        source.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+
+      def value(hash, key)
+        return nil unless hash.respond_to?(:key?)
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_s]
+      end
+
+      def finding(code, message, entry)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/application_host_activation_operation_digest.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Igniter
+  module Application
+    class ApplicationHostActivationOperationDigest
+      def self.compute(dry_run_or_hash)
+        new(dry_run_or_hash).compute
+      end
+
+      def initialize(dry_run_or_hash)
+        @payload = normalize_hash(dry_run_or_hash.respond_to?(:to_h) ? dry_run_or_hash.to_h : dry_run_or_hash)
+      end
+
+      def compute
+        Digest::SHA256.hexdigest(JSON.generate(normalized_payload))
+      end
+
+      private
+
+      attr_reader :payload
+
+      def normalized_payload
+        {
+          would_apply: normalize_operations(value(payload, :would_apply)),
+          skipped: normalize_operations(value(payload, :skipped))
+        }
+      end
+
+      def normalize_operations(operations)
+        Array(operations).map { |entry| normalize_hash(entry) }
+                         .sort_by { |entry| [value(entry, :type).to_s, value(entry, :destination).to_s] }
+                         .map { |entry| normalize_value(entry) }
+      end
+
+      def normalize_value(item)
+        case item
+        when Hash
+          item.each_with_object({}) do |(key, value), result|
+            next if key.to_s.end_with?("_at")
+
+            result[key.to_s] = normalize_value(value)
+          end.sort.to_h
+        when Array
+          item.map { |entry| normalize_value(entry) }
+        when Symbol
+          item.to_s
+        else
+          item
+        end
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : {}
+        source.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+
+      def value(hash, key)
+        return nil unless hash.respond_to?(:key?)
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_s]
+      end
+    end
+  end
+end