igniter 0.5.1 → 0.5.2

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationHostActivationCommitReadiness
+      attr_reader :dry_run_payload, :provided_adapters, :metadata
+
+      def self.build(dry_run, provided_adapters: [], metadata: {})
+        new(dry_run: dry_run, provided_adapters: provided_adapters, metadata: metadata)
+      end
+
+      def initialize(dry_run:, provided_adapters: [], metadata: {})
+        @dry_run_payload = payload_from(dry_run).freeze
+        @provided_adapters = Array(provided_adapters).map { |entry| normalize_adapter(entry) }.freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def ready?
+        blockers.empty?
+      end
+
+      def to_h
+        {
+          ready: ready?,
+          commit_allowed: ready?,
+          dry_run: dry_run?,
+          committed: committed?,
+          blockers: blockers,
+          warnings: warnings,
+          required_adapters: required_adapters,
+          provided_adapters: provided_adapters.map(&:dup),
+          would_apply_count: would_apply.length,
+          skipped_count: skipped.length,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def blockers
+        [].tap do |items|
+          items << blocker(:dry_run_missing, "Activation commit readiness requires dry-run evidence.", dry_run_payload) unless
+            dry_run?
+          items << blocker(:dry_run_committed, "Activation commit readiness cannot consume committed evidence.", dry_run_payload) if
+            committed?
+          items << blocker(:dry_run_not_executable, "Activation dry-run is not executable.", dry_run_payload) unless
+            dry_run_executable?
+          refusals.each do |entry|
+            items << blocker(:dry_run_refusal, "Activation dry-run has unresolved refusals.", entry)
+          end
+          missing_adapters.each do |entry|
+            items << blocker(:missing_adapter_evidence, "Activation commit readiness requires explicit adapter evidence.", entry)
+          end
+        end
+      end
+
+      def warnings
+        dry_run_warnings.map do |entry|
+          warning(:dry_run_warning, "Activation dry-run reported a warning.", entry)
+        end
+      end
+
+      def required_adapters
+        [].tap do |items|
+          items << adapter_requirement(:application_host_target, :application_host_adapter, :application_owned_operations, would_apply) if
+            would_apply.any?
+          items << adapter_requirement(:host_evidence_acknowledgement, :host_evidence, :host_owned_evidence, host_owned_skips) if
+            host_owned_skips.any?
+          items << adapter_requirement(:manual_action_acknowledgement, :manual_action_evidence, :manual_host_action, manual_skips) if
+            manual_skips.any?
+          items << adapter_requirement(:web_mount_adapter_evidence, :web_or_host_mount_evidence, :web_or_host_owned_mount, mount_skips) if
+            mount_skips.any?
+        end
+      end
+
+      def missing_adapters
+        required_adapters.reject { |entry| adapter_provided?(entry) }
+      end
+
+      def adapter_provided?(requirement)
+        provided_adapters.any? do |adapter|
+          comparable(value(adapter, :name)) == comparable(value(requirement, :name)) ||
+            comparable(value(adapter, :kind)) == comparable(value(requirement, :kind))
+        end
+      end
+
+      def adapter_requirement(name, kind, reason, operations)
+        {
+          name: name,
+          kind: kind,
+          reason: reason,
+          operation_count: operations.length,
+          operations: operations.map(&:dup)
+        }
+      end
+
+      def dry_run?
+        value(dry_run_payload, :dry_run) == true
+      end
+
+      def committed?
+        value(dry_run_payload, :committed) == true
+      end
+
+      def dry_run_executable?
+        value(dry_run_payload, :executable) == true
+      end
+
+      def would_apply
+        Array(value(dry_run_payload, :would_apply)).map { |entry| normalize_hash(entry) }
+      end
+
+      def skipped
+        Array(value(dry_run_payload, :skipped)).map { |entry| normalize_hash(entry) }
+      end
+
+      def refusals
+        Array(value(dry_run_payload, :refusals)).map { |entry| normalize_hash(entry) }
+      end
+
+      def dry_run_warnings
+        Array(value(dry_run_payload, :warnings)).map { |entry| normalize_hash(entry) }
+      end
+
+      def host_owned_skips
+        skipped.select { |entry| value(entry, :reason).to_s == "host_owned_evidence" }
+      end
+
+      def manual_skips
+        skipped.select { |entry| value(entry, :reason).to_s == "manual_host_action" }
+      end
+
+      def mount_skips
+        skipped.select { |entry| value(entry, :reason).to_s == "web_or_host_owned_mount" }
+      end
+
+      def payload_from(source)
+        payload = source.respond_to?(:to_h) ? source.to_h : source
+        normalize_hash(payload)
+      end
+
+      def normalize_adapter(entry)
+        return { name: entry } unless entry.respond_to?(:to_h)
+
+        normalize_hash(entry)
+      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 comparable(value)
+        value.to_s
+      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 blocker(code, message, entry)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+
+      def warning(code, message, entry)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationHostActivationDryRunResult
+      APPLICATION_OPERATION_TYPES = %i[
+        confirm_load_path
+        confirm_provider
+        confirm_contract
+        confirm_lifecycle
+      ].freeze
+
+      HOST_OWNED_OPERATION_TYPES = %i[
+        confirm_host_export
+        confirm_host_capability
+      ].freeze
+
+      MANUAL_OPERATION_TYPES = %i[
+        acknowledge_manual_actions
+      ].freeze
+
+      MOUNT_OPERATION_TYPES = %i[
+        review_mount_intent
+      ].freeze
+
+      attr_reader :verification_payload, :host_target, :metadata
+
+      def self.dry_run(verification, host_target: nil, metadata: {})
+        new(verification: verification, host_target: host_target, metadata: metadata)
+      end
+
+      def initialize(verification:, host_target: nil, metadata: {})
+        @verification_payload = payload_from(verification).freeze
+        @host_target = host_target
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def executable?
+        refusals.empty?
+      end
+
+      def to_h
+        {
+          dry_run: true,
+          committed: false,
+          executable: executable?,
+          would_apply: would_apply,
+          skipped: skipped,
+          refusals: refusals,
+          warnings: warnings,
+          surface_count: surface_count,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def would_apply
+        return [] unless executable?
+
+        application_operations.map do |operation|
+          operation_result(operation, :dry_run, target: host_target)
+        end
+      end
+
+      def skipped
+        verified_operations.filter_map do |operation|
+          reason = skip_reason(operation)
+          operation_result(operation, :skipped, reason: reason) if reason
+        end
+      end
+
+      def refusals
+        [].tap do |items|
+          items << refusal(:verification_invalid, "Activation plan verification is not valid.", entry: findings) unless
+            verification_valid?
+          items << refusal(:plan_not_executable, "Activation plan is not executable.", entry: verification_payload) unless
+            plan_executable?
+          items << refusal(:missing_host_target, "Application-owned dry-run operations require an explicit host target.", entry: application_operations) if
+            application_operations.any? && missing_host_target?
+          unsupported_operations.each do |operation|
+            items << refusal(:unsupported_operation, "Activation dry-run operation type is not supported.", entry: operation)
+          end
+        end
+      end
+
+      def warnings
+        []
+      end
+
+      def skip_reason(operation)
+        type = operation_type(operation)
+        return :host_owned_evidence if HOST_OWNED_OPERATION_TYPES.include?(type)
+        return :manual_host_action if MANUAL_OPERATION_TYPES.include?(type)
+        return :web_or_host_owned_mount if MOUNT_OPERATION_TYPES.include?(type)
+        return :missing_host_target if APPLICATION_OPERATION_TYPES.include?(type) && missing_host_target?
+        return :unsupported_operation unless APPLICATION_OPERATION_TYPES.include?(type)
+
+        nil
+      end
+
+      def operation_result(operation, status, reason: nil, target: nil)
+        {
+          type: operation_type(operation),
+          status: status,
+          source: value(operation, :source),
+          destination: value(operation, :destination),
+          metadata: operation_metadata(operation),
+          reason: reason,
+          target: target
+        }.compact
+      end
+
+      def application_operations
+        verified_operations.select { |operation| APPLICATION_OPERATION_TYPES.include?(operation_type(operation)) }
+      end
+
+      def unsupported_operations
+        verified_operations.reject do |operation|
+          (
+            APPLICATION_OPERATION_TYPES +
+            HOST_OWNED_OPERATION_TYPES +
+            MANUAL_OPERATION_TYPES +
+            MOUNT_OPERATION_TYPES
+          ).include?(operation_type(operation))
+        end
+      end
+
+      def verification_valid?
+        value(verification_payload, :valid) == true
+      end
+
+      def plan_executable?
+        value(verification_payload, :executable) == true
+      end
+
+      def missing_host_target?
+        host_target.to_s.empty?
+      end
+
+      def verified_operations
+        Array(value(verification_payload, :verified)).map { |entry| normalize_hash(entry) }
+      end
+
+      def findings
+        Array(value(verification_payload, :findings)).map { |entry| normalize_hash(entry) }
+      end
+
+      def surface_count
+        value(verification_payload, :surface_count) || 0
+      end
+
+      def operation_type(operation)
+        type = value(operation, :type)
+        type.respond_to?(:to_sym) ? type.to_sym : type
+      end
+
+      def operation_metadata(operation)
+        metadata = value(operation, :metadata)
+        metadata.respond_to?(:dup) ? metadata.dup : metadata
+      end
+
+      def payload_from(source)
+        payload = source.respond_to?(:to_h) ? source.to_h : source
+        normalize_hash(payload)
+      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_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