igniter 0.4.3 → 0.5.0

data/lib/igniter/metrics/prometheus_exporter.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Metrics
+    # Formats a Collector snapshot into Prometheus text exposition format (0.0.4).
+    #
+    # https://prometheus.io/docs/instrumenting/exposition_formats/
+    #
+    # Usage:
+    #   exporter = PrometheusExporter.new(collector, store: store, registry: registry)
+    #   text = exporter.export          # → String in Prometheus text format
+    #   content_type = exporter.content_type
+    class PrometheusExporter
+      CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8"
+
+      COUNTER_META = {
+        "igniter_executions_total" =>
+          "Total contract executions completed",
+        "igniter_http_requests_total" =>
+          "Total HTTP requests received by igniter-server"
+      }.freeze
+
+      HISTOGRAM_META = {
+        "igniter_execution_duration_seconds" =>
+          "Contract execution duration in seconds",
+        "igniter_http_request_duration_seconds" =>
+          "HTTP request processing duration in seconds"
+      }.freeze
+
+      def initialize(collector, store:, registry:)
+        @collector = collector
+        @store     = store
+        @registry  = registry
+      end
+
+      def content_type
+        CONTENT_TYPE
+      end
+
+      def export # rubocop:disable Metrics/MethodLength
+        snap  = @collector.snapshot
+        lines = []
+
+        emit_counters(lines, snap.counters)
+        emit_histograms(lines, snap.histograms)
+        emit_pending_gauge(lines)
+
+        lines.join("\n") + "\n"
+      end
+
+      private
+
+      def emit_counters(lines, counters) # rubocop:disable Metrics/MethodLength
+        by_metric = counters.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(key, val), memo|
+          name = key.split("{").first
+          memo[name] << [key, val]
+        end
+
+        by_metric.each do |name, entries|
+          lines << "# HELP #{name} #{COUNTER_META.fetch(name, name)}"
+          lines << "# TYPE #{name} counter"
+          entries.each { |key, val| lines << "#{key} #{val}" }
+          lines << ""
+        end
+      end
+
+      def emit_histograms(lines, histograms)
+        histograms.each do |name, by_label|
+          lines << "# HELP #{name} #{HISTOGRAM_META.fetch(name, name)}"
+          lines << "# TYPE #{name} histogram"
+          by_label.each_value { |entry| emit_histogram_entry(lines, name, entry) }
+          lines << ""
+        end
+      end
+
+      def emit_histogram_entry(lines, name, entry) # rubocop:disable Metrics/MethodLength
+        lstr = entry[:labels].map { |k, v| "#{k}=\"#{v}\"" }.join(",")
+        sep  = lstr.empty? ? "" : ","
+
+        Collector::HISTOGRAM_BUCKETS.each do |b|
+          le = b.to_s
+          lines << "#{name}_bucket{#{lstr}#{sep}le=\"#{le}\"} #{entry[:buckets][b]}"
+        end
+        lines << "#{name}_bucket{#{lstr}#{sep}le=\"+Inf\"} #{entry[:count]}"
+        lines << "#{name}_sum{#{lstr}} #{format("%.6f", entry[:sum])}"
+        lines << "#{name}_count{#{lstr}} #{entry[:count]}"
+      end
+
+      def emit_pending_gauge(lines) # rubocop:disable Metrics/MethodLength
+        lines << "# HELP igniter_pending_executions Currently pending executions in store"
+        lines << "# TYPE igniter_pending_executions gauge"
+
+        @registry.names.each do |name|
+          count = @store.list_pending(graph: name).size
+          lines << "igniter_pending_executions{graph=\"#{name}\"} #{count}"
+        rescue StandardError
+          lines << "igniter_pending_executions{graph=\"#{name}\"} 0"
+        end
+
+        lines << ""
+      end
+    end
+  end
+end

data/lib/igniter/metrics/snapshot.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Metrics
+    # Immutable snapshot of collected metrics, safe to read from any thread.
+    Snapshot = Struct.new(:counters, :histograms, keyword_init: true)
+  end
+end

data/lib/igniter/metrics.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "igniter"
+require "igniter/metrics/snapshot"
+require "igniter/metrics/collector"
+require "igniter/metrics/prometheus_exporter"
+
+module Igniter
+  # Metrics collection for Igniter contracts and igniter-server.
+  #
+  # The Collector subscribes to an Igniter::Events::Bus and maintains
+  # in-memory counters and histograms with zero external dependencies.
+  #
+  # Prometheus text format is exported via PrometheusExporter — usable
+  # directly in the /v1/metrics endpoint of igniter-server.
+  #
+  # Usage (standalone):
+  #   require "igniter/metrics"
+  #
+  #   collector = Igniter::Metrics::Collector.new
+  #   contract.execution.events.subscribe(collector)
+  #   contract.resolve_all
+  #
+  #   exporter = Igniter::Metrics::PrometheusExporter.new(
+  #     collector, store: store, registry: registry
+  #   )
+  #   puts exporter.export
+  #
+  # Usage (igniter-server — automatic when metrics_collector is set):
+  #   Igniter::Server.configure do |c|
+  #     c.metrics_collector = Igniter::Metrics::Collector.new
+  #   end
+  #
+  module Metrics
+    class MetricsError < Igniter::Error; end
+  end
+end

data/lib/igniter/model/aggregate_node.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    # Represents a maintained aggregate node in the computation graph.
+    #
+    # An AggregateNode computes an aggregate value over an incremental collection
+    # and updates it in O(change) time by processing only the diff (added/changed/removed
+    # items) rather than iterating over the entire collection on every resolve.
+    #
+    # Supported built-in operators: :count, :sum, :avg, :min, :max, :group_count.
+    # Custom aggregates can be defined with initial:, add:, and remove: lambdas.
+    #
+    # The aggregate node depends on exactly one upstream incremental collection node.
+    # The compiler validates this at definition time.
+    class AggregateNode < Node
+      attr_reader :source_collection, :operator
+
+      def initialize(id:, name:, source_collection:, operator:, # rubocop:disable Metrics/ParameterLists
+                     path: nil, metadata: {})
+        super(
+          id: id,
+          kind: :aggregate,
+          name: name,
+          path: path || name.to_s,
+          dependencies: [source_collection],
+          metadata: metadata
+        )
+        @source_collection = source_collection.to_sym
+        @operator = operator
+      end
+    end
+  end
+end

data/lib/igniter/model/collection_node.rb

@@ -3,9 +3,9 @@
 module Igniter
   module Model
     class CollectionNode < Node
-      attr_reader :source_dependency, :contract_class, :key_name, :mode, :context_dependencies, :input_mapper
+      attr_reader :source_dependency, :contract_class, :key_name, :mode, :window, :context_dependencies, :input_mapper
 
-      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, context_dependencies: [], input_mapper: nil, path: nil, metadata: {})
+      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, window: nil, context_dependencies: [], input_mapper: nil, path: nil, metadata: {})
         super(
           id: id,
           kind: :collection,
@@ -19,6 +19,7 @@ module Igniter
         @contract_class = contract_class
         @key_name = key_name.to_sym
         @mode = mode.to_sym
+        @window = window
         @context_dependencies = Array(context_dependencies).map(&:to_sym)
         @input_mapper = input_mapper
       end

data/lib/igniter/model/compute_node.rb

@@ -57,6 +57,19 @@ module Igniter
         metadata[:type] || executor_metadata[:type]
       end
 
+      # Seconds to cache this node's result across executions (nil = no TTL cache).
+      # Requires Igniter::NodeCache.cache to be configured.
+      def cache_ttl
+        metadata[:cache_ttl]
+      end
+
+      # When true, concurrent executions with identical dep fingerprints share one
+      # computation (the follower waits for the leader's result).
+      # Requires Igniter::NodeCache.coalescing_lock to be configured.
+      def coalesce?
+        metadata[:coalesce] == true
+      end
+
       def const?
         metadata[:kind] == :const
       end

data/lib/igniter/model/remote_node.rb

@@ -4,10 +4,16 @@ 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
+      attr_reader :contract_name, :node_url, :input_mapping, :timeout, :capability, :pinned_to
 
-      def initialize(id:, name:, contract_name:, node_url:, input_mapping:, timeout: 30, path: nil, metadata: {})
+      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,
@@ -20,6 +26,16 @@ module Igniter
         @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

data/lib/igniter/node_cache.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Igniter
+  # Cross-execution TTL cache and request coalescing for compute nodes.
+  #
+  # Activated per-node via the `cache_ttl:` and `coalesce:` options on `compute`:
+  #
+  #   compute :available_slots, with: [...], call: CheckAvailability,
+  #           cache_ttl: 60,     # seconds — reuse result across executions
+  #           coalesce: true     # deduplicate concurrent in-flight requests
+  #
+  # == Setup
+  #
+  #   require "igniter/node_cache"
+  #   Igniter::NodeCache.cache = Igniter::NodeCache::Memory.new
+  #   Igniter::NodeCache.coalescing_lock = Igniter::NodeCache::CoalescingLock.new
+  #
+  # Or via the configure block:
+  #
+  #   Igniter.configure do |c|
+  #     c.node_cache = Igniter::NodeCache::Memory.new
+  #     c.node_coalescing = true   # auto-creates a CoalescingLock
+  #   end
+  #
+  # == AR fingerprinting (Gap 3)
+  #
+  # Cache keys are built from a stable fingerprint of dep values.
+  # For ActiveRecord objects, include Igniter::Fingerprint (or use the Railtie):
+  #
+  #   class Trade < ApplicationRecord
+  #     include Igniter::Fingerprint
+  #     # default: "Trade:42:1712345678"
+  #   end
+  module NodeCache
+    class << self
+      # Global TTL cache backend. nil = disabled (default).
+      # Must respond to: #fetch(key) → value | nil
+      #                  #store(key, value, ttl:)
+      attr_accessor :cache
+
+      # Global coalescing lock. nil = disabled (default).
+      attr_accessor :coalescing_lock
+    end
+
+    # ─── Cache key ────────────────────────────────────────────────────────────
+
+    # Immutable key uniquely identifying a node result for a given set of dep values.
+    # Format: "ttl:{contract_name}:{node_name}:{dep_fingerprint_hex}"
+    class CacheKey
+      attr_reader :hex
+
+      def initialize(contract_name, node_name, dep_hex)
+        @hex = "ttl:#{contract_name}:#{node_name}:#{dep_hex}".freeze
+        freeze
+      end
+
+      def to_s    = @hex
+      def inspect = "#<NodeCache::CacheKey #{@hex}>"
+      def ==(other) = other.is_a?(CacheKey) && other.hex == @hex
+    end
+
+    # ─── Memory backend ───────────────────────────────────────────────────────
+
+    # Thread-safe in-process TTL store. Entries expire after their TTL.
+    # Replace with a Redis-backed implementation for multi-process sharing.
+    class Memory
+      Entry = Struct.new(:value, :expires_at) do
+        def expired? = Time.now.utc > expires_at
+      end
+
+      def initialize
+        @store  = {}
+        @mu     = Mutex.new
+        @hits   = 0
+        @misses = 0
+      end
+
+      # Returns the cached value, or nil on miss / expiry.
+      def fetch(key)
+        @mu.synchronize do
+          entry = @store[key.hex]
+          if entry.nil? || entry.expired?
+            @store.delete(key.hex) if entry
+            @misses += 1
+            nil
+          else
+            @hits += 1
+            entry.value
+          end
+        end
+      end
+
+      # Stores value with a TTL in seconds.
+      def store(key, value, ttl:)
+        @mu.synchronize do
+          @store[key.hex] = Entry.new(value, Time.now.utc + ttl)
+        end
+        value
+      end
+
+      # Remove all expired entries. Call periodically to reclaim memory.
+      def prune!
+        @mu.synchronize do
+          now = Time.now.utc
+          @store.delete_if { |_, e| e.expires_at < now }
+        end
+      end
+
+      def size  = @mu.synchronize { @store.size }
+      def clear = @mu.synchronize { @store.clear; @hits = 0; @misses = 0 }
+      def stats = @mu.synchronize { { size: @store.size, hits: @hits, misses: @misses } }
+    end
+
+    # ─── Coalescing lock ──────────────────────────────────────────────────────
+
+    # In-flight deduplication for concurrent requests with identical dep fingerprints.
+    #
+    # When two executions race to compute the same `coalesce: true` node:
+    #   • The first caller becomes the leader — computes and stores the result.
+    #   • Subsequent callers become followers — wait for the leader, then reuse its result.
+    #
+    # This eliminates duplicate work for concurrent auction-style requests
+    # (e.g. 3 vendors arriving within ~50ms for the same lead).
+    #
+    # Scope: single Ruby process. For Puma multi-worker, extend with a Redis-based
+    # implementation using SETNX advisory locks + Pub/Sub.
+    class CoalescingLock
+      WAIT_TIMEOUT = 30 # seconds before a follower gives up and computes independently
+
+      InFlight = Struct.new(:mutex, :cond, :done, :value, :error, keyword_init: true)
+
+      def initialize
+        @mu      = Mutex.new
+        @flights = {}
+      end
+
+      # Attempt to acquire a computation slot for `hex`.
+      #
+      # Returns [:leader, flight]   — caller is first; must compute then call finish!
+      # Returns [:follower, flight] — another caller is already computing; call wait(flight)
+      def acquire(hex)
+        @mu.synchronize do
+          if @flights.key?(hex)
+            [:follower, @flights[hex]]
+          else
+            flight = InFlight.new(
+              mutex: Mutex.new,
+              cond:  ConditionVariable.new,
+              done:  false,
+              value: nil,
+              error: nil
+            )
+            @flights[hex] = flight
+            [:leader, flight]
+          end
+        end
+      end
+
+      # Called by the leader when computation finishes (success or failure).
+      # Unblocks all waiting followers.
+      def finish!(hex, value: nil, error: nil)
+        flight = @mu.synchronize { @flights.delete(hex) }
+        return unless flight
+
+        flight.mutex.synchronize do
+          flight.value = value
+          flight.error = error
+          flight.done  = true
+          flight.cond.broadcast
+        end
+      end
+
+      # Called by a follower after receiving the flight object from acquire.
+      # Blocks until the leader calls finish!, then returns [value, error].
+      # Times out after WAIT_TIMEOUT seconds and returns [nil, nil] (follower recomputes).
+      def wait(flight)
+        flight.mutex.synchronize do
+          deadline = Time.now + WAIT_TIMEOUT
+          until flight.done
+            remaining = deadline - Time.now
+            break if remaining <= 0
+
+            flight.cond.wait(flight.mutex, remaining)
+          end
+          [flight.value, flight.error]
+        end
+      end
+
+      def in_flight_count = @mu.synchronize { @flights.size }
+    end
+
+    # ─── Fingerprinter ────────────────────────────────────────────────────────
+
+    # Produces a stable hex fingerprint for a set of dependency values.
+    # Used as part of the NodeCache::CacheKey.
+    #
+    # Supports the Igniter::Fingerprint protocol:
+    #   objects responding to #igniter_fingerprint return a stable string
+    #   (e.g. "Trade:42:1712345678").
+    #
+    # Fallback for unknown objects: "#ClassName@object_id" — stable within
+    # a single process but NOT across restarts. Sufficient for the in-process
+    # Memory backend; Redis-backed deployments should ensure all dep objects
+    # implement igniter_fingerprint.
+    module Fingerprinter
+      def self.call(dep_values)
+        Digest::SHA256.hexdigest(serialize(dep_values))[0..23]
+      end
+
+      def self.serialize(val) # rubocop:disable Metrics/CyclomaticComplexity
+        case val
+        when Hash
+          pairs = val.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}:#{serialize(v)}" }
+          "{#{pairs.join(",")}}"
+        when Array  then "[#{val.map { |v| serialize(v) }.join(",")}]"
+        when String then val.inspect
+        when Symbol then ":#{val}"
+        when Numeric, NilClass, TrueClass, FalseClass then val.inspect
+        else
+          if val.respond_to?(:igniter_fingerprint)
+            "fp:#{val.igniter_fingerprint}"
+          else
+            "obj:#{val.class.name}@#{val.object_id}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/replication/bootstrapper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Replication
+    # Abstract base class for deployment bootstrappers.
+    #
+    # Subclasses implement three lifecycle methods:
+    #   install — copy/install the application on the remote
+    #   start   — launch the application process
+    #   verify  — confirm the application is running (default impl provided)
+    class Bootstrapper
+      BootstrapError = Class.new(Igniter::Error)
+
+      # Install the application on the remote server.
+      #
+      # @param session [SSHSession] active SSH session to the remote host
+      # @param manifest [Manifest] self-description of the running instance
+      # @param env [Hash] environment variables to write on remote
+      # @param target_path [String] base directory on the remote server
+      def install(session:, manifest:, env: {}, target_path: "/opt/igniter")
+        raise NotImplementedError, "#{self.class}#install not implemented"
+      end
+
+      # Start the application on the remote server.
+      #
+      # @param session [SSHSession] active SSH session to the remote host
+      # @param manifest [Manifest] self-description of the running instance
+      # @param target_path [String] base directory on the remote server
+      def start(session:, manifest:, target_path: "/opt/igniter")
+        raise NotImplementedError, "#{self.class}#start not implemented"
+      end
+
+      # Verify the application is running on the remote server.
+      # Returns true if Igniter can be loaded, false otherwise.
+      #
+      # @param session [SSHSession] active SSH session to the remote host
+      # @param target_path [String] base directory on the remote server (unused by default impl)
+      def verify(session:, target_path: "/opt/igniter") # rubocop:disable Lint/UnusedMethodArgument
+        result = session.exec("ruby -e 'require \"igniter\"; puts Igniter::VERSION' 2>/dev/null")
+        result[:success] && !result[:stdout].strip.empty?
+      rescue SSHSession::SSHError
+        false
+      end
+
+      protected
+
+      # Write environment variables to a shell-sourceable file on the remote.
+      #
+      # @param session [SSHSession] active SSH session
+      # @param env [Hash] key-value pairs to export
+      # @param path [String] remote path for the env file
+      def write_env_file(session:, env:, path:)
+        return if env.nil? || env.empty?
+
+        require "shellwords"
+        lines = env.map { |k, v| "export #{k}=#{v.to_s.shellescape}" }.join("\n")
+        session.exec!("printf '%s\\n' #{lines.shellescape} > #{path}")
+      end
+    end
+  end
+end

data/lib/igniter/replication/bootstrappers/gem.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Replication
+    module Bootstrappers
+      # Deploys by installing the igniter gem from RubyGems on the remote host.
+      #
+      # Optionally pins a specific gem version. The startup script defaults to
+      # the +igniter-server+ executable installed with the gem.
+      class Gem < Bootstrapper
+        def initialize(version: nil, startup_script: nil)
+          super()
+          @version        = version
+          @startup_script = startup_script
+        end
+
+        def install(session:, manifest:, env: {}, target_path: "/opt/igniter") # rubocop:disable Lint/UnusedMethodArgument
+          ver_flag = @version ? " -v #{@version}" : ""
+          session.exec!("gem install igniter#{ver_flag} --no-document")
+          session.exec!("mkdir -p #{target_path}")
+          write_env_file(session: session, env: env, path: "#{target_path}/.env")
+        end
+
+        def start(session:, manifest:, target_path: "/opt/igniter") # rubocop:disable Lint/UnusedMethodArgument
+          log_path = "#{target_path}/igniter.log"
+          script   = @startup_script || "igniter-server"
+          session.exec!("nohup #{script} >> #{log_path} 2>&1 &")
+        end
+      end
+    end
+  end
+end

data/lib/igniter/replication/bootstrappers/git.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Replication
+    module Bootstrappers
+      # Deploys by cloning a git repository on the remote host.
+      #
+      # Requires git to be installed on the remote. After cloning, installs
+      # bundler and runs bundle install.
+      class Git < Bootstrapper
+        DEFAULT_BRANCH         = "main"
+        DEFAULT_BUNDLE_OPTIONS = "--without development test"
+
+        def initialize(repo_url:, branch: DEFAULT_BRANCH, bundle_options: DEFAULT_BUNDLE_OPTIONS)
+          super()
+          @repo_url       = repo_url
+          @branch         = branch
+          @bundle_options = bundle_options
+        end
+
+        def install(session:, manifest:, env: {}, target_path: "/opt/igniter") # rubocop:disable Lint/UnusedMethodArgument
+          app_path = "#{target_path}/app"
+          session.exec!("mkdir -p #{target_path}")
+          session.exec!("git clone --branch #{@branch} --depth 1 #{@repo_url} #{app_path}")
+          session.exec!("cd #{app_path} && gem install bundler --no-document")
+          session.exec!("cd #{app_path} && bundle install #{@bundle_options}")
+          write_env_file(session: session, env: env, path: "#{target_path}/.env")
+        end
+
+        def start(session:, manifest:, target_path: "/opt/igniter")
+          app_path = "#{target_path}/app"
+          log_path = "#{target_path}/igniter.log"
+          cmd      = manifest.startup_command
+          session.exec!("cd #{app_path} && nohup ruby #{cmd} >> #{log_path} 2>&1 &")
+        end
+      end
+    end
+  end
+end

data/lib/igniter/replication/bootstrappers/tarball.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+
+module Igniter
+  module Replication
+    module Bootstrappers
+      # Deploys by creating a gzipped tarball of the local source tree,
+      # uploading it via SCP, and extracting it on the remote host.
+      #
+      # This strategy works without git or internet access on the remote,
+      # making it suitable for air-gapped or private environments.
+      class Tarball < Bootstrapper
+        def install(session:, manifest:, env: {}, target_path: "/opt/igniter")
+          tarball = create_tarball(manifest)
+          begin
+            remote_tar = "/tmp/igniter_replication_#{Process.pid}.tar.gz"
+            session.upload!(tarball, remote_tar)
+            extract_and_install(session, remote_tar, target_path)
+            write_env_file(session: session, env: env, path: "#{target_path}/.env")
+          ensure
+            FileUtils.rm_f(tarball)
+          end
+        end
+
+        def start(session:, manifest:, target_path: "/opt/igniter")
+          app_path = "#{target_path}/app"
+          log_path = "#{target_path}/igniter.log"
+          cmd      = File.basename(manifest.startup_command)
+          session.exec!("cd #{app_path} && nohup ruby #{cmd} >> #{log_path} 2>&1 &")
+        end
+
+        private
+
+        def extract_and_install(session, remote_tar, target_path)
+          app_path = "#{target_path}/app"
+          session.exec!("mkdir -p #{app_path}")
+          session.exec!("tar -xzf #{remote_tar} -C #{app_path} --strip-components=1")
+          session.exec!("cd #{app_path} && gem install bundler --no-document")
+          session.exec!("cd #{app_path} && bundle install --without development test")
+          session.exec!("rm -f #{remote_tar}")
+        end
+
+        def create_tarball(manifest)
+          source  = manifest.source_path
+          tmpfile = File.join(Dir.tmpdir, "igniter_replication_#{Process.pid}.tar.gz")
+          parent  = File.dirname(source)
+          name    = File.basename(source)
+          system("tar", "-czf", tmpfile, "-C", parent, name)
+          tmpfile
+        end
+      end
+    end
+  end
+end