shuttlebay 0.1.4-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b8d9532060d00b57f7f72413ef6de64db9640d472ca1ef092b1d2d22892916b
+  data.tar.gz: 8172c64b5085e89dce75e35ba51c00efbf515bed106aead640300399fcfe82dc
+SHA512:
+  metadata.gz: b0a08dc827de5a782b85ed5e3ba85766c695eccd78ef9fbb0a7025514664e827515fbb6633b9f786022e02aee01a0737ab0a9dff52ab6f829d035bc4505768b7
+  data.tar.gz: 5186f12cc57b56654cfaebee69baaa833eced3096cdb7e0db8d08791a42e6b33c5960bce0bdf8c161798e993a81bf86dea789c9488968191db8ed487b08412fb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdelkader Boudih
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# Shuttlebay
+
+Run a Rack app as a [Mothership](https://github.com/seuros/mothership) `[[bays.http]]` bay.
+
+Mothership is the HTTP server. Shuttlebay is the Ruby side: it preloads your
+app, forks workers, and runs the app on threads that receive requests over
+Unix-socket docking links. A native engine (Rust, via magnus) decodes the
+docking protocol and builds the Rack env, so Ruby never parses HTTP.
+
+```mermaid
+flowchart TD
+    client([client]) -- HTTP --> mothership["mothership<br/>static, gzip, routing, limits, request ids…"]
+    mothership -- "docking protocol v3<br/>over a Unix socket" --> master["shuttlebay master<br/>config.ru preloaded: Rails, Sinatra, Roda, Padrino, …"]
+    master --> w0["worker 0<br/>threads, one docking link each"]
+    master --> w1["worker 1<br/>threads"]
+```
+
+## Install
+
+```ruby
+# Gemfile
+gem "shuttlebay"
+gem "guardship"    # the mothership binary (or: cargo install mothership)
+```
+
+```toml
+# ship-manifest.toml
+[mothership.bind]
+http = "0.0.0.0:3000"
+
+[[mothership.static_dirs]]   # public/ served by mothership, not Rails
+path = "./public"
+prefix = "/"
+
+[[bays.http]]
+name = "web"
+command = "bundle"
+args = ["exec", "shuttlebay", "config.ru"]
+workers = "auto"   # default: sized from CPUs and memory; 0 = single process
+threads = 5
+routes = [{ bind = "http", pattern = "/.*" }]
+```
+
+```bash
+bundle exec mothership
+```
+
+## What Mothership does instead of Rack middleware
+
+| Concern | Before (app server + middleware) | With Shuttlebay |
+|---|---|---|
+| HTTP parsing, keep-alive, slow clients | App server reactor | Mothership |
+| Static files | `ActionDispatch::Static` / nginx | `[[mothership.static_dirs]]` |
+| `send_file` / `Rack::Sendfile` | X-Sendfile + nginx | `to_path` bodies streamed from disk by Mothership |
+| Compression | `Rack::Deflater` / nginx | `compression = true` |
+| Request id, queue time | `ActionDispatch::RequestId`, LB | `X-Request-Id`, `X-Request-Start: t=<µs>` |
+| Real client IP | `RemoteIp` + proxy config | `REMOTE_ADDR` resolved (Forwarded / PROXY protocol) |
+| Load balancing to workers | kernel accept / `wait_for_less_busy_worker` | idle-thread checkout; queueing in Mothership |
+| Request body buffering | App server | Mothership reads the whole body before claiming a thread |
+
+When Rails is loaded, the bundled Railtie removes `Rack::Sendfile`, since the
+engine offloads `to_path` bodies itself.
+
+## Hooks
+
+`config.ru` loads in the master before forking, so register hooks there:
+
+```ruby
+Shuttlebay.before_fork { ActiveRecord::Base.connection_pool.disconnect! }
+Shuttlebay.on_worker_boot { |index| Rails.logger.info("worker #{index} up") }
+Shuttlebay.on_worker_shutdown { |index| Rails.logger.info("worker #{index} drained") }
+Shuttlebay.out_of_band { GC.start }   # runs when a worker has no request in flight
+run Rails.application
+```
+
+## Fibers
+
+With a fiber scheduler, each worker runs its `threads` docking links as fibers
+on one reactor thread instead of as threads. A request waiting on I/O parks
+its fiber, and the reactor serves the other links meanwhile.
+
+```ruby
+# config.ru (Gemfile: gem "async")
+require "async"
+Shuttlebay.fiber_scheduler { Async::Scheduler.new }
+run Rails.application
+```
+
+The block runs once per worker, after fork, on the reactor thread; any
+`Fiber::Scheduler` works. `threads` in the manifest still counts docking links
+per worker, so Mothership needs no change, but a parked fiber costs no thread,
+so it can go much higher (64, 256).
+
+- Fibers are not preempted: a request burning CPU stalls every other request
+  on its reactor. Size `workers` for CPU and `threads` for I/O wait.
+  `Shuttlebay.fiber_scheduler(reactors: 4) { … }` splits a worker's links
+  across 4 reactor threads, which Ruby does preempt, so one busy request
+  stalls a quarter of the links instead of all of them.
+- Only I/O through Ruby's scheduler yields: Ruby sockets (`Net::HTTP`, Redis
+  clients without hiredis), `pg`, `sleep`. C extensions doing their own
+  blocking I/O (`mysql2`, libcurl gems) stall the reactor.
+- Rails: set `config.active_support.isolation_level = :fiber` and size the
+  Active Record pool to at least `threads`.
+- Hijacked connections (WebSockets) still relay on their own threads.
+- Async's I/O hooks use `IO::Buffer`, so Ruby prints a one-time experimental
+  warning to stderr; `Warning[:experimental] = false` silences it.
+
+## Development server and system tests
+
+```bash
+bin/rails server -u shuttlebay        # or: rackup -s shuttlebay
+```
+
+```ruby
+# test/application_system_test_case.rb
+require "shuttlebay/capybara"
+Capybara.server = :shuttlebay
+```
+
+Both run the app in their own process and start a Mothership that attaches to
+it, so development and tests go through the same HTTP stack as production. The
+binary comes from `MOTHERSHIP_BIN`, the `guardship` gem, or `PATH`. The
+`Threads` option (`rackup -O Threads=5`) or `MS_BAY_THREADS` sets the thread
+count; Mothership sizes its link pool from what the app reports when it docks.
+
+For HTTPS, run Mothership with a `tls` bind and the app as a docking upstream
+(see the Mothership README) instead of the attached server.
+
+## Behaviour
+
+- **Responses:** HEAD, 1xx, 204 and 304 send no body. `to_ary` bodies go out
+  in one write. `each` bodies flush per chunk (SSE, `ActionController::Live`).
+  Rack 3 streaming bodies (`call`) are supported. A `to_path` body with status
+  200 is served by Mothership from disk.
+- **Thread handoff:** after the response's last byte, the thread closes the
+  body and runs `rack.response_finished` callbacks, then sends `Ready`.
+  Mothership routes the next request to that link only after `Ready`, so a
+  request never waits behind Rails' after-response work.
+- **Errors:** an exception before the head goes out becomes a 500. After the
+  head, the link is closed and the response aborts.
+  `rack.response_finished` callbacks run after every response.
+- **WebSockets:** run ActionCable on [orbitcast](https://github.com/seuros/orbitcast),
+  which holds the sockets in Rust and speaks ActionCable's protocol, so no
+  Ruby thread sits on a connection. Every other WebSocket (Faye,
+  `websocket-driver`, custom protocols, or ActionCable's built-in server in
+  development and system tests) goes through `rack.hijack`: the app answers on
+  the hijacked IO, Mothership relays the upgraded connection, and the thread
+  goes back to serving while the relay runs on threads of its own.
+- **Early hints:** not offered (`rack.early_hints` is absent). Mothership's
+  HTTP stack cannot send 1xx responses yet; Rails falls back to `Link`
+  headers on the final response.
+- **Large uploads:** bodies over 1 MiB are spooled to an unlinked temp file
+  (`rack.input` is a `Tempfile`). Memory stays bounded however large uploads
+  are allowed to be.
+- **Signals:** on `TERM`, workers stop accepting, drop idle links, and finish
+  in-flight requests within `MS_BAY_DRAIN_TIMEOUT` (Mothership passes the
+  bay's `request_timeout`). A dead worker is re-forked with backoff.
+- **Deploys:** `kill -USR1` the mothership process to roll the bay to new code
+  with no dropped requests (phased restart).
+- **TLS:** terminated by Mothership on a `tls` bind; the app sees
+  `rack.url_scheme = "https"`.
+- **Logs:** JSON lines on stdout, which Mothership passes through.
+
+## Environment (set by Mothership)
+
+`MS_SOCKET_PATH`, `MS_SHIP`, `MS_BAY_WORKERS`, `MS_BAY_THREADS`, `MS_BAY_DRAIN_TIMEOUT`.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake compile   # builds lib/shuttlebay/shuttlebay.{bundle,so}
+bundle exec rake test
+```
+
+The engine crate (`ext/shuttlebay`) shares the wire format with Mothership
+through `mothership-docking-protocol` and is never published to crates.io.
+Platform gems: `bundle exec rake platforms:build` (rb-sys-dock, Docker).
+
+Releases: release-please tags the version, CI builds the platform and source
+gems and attaches them to the GitHub release. Push them to rubygems.org from a
+workstation:
+
+```bash
+bundle exec rake 'gems:fetch[v0.1.0]'   # download the release's gems into pkg/
+bundle exec rake 'gems:push[v0.1.0]'    # fetch, then gem push each one
+```
+
+## License
+
+MIT

data/exe/shuttlebay

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/shuttlebay/logger'
+
+begin
+  require_relative '../lib/shuttlebay/runtime'
+  Shuttlebay::Server.from_env(ARGV).run
+rescue StandardError, ScriptError => e
+  Shuttlebay::Logger.new.error('shuttlebay stopped', **Shuttlebay::Logger.error_fields(e))
+  exit 1
+end

data/lib/rackup/handler/shuttlebay.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rackup/handler'
+require 'shuttlebay/attached'
+
+module Rackup
+  module Handler
+    module Shuttlebay
+      def self.run(app, **)
+        server = ::Shuttlebay::Attached.new(app, **)
+        yield server if block_given?
+        server.run
+      end
+
+      def self.valid_options
+        {
+          'Host=HOST' => 'Address Mothership listens on (default: 127.0.0.1)',
+          'Port=PORT' => 'Port Mothership listens on (default: 9292)',
+          'Threads=N' => 'Threads running the app (default: MS_BAY_THREADS or 3)'
+        }
+      end
+    end
+
+    register :shuttlebay, Shuttlebay
+  end
+end

data/lib/shuttlebay/attached.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'socket'
+require 'tmpdir'
+require_relative 'runtime'
+
+module Shuttlebay
+  class Attached
+    # sun_path holds 104 bytes on macOS (108 on Linux), terminator included
+    SOCKET_PATH_MAX = 103
+
+    attr_reader :host, :port, :threads
+
+    def initialize(app, trap_signals: true, mothership: Attached.mothership_binary, logger: nil, **options)
+      @app = app
+      @host = options.fetch(:Host, '127.0.0.1').to_s
+      @port = Integer(options.fetch(:Port, 9292))
+      @threads = Attached.threads(options[:Threads])
+      @silent = options.fetch(:Silent, false)
+      @trap_signals = trap_signals
+      @mothership = mothership
+      @logger = logger || (@silent ? Logger.new(File.open(File::NULL, 'w')) : Shuttlebay.logger)
+    end
+
+    def run
+      @dir, socket = Attached.socket_dir
+      listener = UNIXServer.new(socket)
+      manifest = File.join(@dir, 'ship-manifest.toml')
+      File.write(manifest, manifest_toml(socket))
+
+      @worker = Worker.new(app: @app, listener: listener, threads: threads, workers: 0, ship: 'app',
+                           logger: @logger)
+      Shuttlebay.running = true
+      @mothership_pid = spawn_mothership(manifest)
+      watch_mothership
+      at_exit { stop_mothership } unless @trap_signals
+      @logger.info('serving through mothership', url: url, threads: threads)
+      @worker.run(trap_signals: @trap_signals)
+      raise Error, "mothership exited (#{@mothership_exit}); see its output above" if @mothership_exit
+    ensure
+      stop_mothership
+      FileUtils.rm_rf(@dir) if @dir
+    end
+
+    def stop
+      @worker&.stop!
+    end
+
+    def self.mothership_binary(env = ENV)
+      env.fetch('MOTHERSHIP_BIN') do
+        Gem.bin_path('guardship', 'mothership')
+      rescue Gem::Exception
+        'mothership'
+      end
+    end
+
+    # A private directory for the app socket: under $TMPDIR (Dir.tmpdir),
+    # unless that makes the socket path too long for a Unix socket.
+    def self.socket_dir(roots = [Dir.tmpdir, '/tmp'])
+      roots.uniq.each do |root|
+        dir = Dir.mktmpdir('sb', root)
+        socket = File.join(dir, 'app.sock')
+        return [dir, socket] if socket.bytesize <= SOCKET_PATH_MAX
+
+        FileUtils.rm_rf(dir)
+      rescue SystemCallError
+        next
+      end
+      raise Error, "no temp directory gives a Unix socket path under #{SOCKET_PATH_MAX} bytes; " \
+                   'set TMPDIR to a shorter one'
+    end
+
+    def self.threads(option, env = ENV)
+      value = option || env.fetch('MS_BAY_THREADS', '3')
+      count = Integer(value.to_s, 10)
+      raise ArgumentError, "Threads must be at least 1 (got #{value.inspect})" if count < 1
+
+      count
+    end
+
+    private
+
+    def url
+      "http://#{address}"
+    end
+
+    def address
+      "#{host.include?(':') ? "[#{host}]" : host}:#{port}"
+    end
+
+    def manifest_toml(socket)
+      <<~TOML
+        [mothership.bind]
+        http = #{address.dump}
+
+        [[mothership.upstreams]]
+        name = "app"
+        bind = #{"unix://#{socket}".dump}
+        protocol = "docking"
+        routes = [{ bind = "http", pattern = "/.*" }]
+      TOML
+    end
+
+    def spawn_mothership(manifest)
+      output = @silent ? File::NULL : $stdout
+      Process.spawn(@mothership, 'run', '-c', manifest, out: output, err: @silent ? File::NULL : $stderr)
+    rescue SystemCallError => e
+      raise Error, "cannot start mothership (#{@mothership}): #{e.message}. " \
+                   'Install the guardship gem or set MOTHERSHIP_BIN.'
+    end
+
+    def watch_mothership
+      pid = @mothership_pid
+      @watcher = Thread.new do
+        _, status = Process.wait2(pid)
+        next unless @mothership_pid
+
+        @mothership_pid = nil
+        @mothership_exit = status.exitstatus ? "exit #{status.exitstatus}" : "signal #{status.termsig}"
+        @logger.error('mothership exited', status: @mothership_exit)
+        stop
+      rescue Errno::ECHILD
+        nil
+      end
+    end
+
+    def stop_mothership
+      pid = @mothership_pid
+      @mothership_pid = nil
+      return unless pid
+
+      Process.kill('TERM', pid)
+      @watcher&.join(30) || Process.wait(pid)
+    rescue Errno::ESRCH, Errno::ECHILD
+      nil
+    end
+  end
+end

data/lib/shuttlebay/capybara.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'capybara'
+require_relative 'attached'
+
+Capybara.register_server(:shuttlebay) do |app, port, host, **options|
+  Shuttlebay::Attached.new(app, Host: host, Port: port, Silent: true, trap_signals: false, **options).run
+end

data/lib/shuttlebay/engine.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+begin
+  ruby_abi = RUBY_VERSION[/\A\d+\.\d+/]
+  require_relative "#{ruby_abi}/shuttlebay"
+rescue LoadError
+  begin
+    require_relative 'shuttlebay'
+  rescue LoadError => e
+    raise LoadError, "shuttlebay native engine is missing (#{e.message}). " \
+                     'Install a platform shuttlebay gem, or run `bundle exec rake compile` in a checkout.'
+  end
+end
+
+require 'tempfile'
+
+module Shuttlebay
+  module Engine
+    def self.spool_file
+      Tempfile.new('shuttlebay-body', binmode: true).tap(&:unlink)
+    end
+  end
+end

data/lib/shuttlebay/handler.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Shuttlebay
+  class Handler
+    BODYLESS_STATUS = ->(status) { status < 200 || status == 204 || status == 304 }
+
+    LINK_LOST = [IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN, Errno::EBADF].freeze
+
+    INTERNAL_ERROR_BODY = 'Internal Server Error'
+
+    def initialize(app, template:, logger: Shuttlebay.logger)
+      @app = app
+      @template = template
+      @logger = logger
+    end
+
+    def serve(io, codec, stopping: -> { false }, after_request: -> {})
+      until stopping.call
+        env = codec.read_request(io, @template)
+        break unless env
+
+        outcome = handle(io, codec, env)
+        return :detached if outcome == :detached
+        break unless outcome
+
+        run_after_request(after_request)
+        codec.ready(io)
+      end
+    end
+
+    def handle(io, codec, env)
+      env['rack.response_finished'] = finished = []
+      status = headers = body = error = nil
+      tunnel = offer_hijack(env)
+
+      begin
+        status, headers, body = @app.call(env)
+        return detach(io, codec, tunnel.tap { tunnel = nil }) if tunnel && env['rack.hijack_io']
+
+        status = Integer(status)
+      rescue StandardError, ScriptError => e
+        error = e
+        @logger.error('request failed', path: env['PATH_INFO'], **Logger.error_fields(e))
+        return internal_error(io, codec)
+      end
+
+      kept, error = respond(io, codec, env, status, headers, body)
+      kept
+    ensure
+      tunnel&.discard
+      close_body(body)
+      run_finished(finished, env, status, headers, error)
+      close_input(env)
+    end
+
+    private
+
+    def offer_hijack(env)
+      return unless env['HTTP_UPGRADE']
+
+      tunnel = Tunnel.new(logger: @logger)
+      env['rack.hijack?'] = true
+      env['rack.hijack'] = lambda do
+        env['rack.hijack_io'] = tunnel.app_io
+      end
+      tunnel
+    end
+
+    def detach(io, codec, tunnel)
+      Thread.new { tunnel.start(io, codec) }
+      :detached
+    end
+
+    def respond(io, codec, env, status, headers, body)
+      head_sent = false
+      kind, path = reply_kind(env, status, body)
+      chunks = body.to_ary if kind == :stream && body.respond_to?(:to_ary)
+
+      codec.reply(io, status, headers, kind, path)
+      head_sent = true
+      write_body(io, codec, body, chunks) if kind == :stream
+      codec.finish(io)
+      [true, nil]
+    rescue *LINK_LOST => e
+      @logger.debug('link lost mid-response', **Logger.error_fields(e))
+      [false, e]
+    rescue StandardError, ScriptError => e
+      @logger.error('response failed', path: env['PATH_INFO'], head_sent: head_sent, **Logger.error_fields(e))
+      [head_sent ? false : internal_error(io, codec), e]
+    end
+
+    def reply_kind(env, status, body)
+      return [:empty, nil] if env['REQUEST_METHOD'] == 'HEAD' || BODYLESS_STATUS.call(status)
+
+      if status == 200 && body.respond_to?(:to_path)
+        path = File.expand_path(body.to_path)
+        return [:file, path] if File.file?(path) && File.readable?(path)
+      end
+
+      [:stream, nil]
+    end
+
+    def write_body(io, codec, body, chunks)
+      if chunks
+        chunks.each { |chunk| codec.write(io, chunk) }
+      elsif body.respond_to?(:each)
+        body.each do |chunk|
+          codec.write(io, chunk)
+          codec.flush(io)
+        end
+      else
+        body.call(Stream.new(io, codec))
+      end
+    end
+
+    def internal_error(io, codec)
+      codec.reply(io, 500, { 'content-type' => 'text/plain' }, :stream)
+      codec.write(io, INTERNAL_ERROR_BODY)
+      codec.finish(io)
+      true
+    rescue *LINK_LOST, Engine::ProtocolError
+      false
+    end
+
+    def close_input(env)
+      input = env['rack.input']
+      input.close if input.respond_to?(:close)
+    rescue StandardError => e
+      @logger.error('rack.input close failed', **Logger.error_fields(e))
+    end
+
+    def close_body(body)
+      body.close if body.respond_to?(:close)
+    rescue StandardError => e
+      @logger.error('body close failed', **Logger.error_fields(e))
+    end
+
+    def run_after_request(hook)
+      hook.call
+    rescue StandardError => e
+      @logger.error('after-request hook failed', **Logger.error_fields(e))
+    end
+
+    def run_finished(callbacks, env, status, headers, error)
+      callbacks.reverse_each do |callback|
+        callback.call(env, status, headers, error)
+      rescue StandardError => e
+        @logger.error('rack.response_finished callback failed', **Logger.error_fields(e))
+      end
+    end
+  end
+end

data/lib/shuttlebay/logger.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Shuttlebay
+  class Logger
+    LEVELS = %i[debug info warn error].freeze
+
+    def initialize(io = $stdout, ship: ENV.fetch('MS_SHIP', 'rack'))
+      @io = io
+      @io.sync = true
+      @ship = ship
+    end
+
+    LEVELS.each do |level|
+      define_method(level) { |msg, **fields| log(level, msg, **fields) }
+    end
+
+    def log(level, msg, **fields)
+      line = JSON.generate({ level: level, msg: msg, ship: @ship, pid: Process.pid, **fields })
+      @io.write("#{line}\n")
+    end
+
+    def self.error_fields(error)
+      { error: error.class.name, message: error.message, backtrace: error.backtrace.first(10) }
+    end
+  end
+end

data/lib/shuttlebay/process_control.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Shuttlebay
+  module ProcessControl
+    private
+
+    def trap_signals(signals, wake_w)
+      signals.to_h do |signal, code|
+        [signal, trap(signal) { wake_w.write_nonblock(code, exception: false) }]
+      end
+    end
+
+    def close_self_pipe(previous, wake_r, wake_w)
+      previous&.each { |signal, handler| trap(signal, handler || 'DEFAULT') }
+      [wake_r, wake_w].compact.each(&:close)
+    end
+
+    def run_worker_process(index, signals)
+      signals.each_key { |signal| trap(signal, 'DEFAULT') }
+      yield.run
+      $stdout.flush
+      exit!(0)
+    rescue StandardError, ScriptError => e
+      @logger.error('worker crashed', index: index, **Logger.error_fields(e))
+      $stdout.flush
+      exit!(1)
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/shuttlebay/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rack/sendfile'
+
+module Shuttlebay
+  class Railtie < ::Rails::Railtie
+    initializer 'shuttlebay.mothership_serves_files' do |app|
+      app.config.middleware.delete(::Rack::Sendfile) if Shuttlebay.running?
+    end
+  end
+end