shuttlebay 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4038d15bb64a686fa2abc8662520807bbdedc3ac6d3796688ccb57c4acef8aaa
-  data.tar.gz: 1bfb6f3eb2456f5b3b16117a45d5daa97f9c58e08420bf53c888d023b3f28210
+  metadata.gz: 65929907b2e26eb80f96fbb87c41903626e320d301d8cc0e0bd36ddbe29228ae
+  data.tar.gz: c4ce7ea0de33c5acb37315645b895a25654f51699c283533aa07bb75a01ce408
 SHA512:
-  metadata.gz: 472a1f07635596621b47dfd053f6ffacb4d579def811317a90160cff2d9c52c547ee562f6b2071f2e559fe1228e9a18ecccb3fcf8457d2cb3fcdc6707f67bf1b
-  data.tar.gz: ffba9bc614e3b26f51db20e397d44cb640ca32a6ca58bda9e7c33f26eb4d9627991ee99e981cab37f9c047d2162980505f3aa1448695e229fd80a2f3b7ba3d37
+  metadata.gz: 3258cb81038a1687dfccf846fceb21fd517ff4bf89f383fcf5668de0b558da2834d8be5be9c0f61f8b23e4eb01cec508f6637407665f7ebb520b0335be0c36e1
+  data.tar.gz: 9986d6fa8615b58f4e08b7f205e2cdee43e5dbae170f7287cf6ef842dd3cfe991900b78ee724f57d74cfcd528502a66853b8b786864878c721012ebf3185c68f

data/Cargo.lock

@@ -69,9 +69,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.18.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
+checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be"
 
 [[package]]
 name = "glob"
@@ -102,9 +102,9 @@ checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
 
 [[package]]
 name = "libc"
-version = "0.2.190"
+version = "0.2.191"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce5d3ddc6d3fa000eb1536d85e147bfe31aacaba692ed6a876f95cb7c855be78"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
 
 [[package]]
 name = "libloading"
@@ -118,9 +118,9 @@ dependencies = [
 
 [[package]]
 name = "magnus"
-version = "0.9.2"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9068710e00d21be762edca59b9c4c8946dbdb29820d4f76ad559afea07982c9"
+checksum = "40ef424404d166cbb71c8b8d19c9c589c748c4547c1afa1928c5504299f6c713"
 dependencies = [
  "bytes",
  "magnus-macros",
@@ -154,9 +154,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "mothership-docking-protocol"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaec5966e84e1a3c65b5846bd89c0c0621de6c75362f9c669636449fdf5a4b99"
+checksum = "e43cb62ea01813b2fe88036c2e65c724a0020f97139023f4b8aea5e78626461b"
 dependencies = [
  "serde",
  "serde_json",
@@ -289,14 +289,14 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.151"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
 dependencies = [
  "itoa",
  "memchr",
@@ -319,7 +319,7 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "shuttlebay"
-version = "0.1.0"
+version = "0.1.4"
 dependencies = [
  "magnus",
  "mothership-docking-protocol",
@@ -330,9 +330,9 @@ dependencies = [
 
 [[package]]
 name = "state-machines"
-version = "0.30.0"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2bc4296143483a9608a37ba4cf9955b42b8e2154dc58917df4f9cbe8120ebb4"
+checksum = "f9b6f45e43f20a6eba0d7c03779b53775e0d9b40a452b89e55ea7aae87fa7a14"
 dependencies = [
  "state-machines-core",
  "state-machines-macro",
@@ -340,19 +340,19 @@ dependencies = [
 
 [[package]]
 name = "state-machines-core"
-version = "0.11.0"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54b3da777f8a61919bdb3c6e9e445f2995f851b967e5d73b5949290dccfdcddd"
+checksum = "f7a38d0afcf79a49438b4342ea90beec6490664a0725b2932f6e816d83bc46fe"
 
 [[package]]
 name = "state-machines-macro"
-version = "0.30.0"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edf80d0c48518c7fb7fbb1dd4dda13a8dc189c1f15ac435545b351d5f2c276b1"
+checksum = "604a644fc18fffd8845eb7f48e332d79a24750ac9d463a39d9b3cb10c44fcc28"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.9",
 ]
 
 [[package]]
@@ -368,9 +368,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.6"
+version = "3.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -394,14 +394,14 @@ checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.6",
+ "syn 3.0.9",
 ]
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.26"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
 
 [[package]]
 name = "windows-link"

data/README.md

@@ -15,6 +15,10 @@ flowchart TD
     master --> w1["worker 1<br/>threads"]
 ```
 
+**New here?** [docs/guide.md](docs/guide.md) walks a Rails app from install to
+production: the manifest, coming from Puma, moving `Rack::Attack` rules,
+caching, TLS and HTTP/2, Docker and Kamal, several hosts.
+
 ## Install
 
 ```ruby
@@ -57,9 +61,59 @@ bundle exec mothership
 | 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 |
+| `ETag` / `If-None-Match` → 304 | `Rack::ETag`, `Rack::ConditionalGet` | Mothership hashes complete bodies and answers 304 |
+| IP allowlists, rate limits | `Rack::Attack` | `ip_allowlist`, `rate_limits`, `trusted_proxies` in the manifest |
+| Page / API caching | CDN, `Rack::Cache` | `[mothership.response_cache]`, purged by tag |
+
+When Rails is loaded, the bundled Railtie removes the middleware Mothership
+makes redundant:
+
+- `Rack::Sendfile`: the engine offloads `to_path` bodies itself.
+- `ActionDispatch::Static`: when Mothership serves the app's `public/` as a
+  static dir (`MS_STATIC_ROOTS`). `config.public_file_server.headers` it
+  does not send (per `MS_STATIC_HEADERS`) are logged at boot: move them to
+  the static dir's `headers` in the manifest.
+- `Rack::ETag` and `Rack::ConditionalGet`: when Mothership validates
+  conditionals (`MS_CONDITIONAL_GET=1`), so bodies are not hashed twice.
+
+Other Rack apps (Sinatra, Roda, Hanami) ask the same in `config.ru`;
+`Shuttlebay.offloaded?` is false under any other server:
+
+```ruby
+use Rack::ETag unless Shuttlebay.offloaded?(:conditional_get)
+use Rack::ConditionalGet unless Shuttlebay.offloaded?(:conditional_get)
+use Rack::Static, urls: [""], root: "public", cascade: true unless Shuttlebay.offloaded?(:static, "public")
+use Rack::Sendfile unless Shuttlebay.offloaded?(:sendfile)
+run App
+```
+
+Rate limiting and allowlists in `Rack::Attack` are app configuration: drop
+them yourself once the manifest enforces the same rules.
+
+## Caching at the edge
+
+Mothership's response cache keeps entries until their data changes when the
+app tags responses with what they show and purges the tags on change:
+
+```ruby
+class BooksController < ApplicationController
+  def show
+    @book = Book.find(params[:id])
+    Shuttlebay::Cache.tag(response.headers, "book-#{@book.id}", "books")
+    expires_in 1.hour, public: true   # or a manifest rule
+  end
+end
+
+class Book < ApplicationRecord
+  after_commit { Shuttlebay::Cache.purge(tags: ["book-#{id}", "books"]) }
+end
+```
 
-When Rails is loaded, the bundled Railtie removes `Rack::Sendfile`, since the
-engine offloads `to_path` bodies itself.
+`purge` also takes `urls:` (path and query), `prefixes:`, `all: true`, and
+`soft: true` (mark stale and revalidate instead of dropping). It posts to
+`MS_ADMIN_URL`, returns the number purged, is a no-op returning `nil` where
+there is no Mothership, and raises `Shuttlebay::Error` when Mothership refuses
+(e.g. no cache configured) or a network error when it is unreachable.
 
 ## Hooks
 
@@ -67,7 +121,7 @@ engine offloads `to_path` bodies itself.
 
 ```ruby
 Shuttlebay.before_fork { ActiveRecord::Base.connection_pool.disconnect! }
-Shuttlebay.on_worker_boot { |index| Rails.logger.info("worker #{index} up") }
+Shuttlebay.on_worker_boot { |index, ship| Rails.logger.info("#{ship} 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
@@ -152,18 +206,35 @@ For HTTPS, run Mothership with a `tls` bind and the app as a docking upstream
 - **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.
+- **Warmup:** the master calls `Process.warmup` once the app is loaded, so
+  workers fork from a compacted heap. `Shuttlebay.warmup = false` in
+  `config.ru` skips it.
+- **Forks:** a `fork_from` bay in the manifest is served by this master: it
+  loads that bay's app too and forks its workers, sharing the preloaded heap.
+  A fork app that fails to load is logged and skipped. Each worker serves one
+  bay: it holds only that bay's socket, logs and sees (`MS_SHIP`) its name,
+  and hooks get it as their second argument (`|index, ship|`; hooks taking
+  only the index keep working).
 - **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"`.
+- **TLS:** terminated by Mothership on a `tls` bind (guardship 0.2.1 and
+  later ship with TLS); the app sees `rack.url_scheme = "https"`.
+- **HTTP/2:** browsers get it from Mothership's `tls` binds (ALPN), or from
+  the CDN or proxy in front; cleartext binds also take HTTP/2 with prior
+  knowledge. The app is unaffected: every request reaches it the same way,
+  as a Rack env, whatever the client spoke.
 - **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`.
+`MS_SOCKET_PATH`, `MS_SHIP`, `MS_BAY_WORKERS`, `MS_BAY_THREADS`, `MS_BAY_DRAIN_TIMEOUT`,
+`MS_STATIC_ROOTS` (directories Mothership serves at `/`, one per line),
+`MS_STATIC_HEADERS` (the headers their files carry, JSON by path),
+`MS_CONDITIONAL_GET=1` (Mothership answers conditionals),
+`MS_ADMIN_URL` (admin endpoint for cache purges).
 
 ## Development
 

data/docs/guide.md

@@ -0,0 +1,282 @@
+# Running a Rails app on Shuttlebay
+
+From `rails new` (or an app on Puma) to production behind Mothership. Any
+Rack app works the same way; the Rails-specific parts are marked.
+
+Mothership is the HTTP server: it terminates connections, serves `public/`,
+compresses, limits, caches and routes. Shuttlebay runs your app on threads
+that Mothership hands finished requests to. There is no Puma, no Thruster
+and no nginx left in the request path.
+
+## 1. Install
+
+```ruby
+# Gemfile
+gem "shuttlebay"
+gem "guardship"   # the mothership binary, prebuilt for macOS, Linux, FreeBSD 15+
+```
+
+```bash
+bundle install
+bundle exec mothership --help
+```
+
+Keep Puma in the Gemfile if you like: nothing below removes it, and
+`rails server` without `-u` still uses it.
+
+## 2. Development and system tests
+
+```bash
+bin/rails server -u shuttlebay
+```
+
+```ruby
+# test/application_system_test_case.rb
+require "shuttlebay/capybara"
+Capybara.server = :shuttlebay
+```
+
+Both start a Mothership attached to the app, so what you test is the stack
+you deploy.
+
+## 3. The manifest
+
+Mothership reads `ship-manifest.toml` from the directory it starts in:
+
+```toml
+[mothership]
+compression = true
+
+[mothership.bind]
+http = "0.0.0.0:3000"
+
+[[mothership.static_dirs]]
+path = "./public"
+prefix = "/"
+headers = { "cache-control" = "public, max-age=31536000" }
+
+[[bays.http]]
+name = "web"
+command = "bundle"
+args = ["exec", "shuttlebay", "config.ru"]
+env = { RAILS_ENV = "production" }
+workers = "auto"
+threads = 5
+routes = [{ bind = "http", pattern = "/.*" }]
+```
+
+```bash
+bundle exec mothership clearance   # validate the manifest
+bundle exec mothership chart       # what is routed where
+bundle exec mothership             # run
+```
+
+- `workers = "auto"` forks one worker per CPU the process may use, as many as
+  memory affords (512 MiB each); a 1 CPU or 1 GiB container serves from one
+  process. A number, or `"$WEB_CONCURRENCY"`, works too.
+- `threads` is the threads per worker, each with its own docking link to
+  Mothership. A request goes only to an idle thread; when all are busy it
+  waits in Mothership (`queue_timeout`, 30 s, then `503`).
+- The static dir serves `public/` before any request reaches Rails, `/about`
+  from `about.html` and precompressed `.br`/`.gz` files included. The
+  Railtie sees that and drops `ActionDispatch::Static`. Give it the headers
+  your `config.public_file_server.headers` sets: the Railtie logs a warning at
+  boot for any it does not see there.
+
+## 4. Coming from Puma
+
+| `config/puma.rb` | With Shuttlebay |
+|---|---|
+| `workers ENV.fetch("WEB_CONCURRENCY")` | `workers = "$WEB_CONCURRENCY"` (or `"auto"`) |
+| `threads n, n` / `RAILS_MAX_THREADS` | `threads = "$RAILS_MAX_THREADS"` |
+| `port` / `bind` | `[mothership.bind]` |
+| `preload_app!` | always: `config.ru` loads in the master, then workers fork |
+| `before_fork`, `on_worker_boot`, `on_worker_shutdown`, `out_of_band` | `Shuttlebay.before_fork { }` and friends, in `config.ru` |
+| `worker_timeout` | the bay's `request_timeout` (`504`, then the stuck worker is recycled) |
+| `pumactl phased-restart` / `plugin :tmp_restart` | `kill -USR1` the mothership process |
+| `wait_for_less_busy_worker` | built in: requests only go to idle threads |
+
+Hooks go in `config.ru`, before `run`:
+
+```ruby
+# config.ru
+require_relative "config/environment"
+
+Shuttlebay.on_worker_boot { |index| Rails.logger.info("worker #{index} up") }
+Shuttlebay.out_of_band { GC.start }   # when a worker has no request in flight
+
+run Rails.application
+Rails.application.load_server
+```
+
+`config/puma.rb` can stay for `rails server`; Shuttlebay never reads it.
+
+## 5. Let Mothership do the middleware's work
+
+Under Mothership the Railtie removes, on its own, what Mothership already does:
+`Rack::Sendfile`, `ActionDispatch::Static` (when the static dir serves
+`public/`) and `Rack::ETag` / `Rack::ConditionalGet` (Mothership tags pages and
+answers revalidations itself, off the GVL). Nothing changes under Puma.
+
+`Rack::Attack` rules are your configuration, so you move them yourself:
+
+```ruby
+# config/initializers/rack_attack.rb, before
+Rack::Attack.throttle("api", limit: 60, period: 1.minute) do |req|
+  req.ip if req.path.start_with?("/api/")
+end
+```
+
+```toml
+# ship-manifest.toml, after
+[[mothership.rate_limits]]
+pattern = "^/api/"
+limit = 60
+period = "1m"
+```
+
+Mothership keeps the counts in memory, with no cache-store write per request,
+and answers `429` with `Retry-After`. Allowlists move to
+`[[mothership.ip_allowlist]]`; see the Mothership README for both.
+
+## 6. Behind a CDN or a proxy
+
+Behind Cloudflare, Kamal proxy or a load balancer, tell Mothership which
+proxies to see through, so allowlists and rate limits apply to the visitor,
+not to the proxy:
+
+```toml
+[mothership]
+trusted_proxies = ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]   # + your CDN's ranges
+```
+
+The app's `REMOTE_ADDR` is the address that connected to Mothership (or the
+PROXY-protocol one, with `proxy_protocol = true` on the bind), and the
+forwarding headers pass through. Rails resolves `request.remote_ip` from them
+as it always has: keep the configuration you need for that today (for
+Cloudflare, `cloudflare-rails`).
+
+## 7. Caching
+
+Mothership can cache whole responses in memory, the way a CDN does, purged by
+tag when the data changes:
+
+```toml
+[mothership]
+metrics_port = 9090   # also serves the purge endpoint, on 127.0.0.1
+
+[mothership.response_cache]
+status_header = true  # Cache-Status on responses
+
+[[mothership.response_cache.rules]]
+pattern = "^/api/"
+ttl = "5m"
+stale = "1m"
+bypass_cookies = ["_myapp_session"]   # signed-in users skip the cache
+```
+
+```ruby
+class BooksController < ApplicationController
+  def show
+    @book = Book.find(params[:id])
+    Shuttlebay::Cache.tag(response.headers, "book-#{@book.id}")
+  end
+end
+
+class Book < ApplicationRecord
+  after_commit { Shuttlebay::Cache.purge(tags: ["book-#{id}"]) }
+end
+```
+
+A successful `POST`/`PUT`/`PATCH`/`DELETE` through Mothership already
+invalidates its own URL. Requests with `Authorization`, or with a cookie a rule
+does not let through, never touch a rule's cache. The README's caching section
+covers the rest.
+
+## 8. TLS and HTTP/2
+
+Behind a CDN or Kamal proxy, they terminate TLS and speak HTTP/2 to browsers;
+Mothership listens on plain HTTP behind them. To terminate TLS in Mothership
+itself (guardship 0.2.1 and later):
+
+```toml
+[mothership.bind]
+http = "0.0.0.0:80"
+https = { addr = "0.0.0.0:443", tls = { cert = "/etc/letsencrypt/live/app/fullchain.pem", key = "/etc/letsencrypt/live/app/privkey.pem" } }
+```
+
+Browsers then get HTTP/2 (negotiated over ALPN), the app sees
+`rack.url_scheme = "https"`, and renewed certificates are picked up without a
+restart.
+
+## 9. Docker and Kamal
+
+Mothership replaces `./bin/thrust ./bin/rails server` in the Dockerfile Rails
+generates:
+
+```dockerfile
+EXPOSE 80
+CMD ["bundle", "exec", "mothership"]
+```
+
+with the bind on port 80 (`http = "0.0.0.0:80"`), where kamal-proxy expects
+the app. Rails' `bin/docker-entrypoint` prepares the database only when the
+command is `./bin/rails server`, so run that as a prelaunch job instead:
+
+```toml
+[[mothership.prelaunch]]
+name = "db-prepare"
+command = "bin/rails"
+args = ["db:prepare"]
+```
+
+```yaml
+# config/deploy.yml
+proxy:
+  host: app.example.com
+  ssl: true
+  healthcheck:
+    path: /up
+```
+
+Mothership runs fine as PID 1: on Linux it reaps and forwards signals itself
+(`docker run --init` is still the safer default elsewhere). Kamal deploys by
+starting a new container and moving traffic to it once `/up` answers, so
+phased restarts (`kill -USR1`) are for servers you deploy to in place.
+
+On several hosts:
+
+- Run prelaunch jobs (migrations) once: tag one host and elect it.
+
+  ```yaml
+  servers:
+    web:
+      - 10.0.0.5: flagship
+      - 10.0.0.6
+  env:
+    tags:
+      flagship:
+        MS_FLAGSHIP: "true"
+  ```
+
+  ```toml
+  [mothership.flagship]
+  enabled = true
+  election = "static"
+  static_flagship = "$MS_FLAGSHIP"
+  ```
+
+- With a response cache, let the hosts relay purges and invalidations to one
+  another (`[mothership.response_cache.peers]` in the Mothership README).
+
+## 10. Watching it run
+
+- `bundle exec mothership health` prints the fleet's health as JSON (needs
+  `metrics_port`); `/metrics` serves Prometheus metrics, `mothership_http_bay_*`
+  among them.
+- Both Mothership and Shuttlebay log JSON lines to stdout.
+- `503 Starting`: the bay is still booting (`boot_timeout`, 120 s).
+- `503` once running: every thread was busy for `queue_timeout`; add
+  `threads` (I/O-bound apps) or `workers` (CPU-bound ones).
+- `504`: no response head within `request_timeout` (60 s); the stuck worker
+  is recycled.

data/ext/shuttlebay/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shuttlebay"
-version = "0.1.4" # x-release-please-version
+version = "0.2.0" # x-release-please-version
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
@@ -25,7 +25,7 @@ expect_used = "deny"
 
 [dependencies]
 magnus = { version = "0.9", features = ["bytes"] }
-rb-sys = "0.9.124"
-mothership-docking-protocol = "0.2.0"
+rb-sys = "0.9.130"
+mothership-docking-protocol = "0.3.0"
 serde_json = "1.0"
-state-machines = "0.30"
+state-machines = "0.32"