igniter 0.5.1 → 0.5.2

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshMembershipSource
+      attr_reader :name, :metadata, :feed
+
+      def initialize(name: :memory, metadata: {})
+        @name = name.to_sym
+        @metadata = metadata.dup.freeze
+        @feed = MembershipFeed.new(name: @name, metadata: @metadata)
+        freeze
+      end
+
+      def call(environment:, allow_degraded:, metadata: {}, previous_membership: nil)
+        version = previous_membership&.version || 1
+        snapshot_id = next_snapshot_id(version: version)
+
+        MeshMembership.new(
+          peers: environment.peers,
+          allow_degraded: allow_degraded,
+          metadata: self.metadata.merge(metadata),
+          version: version,
+          epoch: previous_membership&.epoch,
+          events: [],
+          source: name,
+          snapshot_id: snapshot_id,
+          previous_snapshot_id: previous_membership&.snapshot_id,
+          lineage: next_lineage(previous_membership: previous_membership, snapshot_id: snapshot_id),
+          feed: feed
+        )
+      end
+
+      def to_h
+        feed.to_h
+      end
+
+      private
+
+      def next_snapshot_id(version:)
+        "#{name}/#{version}"
+      end
+
+      def next_lineage(previous_membership:, snapshot_id:)
+        Array(previous_membership&.lineage) + [snapshot_id]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshRetryPolicy
+      attr_reader :name, :max_attempts, :fallback_on_failure, :retry_statuses, :allow_degraded, :metadata
+
+      def initialize(name:, max_attempts: nil, fallback_on_failure: true, retry_statuses: [:failed],
+                     allow_degraded: false, metadata: {})
+        @name = name.to_sym
+        @max_attempts = max_attempts.nil? ? nil : Integer(max_attempts)
+        @fallback_on_failure = fallback_on_failure == true
+        @retry_statuses = Array(retry_statuses).map(&:to_sym).uniq.sort.freeze
+        @allow_degraded = allow_degraded == true
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def candidate_peers(peers)
+        candidates = Array(peers)
+        return candidates if max_attempts.nil?
+
+        candidates.first(max_attempts)
+      end
+
+      def retryable_status?(status)
+        fallback_on_failure && retry_statuses.include?(status.to_sym)
+      end
+
+      def to_h
+        {
+          name: name,
+          max_attempts: max_attempts,
+          fallback_on_failure: fallback_on_failure,
+          retry_statuses: retry_statuses.dup,
+          allow_degraded: allow_degraded,
+          metadata: metadata.dup
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class MeshTrustPolicy
+      attr_reader :name, :allowed_peers, :blocked_peers, :required_roles,
+                  :required_labels, :required_metadata, :metadata
+
+      def initialize(name:, allowed_peers: nil, blocked_peers: [], required_roles: [],
+                     required_labels: {}, required_metadata: {}, metadata: {})
+        @name = name.to_sym
+        @allowed_peers = normalize_optional_names(allowed_peers)
+        @blocked_peers = normalize_names(blocked_peers)
+        @required_roles = normalize_names(required_roles)
+        @required_labels = normalize_hash(required_labels)
+        @required_metadata = normalize_hash(required_metadata)
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def self.permissive(metadata: {})
+        new(name: :permissive, metadata: metadata)
+      end
+
+      def admit(peer:, plan_kind:, action:, membership:)
+        return denied(peer, :blocked_peer, "mesh trust policy #{name} blocked #{peer.name}", plan_kind, action, membership) if blocked_peers.include?(peer.name)
+        return denied(peer, :unlisted_peer, "mesh trust policy #{name} rejected #{peer.name}", plan_kind, action, membership) unless allowed_peer?(peer.name)
+        return denied(peer, :missing_roles, "mesh trust policy #{name} requires roles #{required_roles.inspect}", plan_kind, action, membership) unless roles_allowed?(peer)
+        return denied(peer, :missing_labels, "mesh trust policy #{name} requires labels #{required_labels.inspect}", plan_kind, action, membership) unless labels_allowed?(peer)
+        return denied(peer, :missing_metadata, "mesh trust policy #{name} requires metadata #{required_metadata.inspect}", plan_kind, action, membership) unless metadata_allowed?(peer)
+
+        MeshAdmissionResult.new(
+          peer_name: peer.name,
+          allowed: true,
+          code: accepted_code,
+          metadata: result_metadata(peer, plan_kind, action, membership),
+          reason: DecisionExplanation.new(
+            code: accepted_code,
+            message: accepted_message(peer, plan_kind),
+            metadata: result_metadata(peer, plan_kind, action, membership)
+          )
+        )
+      end
+
+      def to_h
+        {
+          name: name,
+          allowed_peers: allowed_peers&.dup,
+          blocked_peers: blocked_peers.dup,
+          required_roles: required_roles.dup,
+          required_labels: required_labels.dup,
+          required_metadata: required_metadata.dup,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def normalize_names(values)
+        Array(values).map(&:to_sym).uniq.sort.freeze
+      end
+
+      def normalize_optional_names(values)
+        return nil if values.nil?
+
+        normalize_names(values)
+      end
+
+      def normalize_hash(values)
+        values.each_with_object({}) do |(key, value), memo|
+          memo[key.to_sym] = value
+        end.freeze
+      end
+
+      def allowed_peer?(peer_name)
+        return true if allowed_peers.nil?
+
+        allowed_peers.include?(peer_name)
+      end
+
+      def roles_allowed?(peer)
+        required_roles.all? { |role| peer.roles.include?(role) }
+      end
+
+      def labels_allowed?(peer)
+        peer.matches_labels?(required_labels)
+      end
+
+      def metadata_allowed?(peer)
+        required_metadata.all? do |key, value|
+          peer.metadata[key] == value
+        end
+      end
+
+      def denied(peer, code, message, plan_kind, action, membership)
+        details = result_metadata(peer, plan_kind, action, membership)
+        MeshAdmissionResult.new(
+          peer_name: peer.name,
+          allowed: false,
+          code: code,
+          metadata: details,
+          reason: DecisionExplanation.new(
+            code: code,
+            message: message,
+            metadata: details
+          )
+        )
+      end
+
+      def accepted_code
+        name == :permissive ? :mesh_permissive_accept : :mesh_trust_accept
+      end
+
+      def accepted_message(peer, plan_kind)
+        return "permissive mesh admission accepted #{peer.name} for #{plan_kind}" if name == :permissive
+
+        "mesh trust policy #{name} accepted #{peer.name} for #{plan_kind}"
+      end
+
+      def result_metadata(peer, plan_kind, action, membership)
+        {
+          policy: to_h,
+          peer: peer.to_h,
+          plan_kind: plan_kind.to_sym,
+          subject: action.to_h,
+          membership: membership.to_h
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class OperatorTimeline
+      attr_reader :kind, :status, :event_log, :metadata, :explanation
+
+      def initialize(kind:, status:, event_log:, metadata: {}, explanation: nil)
+        @kind = kind.to_sym
+        @status = status.to_sym
+        @event_log = event_log
+        @metadata = metadata.dup.freeze
+        @explanation = DecisionExplanation.normalize(
+          explanation,
+          default_code: @status,
+          metadata: @metadata
+        )
+        freeze
+      end
+
+      def to_h
+        {
+          kind: kind,
+          status: status,
+          event_count: event_log.event_count,
+          event_log: event_log.to_h,
+          metadata: metadata.dup,
+          explanation: explanation&.to_h
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class OwnershipClaim
+      attr_reader :target, :owner, :metadata, :reason
+
+      def initialize(target:, owner:, metadata: {}, reason: nil)
+        @target = target.to_s
+        @owner = owner
+        @metadata = metadata.dup.freeze
+        @reason = DecisionExplanation.normalize(
+          reason,
+          default_code: :ownership_claim,
+          metadata: @metadata
+        )
+        freeze
+      end
+
+      def to_h
+        {
+          target: target,
+          owner: owner.name,
+          metadata: metadata.dup,
+          reason: reason&.to_h
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class OwnershipPlan
+      attr_reader :mode, :claims, :metadata, :explanation
+
+      def initialize(mode:, claims:, metadata: {}, explanation: nil)
+        @mode = mode.to_sym
+        @claims = Array(claims).freeze
+        @metadata = metadata.dup.freeze
+        @explanation = DecisionExplanation.normalize(
+          explanation,
+          default_code: @mode,
+          metadata: @metadata
+        )
+        freeze
+      end
+
+      def owner_names
+        claims.map { |claim| claim.owner.name }.uniq
+      end
+
+      def targets
+        claims.map(&:target).uniq
+      end
+
+      def to_h
+        {
+          mode: mode,
+          claims: claims.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/ownership_policy.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class OwnershipPolicy
+      attr_reader :name, :owner_limit, :use_topology_policy, :metadata
+
+      def initialize(name:, owner_limit: 1, use_topology_policy: true, metadata: {})
+        @name = name.to_sym
+        @owner_limit = Integer(owner_limit)
+        @use_topology_policy = use_topology_policy == true
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def self.distributed(metadata: {})
+        new(name: :distributed, metadata: metadata)
+      end
+
+      def plan(peers:, query:, target:, topology_policy: nil, metadata: {})
+        candidates = candidate_owners(peers: peers, query: query, topology_policy: topology_policy)
+
+        if candidates.empty?
+          return OwnershipPlan.new(
+            mode: :unowned,
+            claims: [],
+            metadata: plan_metadata(query, target, candidates, metadata),
+            explanation: DecisionExplanation.new(
+              code: :unowned_target,
+              message: "no owner available for #{target}",
+              metadata: plan_metadata(query, target, candidates, metadata)
+            )
+          )
+        end
+
+        claims = candidates.first(owner_limit).map do |owner|
+          OwnershipClaim.new(
+            target: target,
+            owner: owner,
+            metadata: {
+              policy: name,
+              query: query.to_h
+            },
+            reason: DecisionExplanation.new(
+              code: :ownership_assigned,
+              message: "assign #{target} to #{owner.name}",
+              metadata: {
+                policy: name,
+                target: target,
+                owner: owner.name
+              }
+            )
+          )
+        end
+
+        OwnershipPlan.new(
+          mode: :assigned,
+          claims: claims,
+          metadata: plan_metadata(query, target, candidates, metadata),
+          explanation: DecisionExplanation.new(
+            code: :ownership_plan,
+            message: "assigned #{target} to #{claims.length} owner(s)",
+            metadata: plan_metadata(query, target, candidates, metadata)
+          )
+        )
+      end
+
+      def to_h
+        {
+          name: name,
+          owner_limit: owner_limit,
+          use_topology_policy: use_topology_policy,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def candidate_owners(peers:, query:, topology_policy:)
+        candidates =
+          if use_topology_policy && !topology_policy.nil?
+            topology_policy.destinations_for(peers: peers, query: query)
+          else
+            Array(peers).select { |peer| query.matches_peer?(peer) }
+          end
+
+        candidates.select { |peer| query.matches_capabilities?(peer) }
+      end
+
+      def plan_metadata(query, target, candidates, extra_metadata)
+        {
+          policy: to_h,
+          target: target.to_s,
+          query: query.to_h,
+          candidate_owner_names: candidates.map(&:name)
+        }.merge(extra_metadata)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class Peer
+      attr_reader :profile, :transport
+
+      def initialize(name:, capabilities:, transport:, metadata: {}, roles: [], labels: {}, region: nil, zone: nil,
+                     profile: nil, capability_catalog: nil, health: nil, health_status: :healthy, health_checks: {})
+        raise ArgumentError, "peer transport must respond to call(request:)" unless transport.respond_to?(:call)
+
+        @profile = profile || PeerProfile.new(
+          name: name,
+          capabilities: capabilities,
+          roles: roles,
+          labels: labels,
+          region: region,
+          zone: zone,
+          metadata: metadata,
+          capability_catalog: capability_catalog,
+          health: health,
+          health_status: health_status,
+          health_checks: health_checks
+        )
+        @transport = transport
+        freeze
+      end
+
+      def name
+        profile.name
+      end
+
+      def capabilities
+        profile.capabilities
+      end
+
+      def roles
+        profile.roles
+      end
+
+      def labels
+        profile.labels
+      end
+
+      def region
+        profile.region
+      end
+
+      def zone
+        profile.zone
+      end
+
+      def metadata
+        profile.metadata
+      end
+
+      def health
+        profile.health
+      end
+
+      def supports_capabilities?(required_capabilities)
+        profile.supports_capabilities?(required_capabilities)
+      end
+
+      def supports_traits?(required_traits)
+        profile.supports_traits?(required_traits)
+      end
+
+      def matches_labels?(required_labels)
+        profile.matches_labels?(required_labels)
+      end
+
+      def matches_region?(preferred_region)
+        profile.matches_region?(preferred_region)
+      end
+
+      def matches_zone?(preferred_zone)
+        profile.matches_zone?(preferred_zone)
+      end
+
+      def to_h
+        profile.to_h
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Cluster
+    class PeerDiscovery
+      attr_reader :metadata
+
+      def initialize(metadata: {})
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def peers_for(plan_kind:, plan:, action:, membership:)
+        ordered_names = ordered_candidate_names(plan_kind: plan_kind, plan: plan, action: action)
+        discovered = ordered_names.filter_map { |name| membership.fetch(name) }
+        query = query_for(plan)
+        discovered |= membership.select(query: query) unless query.nil?
+        discovered.freeze
+      end
+
+      def to_h
+        {
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def ordered_candidate_names(plan_kind:, plan:, action:)
+        names = []
+
+        case plan_kind.to_sym
+        when :rebalance
+          names << action.destination.name
+          names.concat(Array(plan.metadata[:destination_names]))
+        when :ownership
+          names << action.owner.name
+          names.concat(Array(plan.metadata[:candidate_owner_names]))
+        when :lease
+          names << action.owner.name
+          names.concat(Array(plan.metadata.dig(:ownership, :owner_names)))
+        when :failover
+          names << action.destination.name
+          names.concat(Array(plan.metadata[:destination_names]))
+          names.concat(Array(plan.metadata.dig(:ownership, :owner_names)))
+        end
+
+        names.map(&:to_sym).uniq
+      end
+
+      def query_for(plan)
+        query_hash =
+          plan.metadata[:query] ||
+          plan.metadata.dig(:ownership, :metadata, :query)
+
+        return nil unless query_hash.is_a?(Hash)
+
+        CapabilityQuery.from_routing(query_hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Igniter
+  module Cluster
+    class PeerHealth
+      attr_reader :status, :checks, :observed_at, :metadata
+
+      def initialize(status: :healthy, checks: {}, observed_at: Time.now.utc, metadata: {})
+        @status = status.to_sym
+        @checks = normalize_checks(checks)
+        @observed_at = observed_at
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def healthy?
+        status == :healthy
+      end
+
+      def degraded?
+        status == :degraded
+      end
+
+      def unhealthy?
+        status == :unhealthy
+      end
+
+      def available?(allow_degraded: false)
+        return true if healthy?
+        return true if degraded? && allow_degraded
+
+        false
+      end
+
+      def to_h
+        {
+          status: status,
+          checks: checks.dup,
+          observed_at: observed_at.iso8601,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def normalize_checks(checks)
+        checks.each_with_object({}) do |(key, value), memo|
+          memo[key.to_sym] = value
+        end.freeze
+      end
+    end
+  end
+end