igniter 0.5.0 → 0.5.2

data/packages/igniter-cluster/lib/igniter/cluster/lease_plan.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class LeasePlan
+      attr_reader :mode, :grants, :metadata, :explanation
+
+      def initialize(mode:, grants:, metadata: {}, explanation: nil)
+        @mode = mode.to_sym
+        @grants = Array(grants).freeze
+        @metadata = metadata.dup.freeze
+        @explanation = DecisionExplanation.normalize(
+          explanation,
+          default_code: @mode,
+          metadata: @metadata
+        )
+        freeze
+      end
+
+      def owner_names
+        grants.map { |grant| grant.owner.name }.uniq
+      end
+
+      def targets
+        grants.map(&:target).uniq
+      end
+
+      def to_h
+        {
+          mode: mode,
+          grants: grants.map(&:to_h),
+          owner_names: owner_names,
+          targets: targets,
+          metadata: metadata.dup,
+          explanation: explanation&.to_h
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/lease_policy.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class LeasePolicy
+      attr_reader :name, :ttl_seconds, :renewable, :metadata, :clock
+
+      def initialize(name:, ttl_seconds: 300, renewable: true, metadata: {}, clock: nil)
+        @name = name.to_sym
+        @ttl_seconds = Integer(ttl_seconds)
+        @renewable = renewable == true
+        @metadata = metadata.dup.freeze
+        @clock = clock || -> { Time.now.utc }
+        freeze
+      end
+
+      def self.ephemeral(metadata: {})
+        new(name: :ephemeral, metadata: metadata)
+      end
+
+      def plan(target:, ownership_plan:, metadata: {})
+        if ownership_plan.claims.empty?
+          details = plan_metadata(target, ownership_plan, metadata)
+          return LeasePlan.new(
+            mode: :unleased,
+            grants: [],
+            metadata: details,
+            explanation: DecisionExplanation.new(
+              code: :unleased_target,
+              message: "no lease granted for #{target}",
+              metadata: details
+            )
+          )
+        end
+
+        issued_at = clock.call
+        expires_at = issued_at + ttl_seconds
+        grants = ownership_plan.claims.map do |claim|
+          LeaseGrant.new(
+            target: target,
+            owner: claim.owner,
+            ttl_seconds: ttl_seconds,
+            renewable: renewable,
+            issued_at: issued_at,
+            expires_at: expires_at,
+            metadata: {
+              policy: name,
+              ownership: ownership_plan.to_h
+            },
+            reason: DecisionExplanation.new(
+              code: :lease_granted,
+              message: "granted #{ttl_seconds}s lease for #{target} to #{claim.owner.name}",
+              metadata: {
+                target: target.to_s,
+                owner: claim.owner.name,
+                ttl_seconds: ttl_seconds,
+                policy: name
+              }
+            )
+          )
+        end
+
+        details = plan_metadata(target, ownership_plan, metadata)
+        LeasePlan.new(
+          mode: :granted,
+          grants: grants,
+          metadata: details,
+          explanation: DecisionExplanation.new(
+            code: :lease_plan,
+            message: "granted #{grants.length} lease(s) for #{target}",
+            metadata: details
+          )
+        )
+      end
+
+      def to_h
+        {
+          name: name,
+          ttl_seconds: ttl_seconds,
+          renewable: renewable,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def plan_metadata(target, ownership_plan, extra_metadata)
+        {
+          policy: to_h,
+          target: target.to_s,
+          ownership: ownership_plan.to_h
+        }.merge(extra_metadata)
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/membership_delta.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MembershipDelta
+      attr_reader :feed, :from_snapshot_ref, :to_snapshot_ref, :joined_peer_names,
+                  :left_peer_names, :updated_peer_names, :events, :metadata
+
+      def initialize(feed:, to_snapshot_ref:, from_snapshot_ref: nil, joined_peer_names: [],
+                     left_peer_names: [], updated_peer_names: [], events: [], metadata: {})
+        @feed = feed
+        @from_snapshot_ref = from_snapshot_ref&.dup&.freeze
+        @to_snapshot_ref = to_snapshot_ref.dup.freeze
+        @joined_peer_names = Array(joined_peer_names).map(&:to_sym).freeze
+        @left_peer_names = Array(left_peer_names).map(&:to_sym).freeze
+        @updated_peer_names = Array(updated_peer_names).map(&:to_sym).freeze
+        @events = Array(events).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def to_h
+        {
+          feed: feed.to_h,
+          from_snapshot_ref: from_snapshot_ref&.dup,
+          to_snapshot_ref: to_snapshot_ref.dup,
+          joined_peer_names: joined_peer_names.dup,
+          left_peer_names: left_peer_names.dup,
+          updated_peer_names: updated_peer_names.dup,
+          events: events.map(&:to_h),
+          metadata: metadata.dup
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/membership_feed.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MembershipFeed
+      attr_reader :name, :metadata, :discovery_feed
+
+      def initialize(name:, metadata: {}, discovery_feed: nil)
+        @name = name.to_sym
+        @metadata = metadata.dup.freeze
+        @discovery_feed = discovery_feed || DiscoveryFeed.new(name: @name, metadata: @metadata)
+        freeze
+      end
+
+      def to_h
+        {
+          name: name,
+          metadata: metadata.dup,
+          discovery_feed: discovery_feed.to_h
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/membership_projection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MembershipProjection
+      attr_reader :mode, :query, :peer_views, :candidate_views, :stages, :metadata, :explanation
+
+      def initialize(mode:, query:, peer_views:, candidate_views:, stages: [], metadata: {}, explanation: nil)
+        @mode = mode.to_sym
+        @query = query
+        @peer_views = Array(peer_views).freeze
+        @candidate_views = Array(candidate_views).freeze
+        @stages = Array(stages).freeze
+        @metadata = metadata.dup.freeze
+        @explanation = DecisionExplanation.normalize(
+          explanation,
+          default_code: @mode,
+          metadata: @metadata
+        )
+        freeze
+      end
+
+      def candidates
+        candidate_views.map(&:peer).freeze
+      end
+
+      def candidate_names
+        candidates.map(&:name)
+      end
+
+      def to_h
+        {
+          mode: mode,
+          query: query.to_h,
+          peer_views: peer_views.map(&:to_h),
+          candidate_views: candidate_views.map(&:to_h),
+          candidate_names: candidate_names,
+          stages: stages.map(&:to_h),
+          metadata: metadata.dup,
+          explanation: explanation&.to_h
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/membership_snapshot.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MembershipSnapshot
+      attr_reader :feed, :snapshot_id, :previous_snapshot_id, :version, :epoch,
+                  :lineage, :peer_names, :available_peer_names, :events, :metadata
+
+      def initialize(feed:, snapshot_id:, version:, epoch:, lineage:, peer_names:, available_peer_names:,
+                     previous_snapshot_id: nil, events: [], metadata: {})
+        @feed = feed
+        @snapshot_id = snapshot_id.to_s
+        @previous_snapshot_id = previous_snapshot_id&.to_s
+        @version = Integer(version)
+        @epoch = epoch.to_s
+        @lineage = Array(lineage).map(&:to_s).freeze
+        @peer_names = Array(peer_names).map(&:to_sym).freeze
+        @available_peer_names = Array(available_peer_names).map(&:to_sym).freeze
+        @events = Array(events).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def reference
+        {
+          feed: feed.to_h,
+          snapshot_id: snapshot_id,
+          previous_snapshot_id: previous_snapshot_id,
+          version: version,
+          epoch: epoch,
+          lineage: lineage.dup
+        }
+      end
+
+      def to_h
+        reference.merge(
+          peer_names: peer_names.dup,
+          available_peer_names: available_peer_names.dup,
+          events: events.map(&:to_h),
+          metadata: metadata.dup
+        )
+      end
+
+      def delta(previous_snapshot: nil)
+        MembershipDelta.new(
+          feed: feed,
+          from_snapshot_ref: previous_snapshot&.reference,
+          to_snapshot_ref: reference,
+          joined_peer_names: peer_names_for(:peer_joined),
+          left_peer_names: peer_names_for(:peer_left),
+          updated_peer_names: peer_names_for(:peer_updated),
+          events: events,
+          metadata: metadata
+        )
+      end
+
+      private
+
+      def peer_names_for(type)
+        events.select { |event| event.type == type }.map(&:peer_name)
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/memory_incident_registry.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MemoryIncidentRegistry
+      def initialize(entries: {})
+        @entries = {}
+        @actions = {}
+        @next_sequence = 0
+        @next_action_sequence = 0
+        @mutex = Mutex.new
+
+        entries.each_value { |entry| write(entry) }
+      end
+
+      def record(report, metadata: {})
+        @mutex.synchronize do
+          @next_sequence += 1
+          write_unlocked(IncidentEntry.from_report(report, sequence: @next_sequence, metadata: metadata))
+        end
+      end
+
+      def write(entry)
+        @mutex.synchronize do
+          write_unlocked(entry)
+        end
+      end
+
+      def fetch(id)
+        @mutex.synchronize do
+          @entries.fetch(id.to_s)
+        end
+      end
+
+      def entries
+        @mutex.synchronize do
+          @entries.values.sort_by(&:sequence)
+        end
+      end
+
+      def record_action(incident, kind:, status: :recorded, actor: nil, note: nil, metadata: {})
+        @mutex.synchronize do
+          entry = resolve_entry_unlocked(incident)
+          @next_action_sequence += 1
+          action = IncidentAction.new(
+            incident_key: entry.incident_key,
+            sequence: @next_action_sequence,
+            kind: kind,
+            status: status,
+            actor: actor,
+            note: note,
+            metadata: metadata.merge(
+              incident_id: entry.id,
+              incident_kind: entry.incident.kind,
+              incident_resolution: entry.resolution
+            ),
+            explanation: DecisionExplanation.new(
+              code: :"incident_#{kind}",
+              message: "recorded #{kind} for #{entry.incident.kind} incident",
+              metadata: {
+                incident_id: entry.id,
+                incident_key: entry.incident_key
+              }
+            )
+          )
+          @actions[action.id] = action
+          action
+        end
+      end
+
+      def actions(incident = nil)
+        @mutex.synchronize do
+          selected = if incident.nil?
+                       @actions.values
+                     else
+                       key = resolve_incident_key_unlocked(incident)
+                       @actions.values.select { |action| action.incident_key == key }
+                     end
+          selected.sort_by(&:sequence)
+        end
+      end
+
+      def workflow(incident)
+        @mutex.synchronize do
+          key = resolve_incident_key_unlocked(incident)
+          build_workflow_unlocked(key)
+        end
+      end
+
+      def workflows
+        @mutex.synchronize do
+          @entries.values.map(&:incident_key).uniq.sort.map { |key| build_workflow_unlocked(key) }
+        end
+      end
+
+      def active_set
+        snapshot = entries
+        latest_entries = snapshot.group_by(&:incident_key).values.map { |group| group.max_by(&:sequence) }
+        active_entries = latest_entries.select do |entry|
+          entry.active? && build_workflow_for_snapshot(entry.incident_key, snapshot).active?
+        end
+
+        ActiveIncidentSet.new(
+          entries: active_entries,
+          metadata: {
+            registry: :memory,
+            total_entries: snapshot.length
+          }
+        )
+      end
+
+      private
+
+      def write_unlocked(entry)
+        @entries[entry.id] = entry
+        @next_sequence = [@next_sequence, entry.sequence].max
+        entry
+      end
+
+      def resolve_entry_unlocked(incident)
+        return incident if incident.is_a?(IncidentEntry)
+
+        ref = incident.to_s
+        return @entries.fetch(ref) if @entries.key?(ref)
+
+        entries_for_key = @entries.values.select { |entry| entry.incident_key == ref }
+        return entries_for_key.max_by(&:sequence) unless entries_for_key.empty?
+
+        raise KeyError, "unknown incident #{incident.inspect}"
+      end
+
+      def resolve_incident_key_unlocked(incident)
+        return incident.incident_key if incident.respond_to?(:incident_key)
+
+        resolve_entry_unlocked(incident).incident_key
+      rescue KeyError
+        incident.to_s
+      end
+
+      def build_workflow_unlocked(incident_key)
+        workflow_entries = @entries.values.select { |entry| entry.incident_key == incident_key }
+        workflow_actions = @actions.values.select { |action| action.incident_key == incident_key }
+        IncidentWorkflow.new(
+          incident_key: incident_key,
+          entries: workflow_entries,
+          actions: workflow_actions,
+          metadata: {
+            registry: :memory,
+            latest_entry_id: workflow_entries.max_by(&:sequence)&.id
+          }
+        )
+      end
+
+      def build_workflow_for_snapshot(incident_key, snapshot)
+        workflow_entries = snapshot.select { |entry| entry.incident_key == incident_key }
+        workflow_actions = @actions.values.select { |action| action.incident_key == incident_key }
+        IncidentWorkflow.new(
+          incident_key: incident_key,
+          entries: workflow_entries,
+          actions: workflow_actions,
+          metadata: {
+            registry: :memory,
+            latest_entry_id: workflow_entries.max_by(&:sequence)&.id
+          }
+        )
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/memory_peer_registry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MemoryPeerRegistry
+      def initialize
+        @peers = {}
+      end
+
+      def register(peer)
+        @peers[peer.name] = peer
+        peer
+      end
+
+      def fetch(name)
+        @peers.fetch(name.to_sym)
+      end
+
+      def peers
+        @peers.values.sort_by(&:name)
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/mesh_admission.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshAdmission
+      attr_reader :policy
+
+      def initialize(policy:)
+        @policy = policy
+        freeze
+      end
+
+      def admit(peer:, plan_kind:, action:, membership:)
+        policy.admit(peer: peer, plan_kind: plan_kind, action: action, membership: membership)
+      end
+
+      def to_h
+        {
+          policy: policy.to_h
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/mesh_admission_result.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshAdmissionResult
+      attr_reader :peer_name, :allowed, :code, :metadata, :reason
+
+      def initialize(peer_name:, allowed:, code:, metadata: {}, reason: nil)
+        @peer_name = peer_name.to_sym
+        @allowed = allowed == true
+        @code = code.to_sym
+        @metadata = metadata.dup.freeze
+        @reason = DecisionExplanation.normalize(
+          reason,
+          default_code: @code,
+          metadata: @metadata
+        )
+        freeze
+      end
+
+      def allowed?
+        allowed
+      end
+
+      def denied?
+        !allowed?
+      end
+
+      def to_h
+        {
+          peer: peer_name,
+          allowed: allowed?,
+          code: code,
+          metadata: metadata.dup,
+          reason: reason&.to_h
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/mesh_execution_attempt.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshExecutionAttempt
+      attr_reader :peer_name, :status, :request, :response_metadata, :membership, :membership_delta, :explanation
+
+      def initialize(peer_name:, status:, request:, membership:, membership_delta:, response_metadata: {},
+                     explanation: nil)
+        @peer_name = peer_name.to_sym
+        @status = status.to_sym
+        @request = request
+        @response_metadata = response_metadata.dup.freeze
+        @membership = membership
+        @membership_delta = membership_delta
+        @explanation = DecisionExplanation.normalize(
+          explanation,
+          default_code: @status,
+          metadata: @response_metadata
+        )
+        freeze
+      end
+
+      def completed?
+        status == :completed
+      end
+
+      def failed?
+        status == :failed
+      end
+
+      def skipped?
+        status == :skipped
+      end
+
+      def to_h
+        {
+          peer: peer_name,
+          status: status,
+          membership_delta: membership_delta.to_h,
+          membership_snapshot_ref: membership.snapshot_ref,
+          membership_snapshot: membership.snapshot.to_h,
+          membership: membership.to_h,
+          request: request.to_h,
+          response_metadata: response_metadata.dup,
+          explanation: explanation&.to_h
+        }
+      end
+    end
+  end
+end

data/packages/igniter-cluster/lib/igniter/cluster/mesh_execution_request.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshExecutionRequest
+      attr_reader :trace_id, :plan_kind, :action_type, :subject, :action, :metadata
+
+      def initialize(trace_id:, plan_kind:, action_type:, subject:, action:, metadata: {})
+        @trace_id = trace_id.to_s
+        @plan_kind = plan_kind.to_sym
+        @action_type = action_type.to_sym
+        @subject = deep_freeze(normalize_hash(subject))
+        @action = deep_freeze(normalize_hash(action))
+        @metadata = deep_freeze(normalize_hash(metadata))
+        freeze
+      end
+
+      def to_h
+        {
+          trace_id: trace_id,
+          plan_kind: plan_kind,
+          action_type: action_type,
+          subject: deep_dup(subject),
+          action: deep_dup(action),
+          metadata: deep_dup(metadata)
+        }
+      end
+
+      private
+
+      def normalize_hash(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), memo|
+            memo[key.to_sym] = normalize_hash(entry)
+          end
+        when Array
+          value.map { |entry| normalize_hash(entry) }
+        else
+          value
+        end
+      end
+
+      def deep_freeze(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), memo|
+            memo[key] = deep_freeze(entry)
+          end.freeze
+        when Array
+          value.map { |entry| deep_freeze(entry) }.freeze
+        else
+          value.freeze
+        end
+      end
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), memo|
+            memo[key] = deep_dup(entry)
+          end
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end