igniter 0.5.0 → 0.5.1

data/lib/igniter/mesh.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "mesh/errors"
-require_relative "mesh/peer"
-require_relative "mesh/peer_registry"
-require_relative "mesh/config"
-require_relative "mesh/router"
-require_relative "mesh/announcer"
-require_relative "mesh/poller"
-require_relative "mesh/discovery"
-require_relative "mesh/gossip"
-
-module Igniter
-  # Mesh routing for remote: nodes.
-  #
-  # Phase 1 — Static Mesh:
-  #   Declare peer topology via add_peer. capability: and pinned_to: routing
-  #   modes select alive peers at resolution time.
-  #
-  # Phase 2 — Dynamic Discovery:
-  #   Configure seed URLs and call start_discovery!. The local node announces
-  #   itself to seeds and polls them for the current peer list in the background.
-  #
-  # Usage:
-  #
-  #   require "igniter/extensions/mesh"
-  #
-  #   Igniter::Mesh.configure do |c|
-  #     c.peer_name          = "api-node"
-  #     c.local_url          = "http://api.internal:4567"
-  #     c.local_capabilities = [:api]
-  #     c.seeds              = %w[http://orders.internal:4567 http://audit.internal:4567]
-  #     c.discovery_interval = 30   # seconds (default)
-  #
-  #     # Static peers still work alongside dynamic discovery:
-  #     c.add_peer "legacy-node",
-  #                url: "http://legacy.internal:4567",
-  #                capabilities: [:billing]
-  #   end
-  #
-  #   Igniter::Mesh.start_discovery!   # announce + poll + background thread
-  #   # …
-  #   Igniter::Mesh.stop_discovery!    # deannounce + stop thread (on shutdown)
-  module Mesh
-    class << self
-      def config
-        @config ||= Config.new
-      end
-
-      def configure
-        yield config
-        self
-      end
-
-      def router
-        @router ||= Router.new(config)
-      end
-
-      # Start dynamic discovery: announce self to seeds, do an immediate poll,
-      # then begin background polling at config.discovery_interval.
-      def start_discovery!
-        discovery.start
-        self
-      end
-
-      # Stop dynamic discovery: deannounce self from seeds, stop background thread.
-      def stop_discovery!
-        @discovery&.stop
-        @discovery = nil
-        self
-      end
-
-      def discovery
-        @discovery ||= Discovery.new(config)
-      end
-
-      # Reset all singletons (config, router, discovery). Useful in tests.
-      def reset!
-        stop_discovery!
-        @config = nil
-        @router = nil
-      end
-    end
-  end
-end

data/lib/igniter/model/remote_node.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Model
-    # Represents a node that executes a contract on a remote igniter-server node.
-    # The result is the outputs hash returned by the remote contract.
-    #
-    # Three routing modes:
-    #   :static     — node_url is a hard-coded URL (original behaviour)
-    #   :capability — auto-select an alive peer advertising the given capability
-    #   :pinned     — must use the specific named peer; IncidentError if down
-    class RemoteNode < Node
-      attr_reader :contract_name, :node_url, :input_mapping, :timeout, :capability, :pinned_to
-
-      def initialize(id:, name:, contract_name:, input_mapping:, # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
-                     node_url: "", timeout: 30, path: nil, metadata: {}, capability: nil, pinned_to: nil)
-        super(
-          id: id,
-          kind: :remote,
-          name: name,
-          path: path || name.to_s,
-          dependencies: input_mapping.values.map(&:to_sym),
-          metadata: metadata
-        )
-        @contract_name = contract_name.to_s
-        @node_url      = node_url.to_s
-        @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
-        @timeout       = Integer(timeout)
-        @capability    = capability&.to_sym
-        @pinned_to     = pinned_to&.to_s
-      end
-
-      # Returns :static, :capability, or :pinned.
-      def routing_mode
-        return :pinned     if @pinned_to
-        return :capability if @capability
-
-        :static
-      end
-    end
-  end
-end

data/lib/igniter/replication/node_role.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Replication
-    # Immutable description of a specialised role a differentiated node can assume.
-    #
-    # When a node replicates with differentiation it carries a NodeRole that
-    # shapes its remote configuration: which contracts to activate, which env
-    # vars to inject, and which capability tags to advertise in the mesh.
-    #
-    # @example
-    #   role = NodeRole.new(
-    #     name:          :worker,
-    #     contracts:     ["ComputeContract"],
-    #     capabilities:  [:compute],
-    #     env_overrides: { "WORKER_POOL" => "8" },
-    #     tags:          [:cpu_heavy]
-    #   )
-    class NodeRole
-      attr_reader :name, :contracts, :capabilities, :env_overrides, :tags
-
-      def initialize(name:, contracts: [], capabilities: [], env_overrides: {}, tags: [])
-        @name          = name.to_sym
-        @contracts     = Array(contracts).map(&:to_s).freeze
-        @capabilities  = Array(capabilities).map(&:to_sym).freeze
-        @env_overrides = Hash(env_overrides).transform_keys(&:to_s).freeze
-        @tags          = Array(tags).map(&:to_sym).freeze
-        freeze
-      end
-
-      def to_h
-        {
-          name:          @name,
-          contracts:     @contracts,
-          capabilities:  @capabilities,
-          env_overrides: @env_overrides,
-          tags:          @tags
-        }
-      end
-    end
-  end
-end

data/lib/igniter/replication/role_registry.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Replication
-    # Module-level registry of named NodeRoles.
-    #
-    # @example
-    #   RoleRegistry.define(:worker,
-    #     contracts:     ["ComputeContract"],
-    #     capabilities:  [:compute],
-    #     env_overrides: { "WORKER_POOL" => "4" }
-    #   )
-    #
-    #   role = RoleRegistry.fetch(:worker)
-    #   role.env_overrides  # => { "WORKER_POOL" => "4" }
-    module RoleRegistry
-      @roles = {}
-
-      class << self
-        # Define and register a new role.
-        #
-        # @param name          [Symbol, String]
-        # @param contracts     [Array<String>]
-        # @param capabilities  [Array<Symbol>]
-        # @param env_overrides [Hash]
-        # @param tags          [Array<Symbol>]
-        # @return [NodeRole]
-        def define(name, contracts: [], capabilities: [], env_overrides: {}, tags: [])
-          role = NodeRole.new(
-            name:          name,
-            contracts:     contracts,
-            capabilities:  capabilities,
-            env_overrides: env_overrides,
-            tags:          tags
-          )
-          @roles[role.name] = role
-        end
-
-        # Fetch a role by name.
-        #
-        # @param name [Symbol, String]
-        # @return [NodeRole]
-        # @raise [ArgumentError] if not registered
-        def fetch(name)
-          @roles.fetch(name.to_sym) do
-            raise ArgumentError,
-                  "Unknown role: #{name}. Available: #{@roles.keys.join(", ")}"
-          end
-        end
-
-        # Returns true if a role with the given name is registered.
-        #
-        # @param name [Symbol, String]
-        # @return [Boolean]
-        def registered?(name)
-          @roles.key?(name.to_sym)
-        end
-
-        # All registered roles (copy to prevent external mutation).
-        #
-        # @return [Hash{Symbol => NodeRole}]
-        def all
-          @roles.dup
-        end
-
-        # Remove all registrations. Useful in tests.
-        def reset!
-          @roles = {}
-        end
-      end
-    end
-  end
-end

data/lib/igniter/replication.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "replication/manifest"
-require_relative "replication/ssh_session"
-require_relative "replication/bootstrapper"
-require_relative "replication/bootstrappers/git"
-require_relative "replication/bootstrappers/gem"
-require_relative "replication/bootstrappers/tarball"
-require_relative "replication/replication_agent"
-require_relative "replication/node_role"
-require_relative "replication/role_registry"
-require_relative "replication/network_topology"
-require_relative "replication/expansion_plan"
-require_relative "replication/expansion_planner"
-require_relative "replication/reflective_replication_agent"
-
-module Igniter
-  # Self-replication capability: deploy a running Igniter instance to a
-  # remote server via SSH using one of three deployment strategies.
-  #
-  # Usage:
-  #   require "igniter/replication"
-  #   ref = Igniter::Replication::ReplicationAgent.start
-  #   ref.send(:replicate,
-  #     host:     "10.0.0.2",
-  #     user:     "deploy",
-  #     strategy: :git,
-  #     bootstrapper_options: { repo_url: "https://github.com/org/app" }
-  #   )
-  #
-  module Replication
-    ReplicationError = Class.new(Igniter::Error)
-
-    BOOTSTRAPPERS = {
-      git: Bootstrappers::Git,
-      gem: Bootstrappers::Gem,
-      tarball: Bootstrappers::Tarball
-    }.freeze
-
-    # Instantiate the bootstrapper for the given strategy.
-    #
-    # @param strategy [Symbol] one of :git, :gem, :tarball
-    # @param options  [Hash]   forwarded to the bootstrapper constructor
-    # @return [Bootstrapper]
-    # @raise [ArgumentError] for unknown strategies
-    def self.bootstrapper_for(strategy, **options)
-      klass = BOOTSTRAPPERS.fetch(strategy.to_sym) do
-        raise ArgumentError,
-              "Unknown bootstrapper: #{strategy}. Available: #{BOOTSTRAPPERS.keys.join(", ")}"
-      end
-      klass.new(**options)
-    end
-  end
-end