shuttlebay 0.1.4 → 0.2.0

data/lib/shuttlebay/server.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'socket'
 
 module Shuttlebay
@@ -11,9 +12,10 @@ module Shuttlebay
     STABLE_AFTER = 30.0
     SIGNALS = { 'TERM' => 'T', 'INT' => 'I', 'QUIT' => 'Q', 'CHLD' => 'C' }.freeze
 
-    Slot = Struct.new(:index, :pid, :started_at, :backoff, :respawn_at)
+    Group = Struct.new(:ship, :app_path, :socket_path, :workers, :threads, :app, :listener)
+    Slot = Struct.new(:group, :index, :pid, :started_at, :backoff, :respawn_at)
 
-    attr_reader :app_path, :socket_path, :workers, :threads, :ship
+    attr_reader :app_path, :socket_path, :workers, :threads, :ship, :forks
 
     def self.from_env(argv, env = ENV)
       socket_path = env.fetch('MS_SOCKET_PATH') do
@@ -24,34 +26,48 @@ module Shuttlebay
         socket_path: socket_path,
         workers: Integer(env.fetch('MS_BAY_WORKERS', '0'), 10),
         threads: Integer(env.fetch('MS_BAY_THREADS', '3'), 10),
-        ship: env.fetch('MS_SHIP', 'rack')
+        ship: env.fetch('MS_SHIP', 'rack'),
+        forks: parse_forks(env.fetch('MS_BAY_FORKS', '[]'))
       )
     end
 
-    def initialize(app_path:, socket_path:, workers:, threads:, ship:, logger: Shuttlebay.logger)
+    def self.parse_forks(json)
+      JSON.parse(json).map do |fork|
+        Group.new(fork.fetch('ship'), fork.fetch('app'), fork.fetch('socket'),
+                  Integer(fork.fetch('workers')).clamp(1..), Integer(fork.fetch('threads')))
+      end
+    end
+
+    def initialize(app_path:, socket_path:, workers:, threads:, ship:, forks: [], logger: Shuttlebay.logger)
       raise ArgumentError, "workers must be >= 0 (got #{workers})" if workers.negative?
       raise ArgumentError, "threads must be >= 1 (got #{threads})" if threads < 1
+      forks.each { |fork| raise ArgumentError, "#{fork.ship}: threads must be >= 1" if fork.threads < 1 }
 
       @app_path = app_path
       @socket_path = socket_path
       @workers = workers
       @threads = threads
       @ship = ship
+      @forks = forks
       @logger = logger
       @master_pid = Process.pid
     end
 
     def run
       Shuttlebay.running = true
-      app = load_app
-      @listener = bind
-      @logger.info('app loaded, socket bound', app: app_path, socket: socket_path,
-                                               workers: workers, threads: threads)
+      primary = Group.new(ship, app_path, socket_path, workers.clamp(1..), threads, load_app(app_path))
+      forked = load_forks
+      Process.warmup if Shuttlebay.warmup?
+      [primary, *forked].each do |group|
+        group.listener = bind(group.socket_path)
+        @logger.info('app loaded, socket bound', ship: group.ship, app: group.app_path, socket: group.socket_path,
+                                                 workers: group.workers, threads: group.threads)
+      end
 
-      if workers.zero?
-        worker(app, index: nil).run
+      if workers.zero? && forked.empty?
+        worker(primary, index: nil).run
       else
-        supervise(app)
+        supervise([primary, *forked])
       end
     ensure
       cleanup if Process.pid == @master_pid
@@ -59,7 +75,7 @@ module Shuttlebay
 
     private
 
-    def load_app
+    def load_app(app_path)
       require 'rack'
       require 'rack/builder'
       path = File.expand_path(app_path)
@@ -68,26 +84,45 @@ module Shuttlebay
       Rack::Builder.parse_file(path)
     end
 
-    def bind
+    def load_forks
+      forks.filter_map do |group|
+        group.app = load_app(group.app_path)
+        group
+      rescue StandardError, ScriptError => e
+        @logger.error('fork app failed to load, skipped', ship: group.ship, app: group.app_path,
+                                                          **Logger.error_fields(e))
+        nil
+      end
+    end
+
+    def bind(socket_path)
       if File.exist?(socket_path)
         raise ArgumentError, "#{socket_path} exists and is not a socket" unless File.socket?(socket_path)
 
         File.unlink(socket_path)
       end
-      UNIXServer.new(socket_path).tap { |server| server.listen(1024) }
+      UNIXServer.new(socket_path).tap do |server|
+        server.listen(1024)
+        bound << [server, socket_path]
+      end
     end
 
-    def worker(app, index:)
-      Worker.new(app: app, listener: @listener, threads: threads, workers: workers, ship: ship,
-                 index: index, master_pid: index && @master_pid, logger: @logger)
+    def bound
+      @bound ||= []
     end
 
-    def supervise(app)
+    def worker(group, index:)
+      Worker.new(app: group.app, listener: group.listener, threads: group.threads, workers: group.workers,
+                 ship: group.ship, index: index, master_pid: index && @master_pid, logger: @logger)
+    end
+
+    def supervise(groups)
       wake_r, wake_w = IO.pipe
       previous = trap_signals(SIGNALS, wake_w)
-      @app = app
       Shuttlebay.run_hooks(:before_fork)
-      @slots = Array.new(workers) { |index| Slot.new(index, nil, nil, RESPAWN_MIN, monotonic) }
+      @slots = groups.flat_map do |group|
+        Array.new(group.workers) { |index| Slot.new(group, index, nil, nil, RESPAWN_MIN, monotonic) }
+      end
       @stopping = false
 
       until @stopping && @slots.none?(&:pid)
@@ -120,14 +155,28 @@ module Shuttlebay
       @slots.each do |slot|
         next if slot.pid || slot.respawn_at > now
 
-        slot.pid = spawn_worker(slot.index)
+        slot.pid = spawn_worker(slot)
         slot.started_at = now
       end
     end
 
-    def spawn_worker(index)
-      app = @app
-      fork { run_worker_process(index, SIGNALS) { worker(app, index: index) } }
+    def spawn_worker(slot)
+      fork do
+        become(slot.group)
+        run_worker_process(slot.index, SIGNALS) { worker(slot.group, index: slot.index) }
+      end
+    end
+
+    # In a freshly forked worker of `group`: it serves that bay alone, so the
+    # other bays' listening sockets are closed, and a fork's worker logs (and
+    # sees in MS_SHIP) the fork's name rather than its parent's.
+    def become(group)
+      bound.each { |server, path| server.close unless path == group.socket_path }
+      return if group.ship == ship
+
+      ENV['MS_SHIP'] = group.ship
+      @logger = @logger.respond_to?(:for_ship) ? @logger.for_ship(group.ship) : @logger
+      Shuttlebay.logger = @logger
     end
 
     def reap
@@ -153,7 +202,7 @@ module Shuttlebay
       slot.respawn_at = monotonic + delay
       return if @stopping
 
-      @logger.warn('worker exited, respawning', index: slot.index, pid: pid,
+      @logger.warn('worker exited, respawning', ship: slot.group.ship, index: slot.index, pid: pid,
                                                 status: status && (status.exitstatus || status.termsig),
                                                 uptime: uptime.round(3), respawn_in: delay)
     end
@@ -190,10 +239,12 @@ module Shuttlebay
     end
 
     def cleanup
-      @listener&.close
-      File.unlink(socket_path) if socket_path && File.socket?(socket_path)
-    rescue SystemCallError => e
-      @logger.warn('socket cleanup failed', socket: socket_path, error: e.message)
+      bound.each do |server, path|
+        server.close
+        File.unlink(path) if File.socket?(path)
+      rescue SystemCallError => e
+        @logger.warn('socket cleanup failed', socket: path, error: e.message)
+      end
     end
   end
 end

data/lib/shuttlebay/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shuttlebay
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

data/lib/shuttlebay/worker.rb

@@ -41,7 +41,7 @@ module Shuttlebay
     def run(trap_signals: true)
       @wake_r, @wake_w = IO.pipe
       previous = trap_signals(SIGNALS, @wake_w) if trap_signals
-      Shuttlebay.run_hooks(:worker_boot, @index) if forked?
+      Shuttlebay.run_hooks(:worker_boot, @index, @ship) if forked?
       pool = spawn_pool
       @logger.info('worker serving', index: @index, threads: @threads, reactors: @reactors)
 
@@ -158,7 +158,7 @@ module Shuttlebay
     end
 
     def run_shutdown_hooks
-      Shuttlebay.run_hooks(:worker_shutdown, @index)
+      Shuttlebay.run_hooks(:worker_shutdown, @index, @ship)
     rescue StandardError => e
       @logger.error('on_worker_shutdown hook failed', **Logger.error_fields(e))
     end

data/lib/shuttlebay.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
 require_relative 'shuttlebay/runtime'
+require_relative 'shuttlebay/cache'
 require_relative 'shuttlebay/railtie' if defined?(Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shuttlebay
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -66,19 +66,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.40'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: guardship
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: padded_cell
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -137,16 +151,19 @@ files:
 - Cargo.toml
 - LICENSE.txt
 - README.md
+- docs/guide.md
 - exe/shuttlebay
 - ext/shuttlebay/Cargo.toml
 - ext/shuttlebay/extconf.rb
 - ext/shuttlebay/src/codec.rs
 - ext/shuttlebay/src/headers.rs
+- ext/shuttlebay/src/interned.rs
 - ext/shuttlebay/src/lib.rs
 - ext/shuttlebay/src/link.rs
 - lib/rackup/handler/shuttlebay.rb
 - lib/shuttlebay.rb
 - lib/shuttlebay/attached.rb
+- lib/shuttlebay/cache.rb
 - lib/shuttlebay/capybara.rb
 - lib/shuttlebay/engine.rb
 - lib/shuttlebay/handler.rb