Bump version for 0.15.1

Revert "Configurable SSH log levels"

.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+on: 
+  push:
+    branches:
+      - main
+  pull_request:
+jobs:
+  tests:
+    strategy:
+      matrix:
+        ruby-version:
+          - "2.7"
+          - "3.1"
+          - "3.2"
+        gemfile:
+          - Gemfile
+          - gemfiles/rails_edge.gemfile
+        continue-on-error: [false]
+    name: ${{ format('Tests (Ruby {0})', matrix.ruby-version) }}
+    runs-on: ubuntu-latest
+    continue-on-error: ${{ matrix.continue-on-error }}
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/${{ matrix.gemfile }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Run tests
+        run: bin/test

.github/workflows/docker-publish.yml

@@ -0,0 +1,41 @@
+name: Docker
+
+on:
+  release:
+    types: [created]
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v3
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      -
+        name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            ghcr.io/mrsked/mrsk:latest
+            ghcr.io/mrsked/mrsk:${{ github.ref_name }}

.gitignore

@@ -1,2 +1,5 @@
 .byebug_history
 *.gem
+coverage/*
+.DS_Store
+gemfiles/*.lock

CODE_OF_CONDUCT.md

@@ -0,0 +1,41 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of the MRSK project, we pledge to create a welcoming and inclusive environment for everyone. We value the participation of each member of our community and want all contributors to feel respected and valued.
+
+We are committed to providing a harassment-free experience for everyone, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, age, or religion (or lack thereof). We do not tolerate harassment of participants in any form.
+
+This code of conduct applies to all MRSK project spaces, including but not limited to project code, issue trackers, chat rooms, and mailing lists. Violations of this code of conduct may result in removal from the project community.
+
+## Our standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned with this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Reporting
+
+If you are subject to or witness unacceptable behavior, or have any other concerns, please notify a project maintainer. All reports will be kept confidential and will be reviewed and investigated promptly.
+
+We will investigate every complaint and take appropriate action. We reserve the right to remove any content that violates this Code of Conduct, or to temporarily or permanently ban any contributor for other behaviors that we deem inappropriate, threatening, offensive, or harmful.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 1.4, available at <https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>.

CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Contributing to MRSK development
+
+Thank you for considering contributing to MRSK! This document outlines some guidelines for contributing to this open source project.
+
+Please make sure to review our [Code of Conduct](CODE_OF_CONDUCT.md) before contributing to MRSK.
+
+There are several ways you can contribute to the betterment of the project:
+
+- **Report an issue?** - If the issue isn’t reported, we can’t fix it. Please report any bugs, feature, and/or improvement requests on the [MRSK GitHub Issues tracker](https://github.com/mrsked/mrsk/issues).
+- **Submit patches** - Do you have a new feature or a fix you'd like to share? [Submit a pull request](https://github.com/mrsked/mrsk/pulls)!
+- **Write blog articles** - Are you using MRSK? We'd love to hear how you're using it with your projects. Write a tutorial and post it on your blog!
+
+## Issues
+
+If you encounter any issues with the project, please check the [existing issues](https://github.com/mrsked/mrsk/issues) first to see if the issue has already been reported. If the issue hasn't been reported, please open a new issue with a clear description of the problem and steps to reproduce it.
+
+## Pull Requests
+
+Please keep the following guidelines in mind when opening a pull request:
+
+- Ensure that your code passes the project's minitests by running ./bin/test.
+- Provide a clear and detailed description of your changes.
+- Keep your changes focused on a single concern.
+- Write clean and readable code that follows the project's code style.
+- Use descriptive variable and function names.
+- Write clear and concise commit messages.
+- Add tests for your changes, if possible.
+- Ensure that your changes don't break existing functionality.
+
+#### Commit message guidelines
+
+A good commit message should describe what changed and why.
+
+## Development
+
+The `main` branch is regularly built and tested, but it is not guaranteed to be completely stable. Tags are created regularly from release branches to indicate new official, stable release versions of MRSK.
+
+MRSK is written in Ruby. You should have Ruby 3.2+ installed on your machine in order to work on MRSK. If that's already setup, run `bundle` in the root directory to install all dependencies. Then you can run `bin/test` to run all tests.
+
+1. Fork the project repository.
+2. Create a new branch for your contribution.
+3. Write your code or make the desired changes.
+4. **Ensure that your code passes the project's minitests by running ./bin/test.**
+5. Commit your changes and push them to your forked repository.
+6. [Open a pull request](https://github.com/mrsked/mrsk/pulls) to the main project repository with a detailed description of your changes.
+
+## License
+
+MRSK is released under the MIT License. By contributing to this project, you agree to license your contributions under the same license.

Dockerfile

@@ -0,0 +1,40 @@
+# Use the official Ruby 3.2.0 Alpine image as the base image
+FROM ruby:3.2.0-alpine
+
+# Install  docker/buildx-bin
+COPY --from=docker/buildx-bin /buildx /usr/libexec/docker/cli-plugins/docker-buildx
+
+# Set the working directory to /mrsk
+WORKDIR /mrsk
+
+# Copy the Gemfile, Gemfile.lock into the container
+COPY Gemfile Gemfile.lock mrsk.gemspec ./
+
+# Required in mrsk.gemspec
+COPY lib/mrsk/version.rb /mrsk/lib/mrsk/version.rb
+
+# Install system dependencies
+RUN apk add --no-cache --update build-base git docker openrc openssh-client-default \
+    && rc-update add docker boot \
+    && gem install bundler --version=2.4.3 \
+    && bundle install
+
+# Copy the rest of our application code into the container.
+# We do this after bundle install, to avoid having to run bundle
+# every time we do small fixes in the source code.
+COPY . .
+
+# Install the gem locally from the project folder
+RUN gem build mrsk.gemspec && \
+    gem install ./mrsk-*.gem --no-document
+
+# Set the working directory to /workdir
+WORKDIR /workdir
+
+# Tell git it's safe to access /workdir/.git even if
+# the directory is owned by a different user
+RUN git config --global --add safe.directory /workdir
+
+# Set the entrypoint to run the installed binary in /workdir
+# Example:  docker run -it -v "$PWD:/workdir" mrsk init
+ENTRYPOINT ["mrsk"]

Gemfile

@@ -2,5 +2,3 @@ source 'https://rubygems.org'
 git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 gemspec
-
-gem "debug"

Gemfile.lock

@@ -1,95 +1,106 @@
 PATH
   remote: .
   specs:
-    mrsk (0.0.2)
-      railties (>= 7.0.0)
+    mrsk (0.15.1)
+      activesupport (>= 7.0)
+      bcrypt_pbkdf (~> 1.0)
+      dotenv (~> 2.8)
+      ed25519 (~> 1.2)
+      net-ssh (~> 7.0)
       sshkit (~> 1.21)
+      thor (~> 1.2)
+      zeitwerk (~> 2.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (7.0.4)
-      actionview (= 7.0.4)
-      activesupport (= 7.0.4)
+    actionpack (7.0.4.3)
+      actionview (= 7.0.4.3)
+      activesupport (= 7.0.4.3)
       rack (~> 2.0, >= 2.2.0)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.2.0)
-    actionview (7.0.4)
-      activesupport (= 7.0.4)
+    actionview (7.0.4.3)
+      activesupport (= 7.0.4.3)
       builder (~> 3.1)
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.1, >= 1.2.0)
-    activesupport (7.0.4)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
+    bcrypt_pbkdf (1.1.0)
     builder (3.2.4)
-    concurrent-ruby (1.1.10)
+    concurrent-ruby (1.2.2)
     crass (1.0.6)
-    debug (1.7.1)
+    debug (1.7.2)
       irb (>= 1.5.0)
       reline (>= 0.3.1)
+    dotenv (2.8.1)
+    ed25519 (1.3.0)
     erubi (1.12.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     io-console (0.6.0)
-    irb (1.6.2)
+    irb (1.6.3)
       reline (>= 0.3.0)
-    loofah (2.19.1)
+    loofah (2.20.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     method_source (1.0.0)
-    minitest (5.17.0)
+    minitest (5.18.0)
+    mocha (2.0.2)
+      ruby2_keywords (>= 0.0.5)
     net-scp (4.0.0)
       net-ssh (>= 2.6.5, < 8.0.0)
-    net-ssh (7.0.1)
-    nokogiri (1.14.0.rc1-arm64-darwin)
+    net-ssh (7.1.0)
+    nokogiri (1.14.2-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.14.0.rc1-x86_64-darwin)
+    nokogiri (1.14.2-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.14.0.rc1-x86_64-linux)
+    nokogiri (1.14.2-x86_64-linux)
       racc (~> 1.4)
     racc (1.6.2)
-    rack (2.2.5)
-    rack-test (2.0.2)
+    rack (2.2.6.4)
+    rack-test (2.1.0)
       rack (>= 1.3)
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.4.4)
+    rails-html-sanitizer (1.5.0)
       loofah (~> 2.19, >= 2.19.1)
-    railties (7.0.4)
-      actionpack (= 7.0.4)
-      activesupport (= 7.0.4)
+    railties (7.0.4.3)
+      actionpack (= 7.0.4.3)
+      activesupport (= 7.0.4.3)
       method_source
       rake (>= 12.2)
       thor (~> 1.0)
       zeitwerk (~> 2.5)
     rake (13.0.6)
-    reline (0.3.2)
+    reline (0.3.3)
       io-console (~> 0.5)
-    sshkit (1.21.3)
+    ruby2_keywords (0.0.5)
+    sshkit (1.21.4)
       net-scp (>= 1.1.2)
       net-ssh (>= 2.8.0)
     thor (1.2.1)
-    tzinfo (2.0.5)
+    tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.6.6)
+    zeitwerk (2.6.7)
 
 PLATFORMS
-  arm64-darwin-20
-  arm64-darwin-21
-  arm64-darwin-22
-  x86_64-darwin-20
-  x86_64-darwin-21
+  arm64-darwin
+  x86_64-darwin
   x86_64-linux
 
 DEPENDENCIES
   debug
+  mocha
   mrsk!
+  railties
 
 BUNDLED WITH
    2.4.3

bin/mrsk

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+# Prevent failures from being reported twice.
+Thread.report_on_exception = false
+
+require "mrsk"
+
+begin
+  Mrsk::Cli::Main.start(ARGV)
+rescue SSHKit::Runner::ExecuteError => e
+  puts "  \e[31mERROR (#{e.cause.class}): #{e.message}\e[0m"
+  puts e.cause.backtrace if ENV["VERBOSE"]
+  exit 1
+rescue => e
+  puts "  \e[31mERROR (#{e.class}): #{e.message}\e[0m"
+  puts e.backtrace if ENV["VERBOSE"]
+  exit 1
+end

gemfiles/rails_edge.gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+git "https://github.com/rails/rails.git" do
+  gem "railties"
+  gem "activesupport"
+end
+
+gemspec path: "../"

lib/mrsk.rb

@@ -1,8 +1,10 @@
 module Mrsk
 end
 
-require "mrsk/version"
-require "mrsk/engine"
+require "active_support"
+require "zeitwerk"
 
-require "mrsk/configuration"
-require "mrsk/commands"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/mrsk/sshkit_with_ext.rb")
+loader.setup
+loader.eager_load # We need all commands loaded.

lib/mrsk/cli.rb

@@ -0,0 +1,7 @@
+module Mrsk::Cli
+  class LockError < StandardError; end
+  class HookError < StandardError; end
+end
+
+# SSHKit uses instance eval, so we need a global const for ergonomics
+MRSK = Mrsk::Commander.new

lib/mrsk/cli/accessory.rb

@@ -0,0 +1,239 @@
+class Mrsk::Cli::Accessory < Mrsk::Cli::Base
+  desc "boot [NAME]", "Boot new accessory service on host (use NAME=all to boot all accessories)"
+  def boot(name, login: true)
+    mutating do
+      if name == "all"
+        MRSK.accessory_names.each { |accessory_name| boot(accessory_name) }
+      else
+        with_accessory(name) do |accessory|
+          directories(name)
+          upload(name)
+
+          on(accessory.hosts) do
+            execute *MRSK.registry.login if login
+            execute *MRSK.auditor.record("Booted #{name} accessory"), verbosity: :debug
+            execute *accessory.run
+          end
+        end
+      end
+    end
+  end
+
+  desc "upload [NAME]", "Upload accessory files to host", hide: true
+  def upload(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          accessory.files.each do |(local, remote)|
+            accessory.ensure_local_file_present(local)
+
+            execute *accessory.make_directory_for(remote)
+            upload! local, remote
+            execute :chmod, "755", remote
+          end
+        end
+      end
+    end
+  end
+
+  desc "directories [NAME]", "Create accessory directories on host", hide: true
+  def directories(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          accessory.directories.keys.each do |host_path|
+            execute *accessory.make_directory(host_path)
+          end
+        end
+      end
+    end
+  end
+
+  desc "reboot [NAME]", "Reboot existing accessory on host (stop container, remove container, start new container)"
+  def reboot(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *MRSK.registry.login
+        end
+
+        stop(name)
+        remove_container(name)
+        boot(name, login: false)
+      end
+    end
+  end
+
+  desc "start [NAME]", "Start existing accessory container on host"
+  def start(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *MRSK.auditor.record("Started #{name} accessory"), verbosity: :debug
+          execute *accessory.start
+        end
+      end
+    end
+  end
+
+  desc "stop [NAME]", "Stop existing accessory container on host"
+  def stop(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *MRSK.auditor.record("Stopped #{name} accessory"), verbosity: :debug
+          execute *accessory.stop, raise_on_non_zero_exit: false
+        end
+      end
+    end
+  end
+
+  desc "restart [NAME]", "Restart existing accessory container on host"
+  def restart(name)
+    mutating do
+      with_accessory(name) do
+        stop(name)
+        start(name)
+      end
+    end
+  end
+
+  desc "details [NAME]", "Show details about accessory on host (use NAME=all to show all accessories)"
+  def details(name)
+    if name == "all"
+      MRSK.accessory_names.each { |accessory_name| details(accessory_name) }
+    else
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) { puts capture_with_info(*accessory.info) }
+      end
+    end
+  end
+
+  desc "exec [NAME] [CMD]", "Execute a custom command on servers (use --help to show options)"
+  option :interactive, aliases: "-i", type: :boolean, default: false, desc: "Execute command over ssh for an interactive shell (use for console/bash)"
+  option :reuse, type: :boolean, default: false, desc: "Reuse currently running container instead of starting a new one"
+  def exec(name, cmd)
+    with_accessory(name) do |accessory|
+      case
+      when options[:interactive] && options[:reuse]
+        say "Launching interactive command with via SSH from existing container...", :magenta
+        run_locally { exec accessory.execute_in_existing_container_over_ssh(cmd) }
+
+      when options[:interactive]
+        say "Launching interactive command via SSH from new container...", :magenta
+        run_locally { exec accessory.execute_in_new_container_over_ssh(cmd) }
+
+      when options[:reuse]
+        say "Launching command from existing container...", :magenta
+        on(accessory.hosts) do
+          execute *MRSK.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
+          capture_with_info(*accessory.execute_in_existing_container(cmd))
+        end
+
+      else
+        say "Launching command from new container...", :magenta
+        on(accessory.hosts) do
+          execute *MRSK.auditor.record("Executed cmd '#{cmd}' on #{name} accessory"), verbosity: :debug
+          capture_with_info(*accessory.execute_in_new_container(cmd))
+        end
+      end
+    end
+  end
+
+  desc "logs [NAME]", "Show log lines from accessory on host (use --help to show options)"
+  option :since, aliases: "-s", desc: "Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)"
+  option :lines, type: :numeric, aliases: "-n", desc: "Number of log lines to pull from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
+  def logs(name)
+    with_accessory(name) do |accessory|
+      grep = options[:grep]
+
+      if options[:follow]
+        run_locally do
+          info "Following logs on #{accessory.hosts}..."
+          info accessory.follow_logs(grep: grep)
+          exec accessory.follow_logs(grep: grep)
+        end
+      else
+        since = options[:since]
+        lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+        on(accessory.hosts) do
+          puts capture_with_info(*accessory.logs(since: since, lines: lines, grep: grep))
+        end
+      end
+    end
+  end
+
+  desc "remove [NAME]", "Remove accessory container, image and data directory from host (use NAME=all to remove all accessories)"
+  option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
+  def remove(name)
+    mutating do
+      if name == "all"
+        MRSK.accessory_names.each { |accessory_name| remove(accessory_name) }
+      else
+        if options[:confirmed] || ask("This will remove all containers, images and data directories for #{name}. Are you sure?", limited_to: %w( y N ), default: "N") == "y"
+          with_accessory(name) do
+            stop(name)
+            remove_container(name)
+            remove_image(name)
+            remove_service_directory(name)
+          end
+        end
+      end
+    end
+  end
+
+  desc "remove_container [NAME]", "Remove accessory container from host", hide: true
+  def remove_container(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *MRSK.auditor.record("Remove #{name} accessory container"), verbosity: :debug
+          execute *accessory.remove_container
+        end
+      end
+    end
+  end
+
+  desc "remove_image [NAME]", "Remove accessory image from host", hide: true
+  def remove_image(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *MRSK.auditor.record("Removed #{name} accessory image"), verbosity: :debug
+          execute *accessory.remove_image
+        end
+      end
+    end
+  end
+
+  desc "remove_service_directory [NAME]", "Remove accessory directory used for uploaded files and data directories from host", hide: true
+  def remove_service_directory(name)
+    mutating do
+      with_accessory(name) do |accessory|
+        on(accessory.hosts) do
+          execute *accessory.remove_service_directory
+        end
+      end
+    end
+  end
+
+  private
+    def with_accessory(name)
+      if accessory = MRSK.accessory(name)
+        yield accessory
+      else
+        error_on_missing_accessory(name)
+      end
+    end
+
+    def error_on_missing_accessory(name)
+      options = MRSK.accessory_names.presence
+
+      error \
+        "No accessory by the name of '#{name}'" +
+        (options ? " (options: #{options.to_sentence})" : "")
+    end
+end

lib/mrsk/cli/app.rb

@@ -0,0 +1,290 @@
+class Mrsk::Cli::App < Mrsk::Cli::Base
+  desc "boot", "Boot app on servers (or reboot app if already running)"
+  def boot
+    mutating do
+      hold_lock_on_error do
+        say "Get most recent version available as an image...", :magenta unless options[:version]
+        using_version(version_or_latest) do |version|
+          say "Start container with version #{version} using a #{MRSK.config.readiness_delay}s readiness delay (or reboot if already running)...", :magenta
+
+          on(MRSK.hosts) do
+            execute *MRSK.auditor.record("Tagging #{MRSK.config.absolute_image} as the latest image"), verbosity: :debug
+            execute *MRSK.app.tag_current_as_latest
+          end
+
+          on(MRSK.hosts, **MRSK.boot_strategy) do |host|
+            roles = MRSK.roles_on(host)
+
+            roles.each do |role|
+              app = MRSK.app(role: role)
+              auditor = MRSK.auditor(role: role)
+
+              if capture_with_info(*app.container_id_for_version(version, only_running: true), raise_on_non_zero_exit: false).present?
+                tmp_version = "#{version}_replaced_#{SecureRandom.hex(8)}"
+                info "Renaming container #{version} to #{tmp_version} as already deployed on #{host}"
+                execute *auditor.record("Renaming container #{version} to #{tmp_version}"), verbosity: :debug
+                execute *app.rename_container(version: version, new_version: tmp_version)
+              end
+
+              execute *auditor.record("Booted app version #{version}"), verbosity: :debug
+
+              old_version = capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip
+              execute *app.start_or_run(hostname: "#{host}-#{SecureRandom.hex(6)}")
+
+              Mrsk::Utils::HealthcheckPoller.wait_for_healthy(pause_after_ready: true) { capture_with_info(*app.status(version: version)) }
+
+              execute *app.stop(version: old_version), raise_on_non_zero_exit: false if old_version.present?
+            end
+          end
+        end
+      end
+    end
+  end
+
+  desc "start", "Start existing app container on servers"
+  def start
+    mutating do
+      on(MRSK.hosts) do |host|
+        roles = MRSK.roles_on(host)
+
+        roles.each do |role|
+          execute *MRSK.auditor.record("Started app version #{MRSK.config.version}"), verbosity: :debug
+          execute *MRSK.app(role: role).start, raise_on_non_zero_exit: false
+        end
+      end
+    end
+  end
+
+  desc "stop", "Stop app container on servers"
+  def stop
+    mutating do
+      on(MRSK.hosts) do |host|
+        roles = MRSK.roles_on(host)
+
+        roles.each do |role|
+          execute *MRSK.auditor.record("Stopped app", role: role), verbosity: :debug
+          execute *MRSK.app(role: role).stop, raise_on_non_zero_exit: false
+        end
+      end
+    end
+  end
+
+  # FIXME: Drop in favor of just containers?
+  desc "details", "Show details about app containers"
+  def details
+    on(MRSK.hosts) do |host|
+      roles = MRSK.roles_on(host)
+
+      roles.each do |role|
+        puts_by_host host, capture_with_info(*MRSK.app(role: role).info)
+      end
+    end
+  end
+
+  desc "exec [CMD]", "Execute a custom command on servers (use --help to show options)"
+  option :interactive, aliases: "-i", type: :boolean, default: false, desc: "Execute command over ssh for an interactive shell (use for console/bash)"
+  option :reuse, type: :boolean, default: false, desc: "Reuse currently running container instead of starting a new one"
+  def exec(cmd)
+    case
+    when options[:interactive] && options[:reuse]
+      say "Get current version of running container...", :magenta unless options[:version]
+      using_version(options[:version] || current_running_version) do |version|
+        say "Launching interactive command with version #{version} via SSH from existing container on #{MRSK.primary_host}...", :magenta
+        run_locally { exec MRSK.app(role: "web").execute_in_existing_container_over_ssh(cmd, host: MRSK.primary_host) }
+      end
+
+    when options[:interactive]
+      say "Get most recent version available as an image...", :magenta unless options[:version]
+      using_version(version_or_latest) do |version|
+        say "Launching interactive command with version #{version} via SSH from new container on #{MRSK.primary_host}...", :magenta
+        run_locally { exec MRSK.app.execute_in_new_container_over_ssh(cmd, host: MRSK.primary_host) }
+      end
+
+    when options[:reuse]
+      say "Get current version of running container...", :magenta unless options[:version]
+      using_version(options[:version] || current_running_version) do |version|
+        say "Launching command with version #{version} from existing container...", :magenta
+
+        on(MRSK.hosts) do |host|
+          roles = MRSK.roles_on(host)
+
+          roles.each do |role|
+            execute *MRSK.auditor.record("Executed cmd '#{cmd}' on app version #{version}", role: role), verbosity: :debug
+            puts_by_host host, capture_with_info(*MRSK.app(role: role).execute_in_existing_container(cmd))
+          end
+        end
+      end
+
+    else
+      say "Get most recent version available as an image...", :magenta unless options[:version]
+      using_version(version_or_latest) do |version|
+        say "Launching command with version #{version} from new container...", :magenta
+        on(MRSK.hosts) do |host|
+          execute *MRSK.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
+          puts_by_host host, capture_with_info(*MRSK.app.execute_in_new_container(cmd))
+        end
+      end
+    end
+  end
+
+  desc "containers", "Show app containers on servers"
+  def containers
+    on(MRSK.hosts) { |host| puts_by_host host, capture_with_info(*MRSK.app.list_containers) }
+  end
+
+  desc "stale_containers", "Detect app stale containers"
+  option :stop, aliases: "-s", type: :boolean, default: false, desc: "Stop the stale containers found"
+  def stale_containers
+    mutating do
+      stop = options[:stop]
+
+      cli = self
+
+      on(MRSK.hosts) do |host|
+        roles = MRSK.roles_on(host)
+
+        roles.each do |role|
+          cli.send(:stale_versions, host: host, role: role).each do |version|
+            if stop
+              puts_by_host host, "Stopping stale container for role #{role} with version #{version}"
+              execute *MRSK.app(role: role).stop(version: version), raise_on_non_zero_exit: false
+            else
+              puts_by_host host,  "Detected stale container for role #{role} with version #{version} (use `mrsk app stale_containers --stop` to stop)"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  desc "images", "Show app images on servers"
+  def images
+    on(MRSK.hosts) { |host| puts_by_host host, capture_with_info(*MRSK.app.list_images) }
+  end
+
+  desc "logs", "Show log lines from app on servers (use --help to show options)"
+  option :since, aliases: "-s", desc: "Show lines since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)"
+  option :lines, type: :numeric, aliases: "-n", desc: "Number of lines to show from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :follow, aliases: "-f", desc: "Follow log on primary server (or specific host set by --hosts)"
+  def logs
+    # FIXME: Catch when app containers aren't running
+
+    grep = options[:grep]
+
+    if options[:follow]
+      run_locally do
+        info "Following logs on #{MRSK.primary_host}..."
+
+        MRSK.specific_roles ||= ["web"]
+        role = MRSK.roles_on(MRSK.primary_host).first
+
+        info MRSK.app(role: role).follow_logs(host: MRSK.primary_host, grep: grep)
+        exec MRSK.app(role: role).follow_logs(host: MRSK.primary_host, grep: grep)
+      end
+    else
+      since = options[:since]
+      lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+      on(MRSK.hosts) do |host|
+        roles = MRSK.roles_on(host)
+
+        roles.each do |role|
+          begin
+            puts_by_host host, capture_with_info(*MRSK.app(role: role).logs(since: since, lines: lines, grep: grep))
+          rescue SSHKit::Command::Failed
+            puts_by_host host, "Nothing found"
+          end
+        end
+      end
+    end
+  end
+
+  desc "remove", "Remove app containers and images from servers"
+  def remove
+    mutating do
+      stop
+      remove_containers
+      remove_images
+    end
+  end
+
+  desc "remove_container [VERSION]", "Remove app container with given version from servers", hide: true
+  def remove_container(version)
+    mutating do
+      on(MRSK.hosts) do |host|
+        roles = MRSK.roles_on(host)
+
+        roles.each do |role|
+          execute *MRSK.auditor.record("Removed app container with version #{version}", role: role), verbosity: :debug
+          execute *MRSK.app(role: role).remove_container(version: version)
+        end
+      end
+    end
+  end
+
+  desc "remove_containers", "Remove all app containers from servers", hide: true
+  def remove_containers
+    mutating do
+      on(MRSK.hosts) do |host|
+        roles = MRSK.roles_on(host)
+
+        roles.each do |role|
+          execute *MRSK.auditor.record("Removed all app containers", role: role), verbosity: :debug
+          execute *MRSK.app(role: role).remove_containers
+        end
+      end
+    end
+  end
+
+  desc "remove_images", "Remove all app images from servers", hide: true
+  def remove_images
+    mutating do
+      on(MRSK.hosts) do
+        execute *MRSK.auditor.record("Removed all app images"), verbosity: :debug
+        execute *MRSK.app.remove_images
+      end
+    end
+  end
+
+  desc "version", "Show app version currently running on servers"
+  def version
+    on(MRSK.hosts) { |host| puts_by_host host, capture_with_info(*MRSK.app.current_running_version).strip }
+  end
+
+  private
+    def using_version(new_version)
+      if new_version
+        begin
+          old_version = MRSK.config.version
+          MRSK.config.version = new_version
+          yield new_version
+        ensure
+          MRSK.config.version = old_version
+        end
+      else
+        yield MRSK.config.version
+      end
+    end
+
+    def current_running_version(host: MRSK.primary_host)
+      version = nil
+      on(host) { version = capture_with_info(*MRSK.app.current_running_version).strip }
+      version.presence
+    end
+
+    def stale_versions(host:, role:)
+      versions = nil
+      on(host) do
+        versions = \
+          capture_with_info(*MRSK.app(role: role).list_versions, raise_on_non_zero_exit: false)
+          .split("\n")
+          .drop(1)
+      end
+      versions
+    end
+
+    def version_or_latest
+      options[:version] || "latest"
+    end
+end

lib/mrsk/cli/base.rb

@@ -0,0 +1,171 @@
+require "thor"
+require "dotenv"
+require "mrsk/sshkit_with_ext"
+
+module Mrsk::Cli
+  class Base < Thor
+    include SSHKit::DSL
+
+    def self.exit_on_failure?() true end
+
+    class_option :verbose, type: :boolean, aliases: "-v", desc: "Detailed logging"
+    class_option :quiet, type: :boolean, aliases: "-q", desc: "Minimal logging"
+
+    class_option :version, desc: "Run commands against a specific app version"
+
+    class_option :primary, type: :boolean, aliases: "-p", desc: "Run commands only on primary host instead of all"
+    class_option :hosts, aliases: "-h", desc: "Run commands on these hosts instead of all (separate by comma)"
+    class_option :roles, aliases: "-r", desc: "Run commands on these roles instead of all (separate by comma)"
+
+    class_option :config_file, aliases: "-c", default: "config/deploy.yml", desc: "Path to config file"
+    class_option :destination, aliases: "-d", desc: "Specify destination to be used for config file (staging -> deploy.staging.yml)"
+
+    class_option :skip_hooks, aliases: "-H", type: :boolean, default: false, desc: "Don't run hooks"
+
+    def initialize(*)
+      super
+      load_envs
+      initialize_commander(options_with_subcommand_class_options)
+    end
+
+    private
+      def load_envs
+        if destination = options[:destination]
+          Dotenv.load(".env.#{destination}", ".env")
+        else
+          Dotenv.load(".env")
+        end
+      end
+
+      def options_with_subcommand_class_options
+        options.merge(@_initializer.last[:class_options] || {})
+      end
+
+      def initialize_commander(options)
+        MRSK.tap do |commander|
+          if options[:verbose]
+            ENV["VERBOSE"] = "1" # For backtraces via cli/start
+            commander.verbosity = :debug
+          end
+
+          if options[:quiet]
+            commander.verbosity = :error
+          end
+
+          commander.configure \
+            config_file: Pathname.new(File.expand_path(options[:config_file])),
+            destination: options[:destination],
+            version: options[:version]
+
+          commander.specific_hosts    = options[:hosts]&.split(",")
+          commander.specific_roles    = options[:roles]&.split(",")
+          commander.specific_primary! if options[:primary]
+        end
+      end
+
+      def print_runtime
+        started_at = Time.now
+        yield
+        return Time.now - started_at
+      ensure
+        runtime = Time.now - started_at
+        puts "  Finished all in #{sprintf("%.1f seconds", runtime)}"
+      end
+
+      def mutating
+        return yield if MRSK.holding_lock?
+
+        MRSK.config.ensure_env_available
+
+        run_hook "pre-connect"
+
+        acquire_lock
+
+        begin
+          yield
+        rescue
+          if MRSK.hold_lock_on_error?
+            error "  \e[31mDeploy lock was not released\e[0m"
+          else
+            release_lock
+          end
+
+          raise
+        end
+
+        release_lock
+      end
+
+      def acquire_lock
+        raise_if_locked do
+          say "Acquiring the deploy lock...", :magenta
+          on(MRSK.primary_host) { execute *MRSK.lock.acquire("Automatic deploy lock", MRSK.config.version), verbosity: :debug }
+        end
+
+        MRSK.holding_lock = true
+      end
+
+      def release_lock
+        say "Releasing the deploy lock...", :magenta
+        on(MRSK.primary_host) { execute *MRSK.lock.release, verbosity: :debug }
+
+        MRSK.holding_lock = false
+      end
+
+      def raise_if_locked
+        yield
+      rescue SSHKit::Runner::ExecuteError => e
+        if e.message =~ /cannot create directory/
+          on(MRSK.primary_host) { puts capture_with_debug(*MRSK.lock.status) }
+          raise LockError, "Deploy lock found"
+        else
+          raise e
+        end
+      end
+
+      def hold_lock_on_error
+        if MRSK.hold_lock_on_error?
+          yield
+        else
+          MRSK.hold_lock_on_error = true
+          yield
+          MRSK.hold_lock_on_error = false
+        end
+      end
+
+      def run_hook(hook, **extra_details)
+        if !options[:skip_hooks] && MRSK.hook.hook_exists?(hook)
+          details = { hosts: MRSK.hosts.join(","), command: command, subcommand: subcommand }
+
+          say "Running the #{hook} hook...", :magenta
+          run_locally do
+            MRSK.with_verbosity(:debug) { execute *MRSK.hook.run(hook, **details, **extra_details) }
+          rescue SSHKit::Command::Failed
+            raise HookError.new("Hook `#{hook}` failed")
+          end
+        end
+      end
+
+      def command
+        @mrsk_command ||= begin
+          invocation_class, invocation_commands = *first_invocation
+          if invocation_class == Mrsk::Cli::Main
+            invocation_commands[0]
+          else
+            Mrsk::Cli::Main.subcommand_classes.find { |command, clazz| clazz == invocation_class }[0]
+          end
+        end
+      end
+
+      def subcommand
+        @mrsk_subcommand ||= begin
+          invocation_class, invocation_commands = *first_invocation
+          invocation_commands[0] if invocation_class != Mrsk::Cli::Main
+        end
+      end
+
+      def first_invocation
+        instance_variable_get("@_invocations").first
+      end
+    end
+end

lib/mrsk/cli/build.rb

@@ -0,0 +1,100 @@
+class Mrsk::Cli::Build < Mrsk::Cli::Base
+  class BuildError < StandardError; end
+
+  desc "deliver", "Build app and push app image to registry then pull image on servers"
+  def deliver
+    mutating do
+      push
+      pull
+    end
+  end
+
+  desc "push", "Build and push app image to registry"
+  def push
+    mutating do
+      cli = self
+
+      verify_local_dependencies
+      run_hook "pre-build"
+
+      run_locally do
+        begin
+          MRSK.with_verbosity(:debug) { execute *MRSK.builder.push }
+        rescue SSHKit::Command::Failed => e
+          if e.message =~ /(no builder)|(no such file or directory)/
+            error "Missing compatible builder, so creating a new one first"
+
+            if cli.create
+              MRSK.with_verbosity(:debug) { execute *MRSK.builder.push }
+            end
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  desc "pull", "Pull app image from registry onto servers"
+  def pull
+    mutating do
+      on(MRSK.hosts) do
+        execute *MRSK.auditor.record("Pulled image with version #{MRSK.config.version}"), verbosity: :debug
+        execute *MRSK.builder.clean, raise_on_non_zero_exit: false
+        execute *MRSK.builder.pull
+      end
+    end
+  end
+
+  desc "create", "Create a build setup"
+  def create
+    mutating do
+      run_locally do
+        begin
+          debug "Using builder: #{MRSK.builder.name}"
+          execute *MRSK.builder.create
+        rescue SSHKit::Command::Failed => e
+          if e.message =~ /stderr=(.*)/
+            error "Couldn't create remote builder: #{$1}"
+            false
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+
+  desc "remove", "Remove build setup"
+  def remove
+    mutating do
+      run_locally do
+        debug "Using builder: #{MRSK.builder.name}"
+        execute *MRSK.builder.remove
+      end
+    end
+  end
+
+  desc "details", "Show build setup"
+  def details
+    run_locally do
+      puts "Builder: #{MRSK.builder.name}"
+      puts capture(*MRSK.builder.info)
+    end
+  end
+
+  private
+    def verify_local_dependencies
+      run_locally do
+        begin
+          execute *MRSK.builder.ensure_local_dependencies_installed
+        rescue SSHKit::Command::Failed => e
+          build_error = e.message =~ /command not found/ ?
+            "Docker is not installed locally" :
+            "Docker buildx plugin is not installed locally"
+
+          raise BuildError, build_error
+        end
+      end
+    end
+end

lib/mrsk/cli/healthcheck.rb

@@ -0,0 +1,20 @@
+class Mrsk::Cli::Healthcheck < Mrsk::Cli::Base
+  default_command :perform
+
+  desc "perform", "Health check current app version"
+  def perform
+    on(MRSK.primary_host) do
+      begin
+        execute *MRSK.healthcheck.run
+        Mrsk::Utils::HealthcheckPoller.wait_for_healthy { capture_with_info(*MRSK.healthcheck.status) }
+      rescue Mrsk::Utils::HealthcheckPoller::HealthcheckError => e
+        error capture_with_info(*MRSK.healthcheck.logs)
+        error capture_with_pretty_json(*MRSK.healthcheck.container_health_log)
+        raise
+      ensure
+        execute *MRSK.healthcheck.stop, raise_on_non_zero_exit: false
+        execute *MRSK.healthcheck.remove, raise_on_non_zero_exit: false
+      end
+    end
+  end
+end

lib/mrsk/cli/lock.rb

@@ -0,0 +1,37 @@
+class Mrsk::Cli::Lock < Mrsk::Cli::Base
+  desc "status", "Report lock status"
+  def status
+    handle_missing_lock do
+      on(MRSK.primary_host) { puts capture_with_debug(*MRSK.lock.status) }
+    end
+  end
+
+  desc "acquire", "Acquire the deploy lock"
+  option :message, aliases: "-m", type: :string, desc: "A lock message", required: true
+  def acquire
+    message = options[:message]
+    raise_if_locked do
+      on(MRSK.primary_host) { execute *MRSK.lock.acquire(message, MRSK.config.version), verbosity: :debug }
+      say "Acquired the deploy lock"
+    end
+  end
+
+  desc "release", "Release the deploy lock"
+  def release
+    handle_missing_lock do
+      on(MRSK.primary_host) { execute *MRSK.lock.release, verbosity: :debug }
+      say "Released the deploy lock"
+    end
+  end
+
+  private
+    def handle_missing_lock
+      yield
+    rescue SSHKit::Runner::ExecuteError => e
+      if e.message =~ /No such file or directory/
+        say "There is no deploy lock"
+      else
+        raise
+      end
+    end
+end

lib/mrsk/cli/main.rb

@@ -0,0 +1,249 @@
+class Mrsk::Cli::Main < Mrsk::Cli::Base
+  desc "setup", "Setup all accessories and deploy app to servers"
+  def setup
+    print_runtime do
+      mutating do
+        invoke "mrsk:cli:server:bootstrap"
+        invoke "mrsk:cli:accessory:boot", [ "all" ]
+        deploy
+      end
+    end
+  end
+
+  desc "deploy", "Deploy app to servers"
+  option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip image build and push"
+  def deploy
+    runtime = print_runtime do
+      mutating do
+        invoke_options = deploy_options
+
+        say "Log into image registry...", :magenta
+        invoke "mrsk:cli:registry:login", [], invoke_options
+
+        if options[:skip_push]
+          say "Pull app image...", :magenta
+          invoke "mrsk:cli:build:pull", [], invoke_options
+        else
+          say "Build and push app image...", :magenta
+          invoke "mrsk:cli:build:deliver", [], invoke_options
+        end
+
+        run_hook "pre-deploy"
+
+        say "Ensure Traefik is running...", :magenta
+        invoke "mrsk:cli:traefik:boot", [], invoke_options
+
+        say "Ensure app can pass healthcheck...", :magenta
+        invoke "mrsk:cli:healthcheck:perform", [], invoke_options
+
+        say "Detect stale containers...", :magenta
+        invoke "mrsk:cli:app:stale_containers", [], invoke_options
+
+        invoke "mrsk:cli:app:boot", [], invoke_options
+
+        say "Prune old containers and images...", :magenta
+        invoke "mrsk:cli:prune:all", [], invoke_options
+      end
+    end
+
+    run_hook "post-deploy", runtime: runtime.round
+  end
+
+  desc "redeploy", "Deploy app to servers without bootstrapping servers, starting Traefik, pruning, and registry login"
+  option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip image build and push"
+  def redeploy
+    runtime = print_runtime do
+      mutating do
+        invoke_options = deploy_options
+
+        if options[:skip_push]
+          say "Pull app image...", :magenta
+          invoke "mrsk:cli:build:pull", [], invoke_options
+        else
+          say "Build and push app image...", :magenta
+          invoke "mrsk:cli:build:deliver", [], invoke_options
+        end
+
+        run_hook "pre-deploy"
+
+        say "Ensure app can pass healthcheck...", :magenta
+        invoke "mrsk:cli:healthcheck:perform", [], invoke_options
+
+        say "Detect stale containers...", :magenta
+        invoke "mrsk:cli:app:stale_containers", [], invoke_options
+
+        invoke "mrsk:cli:app:boot", [], invoke_options
+      end
+    end
+
+    run_hook "post-deploy", runtime: runtime.round
+  end
+
+  desc "rollback [VERSION]", "Rollback app to VERSION"
+  def rollback(version)
+    rolled_back = false
+    runtime = print_runtime do
+      mutating do
+        invoke_options = deploy_options
+
+        MRSK.config.version = version
+        old_version = nil
+
+        if container_available?(version)
+          run_hook "pre-deploy"
+
+          invoke "mrsk:cli:app:boot", [], invoke_options.merge(version: version)
+          rolled_back = true
+        else
+          say "The app version '#{version}' is not available as a container (use 'mrsk app containers' for available versions)", :red
+        end
+      end
+    end
+
+    run_hook "post-deploy", runtime: runtime.round if rolled_back
+  end
+
+  desc "details", "Show details about all containers"
+  def details
+    invoke "mrsk:cli:traefik:details"
+    invoke "mrsk:cli:app:details"
+    invoke "mrsk:cli:accessory:details", [ "all" ]
+  end
+
+  desc "audit", "Show audit log from servers"
+  def audit
+    on(MRSK.hosts) do |host|
+      puts_by_host host, capture_with_info(*MRSK.auditor.reveal)
+    end
+  end
+
+  desc "config", "Show combined config (including secrets!)"
+  def config
+    run_locally do
+      puts Mrsk::Utils.redacted(MRSK.config.to_h).to_yaml
+    end
+  end
+
+  desc "init", "Create config stub in config/deploy.yml and env stub in .env"
+  option :bundle, type: :boolean, default: false, desc: "Add MRSK to the Gemfile and create a bin/mrsk binstub"
+  def init
+    require "fileutils"
+
+    if (deploy_file = Pathname.new(File.expand_path("config/deploy.yml"))).exist?
+      puts "Config file already exists in config/deploy.yml (remove first to create a new one)"
+    else
+      FileUtils.mkdir_p deploy_file.dirname
+      FileUtils.cp_r Pathname.new(File.expand_path("templates/deploy.yml", __dir__)), deploy_file
+      puts "Created configuration file in config/deploy.yml"
+    end
+
+    unless (deploy_file = Pathname.new(File.expand_path(".env"))).exist?
+      FileUtils.cp_r Pathname.new(File.expand_path("templates/template.env", __dir__)), deploy_file
+      puts "Created .env file"
+    end
+
+    unless (hooks_dir = Pathname.new(File.expand_path(".mrsk/hooks"))).exist?
+      hooks_dir.mkpath
+      Pathname.new(File.expand_path("templates/sample_hooks", __dir__)).each_child do |sample_hook|
+        FileUtils.cp sample_hook, hooks_dir, preserve: true
+      end
+      puts "Created sample hooks in .mrsk/hooks"
+    end
+
+    if options[:bundle]
+      if (binstub = Pathname.new(File.expand_path("bin/mrsk"))).exist?
+        puts "Binstub already exists in bin/mrsk (remove first to create a new one)"
+      else
+        puts "Adding MRSK to Gemfile and bundle..."
+        run_locally do
+          execute :bundle, :add, :mrsk
+          execute :bundle, :binstubs, :mrsk
+        end
+        puts "Created binstub file in bin/mrsk"
+      end
+    end
+  end
+
+  desc "envify", "Create .env by evaluating .env.erb (or .env.staging.erb -> .env.staging when using -d staging)"
+  def envify
+    if destination = options[:destination]
+      env_template_path = ".env.#{destination}.erb"
+      env_path          = ".env.#{destination}"
+    else
+      env_template_path = ".env.erb"
+      env_path          = ".env"
+    end
+
+    File.write(env_path, ERB.new(File.read(env_template_path)).result, perm: 0600)
+  end
+
+  desc "remove", "Remove Traefik, app, accessories, and registry session from servers"
+  option :confirmed, aliases: "-y", type: :boolean, default: false, desc: "Proceed without confirmation question"
+  def remove
+    mutating do
+      if options[:confirmed] || ask("This will remove all containers and images. Are you sure?", limited_to: %w( y N ), default: "N") == "y"
+        invoke "mrsk:cli:traefik:remove", [], options.without(:confirmed)
+        invoke "mrsk:cli:app:remove", [], options.without(:confirmed)
+        invoke "mrsk:cli:accessory:remove", [ "all" ], options
+        invoke "mrsk:cli:registry:logout", [], options.without(:confirmed)
+      end
+    end
+  end
+
+  desc "version", "Show MRSK version"
+  def version
+    puts Mrsk::VERSION
+  end
+
+  desc "accessory", "Manage accessories (db/redis/search)"
+  subcommand "accessory", Mrsk::Cli::Accessory
+
+  desc "app", "Manage application"
+  subcommand "app", Mrsk::Cli::App
+
+  desc "build", "Build application image"
+  subcommand "build", Mrsk::Cli::Build
+
+  desc "healthcheck", "Healthcheck application"
+  subcommand "healthcheck", Mrsk::Cli::Healthcheck
+
+  desc "lock", "Manage the deploy lock"
+  subcommand "lock", Mrsk::Cli::Lock
+
+  desc "prune", "Prune old application images and containers"
+  subcommand "prune", Mrsk::Cli::Prune
+
+  desc "registry", "Login and -out of the image registry"
+  subcommand "registry", Mrsk::Cli::Registry
+
+  desc "server", "Bootstrap servers with curl and Docker"
+  subcommand "server", Mrsk::Cli::Server
+
+  desc "traefik", "Manage Traefik load balancer"
+  subcommand "traefik", Mrsk::Cli::Traefik
+
+  private
+    def container_available?(version)
+      begin
+        on(MRSK.hosts) do
+          MRSK.roles_on(host).each do |role|
+            container_id = capture_with_info(*MRSK.app(role: role).container_id_for_version(version))
+            raise "Container not found" unless container_id.present?
+          end
+        end
+      rescue SSHKit::Runner::ExecuteError => e
+        if e.message =~ /Container not found/
+          say "Error looking for container version #{version}: #{e.message}"
+          return false
+        else
+          raise
+        end
+      end
+
+      true
+    end
+
+    def deploy_options
+      { "version" => MRSK.config.version }.merge(options.without("skip_push"))
+    end
+end

lib/mrsk/cli/prune.rb

@@ -0,0 +1,30 @@
+class Mrsk::Cli::Prune < Mrsk::Cli::Base
+  desc "all", "Prune unused images and stopped containers"
+  def all
+    mutating do
+      containers
+      images
+    end
+  end
+
+  desc "images", "Prune dangling images"
+  def images
+    mutating do
+      on(MRSK.hosts) do
+        execute *MRSK.auditor.record("Pruned images"), verbosity: :debug
+        execute *MRSK.prune.dangling_images
+        execute *MRSK.prune.tagged_images
+      end
+    end
+  end
+
+  desc "containers", "Prune all stopped containers, except the last 5"
+  def containers
+    mutating do
+      on(MRSK.hosts) do
+        execute *MRSK.auditor.record("Pruned containers"), verbosity: :debug
+        execute *MRSK.prune.containers
+      end
+    end
+  end
+end

lib/mrsk/cli/registry.rb

@@ -0,0 +1,18 @@
+class Mrsk::Cli::Registry < Mrsk::Cli::Base
+  desc "login", "Log in to registry locally and remotely"
+  def login
+    run_locally    { execute *MRSK.registry.login }
+    on(MRSK.hosts) { execute *MRSK.registry.login }
+  # FIXME: This rescue needed?
+  rescue ArgumentError => e
+    puts e.message
+  end
+
+  desc "logout", "Log out of registry remotely"
+  def logout
+    on(MRSK.hosts) { execute *MRSK.registry.logout }
+  # FIXME: This rescue needed?
+  rescue ArgumentError => e
+    puts e.message
+  end
+end

lib/mrsk/cli/server.rb

@@ -0,0 +1,21 @@
+class Mrsk::Cli::Server < Mrsk::Cli::Base
+  desc "bootstrap", "Set up Docker to run MRSK apps"
+  def bootstrap
+    missing = []
+
+    on(MRSK.hosts | MRSK.accessory_hosts) do |host|
+      unless execute(*MRSK.docker.installed?, raise_on_non_zero_exit: false)
+        if execute(*MRSK.docker.superuser?, raise_on_non_zero_exit: false)
+          info "Missing Docker on #{host}. Installing…"
+          execute *MRSK.docker.install
+        else
+          missing << host
+        end
+      end
+    end
+
+    if missing.any?
+      raise "Docker is not installed on #{missing.join(", ")} and can't be automatically installed without having root access and the `curl` command available. Install Docker manually: https://docs.docker.com/engine/install/"
+    end
+  end
+end

lib/mrsk/cli/templates/deploy.yml

@@ -0,0 +1,74 @@
+# Name of your application. Used to uniquely configure containers.
+service: my-app
+
+# Name of the container image.
+image: user/my-app
+
+# Deploy to these servers.
+servers:
+  - 192.168.0.1
+
+# Credentials for your image host.
+registry:
+  # Specify the registry server, if you're not using Docker Hub
+  # server: registry.digitalocean.com / ghcr.io / ...
+  username: my-user
+
+  # Always use an access token rather than real password when possible.
+  password:
+    - MRSK_REGISTRY_PASSWORD
+
+# Inject ENV variables into containers (secrets come from .env).
+# env:
+#   clear:
+#     DB_HOST: 192.168.0.2
+#   secret:
+#     - RAILS_MASTER_KEY
+
+# Use a different ssh user than root
+# ssh:
+#   user: app
+
+# Configure builder setup.
+# builder:
+#   args:
+#     RUBY_VERSION: 3.2.0
+#   secrets:
+#     - GITHUB_TOKEN
+#   remote:
+#     arch: amd64
+#     host: ssh://app@192.168.0.1
+
+# Use accessory services (secrets come from .env).
+# accessories:
+#   db:
+#     image: mysql:8.0
+#     host: 192.168.0.2
+#     port: 3306
+#     env:
+#       clear:
+#         MYSQL_ROOT_HOST: '%'
+#       secret:
+#         - MYSQL_ROOT_PASSWORD
+#     files:
+#       - config/mysql/production.cnf:/etc/mysql/my.cnf
+#       - db/production.sql.erb:/docker-entrypoint-initdb.d/setup.sql
+#     directories:
+#       - data:/var/lib/mysql
+#   redis:
+#     image: redis:7.0
+#     host: 192.168.0.2
+#     port: 6379
+#     directories:
+#       - data:/data
+
+# Configure custom arguments for Traefik
+# traefik:
+#   args:
+#     accesslog: true
+#     accesslog.format: json
+
+# Configure a custom healthcheck (default is /up on port 3000)
+# healthcheck:
+#   path: /healthz
+#   port: 4000

lib/mrsk/cli/templates/sample_hooks/post-deploy.sample

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+# A sample post-deploy hook
+#
+# These environment variables are available:
+# MRSK_RECORDED_AT
+# MRSK_PERFORMER
+# MRSK_VERSION
+# MRSK_HOSTS
+# MRSK_ROLE (if set)
+# MRSK_DESTINATION (if set)
+# MRSK_RUNTIME
+
+echo "$MRSK_PERFORMER deployed $MRSK_VERSION to $MRSK_DESTINATION in $MRSK_RUNTIME seconds"

lib/mrsk/cli/templates/sample_hooks/pre-build.sample

@@ -0,0 +1,51 @@
+#!/bin/sh
+
+# A sample pre-build hook
+#
+# Checks:
+# 1. We have a clean checkout
+# 2. A remote is configured
+# 3. The branch has been pushed to the remote
+# 4. The version we are deploying matches the remote
+#
+# These environment variables are available:
+# MRSK_RECORDED_AT
+# MRSK_PERFORMER
+# MRSK_VERSION
+# MRSK_HOSTS
+# MRSK_ROLE (if set)
+# MRSK_DESTINATION (if set)
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "Git checkout is not clean, aborting..." >&2
+  git status --porcelain >&2
+  exit 1
+fi
+
+first_remote=$(git remote)
+
+if [ -z "$first_remote" ]; then
+  echo "No git remote set, aborting..." >&2
+  exit 1
+fi
+
+current_branch=$(git branch --show-current)
+
+if [ -z "$current_branch" ]; then
+  echo "No git remote set, aborting..." >&2
+  exit 1
+fi
+
+remote_head=$(git ls-remote $first_remote --tags $current_branch | cut -f1)
+
+if [ -z "$remote_head" ]; then
+  echo "Branch not pushed to remote, aborting..." >&2
+  exit 1
+fi
+
+if [ "$MRSK_VERSION" != "$remote_head" ]; then
+  echo "Version ($MRSK_VERSION) does not match remote HEAD ($remote_head), aborting..." >&2
+  exit 1
+fi
+
+exit 0

lib/mrsk/cli/templates/sample_hooks/pre-connect.sample

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+# A sample pre-connect check
+#
+# Warms DNS before connecting to hosts in parallel
+#
+# These environment variables are available:
+# MRSK_RECORDED_AT
+# MRSK_PERFORMER
+# MRSK_VERSION
+# MRSK_HOSTS
+# MRSK_ROLE (if set)
+# MRSK_DESTINATION (if set)
+# MRSK_RUNTIME
+
+hosts = ENV["MRSK_HOSTS"].split(",")
+results = nil
+max = 3
+
+elapsed = Benchmark.realtime do
+  results = hosts.map do |host|
+    Thread.new do
+      tries = 1
+
+      begin
+        Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)
+      rescue SocketError
+        if tries < max
+          puts "Retrying DNS warmup: #{host}"
+          tries += 1
+          sleep rand
+          retry
+        else
+          puts "DNS warmup failed: #{host}"
+          host
+        end
+      end
+
+      tries
+    end
+  end.map(&:value)
+end
+
+retries = results.sum - hosts.size
+nopes = results.count { |r| r == max }
+
+puts "Prewarmed %d DNS lookups in %.2f sec: %d retries, %d failures" % [ hosts.size, elapsed, retries, nopes ]

lib/mrsk/cli/templates/sample_hooks/pre-deploy.sample

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+
+# A sample pre-deploy hook
+#
+# Checks the Github status of the build, waiting for a pending build to complete for up to 720 seconds.
+#
+# Fails unless the combined status is "success"
+#
+# These environment variables are available:
+# MRSK_RECORDED_AT
+# MRSK_PERFORMER
+# MRSK_VERSION
+# MRSK_HOSTS
+# MRSK_COMMAND
+# MRSK_SUBCOMMAND
+# MRSK_ROLE (if set)
+# MRSK_DESTINATION (if set)
+
+# Only check the build status for production deployments
+if ENV["MRSK_COMMAND"] == "rollback" || ENV["MRSK_DESTINATION"] != "production"
+  exit 0
+end
+
+require "bundler/inline"
+
+# true = install gems so this is fast on repeat invocations
+gemfile(true, quiet: true) do
+  source "https://rubygems.org"
+
+  gem "octokit"
+  gem "faraday-retry"
+end
+
+MAX_ATTEMPTS = 72
+ATTEMPTS_GAP = 10
+
+def exit_with_error(message)
+  $stderr.puts message
+  exit 1
+end
+
+class GithubStatusChecks
+  attr_reader :remote_url, :git_sha, :github_client, :combined_status
+
+  def initialize
+    @remote_url = `git config --get remote.origin.url`.strip.delete_prefix("https://github.com/")
+    @git_sha = `git rev-parse HEAD`.strip
+    @github_client = Octokit::Client.new(access_token: ENV["GITHUB_TOKEN"])
+    refresh!
+  end
+
+  def refresh!
+    @combined_status = github_client.combined_status(remote_url, git_sha)
+  end
+
+  def state
+    combined_status[:state]
+  end
+
+  def first_status_url
+    first_status = combined_status[:statuses].find { |status| status[:state] == state }
+    first_status && first_status[:target_url]
+  end
+
+  def complete_count
+    combined_status[:statuses].count { |status| status[:state] != "pending"}
+  end
+
+  def total_count
+    combined_status[:statuses].count
+  end
+
+  def current_status
+    if total_count > 0
+      "Completed #{complete_count}/#{total_count} checks, see #{first_status_url} ..."
+    else
+      "Build not started..."
+    end
+  end
+end
+
+
+$stdout.sync = true
+
+puts "Checking build status..."
+attempts = 0
+checks = GithubStatusChecks.new
+
+begin
+  loop do
+    case checks.state
+    when "success"
+      puts "Checks passed, see #{checks.first_status_url}"
+      exit 0
+    when "failure"
+      exit_with_error "Checks failed, see #{checks.first_status_url}"
+    when "pending"
+      attempts += 1
+    end
+
+    exit_with_error "Checks are still pending, gave up after #{MAX_ATTEMPTS * ATTEMPTS_GAP} seconds" if attempts == MAX_ATTEMPTS
+
+    puts checks.current_status
+    sleep(ATTEMPTS_GAP)
+    checks.refresh!
+  end
+rescue Octokit::NotFound
+  exit_with_error "Build status could not be found"
+end

lib/mrsk/cli/templates/template.env

@@ -0,0 +1,2 @@
+MRSK_REGISTRY_PASSWORD=change-this
+RAILS_MASTER_KEY=another-env

lib/mrsk/cli/traefik.rb

@@ -0,0 +1,111 @@
+class Mrsk::Cli::Traefik < Mrsk::Cli::Base
+  desc "boot", "Boot Traefik on servers"
+  def boot
+    mutating do
+      on(MRSK.traefik_hosts) do
+        execute *MRSK.registry.login
+        execute *MRSK.traefik.run, raise_on_non_zero_exit: false
+      end
+    end
+  end
+
+  desc "reboot", "Reboot Traefik on servers (stop container, remove container, start new container)"
+  option :rolling, type: :boolean, default: false, desc: "Reboot traefik on hosts in sequence, rather than in parallel"
+  def reboot
+    mutating do
+      on(MRSK.traefik_hosts, in: options[:rolling] ? :sequence : :parallel) do
+        execute *MRSK.auditor.record("Rebooted traefik"), verbosity: :debug
+        execute *MRSK.registry.login
+        execute *MRSK.traefik.stop, raise_on_non_zero_exit: false
+        execute *MRSK.traefik.remove_container
+        execute *MRSK.traefik.run, raise_on_non_zero_exit: false
+      end
+    end
+  end
+
+  desc "start", "Start existing Traefik container on servers"
+  def start
+    mutating do
+      on(MRSK.traefik_hosts) do
+        execute *MRSK.auditor.record("Started traefik"), verbosity: :debug
+        execute *MRSK.traefik.start, raise_on_non_zero_exit: false
+      end
+    end
+  end
+
+  desc "stop", "Stop existing Traefik container on servers"
+  def stop
+    mutating do
+      on(MRSK.traefik_hosts) do
+        execute *MRSK.auditor.record("Stopped traefik"), verbosity: :debug
+        execute *MRSK.traefik.stop, raise_on_non_zero_exit: false
+      end
+    end
+  end
+
+  desc "restart", "Restart existing Traefik container on servers"
+  def restart
+    mutating do
+      stop
+      start
+    end
+  end
+
+  desc "details", "Show details about Traefik container from servers"
+  def details
+    on(MRSK.traefik_hosts) { |host| puts_by_host host, capture_with_info(*MRSK.traefik.info), type: "Traefik" }
+  end
+
+  desc "logs", "Show log lines from Traefik on servers"
+  option :since, aliases: "-s", desc: "Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)"
+  option :lines, type: :numeric, aliases: "-n", desc: "Number of log lines to pull from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
+  def logs
+    grep = options[:grep]
+
+    if options[:follow]
+      run_locally do
+        info "Following logs on #{MRSK.primary_host}..."
+        info MRSK.traefik.follow_logs(host: MRSK.primary_host, grep: grep)
+        exec MRSK.traefik.follow_logs(host: MRSK.primary_host, grep: grep)
+      end
+    else
+      since = options[:since]
+      lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
+
+      on(MRSK.traefik_hosts) do |host|
+        puts_by_host host, capture(*MRSK.traefik.logs(since: since, lines: lines, grep: grep)), type: "Traefik"
+      end
+    end
+  end
+
+  desc "remove", "Remove Traefik container and image from servers"
+  def remove
+    mutating do
+      stop
+      remove_container
+      remove_image
+    end
+  end
+
+  desc "remove_container", "Remove Traefik container from servers", hide: true
+  def remove_container
+    mutating do
+      on(MRSK.traefik_hosts) do
+        execute *MRSK.auditor.record("Removed traefik container"), verbosity: :debug
+        execute *MRSK.traefik.remove_container
+      end
+    end
+  end
+
+  desc "remove_image", "Remove Traefik image from servers", hide: true
+  def remove_image
+    mutating do
+      on(MRSK.traefik_hosts) do
+        execute *MRSK.auditor.record("Removed traefik image"), verbosity: :debug
+        execute *MRSK.traefik.remove_image
+      end
+    end
+  end
+end

lib/mrsk/commander.rb

@@ -0,0 +1,150 @@
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
+
+class Mrsk::Commander
+  attr_accessor :verbosity, :holding_lock, :hold_lock_on_error
+
+  def initialize
+    self.verbosity = :info
+    self.holding_lock = false
+    self.hold_lock_on_error = false
+  end
+
+  def config
+    @config ||= Mrsk::Configuration.create_from(**@config_kwargs).tap do |config|
+      @config_kwargs = nil
+      configure_sshkit_with(config)
+    end
+  end
+
+  def configure(**kwargs)
+    @config, @config_kwargs = nil, kwargs
+  end
+
+  attr_reader :specific_roles, :specific_hosts
+
+  def specific_primary!
+    self.specific_hosts = [ config.primary_web_host ]
+  end
+
+  def specific_roles=(role_names)
+    @specific_roles = config.roles.select { |r| role_names.include?(r.name) } if role_names.present?
+  end
+
+  def specific_hosts=(hosts)
+    @specific_hosts = config.all_hosts & hosts if hosts.present?
+  end
+
+  def primary_host
+    specific_hosts&.first || specific_roles&.first&.primary_host || config.primary_web_host
+  end
+
+  def roles
+    (specific_roles || config.roles).select do |role|
+      ((specific_hosts || config.all_hosts) & role.hosts).any?
+    end
+  end
+
+  def hosts
+    (specific_hosts || config.all_hosts).select do |host|
+      (specific_roles || config.roles).flat_map(&:hosts).include?(host)
+    end
+  end
+
+  def boot_strategy
+    if config.boot.limit.present?
+      { in: :groups, limit: config.boot.limit, wait: config.boot.wait }
+    else
+      {}
+    end
+  end
+
+  def roles_on(host)
+    roles.select { |role| role.hosts.include?(host.to_s) }.map(&:name)
+  end
+
+  def traefik_hosts
+    specific_hosts || config.traefik_hosts
+  end
+
+  def accessory_hosts
+    specific_hosts || config.accessories.flat_map(&:hosts)
+  end
+
+  def accessory_names
+    config.accessories&.collect(&:name) || []
+  end
+
+
+  def app(role: nil)
+    Mrsk::Commands::App.new(config, role: role)
+  end
+
+  def accessory(name)
+    Mrsk::Commands::Accessory.new(config, name: name)
+  end
+
+  def auditor(**details)
+    Mrsk::Commands::Auditor.new(config, **details)
+  end
+
+  def builder
+    @builder ||= Mrsk::Commands::Builder.new(config)
+  end
+
+  def docker
+    @docker ||= Mrsk::Commands::Docker.new(config)
+  end
+
+  def healthcheck
+    @healthcheck ||= Mrsk::Commands::Healthcheck.new(config)
+  end
+
+  def hook
+    @hook ||= Mrsk::Commands::Hook.new(config)
+  end
+
+  def lock
+    @lock ||= Mrsk::Commands::Lock.new(config)
+  end
+
+  def prune
+    @prune ||= Mrsk::Commands::Prune.new(config)
+  end
+
+  def registry
+    @registry ||= Mrsk::Commands::Registry.new(config)
+  end
+
+  def traefik
+    @traefik ||= Mrsk::Commands::Traefik.new(config)
+  end
+
+  def with_verbosity(level)
+    old_level = self.verbosity
+
+    self.verbosity = level
+    SSHKit.config.output_verbosity = level
+
+    yield
+  ensure
+    self.verbosity = old_level
+    SSHKit.config.output_verbosity = old_level
+  end
+
+  def holding_lock?
+    self.holding_lock
+  end
+
+  def hold_lock_on_error?
+    self.hold_lock_on_error
+  end
+
+  private
+    # Lazy setup of SSHKit
+    def configure_sshkit_with(config)
+      SSHKit::Backend::Netssh.configure { |ssh| ssh.ssh_options = config.ssh_options }
+      SSHKit.config.command_map[:docker] = "docker" # No need to use /usr/bin/env, just clogs up the logs
+      SSHKit.config.output_verbosity = verbosity
+    end
+end

lib/mrsk/commands.rb

@@ -1,25 +1,2 @@
-require "sshkit"
-
 module Mrsk::Commands
-  class Base
-    attr_accessor :config
-
-    def initialize(config)
-      @config = config
-    end
-
-    private
-      def docker(*args)
-        args.compact.unshift :docker
-      end
-
-      # Copied from SSHKit::Backend::Abstract#redact to be available inside Commands classes
-      def redact(arg) # Used in execute_command to hide redact() args a user passes in
-        arg.to_s.extend(SSHKit::Redaction) # to_s due to our inability to extend Integer, etc
-      end      
-  end
 end
-
-require "mrsk/commands/app"
-require "mrsk/commands/traefik"
-require "mrsk/commands/registry"

lib/mrsk/commands/accessory.rb

@@ -0,0 +1,113 @@
+class Mrsk::Commands::Accessory < Mrsk::Commands::Base
+  attr_reader :accessory_config
+  delegate :service_name, :image, :hosts, :port, :files, :directories, :cmd,
+           :publish_args, :env_args, :volume_args, :label_args, :option_args, to: :accessory_config
+
+  def initialize(config, name:)
+    super(config)
+    @accessory_config = config.accessory(name)
+  end
+
+  def run
+    docker :run,
+      "--name", service_name,
+      "--detach",
+      "--restart", "unless-stopped",
+      *config.logging_args,
+      *publish_args,
+      *env_args,
+      *volume_args,
+      *label_args,
+      *option_args,
+      image,
+      cmd
+  end
+
+  def start
+    docker :container, :start, service_name
+  end
+
+  def stop
+    docker :container, :stop, service_name
+  end
+
+  def info
+    docker :ps, *service_filter
+  end
+
+
+  def logs(since: nil, lines: nil, grep: nil)
+    pipe \
+      docker(:logs, service_name, (" --since #{since}" if since), (" --tail #{lines}" if lines), "--timestamps", "2>&1"),
+      ("grep '#{grep}'" if grep)
+  end
+
+  def follow_logs(grep: nil)
+    run_over_ssh \
+      pipe \
+        docker(:logs, service_name, "--timestamps", "--tail", "10", "--follow", "2>&1"),
+        (%(grep "#{grep}") if grep)
+  end
+
+
+  def execute_in_existing_container(*command, interactive: false)
+    docker :exec,
+      ("-it" if interactive),
+      service_name,
+      *command
+  end
+
+  def execute_in_new_container(*command, interactive: false)
+    docker :run,
+      ("-it" if interactive),
+      "--rm",
+      *env_args,
+      *volume_args,
+      image,
+      *command
+  end
+
+  def execute_in_existing_container_over_ssh(*command)
+    run_over_ssh execute_in_existing_container(*command, interactive: true)
+  end
+
+  def execute_in_new_container_over_ssh(*command)
+    run_over_ssh execute_in_new_container(*command, interactive: true)
+  end
+
+  def run_over_ssh(command)
+    super command, host: hosts.first
+  end
+
+
+  def ensure_local_file_present(local_file)
+    if !local_file.is_a?(StringIO) && !Pathname.new(local_file).exist?
+      raise "Missing file: #{local_file}"
+    end
+  end
+
+  def make_directory_for(remote_file)
+    make_directory Pathname.new(remote_file).dirname.to_s
+  end
+
+  def make_directory(path)
+    [ :mkdir, "-p", path ]
+  end
+
+  def remove_service_directory
+    [ :rm, "-rf", service_name ]
+  end
+
+  def remove_container
+    docker :container, :prune, "--force", *service_filter
+  end
+
+  def remove_image
+    docker :image, :rm, "--force", image
+  end
+
+  private
+    def service_filter
+      [ "--filter", "label=service=#{service_name}" ]
+    end
+end

lib/mrsk/commands/app.rb

@@ -1,66 +1,169 @@
 class Mrsk::Commands::App < Mrsk::Commands::Base
-  def push
-    # TODO: Run 'docker buildx create --use' when needed
-    # TODO: Make multiarch an option so Linux users can enjoy speedier builds
-    docker :buildx, :build, "--push", "--platform linux/amd64,linux/arm64", "-t", config.absolute_image, "."
+  ACTIVE_DOCKER_STATUSES = [ :running, :restarting ]
+
+  attr_reader :role
+
+  def initialize(config, role: nil)
+    super(config)
+    @role = role
   end
 
-  def pull
-    docker :pull, config.absolute_image
+  def start_or_run(hostname: nil)
+    combine start, run(hostname: hostname), by: "||"
   end
 
-  def run(role: :web)
-    role = config.role(role)
+  def run(hostname: nil)
+    role = config.role(self.role)
 
     docker :run,
-      "-d",
+      "--detach",
       "--restart unless-stopped",
-      "--name", config.service_with_version,
-      "-e", redact("RAILS_MASTER_KEY=#{config.master_key}"),
-      *config.env_args,
+      "--name", container_name,
+      *(["--hostname", hostname] if hostname),
+      "-e", "MRSK_CONTAINER_NAME=\"#{container_name}\"",
+      *role.env_args,
+      *role.health_check_args,
+      *config.logging_args,
+      *config.volume_args,
       *role.label_args,
+      *role.option_args,
       config.absolute_image,
       role.cmd
   end
 
   def start
-    docker :start, config.service_with_version
+    docker :start, container_name
   end
 
-  def stop
-    [ "docker ps -q #{service_filter.join(" ")} | xargs docker stop" ]
+  def status(version:)
+    pipe container_id_for_version(version), xargs(docker(:inspect, "--format", DOCKER_HEALTH_STATUS_FORMAT))
+  end
+
+  def stop(version: nil)
+    pipe \
+      version ? container_id_for_version(version) : current_running_container_id,
+      xargs(config.stop_wait_time ? docker(:stop, "-t", config.stop_wait_time) : docker(:stop))
   end
 
   def info
-    docker :ps, *service_filter
+    docker :ps, *filter_args
   end
 
-  def logs
-    [ "docker ps -q #{service_filter.join(" ")} | xargs docker logs -f" ]
+
+  def logs(since: nil, lines: nil, grep: nil)
+    pipe \
+      current_running_container_id,
+      "xargs docker logs#{" --since #{since}" if since}#{" --tail #{lines}" if lines} 2>&1",
+      ("grep '#{grep}'" if grep)
   end
 
-  def exec(*command)
-    docker :exec, 
-      "-e", redact("RAILS_MASTER_KEY=#{config.master_key}"),
-      *config.env_args,
-      config.service_with_version,
+  def follow_logs(host:, grep: nil)
+    run_over_ssh \
+      pipe(
+        current_running_container_id,
+        "xargs docker logs --timestamps --tail 10 --follow 2>&1",
+        (%(grep "#{grep}") if grep)
+      ),
+      host: host
+  end
+
+
+  def execute_in_existing_container(*command, interactive: false)
+    docker :exec,
+      ("-it" if interactive),
+      container_name,
       *command
   end
 
+  def execute_in_new_container(*command, interactive: false)
+    docker :run,
+      ("-it" if interactive),
+      "--rm",
+      *config.env_args,
+      *config.volume_args,
+      config.absolute_image,
+      *command
+  end
+
+  def execute_in_existing_container_over_ssh(*command, host:)
+    run_over_ssh execute_in_existing_container(*command, interactive: true), host: host
+  end
+
+  def execute_in_new_container_over_ssh(*command, host:)
+    run_over_ssh execute_in_new_container(*command, interactive: true), host: host
+  end
+
+
+  def current_running_container_id
+    docker :ps, "--quiet", *filter_args(statuses: ACTIVE_DOCKER_STATUSES), "--latest"
+  end
+
+  def container_id_for_version(version, only_running: false)
+    container_id_for(container_name: container_name(version), only_running: only_running)
+  end
+
+  def current_running_version
+    list_versions("--latest", statuses: ACTIVE_DOCKER_STATUSES)
+  end
+
+  def list_versions(*docker_args, statuses: nil)
+    pipe \
+      docker(:ps, *filter_args(statuses: statuses), *docker_args, "--format", '"{{.Names}}"'),
+      %(grep -oE "\\-[^-]+$"), # Extract SHA from "service-role-dest-SHA"
+      %(cut -c 2-)
+  end
+
   def list_containers
-    docker :container, :ls, "-a", *service_filter
+    docker :container, :ls, "--all", *filter_args
+  end
+
+  def list_container_names
+    [ *list_containers, "--format", "'{{ .Names }}'" ]
+  end
+
+  def remove_container(version:)
+    pipe \
+      container_id_for(container_name: container_name(version)),
+      xargs(docker(:container, :rm))
+  end
+
+  def rename_container(version:, new_version:)
+    docker :rename, container_name(version), container_name(new_version)
   end
 
   def remove_containers
-    docker :container, :prune, "-f", *service_filter
+    docker :container, :prune, "--force", *filter_args
+  end
+
+  def list_images
+    docker :image, :ls, config.repository
   end
 
   def remove_images
-    docker :image, :prune, "-a", "-f", *service_filter
+    docker :image, :prune, "--all", "--force", *filter_args
   end
 
+  def tag_current_as_latest
+    docker :tag, config.absolute_image, config.latest_image
+  end
+
+
   private
-    def service_filter
-      [ "--filter", "label=service=#{config.service}" ]
+    def container_name(version = nil)
+      [ config.service, role, config.destination, version || config.version ].compact.join("-")
+    end
+
+    def filter_args(statuses: nil)
+      argumentize "--filter", filters(statuses: statuses)
+    end
+
+    def filters(statuses: nil)
+      [ "label=service=#{config.service}" ].tap do |filters|
+        filters << "label=destination=#{config.destination}" if config.destination
+        filters << "label=role=#{role}" if role
+        statuses&.each do |status|
+          filters << "status=#{status}"
+        end
+      end
     end
 end

lib/mrsk/commands/auditor.rb

@@ -0,0 +1,28 @@
+class Mrsk::Commands::Auditor < Mrsk::Commands::Base
+  attr_reader :details
+
+  def initialize(config, **details)
+    super(config)
+    @details = details
+  end
+
+  # Runs remotely
+  def record(line, **details)
+    append \
+      [ :echo, audit_tags(**details).except(:version, :service_version).to_s, line ],
+      audit_log_file
+  end
+
+  def reveal
+    [ :tail, "-n", 50, audit_log_file ]
+  end
+
+  private
+    def audit_log_file
+      [ "mrsk", config.service, config.destination, "audit.log" ].compact.join("-")
+    end
+
+    def audit_tags(**details)
+      tags(**self.details, **details)
+    end
+end

lib/mrsk/commands/base.rb

@@ -0,0 +1,65 @@
+module Mrsk::Commands
+  class Base
+    delegate :sensitive, :argumentize, to: Mrsk::Utils
+
+    DOCKER_HEALTH_STATUS_FORMAT = "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'"
+    DOCKER_HEALTH_LOG_FORMAT    = "'{{json .State.Health}}'"
+
+    attr_accessor :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run_over_ssh(*command, host:)
+      "ssh".tap do |cmd|
+        if config.ssh_proxy && config.ssh_proxy.is_a?(Net::SSH::Proxy::Jump)
+          cmd << " -J #{config.ssh_proxy.jump_proxies}"
+        elsif config.ssh_proxy && config.ssh_proxy.is_a?(Net::SSH::Proxy::Command)
+          cmd << " -o ProxyCommand='#{config.ssh_proxy.command_line_template}'"
+        end
+        cmd << " -t #{config.ssh_user}@#{host} '#{command.join(" ")}'"
+      end
+    end
+
+    def container_id_for(container_name:, only_running: false)
+      docker :container, :ls, *("--all" unless only_running), "--filter", "name=^#{container_name}$", "--quiet"
+    end
+
+    private
+      def combine(*commands, by: "&&")
+        commands
+          .compact
+          .collect { |command| Array(command) + [ by ] }.flatten # Join commands
+          .tap     { |commands| commands.pop } # Remove trailing combiner
+      end
+
+      def chain(*commands)
+        combine *commands, by: ";"
+      end
+
+      def pipe(*commands)
+        combine *commands, by: "|"
+      end
+
+      def append(*commands)
+        combine *commands, by: ">>"
+      end
+
+      def write(*commands)
+        combine *commands, by: ">"
+      end
+
+      def xargs(command)
+        [ :xargs, command ].flatten
+      end
+
+      def docker(*args)
+        args.compact.unshift :docker
+      end
+
+      def tags(**details)
+        Mrsk::Tags.from_config(config, **details)
+      end
+  end
+end

lib/mrsk/commands/builder.rb

@@ -0,0 +1,62 @@
+class Mrsk::Commands::Builder < Mrsk::Commands::Base
+  delegate :create, :remove, :push, :clean, :pull, :info, to: :target
+
+  def name
+    target.class.to_s.remove("Mrsk::Commands::Builder::").underscore.inquiry
+  end
+
+  def target
+    case
+    when !config.builder.multiarch? && !config.builder.cached?
+      native
+    when !config.builder.multiarch? && config.builder.cached?
+      native_cached
+    when config.builder.local? && config.builder.remote?
+      multiarch_remote
+    when config.builder.remote?
+      native_remote
+    else
+      multiarch
+    end
+  end
+
+  def native
+    @native ||= Mrsk::Commands::Builder::Native.new(config)
+  end
+
+  def native_cached
+    @native ||= Mrsk::Commands::Builder::Native::Cached.new(config)
+  end
+
+  def native_remote
+    @native ||= Mrsk::Commands::Builder::Native::Remote.new(config)
+  end
+
+  def multiarch
+    @multiarch ||= Mrsk::Commands::Builder::Multiarch.new(config)
+  end
+
+  def multiarch_remote
+    @multiarch_remote ||= Mrsk::Commands::Builder::Multiarch::Remote.new(config)
+  end
+
+
+  def ensure_local_dependencies_installed
+    if name.native?
+      ensure_local_docker_installed
+    else
+      combine \
+        ensure_local_docker_installed,
+        ensure_local_buildx_installed
+    end
+  end
+
+  private
+    def ensure_local_docker_installed
+      docker "--version"
+    end
+
+    def ensure_local_buildx_installed
+      docker :buildx, "version"
+    end
+end

lib/mrsk/commands/builder/base.rb

@@ -0,0 +1,60 @@
+
+class Mrsk::Commands::Builder::Base < Mrsk::Commands::Base
+  class BuilderError < StandardError; end
+
+  delegate :argumentize, to: Mrsk::Utils
+  delegate :args, :secrets, :dockerfile, :local_arch, :local_host, :remote_arch, :remote_host, :cache_from, :cache_to, to: :builder_config
+
+  def clean
+    docker :image, :rm, "--force", config.absolute_image
+  end
+
+  def pull
+    docker :pull, config.absolute_image
+  end
+
+  def build_options
+    [ *build_tags, *build_cache, *build_labels, *build_args, *build_secrets, *build_dockerfile ]
+  end
+
+  def build_context
+    config.builder.context
+  end
+
+
+  private
+    def build_tags
+      [ "-t", config.absolute_image, "-t", config.latest_image ]
+    end
+
+    def build_cache
+      if cache_to && cache_from
+        ["--cache-to", cache_to,
+          "--cache-from", cache_from]
+      end
+    end
+
+    def build_labels
+      argumentize "--label", { service: config.service }
+    end
+
+    def build_args
+      argumentize "--build-arg", args, sensitive: true
+    end
+
+    def build_secrets
+      argumentize "--secret", secrets.collect { |secret| [ "id", secret ] }
+    end
+
+    def build_dockerfile
+      if Pathname.new(File.expand_path(dockerfile)).exist?
+        argumentize "--file", dockerfile
+      else
+        raise BuilderError, "Missing #{dockerfile}"
+      end
+    end
+
+    def builder_config
+      config.builder
+    end
+end

lib/mrsk/commands/builder/multiarch.rb

@@ -0,0 +1,29 @@
+class Mrsk::Commands::Builder::Multiarch < Mrsk::Commands::Builder::Base
+  def create
+    docker :buildx, :create, "--use", "--name", builder_name
+  end
+
+  def remove
+    docker :buildx, :rm, builder_name
+  end
+
+  def push
+    docker :buildx, :build,
+      "--push",
+      "--platform", "linux/amd64,linux/arm64",
+      "--builder", builder_name,
+      *build_options,
+      build_context
+  end
+
+  def info
+    combine \
+      docker(:context, :ls),
+      docker(:buildx, :ls)
+  end
+
+  private
+    def builder_name
+      "mrsk-#{config.service}-multiarch"
+    end
+end

lib/mrsk/commands/builder/multiarch/remote.rb

@@ -0,0 +1,51 @@
+class Mrsk::Commands::Builder::Multiarch::Remote < Mrsk::Commands::Builder::Multiarch
+  def create
+    combine \
+      create_contexts,
+      create_local_buildx,
+      append_remote_buildx
+  end
+
+  def remove
+    combine \
+      remove_contexts,
+      super
+  end
+
+  private
+    def builder_name
+      super + "-remote"
+    end
+
+    def builder_name_with_arch(arch)
+      "#{builder_name}-#{arch}"
+    end
+
+    def create_local_buildx
+      docker :buildx, :create, "--name", builder_name, builder_name_with_arch(local_arch), "--platform", "linux/#{local_arch}"
+    end
+
+    def append_remote_buildx
+      docker :buildx, :create, "--append", "--name", builder_name, builder_name_with_arch(remote_arch), "--platform", "linux/#{remote_arch}"
+    end
+
+    def create_contexts
+      combine \
+        create_context(local_arch, local_host),
+        create_context(remote_arch, remote_host)
+    end
+
+    def create_context(arch, host)
+      docker :context, :create, builder_name_with_arch(arch), "--description", "'#{builder_name} #{arch} native host'", "--docker", "'host=#{host}'"
+    end
+
+    def remove_contexts
+      combine \
+        remove_context(local_arch),
+        remove_context(remote_arch)
+    end
+
+    def remove_context(arch)
+      docker :context, :rm, builder_name_with_arch(arch)
+    end
+end

lib/mrsk/commands/builder/native.rb

@@ -0,0 +1,20 @@
+class Mrsk::Commands::Builder::Native < Mrsk::Commands::Builder::Base
+  def create
+    # No-op on native without cache
+  end
+
+  def remove
+    # No-op on native without cache
+  end
+
+  def push
+    combine \
+      docker(:build, *build_options, build_context),
+      docker(:push, config.absolute_image),
+      docker(:push, config.latest_image)
+  end
+
+  def info
+    # No-op on native
+  end
+end

lib/mrsk/commands/builder/native/cached.rb

@@ -0,0 +1,16 @@
+class Mrsk::Commands::Builder::Native::Cached < Mrsk::Commands::Builder::Native
+  def create
+    docker :buildx, :create, "--use", "--driver=docker-container"
+  end
+
+  def remove
+    docker :buildx, :rm, builder_name
+  end
+
+  def push
+    docker :buildx, :build,
+      "--push",
+      *build_options,
+      build_context
+  end
+end

lib/mrsk/commands/builder/native/remote.rb

@@ -0,0 +1,59 @@
+class Mrsk::Commands::Builder::Native::Remote < Mrsk::Commands::Builder::Native
+  def create
+    chain \
+      create_context,
+      create_buildx
+  end
+
+  def remove
+    chain \
+      remove_context,
+      remove_buildx
+  end
+
+  def push
+    docker :buildx, :build,
+      "--push",
+      "--platform", platform,
+      "--builder", builder_name,
+      *build_options,
+      build_context
+  end
+
+  def info
+    chain \
+      docker(:context, :ls),
+      docker(:buildx, :ls)
+  end
+
+
+  private
+    def builder_name
+      "mrsk-#{config.service}-native-remote"
+    end
+
+    def builder_name_with_arch
+      "#{builder_name}-#{remote_arch}"
+    end
+
+    def platform
+      "linux/#{remote_arch}"
+    end
+
+    def create_context
+      docker :context, :create,
+        builder_name_with_arch, "--description", "'#{builder_name} #{remote_arch} native host'", "--docker", "'host=#{remote_host}'"
+    end
+
+    def remove_context
+      docker :context, :rm, builder_name_with_arch
+    end
+
+    def create_buildx
+      docker :buildx, :create, "--name", builder_name, builder_name_with_arch, "--platform", platform
+    end
+
+    def remove_buildx
+      docker :buildx, :rm, builder_name
+    end
+end

lib/mrsk/commands/docker.rb

@@ -0,0 +1,21 @@
+class Mrsk::Commands::Docker < Mrsk::Commands::Base
+  # Install Docker using the https://github.com/docker/docker-install convenience script.
+  def install
+    pipe [ :curl, "-fsSL", "https://get.docker.com" ], :sh
+  end
+
+  # Checks the Docker client version. Fails if Docker is not installed.
+  def installed?
+    docker "-v"
+  end
+
+  # Checks the Docker server version. Fails if Docker is not running.
+  def running?
+    docker :version
+  end
+
+  # Do we have superuser access to install Docker and start system services?
+  def superuser?
+    [ '[ "${EUID:-$(id -u)}" -eq 0 ]' ]
+  end
+end

lib/mrsk/commands/healthcheck.rb

@@ -0,0 +1,57 @@
+class Mrsk::Commands::Healthcheck < Mrsk::Commands::Base
+  EXPOSED_PORT = 3999
+
+  def run
+    web = config.role(:web)
+
+    docker :run,
+      "--detach",
+      "--name", container_name_with_version,
+      "--publish", "#{EXPOSED_PORT}:#{config.healthcheck["port"]}",
+      "--label", "service=#{container_name}",
+      "-e", "MRSK_CONTAINER_NAME=\"#{container_name}\"",
+      *web.env_args,
+      *web.health_check_args,
+      *config.volume_args,
+      *web.option_args,
+      config.absolute_image,
+      web.cmd
+  end
+
+  def status
+    pipe container_id, xargs(docker(:inspect, "--format", DOCKER_HEALTH_STATUS_FORMAT))
+  end
+
+  def container_health_log
+    pipe container_id, xargs(docker(:inspect, "--format", DOCKER_HEALTH_LOG_FORMAT))
+  end
+
+  def logs
+    pipe container_id, xargs(docker(:logs, "--tail", 50, "2>&1"))
+  end
+
+  def stop
+    pipe container_id, xargs(docker(:stop))
+  end
+
+  def remove
+    pipe container_id, xargs(docker(:container, :rm))
+  end
+
+  private
+    def container_name
+      [ "healthcheck", config.service, config.destination ].compact.join("-")
+    end
+
+    def container_name_with_version
+      "#{container_name}-#{config.version}"
+    end
+
+    def container_id
+      container_id_for(container_name: container_name_with_version)
+    end
+
+    def health_url
+      "http://localhost:#{EXPOSED_PORT}#{config.healthcheck["path"]}"
+    end
+end

lib/mrsk/commands/hook.rb

@@ -0,0 +1,14 @@
+class Mrsk::Commands::Hook < Mrsk::Commands::Base
+  def run(hook, **details)
+    [ hook_file(hook), env: tags(**details).env ]
+  end
+
+  def hook_exists?(hook)
+    Pathname.new(hook_file(hook)).exist?
+  end
+
+  private
+    def hook_file(hook)
+      "#{config.hooks_path}/#{hook}"
+    end
+end

lib/mrsk/commands/lock.rb

@@ -0,0 +1,63 @@
+require "active_support/duration"
+require "time"
+
+class Mrsk::Commands::Lock < Mrsk::Commands::Base
+  def acquire(message, version)
+    combine \
+      [:mkdir, lock_dir],
+      write_lock_details(message, version)
+  end
+
+  def release
+    combine \
+      [:rm, lock_details_file],
+      [:rm, "-r", lock_dir]
+  end
+
+  def status
+    combine \
+      stat_lock_dir,
+      read_lock_details
+  end
+
+  private
+    def write_lock_details(message, version)
+      write \
+        [:echo, "\"#{Base64.encode64(lock_details(message, version))}\""],
+        lock_details_file
+    end
+
+    def read_lock_details
+      pipe \
+        [:cat, lock_details_file],
+        [:base64, "-d"]
+    end
+
+    def stat_lock_dir
+      write \
+        [:stat, lock_dir],
+        "/dev/null"
+    end
+
+    def lock_dir
+      "mrsk_lock-#{config.service}"
+    end
+
+    def lock_details_file
+      [lock_dir, :details].join("/")
+    end
+
+    def lock_details(message, version)
+      <<~DETAILS.strip
+        Locked by: #{locked_by} at #{Time.now.utc.iso8601}
+        Version: #{version}
+        Message: #{message}
+      DETAILS
+    end
+
+    def locked_by
+      `git config user.name`.strip
+    rescue Errno::ENOENT
+      "Unknown"
+    end
+end

lib/mrsk/commands/prune.rb

@@ -0,0 +1,38 @@
+require "active_support/duration"
+require "active_support/core_ext/numeric/time"
+
+class Mrsk::Commands::Prune < Mrsk::Commands::Base
+  def dangling_images
+    docker :image, :prune, "--force", "--filter", "label=service=#{config.service}", "--filter", "dangling=true"
+  end
+
+  def tagged_images
+    pipe \
+      docker(:image, :ls, *service_filter, "--format", "'{{.ID}} {{.Repository}}:{{.Tag}}'"),
+      "grep -v -w \"#{active_image_list}\"",
+      "while read image tag; do docker rmi $tag; done"
+  end
+
+  def containers(keep_last: 5)
+    pipe \
+      docker(:ps, "-q", "-a", *service_filter, *stopped_containers_filters),
+      "tail -n +#{keep_last + 1}",
+      "while read container_id; do docker rm $container_id; done"
+  end
+
+  private
+    def stopped_containers_filters
+      [ "created", "exited", "dead" ].flat_map { |status| ["--filter", "status=#{status}"] }
+    end
+
+    def active_image_list
+      # Pull the images that are used by any containers
+      # Append repo:latest - to avoid deleting the latest tag
+      # Append repo:<none> - to avoid deleting dangling images that are in use. Unused dangling images are deleted separately
+      "$(docker container ls -a --format '{{.Image}}\\|' --filter label=service=#{config.service} | tr -d '\\n')#{config.latest_image}\\|#{config.repository}:<none>"
+    end
+
+    def service_filter
+      [ "--filter", "label=service=#{config.service}" ]
+    end
+end

lib/mrsk/commands/registry.rb

@@ -2,10 +2,19 @@ class Mrsk::Commands::Registry < Mrsk::Commands::Base
   delegate :registry, to: :config
 
   def login
-    docker :login, registry["server"], "-u", redact(registry["username"]), "-p", redact(registry["password"])
+    docker :login, registry["server"], "-u", sensitive(lookup("username")), "-p", sensitive(lookup("password"))
   end
 
   def logout
     docker :logout, registry["server"]
   end
+
+  private
+    def lookup(key)
+      if registry[key].is_a?(Array)
+        ENV.fetch(registry[key].first).dup
+      else
+        registry[key]
+      end
+    end
 end

lib/mrsk/commands/traefik.rb

@@ -1,12 +1,25 @@
 class Mrsk::Commands::Traefik < Mrsk::Commands::Base
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Mrsk::Utils
+
+  DEFAULT_IMAGE = "traefik:v2.9"
+  CONTAINER_PORT = 80
+  DEFAULT_ARGS = {
+    'log.level' => 'DEBUG'
+  }
+
   def run
     docker :run, "--name traefik",
-      "-d",
-      "--restart unless-stopped",
-      "-p 80:80",
-      "-v /var/run/docker.sock:/var/run/docker.sock",
-      "traefik",
-      "--providers.docker"
+      "--detach",
+      "--restart", "unless-stopped",
+      "--publish", port,
+      "--volume", "/var/run/docker.sock:/var/run/docker.sock",
+      *env_args,
+      *config.logging_args,
+      *label_args,
+      *docker_options_args,
+      image,
+      "--providers.docker",
+      *cmd_option_args
   end
 
   def start
@@ -18,18 +31,70 @@ class Mrsk::Commands::Traefik < Mrsk::Commands::Base
   end
 
   def info
-    docker :ps, "--filter", "name=traefik"
+    docker :ps, "--filter", "name=^traefik$"
   end
 
-  def logs
-    docker :logs, "traefik"
+  def logs(since: nil, lines: nil, grep: nil)
+    pipe \
+      docker(:logs, "traefik", (" --since #{since}" if since), (" --tail #{lines}" if lines), "--timestamps", "2>&1"),
+      ("grep '#{grep}'" if grep)
+  end
+
+  def follow_logs(host:, grep: nil)
+    run_over_ssh pipe(
+      docker(:logs, "traefik", "--timestamps", "--tail", "10", "--follow", "2>&1"),
+      (%(grep "#{grep}") if grep)
+    ).join(" "), host: host
   end
 
   def remove_container
-    docker :container, :prune, "-f", "--filter", "label=org.opencontainers.image.title=Traefik"
+    docker :container, :prune, "--force", "--filter", "label=org.opencontainers.image.title=Traefik"
   end
 
   def remove_image
-    docker :image, :prune, "-a", "-f", "--filter", "label=org.opencontainers.image.title=Traefik"
+    docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=Traefik"
   end
+
+  def port
+    "#{host_port}:#{CONTAINER_PORT}"
+  end
+
+  private
+    def label_args
+      argumentize "--label", labels
+    end
+
+    def env_args
+      env_config = config.traefik["env"] || {}
+
+      if env_config.present?
+        argumentize_env_with_secrets(env_config)
+      else
+        []
+      end
+    end
+
+    def labels
+      config.traefik["labels"] || []
+    end
+
+    def image
+      config.traefik.fetch("image") { DEFAULT_IMAGE }
+    end
+
+    def docker_options_args
+      optionize(config.traefik["options"] || {})
+    end
+
+    def cmd_option_args
+      if args = config.traefik["args"]
+        optionize DEFAULT_ARGS.merge(args), with: "="
+      else
+        optionize DEFAULT_ARGS, with: "="
+      end
+    end
+
+    def host_port
+      config.traefik["host_port"] || CONTAINER_PORT
+    end
 end

lib/mrsk/configuration.rb

@@ -1,27 +1,60 @@
 require "active_support/ordered_options"
 require "active_support/core_ext/string/inquiry"
+require "active_support/core_ext/module/delegation"
+require "pathname"
 require "erb"
+require "net/ssh/proxy/jump"
 
 class Mrsk::Configuration
-  delegate :service, :image, :servers, :env, :registry, :ssh_user, to: :config, allow_nil: true
+  delegate :service, :image, :servers, :env, :labels, :registry, :stop_wait_time, :hooks_path, to: :raw_config, allow_nil: true
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Mrsk::Utils
+
+  attr_accessor :destination
+  attr_accessor :raw_config
 
   class << self
-    def load_file(file)
-      if file.exist?
-        new YAML.load(ERB.new(IO.read(file)).result).symbolize_keys
-      else
-        raise "Configuration file not found in #{file}"
-      end
+    def create_from(config_file:, destination: nil, version: nil)
+      raw_config = load_config_files(config_file, *destination_config_file(config_file, destination))
+
+      new raw_config, destination: destination, version: version
     end
 
-    def argumentize(argument, attributes)
-      attributes.flat_map { |k, v| [ argument, "#{k}=#{v}" ] }
-    end
+    private
+      def load_config_files(*files)
+        files.inject({}) { |config, file| config.deep_merge! load_config_file(file) }
+      end
+
+      def load_config_file(file)
+        if file.exist?
+          YAML.load(ERB.new(IO.read(file)).result).symbolize_keys
+        else
+          raise "Configuration file not found in #{file}"
+        end
+      end
+
+      def destination_config_file(base_config_file, destination)
+        base_config_file.sub_ext(".#{destination}.yml") if destination
+      end
   end
 
-  def initialize(config, validate: true)
-    @config = ActiveSupport::InheritableOptions.new(config)
-    ensure_required_keys_present if validate
+  def initialize(raw_config, destination: nil, version: nil, validate: true)
+    @raw_config = ActiveSupport::InheritableOptions.new(raw_config)
+    @destination = destination
+    @declared_version = version
+    valid? if validate
+  end
+
+
+  def version=(version)
+    @declared_version = version
+  end
+
+  def version
+    @declared_version.presence || ENV["VERSION"] || git_version
+  end
+
+  def abbreviated_version
+    Mrsk::Utils.abbreviate_version(version)
   end
 
 
@@ -33,76 +66,198 @@ class Mrsk::Configuration
     roles.detect { |r| r.name == name.to_s }
   end
 
-  def hosts
-    hosts =
-      case
-      when ENV["HOSTS"]
-        ENV["HOSTS"].split(",")
-      when ENV["ROLES"]
-        role_names = ENV["ROLES"].split(",")
-        roles.select { |r| role_names.include?(r.name) }.flat_map(&:hosts)
-      else
-        roles.flat_map(&:hosts)
-      end
-
-      if hosts.any?
-        hosts
-      else
-        raise ArgumentError, "No hosts found"
-      end
+  def accessories
+    @accessories ||= raw_config.accessories&.keys&.collect { |name| Mrsk::Configuration::Accessory.new(name, config: self) } || []
   end
 
-  def primary_host
-    role(:web).hosts.first
+  def accessory(name)
+    accessories.detect { |a| a.name == name.to_s }
   end
 
 
-  def version
-    @version ||= ENV["VERSION"] || `git rev-parse HEAD`.strip
+  def all_hosts
+    roles.flat_map(&:hosts).uniq
   end
 
+  def primary_web_host
+    role(:web).primary_host
+  end
+
+  def traefik_hosts
+    roles.select(&:running_traefik?).flat_map(&:hosts).uniq
+  end
+
+  def boot
+    Mrsk::Configuration::Boot.new(config: self)
+  end
+
+
   def repository
-    [ config.registry["server"], image ].compact.join("/")
+    [ raw_config.registry["server"], image ].compact.join("/")
   end
 
   def absolute_image
     "#{repository}:#{version}"
   end
 
+  def latest_image
+    "#{repository}:latest"
+  end
+
   def service_with_version
     "#{service}-#{version}"
   end
 
 
   def env_args
-    self.class.argumentize "-e", config.env if config.env.present?
+    if raw_config.env.present?
+      argumentize_env_with_secrets(raw_config.env)
+    else
+      []
+    end
+  end
+
+  def volume_args
+    if raw_config.volumes.present?
+      argumentize "--volume", raw_config.volumes
+    else
+      []
+    end
+  end
+
+  def logging_args
+    if raw_config.logging.present?
+      optionize({ "log-driver" => raw_config.logging["driver"] }.compact) +
+        argumentize("--log-opt", raw_config.logging["options"])
+    else
+      argumentize("--log-opt", { "max-size" => "10m" })
+    end
+  end
+
+
+  def ssh_user
+    if raw_config.ssh.present?
+      raw_config.ssh["user"] || "root"
+    else
+      "root"
+    end
+  end
+
+  def ssh_proxy
+    if raw_config.ssh.present? && raw_config.ssh["proxy"]
+      Net::SSH::Proxy::Jump.new \
+        raw_config.ssh["proxy"].include?("@") ? raw_config.ssh["proxy"] : "root@#{raw_config.ssh["proxy"]}"
+    elsif raw_config.ssh.present? && raw_config.ssh["proxy_command"]
+      Net::SSH::Proxy::Command.new(raw_config.ssh["proxy_command"])
+    end
   end
 
   def ssh_options
-    { user: config.ssh_user || "root", auth_methods: [ "publickey" ] }
+    { user: ssh_user, proxy: ssh_proxy, auth_methods: [ "publickey" ] }.compact
   end
 
-  def master_key
-    ENV["RAILS_MASTER_KEY"] || File.read(Rails.root.join("config/master.key"))
+
+  def healthcheck
+    { "path" => "/up", "port" => 3000, "max_attempts" => 7 }.merge(raw_config.healthcheck || {})
   end
 
+  def readiness_delay
+    raw_config.readiness_delay || 7
+  end
+
+  def minimum_version
+    raw_config.minimum_version
+  end
+
+  def valid?
+    ensure_required_keys_present && ensure_valid_mrsk_version
+  end
+
+
+  def to_h
+    {
+      roles: role_names,
+      hosts: all_hosts,
+      primary_host: primary_web_host,
+      version: version,
+      repository: repository,
+      absolute_image: absolute_image,
+      service_with_version: service_with_version,
+      env_args: env_args,
+      volume_args: volume_args,
+      ssh_options: ssh_options,
+      builder: builder.to_h,
+      accessories: raw_config.accessories,
+      logging: logging_args,
+      healthcheck: healthcheck
+    }.compact
+  end
+
+  def traefik
+    raw_config.traefik || {}
+  end
+
+  def hooks_path
+    raw_config.hooks_path || ".mrsk/hooks"
+  end
+
+  def builder
+    Mrsk::Configuration::Builder.new(config: self)
+  end
+
+  # Will raise KeyError if any secret ENVs are missing
+  def ensure_env_available
+    env_args
+    roles.each(&:env_args)
+
+    true
+  end
 
   private
-    attr_accessor :config
-
+    # Will raise ArgumentError if any required config keys are missing
     def ensure_required_keys_present
-      %i[ service image registry ].each do |key|
-        raise ArgumentError, "Missing required configuration for #{key}" unless config[key].present?
+      %i[ service image registry servers ].each do |key|
+        raise ArgumentError, "Missing required configuration for #{key}" unless raw_config[key].present?
       end
 
-      %w[ username password ].each do |key|
-        raise ArgumentError, "Missing required configuration for registry/#{key}" unless config.registry[key].present?
-      end      
+      if raw_config.registry["username"].blank?
+        raise ArgumentError, "You must specify a username for the registry in config/deploy.yml"
+      end
+
+      if raw_config.registry["password"].blank?
+        raise ArgumentError, "You must specify a password for the registry in config/deploy.yml (or set the ENV variable if that's used)"
+      end
+
+      roles.each do |role|
+        if role.hosts.empty?
+          raise ArgumentError, "No servers specified for the #{role.name} role"
+        end
+      end
+
+      true
     end
 
+    def ensure_valid_mrsk_version
+      if minimum_version && Gem::Version.new(minimum_version) > Gem::Version.new(Mrsk::VERSION)
+        raise ArgumentError, "Current version is #{Mrsk::VERSION}, minimum required is #{minimum_version}"
+      end
+
+      true
+    end
+
+
     def role_names
-      config.servers.is_a?(Array) ? [ "web" ] : config.servers.keys.sort
+      raw_config.servers.is_a?(Array) ? [ "web" ] : raw_config.servers.keys.sort
+    end
+
+    def git_version
+      @git_version ||=
+        if system("git rev-parse")
+          uncommitted_suffix = `git status --porcelain`.strip.present? ? "_uncommitted_#{SecureRandom.hex(8)}" : ""
+
+          "#{`git rev-parse HEAD`.strip}#{uncommitted_suffix}"
+        else
+          raise "Can't use commit hash as version, no git repository found in #{Dir.pwd}"
+        end
     end
 end
-
-require "mrsk/configuration/role"

lib/mrsk/configuration/accessory.rb

@@ -0,0 +1,169 @@
+class Mrsk::Configuration::Accessory
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Mrsk::Utils
+
+  attr_accessor :name, :specifics
+
+  def initialize(name, config:)
+    @name, @config, @specifics = name.inquiry, config, config.raw_config["accessories"][name]
+  end
+
+  def service_name
+    "#{config.service}-#{name}"
+  end
+
+  def image
+    specifics["image"]
+  end
+
+  def hosts
+    if (specifics.keys & ["host", "hosts", "roles"]).size != 1
+      raise ArgumentError, "Specify one of `host`, `hosts` or `roles` for accessory `#{name}`"
+    end
+
+    hosts_from_host || hosts_from_hosts || hosts_from_roles
+  end
+
+  def port
+    if port = specifics["port"]&.to_s
+      port.include?(":") ? port : "#{port}:#{port}"
+    end
+  end
+
+  def publish_args
+    argumentize "--publish", port if port
+  end
+
+  def labels
+    default_labels.merge(specifics["labels"] || {})
+  end
+
+  def label_args
+    argumentize "--label", labels
+  end
+
+  def env
+    specifics["env"] || {}
+  end
+
+  def env_args
+    argumentize_env_with_secrets env
+  end
+
+  def files
+    specifics["files"]&.to_h do |local_to_remote_mapping|
+      local_file, remote_file = local_to_remote_mapping.split(":")
+      [ expand_local_file(local_file), expand_remote_file(remote_file) ]
+    end || {}
+  end
+
+  def directories
+    specifics["directories"]&.to_h do |host_to_container_mapping|
+      host_relative_path, container_path = host_to_container_mapping.split(":")
+      [ expand_host_path(host_relative_path), container_path ]
+    end || {}
+  end
+
+  def volumes
+    specific_volumes + remote_files_as_volumes + remote_directories_as_volumes
+  end
+
+  def volume_args
+    argumentize "--volume", volumes
+  end
+
+  def option_args
+    if args = specifics["options"]
+      optionize args
+    else
+      []
+    end
+  end
+
+  def cmd
+    specifics["cmd"]
+  end
+
+  private
+    attr_accessor :config
+
+    def default_labels
+      { "service" => service_name }
+    end
+
+    def expand_local_file(local_file)
+      if local_file.end_with?("erb")
+        with_clear_env_loaded { read_dynamic_file(local_file) }
+      else
+        Pathname.new(File.expand_path(local_file)).to_s
+      end
+    end
+
+    def with_clear_env_loaded
+      (env["clear"] || env).each { |k, v| ENV[k] = v }
+      yield
+    ensure
+      (env["clear"] || env).each { |k, v| ENV.delete(k) }
+    end
+
+    def read_dynamic_file(local_file)
+      StringIO.new(ERB.new(IO.read(local_file)).result)
+    end
+
+    def expand_remote_file(remote_file)
+      service_name + remote_file
+    end
+
+    def specific_volumes
+      specifics["volumes"] || []
+    end
+
+    def remote_files_as_volumes
+      specifics["files"]&.collect do |local_to_remote_mapping|
+        _, remote_file = local_to_remote_mapping.split(":")
+        "#{service_data_directory + remote_file}:#{remote_file}"
+      end || []
+    end
+
+    def remote_directories_as_volumes
+      specifics["directories"]&.collect do |host_to_container_mapping|
+        host_relative_path, container_path = host_to_container_mapping.split(":")
+        [ expand_host_path(host_relative_path), container_path ].join(":")
+      end || []
+    end
+
+    def expand_host_path(host_relative_path)
+      "#{service_data_directory}/#{host_relative_path}"
+    end
+
+    def service_data_directory
+      "$PWD/#{service_name}"
+    end
+
+    def hosts_from_host
+      if specifics.key?("host")
+        host = specifics["host"]
+        if host
+          [host]
+        else
+          raise ArgumentError, "Missing host for accessory `#{name}`"
+        end
+      end
+    end
+
+    def hosts_from_hosts
+      if specifics.key?("hosts")
+        hosts = specifics["hosts"]
+        if hosts.is_a?(Array)
+          hosts
+        else
+          raise ArgumentError, "Hosts should be an Array for accessory `#{name}`"
+        end
+      end
+    end
+
+    def hosts_from_roles
+      if specifics.key?("roles")
+        specifics["roles"].flat_map { |role| config.role(role).hosts }
+      end
+    end
+end

lib/mrsk/configuration/boot.rb

@@ -0,0 +1,20 @@
+class Mrsk::Configuration::Boot
+  def initialize(config:)
+    @options = config.raw_config.boot || {}
+    @host_count = config.all_hosts.count
+  end
+
+  def limit
+    limit = @options["limit"]
+
+    if limit.to_s.end_with?("%")
+      @host_count * limit.to_i / 100
+    else
+      limit
+    end
+  end
+
+  def wait
+    @options["wait"]
+  end
+end

lib/mrsk/configuration/builder.rb

@@ -0,0 +1,114 @@
+class Mrsk::Configuration::Builder
+  def initialize(config:)
+    @options = config.raw_config.builder || {}
+    @image = config.image
+    @server = config.registry["server"]
+
+    valid?
+  end
+
+  def to_h
+    @options
+  end
+
+  def multiarch?
+    @options["multiarch"] != false
+  end
+
+  def local?
+    !!@options["local"]
+  end
+
+  def remote?
+    !!@options["remote"]
+  end
+
+  def cached?
+    !!@options["cache"]
+  end
+
+  def args
+    @options["args"] || {}
+  end
+
+  def secrets
+    @options["secrets"] || []
+  end
+
+  def dockerfile
+    @options["dockerfile"] || "Dockerfile"
+  end
+
+  def context
+    @options["context"] || "."
+  end
+
+  def local_arch
+    @options["local"]["arch"] if local?
+  end
+
+  def local_host
+    @options["local"]["host"] if local?
+  end
+
+  def remote_arch
+    @options["remote"]["arch"] if remote?
+  end
+
+  def remote_host
+    @options["remote"]["host"] if remote?
+  end
+
+  def cache_from
+    if cached?
+      case @options["cache"]["type"]
+      when "gha"
+        cache_from_config_for_gha
+      when "registry"
+        cache_from_config_for_registry
+      end
+    end
+  end
+
+  def cache_to
+    if cached?
+      case @options["cache"]["type"]
+      when "gha"
+        cache_to_config_for_gha
+      when "registry"
+        cache_to_config_for_registry
+      end
+    end
+  end
+
+  private
+    def valid?
+      if @options["local"] && !@options["remote"]
+        raise ArgumentError, "You must specify both local and remote builder config for remote multiarch builds"
+      end
+
+      if @options["cache"] && @options["cache"]["type"]
+        raise ArgumentError, "Invalid cache type: #{@options["cache"]["type"]}" unless ["gha", "registry"].include?(@options["cache"]["type"])
+      end
+    end
+
+    def cache_image
+      @options["cache"]&.fetch("image", nil) || "#{@image}-build-cache"
+    end
+
+    def cache_from_config_for_gha
+      "type=gha"
+    end
+
+    def cache_from_config_for_registry
+      [ "type=registry", "ref=#{@server}/#{cache_image}" ].compact.join(",")
+    end
+
+    def cache_to_config_for_gha
+      [ "type=gha", @options["cache"]&.fetch("options", nil)].compact.join(",")
+    end
+
+    def cache_to_config_for_registry
+      [ "type=registry", @options["cache"]&.fetch("options", nil), "ref=#{@server}/#{cache_image}" ].compact.join(",")
+    end
+end

lib/mrsk/configuration/role.rb

@@ -1,5 +1,5 @@
 class Mrsk::Configuration::Role
-  delegate :argumentize, to: Mrsk::Configuration
+  delegate :argumentize, :argumentize_env_with_secrets, :optionize, to: Mrsk::Utils
 
   attr_accessor :name
 
@@ -7,18 +7,72 @@ class Mrsk::Configuration::Role
    @name, @config = name.inquiry, config
   end
 
+  def primary_host
+    hosts.first
+  end
+
   def hosts
     @hosts ||= extract_hosts_from_config
   end
 
+  def labels
+    default_labels.merge(traefik_labels).merge(custom_labels)
+  end
+
   def label_args
     argumentize "--label", labels
   end
 
+  def env
+    if config.env && config.env["secret"]
+      merged_env_with_secrets
+    else
+      merged_env
+    end
+  end
+
+  def env_args
+    argumentize_env_with_secrets env
+  end
+
+  def health_check_args
+    if health_check_cmd.present?
+      optionize({ "health-cmd" => health_check_cmd, "health-interval" => health_check_interval })
+    else
+      []
+    end
+  end
+
+  def health_check_cmd
+    options = specializations["healthcheck"] || {}
+    options = config.healthcheck.merge(options) if running_traefik?
+
+    options["cmd"] || http_health_check(port: options["port"], path: options["path"])
+  end
+
+  def health_check_interval
+    options = specializations["healthcheck"] || {}
+    options = config.healthcheck.merge(options) if running_traefik?
+
+    options["interval"] || "1s"
+  end
+
   def cmd
     specializations["cmd"]
   end
 
+  def option_args
+    if args = specializations["options"]
+      optionize args
+    else
+      []
+    end
+  end
+
+  def running_traefik?
+    name.web? || specializations["traefik"]
+  end
+
   private
     attr_accessor :config
 
@@ -27,37 +81,75 @@ class Mrsk::Configuration::Role
         config.servers
       else
         servers = config.servers[name]
-        servers.is_a?(Array) ? servers : servers["hosts"]
-      end
-    end
-
-    def labels
-      if name.web?
-        default_labels.merge(traefik_labels) 
-      else
-        default_labels
+        servers.is_a?(Array) ? servers : Array(servers["hosts"])
       end
     end
 
     def default_labels
-      { "service" => config.service, "role" => name }
+      if config.destination
+        { "service" => config.service, "role" => name, "destination" => config.destination }
+      else
+        { "service" => config.service, "role" => name }
+      end
     end
 
     def traefik_labels
-      {
-        "traefik.http.routers.#{config.service}.rule" => "'PathPrefix(`/`)'",
-        "traefik.http.services.#{config.service}.loadbalancer.healthcheck.path" => "/up",
-        "traefik.http.services.#{config.service}.loadbalancer.healthcheck.interval" => "1s",
-        "traefik.http.middlewares.#{config.service}.retry.attempts" => "3",
-        "traefik.http.middlewares.#{config.service}.retry.initialinterval" => "500ms"
-      }
+      if running_traefik?
+        {
+          # Setting a service property ensures that the generated service name will be consistent between versions
+          "traefik.http.services.#{traefik_service}.loadbalancer.server.scheme" => "http",
+
+          "traefik.http.routers.#{traefik_service}.rule" => "PathPrefix(`/`)",
+          "traefik.http.middlewares.#{traefik_service}-retry.retry.attempts" => "5",
+          "traefik.http.middlewares.#{traefik_service}-retry.retry.initialinterval" => "500ms",
+          "traefik.http.routers.#{traefik_service}.middlewares" => "#{traefik_service}-retry@docker"
+        }
+      else
+        {}
+      end
+    end
+
+    def traefik_service
+      [ config.service, name, config.destination ].compact.join("-")
+    end
+
+    def custom_labels
+      Hash.new.tap do |labels|
+        labels.merge!(config.labels) if config.labels.present?
+        labels.merge!(specializations["labels"]) if specializations["labels"].present?
+      end
     end
 
     def specializations
       if config.servers.is_a?(Array) || config.servers[name].is_a?(Array)
         { }
       else
-        config.servers[name].without("hosts")
+        config.servers[name].except("hosts")
       end
     end
+
+    def specialized_env
+      specializations["env"] || {}
+    end
+
+    def merged_env
+      config.env&.merge(specialized_env) || {}
+    end
+
+    # Secrets are stored in an array, which won't merge by default, so have to do it by hand.
+    def merged_env_with_secrets
+      merged_env.tap do |new_env|
+        new_env["secret"] = Array(config.env["secret"]) + Array(specialized_env["secret"])
+
+        # If there's no secret/clear split, everything is clear
+        clear_app_env  = config.env["secret"] ? Array(config.env["clear"]) : Array(config.env["clear"] || config.env)
+        clear_role_env = specialized_env["secret"] ? Array(specialized_env["clear"]) : Array(specialized_env["clear"] || specialized_env)
+
+        new_env["clear"] = (clear_app_env + clear_role_env).uniq
+      end
+    end
+
+    def http_health_check(port:, path:)
+      "curl -f #{URI.join("http://localhost:#{port}", path)} || exit 1" if path.present? || port.present?
+    end
 end

lib/mrsk/engine.rb

@@ -1,4 +0,0 @@
-module Mrsk
-  class Engine < ::Rails::Engine
-  end
-end

lib/mrsk/sshkit_with_ext.rb

@@ -0,0 +1,56 @@
+require "sshkit"
+require "sshkit/dsl"
+require "active_support/core_ext/hash/deep_merge"
+require "json"
+
+class SSHKit::Backend::Abstract
+  def capture_with_info(*args, **kwargs)
+    capture(*args, **kwargs, verbosity: Logger::INFO)
+  end
+
+  def capture_with_debug(*args, **kwargs)
+    capture(*args, **kwargs, verbosity: Logger::DEBUG)
+  end
+
+  def capture_with_pretty_json(*args, **kwargs)
+    JSON.pretty_generate(JSON.parse(capture(*args, **kwargs)))
+  end
+
+  def puts_by_host(host, output, type: "App")
+    puts "#{type} Host: #{host}\n#{output}\n\n"
+  end
+
+  # Our execution pattern is for the CLI execute args lists returned
+  # from commands, but this doesn't support returning execution options
+  # from the command.
+  #
+  # Support this by using kwargs for CLI options and merging with the
+  # args-extracted options.
+  module CommandEnvMerge
+    private
+
+    # Override to merge options returned by commands in the args list with
+    # options passed by the CLI and pass them along as kwargs.
+    def command(args, options)
+      more_options, args = args.partition { |a| a.is_a? Hash }
+      more_options << options
+
+      build_command(args, **more_options.reduce(:deep_merge))
+    end
+
+    # Destructure options to pluck out env for merge
+    def build_command(args, env: nil, **options)
+      # Rely on native Ruby kwargs precedence rather than explicit Hash merges
+      SSHKit::Command.new(*args, **default_command_options, **options, env: env_for(env))
+    end
+
+    def default_command_options
+      { in: pwd_path, host: @host, user: @user, group: @group }
+    end
+
+    def env_for(env)
+      @env.to_h.merge(env.to_h)
+    end
+  end
+  prepend CommandEnvMerge
+end

lib/mrsk/tags.rb

@@ -0,0 +1,39 @@
+require "time"
+
+class Mrsk::Tags
+  attr_reader :config, :tags
+
+  class << self
+    def from_config(config, **extra)
+      new(**default_tags(config), **extra)
+    end
+
+    def default_tags(config)
+      { recorded_at: Time.now.utc.iso8601,
+        performer: `whoami`.chomp,
+        destination: config.destination,
+        version: config.version,
+        service_version: service_version(config) }
+    end
+
+    def service_version(config)
+      [ config.service, config.abbreviated_version ].compact.join("@")
+    end
+  end
+
+  def initialize(**tags)
+    @tags = tags.compact
+  end
+
+  def env
+    tags.transform_keys { |detail| "MRSK_#{detail.upcase}" }
+  end
+
+  def to_s
+    tags.values.map { |value| "[#{value}]" }.join(" ")
+  end
+
+  def except(*tags)
+    self.class.new(**self.tags.except(*tags))
+  end
+end

lib/mrsk/utils.rb

@@ -0,0 +1,96 @@
+module Mrsk::Utils
+  extend self
+
+  DOLLAR_SIGN_WITHOUT_SHELL_EXPANSION_REGEX = /\$(?!{[^\}]*\})/
+
+  # Return a list of escaped shell arguments using the same named argument against the passed attributes (hash or array).
+  def argumentize(argument, attributes, sensitive: false)
+    Array(attributes).flat_map do |key, value|
+      if value.present?
+        attr = "#{key}=#{escape_shell_value(value)}"
+        attr = self.sensitive(attr, redaction: "#{key}=[REDACTED]") if sensitive
+        [ argument, attr]
+      else
+        [ argument, key ]
+      end
+    end
+  end
+
+  # Return a list of shell arguments using the same named argument against the passed attributes,
+  # but redacts and expands secrets.
+  def argumentize_env_with_secrets(env)
+    if (secrets = env["secret"]).present?
+      argumentize("-e", secrets.to_h { |key| [ key, ENV.fetch(key) ] }, sensitive: true) + argumentize("-e", env["clear"])
+    else
+      argumentize "-e", env.fetch("clear", env)
+    end
+  end
+
+  # Returns a list of shell-dashed option arguments. If the value is true, it's treated like a value-less option.
+  def optionize(args, with: nil)
+    options = if with
+      flatten_args(args).collect { |(key, value)| value == true ? "--#{key}" : "--#{key}#{with}#{escape_shell_value(value)}" }
+    else
+      flatten_args(args).collect { |(key, value)| [ "--#{key}", value == true ? nil : escape_shell_value(value) ] }
+    end
+
+    options.flatten.compact
+  end
+
+  # Flattens a one-to-many structure into an array of two-element arrays each containing a key-value pair
+  def flatten_args(args)
+    args.flat_map { |key, value| value.try(:map) { |entry| [key, entry] } || [ [ key, value ] ] }
+  end
+
+  # Marks sensitive values for redaction in logs and human-visible output.
+  # Pass `redaction:` to change the default `"[REDACTED]"` redaction, e.g.
+  # `sensitive "#{arg}=#{secret}", redaction: "#{arg}=xxxx"
+  def sensitive(...)
+    Mrsk::Utils::Sensitive.new(...)
+  end
+
+  def redacted(value)
+    case
+    when value.respond_to?(:redaction)
+      value.redaction
+    when value.respond_to?(:transform_values)
+      value.transform_values { |value| redacted value }
+    when value.respond_to?(:map)
+      value.map { |element| redacted element }
+    else
+      value
+    end
+  end
+
+  def unredacted(value)
+    case
+    when value.respond_to?(:unredacted)
+      value.unredacted
+    when value.respond_to?(:transform_values)
+      value.transform_values { |value| unredacted value }
+    when value.respond_to?(:map)
+      value.map { |element| unredacted element }
+    else
+      value
+    end
+  end
+
+  # Escape a value to make it safe for shell use.
+  def escape_shell_value(value)
+    value.to_s.dump
+      .gsub(/`/, '\\\\`')
+      .gsub(DOLLAR_SIGN_WITHOUT_SHELL_EXPANSION_REGEX, '\$')
+  end
+
+  # Abbreviate a git revhash for concise display
+  def abbreviate_version(version)
+    if version
+      # Don't abbreviate <sha>_uncommitted_<etc>
+      if version.include?("_")
+        version
+      else
+        version[0...7]
+      end
+    end
+  end
+end

lib/mrsk/utils/healthcheck_poller.rb

@@ -0,0 +1,39 @@
+class Mrsk::Utils::HealthcheckPoller
+  TRAEFIK_HEALTHY_DELAY = 2
+
+  class HealthcheckError < StandardError; end
+
+  class << self
+    def wait_for_healthy(pause_after_ready: false, &block)
+      attempt = 1
+      max_attempts = MRSK.config.healthcheck["max_attempts"]
+
+      begin
+        case status = block.call
+        when "healthy"
+          sleep TRAEFIK_HEALTHY_DELAY if pause_after_ready
+        when "running" # No health check configured
+          sleep MRSK.config.readiness_delay if pause_after_ready
+        else
+          raise HealthcheckError, "container not ready (#{status})"
+        end
+      rescue HealthcheckError => e
+        if attempt <= max_attempts
+          info "#{e.message}, retrying in #{attempt}s (attempt #{attempt}/#{max_attempts})..."
+          sleep attempt
+          attempt += 1
+          retry
+        else
+          raise
+        end
+      end
+
+      info "Container is healthy!"
+    end
+
+    private
+      def info(message)
+        SSHKit.config.output.info(message)
+      end
+  end
+end

lib/mrsk/utils/sensitive.rb

@@ -0,0 +1,19 @@
+require "active_support/core_ext/module/delegation"
+
+class Mrsk::Utils::Sensitive
+  # So SSHKit knows to redact these values.
+  include SSHKit::Redaction
+
+  attr_reader :unredacted, :redaction
+  delegate :to_s, to: :unredacted
+  delegate :inspect, to: :redaction
+
+  def initialize(value, redaction: "[REDACTED]")
+    @unredacted, @redaction = value, redaction
+  end
+
+  # Sensitive values won't leak into YAML output.
+  def encode_with(coder)
+    coder.represent_scalar nil, redaction
+  end
+end

lib/mrsk/version.rb

@@ -1,3 +1,3 @@
 module Mrsk
-  VERSION = "0.0.2"
+  VERSION = "0.15.1"
 end

lib/tasks/mrsk/app.rake

@@ -1,98 +0,0 @@
-require_relative "setup"
-
-app = Mrsk::Commands::App.new(MRSK_CONFIG)
-
-namespace :mrsk do
-  namespace :app do
-    desc "Deliver a newly built app image to servers"
-    task deliver: %i[ push pull ]
-
-    desc "Build locally and push app image to registry"
-    task :push do
-      run_locally { execute *app.push } unless ENV["VERSION"]
-    end
-
-    desc "Pull app image from the registry onto servers"
-    task :pull do
-      on(MRSK_CONFIG.hosts) { execute *app.pull }
-    end
-
-    desc "Run app on servers (or start them if they've already been run)"
-    task :run do
-      MRSK_CONFIG.roles.each do |role|
-        on(role.hosts) do |host|
-          begin
-            execute *app.run(role: role.name)
-          rescue SSHKit::Command::Failed => e
-            if e.message =~ /already in use/
-              puts "Container with same version already deployed on #{host}, starting that instead"
-              execute *app.start, host: host
-            else
-              raise
-            end
-          end
-        end
-      end
-    end
-
-    desc "Start existing app on servers"
-    task :start do
-      on(MRSK_CONFIG.hosts) { execute *app.start, raise_on_non_zero_exit: false }
-    end
-
-    desc "Stop app on servers"
-    task :stop do
-      on(MRSK_CONFIG.hosts) { execute *app.stop, raise_on_non_zero_exit: false }
-    end
-
-    desc "Start app on servers (use VERSION=<git-hash> to designate which version)"
-    task restart: %i[ stop start ]
-
-    desc "Display information about app containers"
-    task :info do
-      on(MRSK_CONFIG.hosts) { |host| puts "App Host: #{host}\n" + capture(*app.info) + "\n\n" }
-    end
-
-    desc "Execute a custom task on servers passed in as CMD='bin/rake some:task'"
-    task :exec do
-      on(MRSK_CONFIG.hosts) { |host| puts "App Host: #{host}\n" + capture(*app.exec(ENV["CMD"])) + "\n\n" }
-    end
-
-    namespace :exec do
-      desc "Execute Rails command on servers, like CMD='runner \"puts %(Hello World)\""
-      task :rails do
-        on(MRSK_CONFIG.hosts) { |host| puts "App Host: #{host}\n" + capture(*app.exec("bin/rails", ENV["CMD"])) + "\n\n" }
-      end
-
-      desc "Execute a custom task on the first defined server"
-      task :once do
-        on(MRSK_CONFIG.primary_host) { |host| puts capture(*app.exec(ENV["CMD"])) }
-      end
-
-      namespace :once do
-        desc "Execute Rails command on the first defined server, like CMD='runner \"puts %(Hello World)\""
-        task :rails do
-          on(MRSK_CONFIG.primary_host) { puts capture(*app.exec("bin/rails", ENV["CMD"])) }
-        end
-      end
-    end
-
-    desc "List all the app containers currently on servers"
-    task :containers do
-      on(MRSK_CONFIG.hosts) { |host| puts "App Host: #{host}\n" + capture(*app.list_containers) + "\n\n" }
-    end
-
-    desc "Tail logs from app containers"
-    task :logs do
-      on(MRSK_CONFIG.hosts) { execute *app.logs }
-    end
-
-    desc "Remove app containers and images from servers"
-    task remove: %i[ stop ] do
-      on(MRSK_CONFIG.hosts) do
-        execute *app.remove_containers
-        execute *app.remove_images
-      end
-    end
-  end
-end

lib/tasks/mrsk/mrsk.rake

@@ -1,26 +0,0 @@
-require_relative "setup"
-
-namespace :mrsk do
-  desc "Deploy app for the first time to a fresh server"
-  task fresh: %w[ server:bootstrap registry:login app:deliver traefik:run app:stop app:run ]
-
-  desc "Push the latest version of the app, ensure Traefik is running, then restart app"
-  task deploy: %w[ registry:login app:deliver traefik:run app:stop app:run prune ]
-
-  desc "Rollback to VERSION=x that was already run as a container on servers"
-  task rollback: %w[ app:restart ]
-
-  desc "Display information about Traefik and app containers"
-  task info: %w[ traefik:info app:info ]
-
-  desc "Create config stub in config/deploy.yml"
-  task :init do
-    require "fileutils"
-    FileUtils.cp_r \
-      Pathname.new(File.expand_path("templates/deploy.yml", __dir__)),
-      Rails.root.join("config/deploy.yml")
-  end
-
-  desc "Remove Traefik, app, and registry session from servers"
-  task remove: %w[ traefik:remove app:remove registry:logout ]
-end

lib/tasks/mrsk/prune.rake

@@ -1,18 +0,0 @@
-require_relative "setup"
-
-namespace :mrsk do
-  desc "Prune unused images and stopped containers"
-  task prune: %w[ prune:containers prune:images ]
-
-  namespace :prune do
-    desc "Prune unused images older than 30 days"
-    task :images do
-      on(MRSK_CONFIG.hosts) { execute "docker image prune -f --filter 'until=720h'" }
-    end
-
-    desc "Prune stopped containers for the service older than 3 days"
-    task :containers do
-      on(MRSK_CONFIG.hosts) { execute "docker container prune -f --filter label=service=#{MRSK_CONFIG.service} --filter 'until=72h'" }
-    end
-  end
-end

lib/tasks/mrsk/registry.rake

@@ -1,18 +0,0 @@
-require_relative "setup"
-
-registry = Mrsk::Commands::Registry.new(MRSK_CONFIG)
-
-namespace :mrsk do
-  namespace :registry do
-    desc "Login to the registry locally and remotely"
-    task :login do
-      run_locally           { execute *registry.login }
-      on(MRSK_CONFIG.hosts) { execute *registry.login }
-    end
-
-    desc "Logout of the registry remotely"
-    task :logout do
-      on(MRSK_CONFIG.hosts) { execute *registry.logout }
-    end
-  end
-end

lib/tasks/mrsk/server.rake

@@ -1,11 +0,0 @@
-require_relative "setup"
-
-namespace :mrsk do
-  namespace :server do
-    desc "Setup Docker on the remote servers"
-    task :bootstrap do
-      # FIXME: Detect when apt-get is not available and use the appropriate alternative
-      on(MRSK_CONFIG.hosts) { execute "apt-get install docker.io -y" }
-    end
-  end
-end

lib/tasks/mrsk/setup.rb

@@ -1,16 +0,0 @@
-require "sshkit"
-require "sshkit/dsl"
-
-include SSHKit::DSL
-
-if (config_file = Rails.root.join("config/deploy.yml")).exist?
-  MRSK_CONFIG = Mrsk::Configuration.load_file(config_file)
-
-  SSHKit::Backend::Netssh.configure { |ssh| ssh.ssh_options = MRSK_CONFIG.ssh_options }
-
-  # No need to use /usr/bin/env, just clogs up the logs
-  SSHKit.config.command_map[:docker] = "docker"
-else
-  # MRSK is missing config/deploy.yml – run 'rake mrsk:init'
-  MRSK_CONFIG = Mrsk::Configuration.new({}, validate: false)
-end

lib/tasks/mrsk/templates/deploy.yml

@@ -1,21 +0,0 @@
-# Name of your application will be used for uniquely configuring Traefik and app containers.
-# Your Dockerfile should set LABEL service=the-same-value to ensure image pruning works.
-service: my-app
-
-# Name of the container image
-image: user/chat
-
-# All the servers targeted for deploy. You can reference a single server for a command by using SERVERS=xxx.xxx.xxx.xxx
-servers:
-  - xxx.xxx.xxx.xxx
-
-# The following envs are made available to the container when started
-env:
-  # Remember never to put passwords or tokens directly into this file, use encrypted credentials
-  # REDIS_URL: redis://x/y
-
-registry:
-  # Specify the registry server, if you're not using Docker Hub
-  # server: registry.digitalocean.com / ghcr.io / ...
-  username: <%= Rails.application.credentials.registry["username"] %>
-  password: <%= Rails.application.credentials.registry["password"] %>

lib/tasks/mrsk/traefik.rake

@@ -1,38 +0,0 @@
-require_relative "setup"
-
-traefik = Mrsk::Commands::Traefik.new(MRSK_CONFIG)
-
-namespace :mrsk do
-  namespace :traefik do
-    desc "Run Traefik on servers"
-    task :run do
-      on(MRSK_CONFIG.role(:web).hosts) { execute *traefik.run, raise_on_non_zero_exit: false }
-    end
-
-    desc "Start existing Traefik on servers"
-    task :start do
-      on(MRSK_CONFIG.role(:web).hosts) { execute *traefik.start, raise_on_non_zero_exit: false }
-    end
-
-    desc "Stop Traefik on servers"
-    task :stop do
-      on(MRSK_CONFIG.role(:web).hosts) { execute *traefik.stop, raise_on_non_zero_exit: false }
-    end
-
-    desc "Restart Traefik on servers"
-    task restart: %i[ stop start ]
-
-    desc "Display information about Traefik containers from servers"
-    task :info do
-      on(MRSK_CONFIG.role(:web).hosts) { |host| puts "Traefik Host: #{host}\n" + capture(*traefik.info) + "\n\n" }
-    end
-
-    desc "Remove Traefik container and image from servers"
-    task remove: %i[ stop ] do
-      on(MRSK_CONFIG.role(:web).hosts) do
-        execute *traefik.remove_container
-        execute *traefik.remove_image
-      end
-    end
-  end
-end

mrsk.gemspec

@@ -6,11 +6,22 @@ Gem::Specification.new do |spec|
   spec.authors     = [ "David Heinemeier Hansson" ]
   spec.email       = "dhh@hey.com"
   spec.homepage    = "https://github.com/rails/mrsk"
-  spec.summary     = "Deploy Docker containers with zero downtime to any host."
+  spec.summary     = "Deploy web apps in containers to servers running Docker with zero downtime."
   spec.license     = "MIT"
 
   spec.files = Dir["lib/**/*", "MIT-LICENSE", "README.md"]
+  spec.executables = %w[ mrsk ]
 
-  spec.add_dependency "railties", ">= 7.0.0"
+  spec.add_dependency "activesupport", ">= 7.0"
   spec.add_dependency "sshkit", "~> 1.21"
+  spec.add_dependency "net-ssh", "~> 7.0"
+  spec.add_dependency "thor", "~> 1.2"
+  spec.add_dependency "dotenv", "~> 2.8"
+  spec.add_dependency "zeitwerk", "~> 2.5"
+  spec.add_dependency "ed25519", "~> 1.2"
+  spec.add_dependency "bcrypt_pbkdf", "~> 1.0"
+
+  spec.add_development_dependency "debug"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "railties"
 end

test/app_command_test.rb

@@ -1,18 +0,0 @@
-require "test_helper"
-require "mrsk/configuration"
-require "mrsk/commands"
-
-ENV["VERSION"] = "123"
-ENV["RAILS_MASTER_KEY"] = "456"
-
-class AppCommandTest < ActiveSupport::TestCase
-  setup do
-    @config = { service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ] }
-    @app = Mrsk::Commands::App.new Mrsk::Configuration.new(@config)
-  end
-
-  test "run" do
-    assert_equal \
-      [:docker, :run, "-d", "--restart unless-stopped", "--name", "app-123", "-e", "RAILS_MASTER_KEY=456", "--label", "service=app", "--label", "role=web", "--label", "traefik.http.routers.app.rule='PathPrefix(`/`)'", "--label", "traefik.http.services.app.loadbalancer.healthcheck.path=/up", "--label", "traefik.http.services.app.loadbalancer.healthcheck.interval=1s", "--label", "traefik.http.middlewares.app.retry.attempts=3", "--label", "traefik.http.middlewares.app.retry.initialinterval=500ms", "dhh/app:123"], @app.run
-  end
-end

test/cli/accessory_test.rb

@@ -0,0 +1,143 @@
+require_relative "cli_test_case"
+
+class CliAccessoryTest < CliTestCase
+  test "boot" do
+    Mrsk::Cli::Accessory.any_instance.expects(:directories).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:upload).with("mysql")
+
+    run_command("boot", "mysql").tap do |output|
+      assert_match /docker login.*on 1.1.1.3/, output
+      assert_match "docker run --name app-mysql --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 3306:3306 -e [REDACTED] -e MYSQL_ROOT_HOST=\"%\" --volume $PWD/app-mysql/etc/mysql/my.cnf:/etc/mysql/my.cnf --volume $PWD/app-mysql/data:/var/lib/mysql --label service=\"app-mysql\" mysql:5.7 on 1.1.1.3", output
+    end
+  end
+
+  test "boot all" do
+    Mrsk::Cli::Accessory.any_instance.expects(:directories).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:upload).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:directories).with("redis")
+    Mrsk::Cli::Accessory.any_instance.expects(:upload).with("redis")
+
+    run_command("boot", "all").tap do |output|
+      assert_match /docker login.*on 1.1.1.3/, output
+      assert_match /docker login.*on 1.1.1.1/, output
+      assert_match /docker login.*on 1.1.1.2/, output
+      assert_match "docker run --name app-mysql --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 3306:3306 -e [REDACTED] -e MYSQL_ROOT_HOST=\"%\" --volume $PWD/app-mysql/etc/mysql/my.cnf:/etc/mysql/my.cnf --volume $PWD/app-mysql/data:/var/lib/mysql --label service=\"app-mysql\" mysql:5.7 on 1.1.1.3", output
+      assert_match "docker run --name app-redis --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 6379:6379 --volume $PWD/app-redis/data:/data --label service=\"app-redis\" redis:latest on 1.1.1.1", output
+      assert_match "docker run --name app-redis --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 6379:6379 --volume $PWD/app-redis/data:/data --label service=\"app-redis\" redis:latest on 1.1.1.2", output
+    end
+  end
+
+  test "upload" do
+    run_command("upload", "mysql").tap do |output|
+      assert_match "mkdir -p app-mysql/etc/mysql", output
+      assert_match "test/fixtures/files/my.cnf app-mysql/etc/mysql/my.cnf", output
+      assert_match "chmod 755 app-mysql/etc/mysql/my.cnf", output
+    end
+  end
+
+  test "directories" do
+    assert_match "mkdir -p $PWD/app-mysql/data", run_command("directories", "mysql")
+  end
+
+  test "reboot" do
+    Mrsk::Commands::Registry.any_instance.expects(:login)
+    Mrsk::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:boot).with("mysql", login: false)
+
+    run_command("reboot", "mysql")
+  end
+
+  test "start" do
+    assert_match "docker container start app-mysql", run_command("start", "mysql")
+  end
+
+  test "stop" do
+    assert_match "docker container stop app-mysql", run_command("stop", "mysql")
+  end
+
+  test "restart" do
+    Mrsk::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:start).with("mysql")
+
+    run_command("restart", "mysql")
+  end
+
+  test "details" do
+    assert_match "docker ps --filter label=service=app-mysql", run_command("details", "mysql")
+  end
+
+  test "details with all" do
+    run_command("details", "all").tap do |output|
+      assert_match "docker ps --filter label=service=app-mysql", output
+      assert_match "docker ps --filter label=service=app-redis", output
+    end
+  end
+
+  test "exec" do
+    run_command("exec", "mysql", "mysql -v").tap do |output|
+      assert_match "Launching command from new container", output
+      assert_match "mysql -v", output
+    end
+  end
+
+  test "exec with reuse" do
+    run_command("exec", "mysql", "--reuse", "mysql -v").tap do |output|
+      assert_match "Launching command from existing container", output
+      assert_match "docker exec app-mysql mysql -v", output
+    end
+  end
+
+  test "logs" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 'docker logs app-mysql --timestamps --tail 10 2>&1'")
+
+    assert_match "docker logs app-mysql  --tail 100 --timestamps 2>&1", run_command("logs", "mysql")
+  end
+
+  test "logs with follow" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1'")
+
+    assert_match "docker logs app-mysql --timestamps --tail 10 --follow 2>&1", run_command("logs", "mysql", "--follow")
+  end
+
+  test "remove with confirmation" do
+    Mrsk::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_image).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_service_directory).with("mysql")
+
+    run_command("remove", "mysql", "-y")
+  end
+
+  test "remove all with confirmation" do
+    Mrsk::Cli::Accessory.any_instance.expects(:stop).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_image).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_service_directory).with("mysql")
+    Mrsk::Cli::Accessory.any_instance.expects(:stop).with("redis")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_container).with("redis")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_image).with("redis")
+    Mrsk::Cli::Accessory.any_instance.expects(:remove_service_directory).with("redis")
+
+    run_command("remove", "all", "-y")
+  end
+
+  test "remove_container" do
+    assert_match "docker container prune --force --filter label=service=app-mysql", run_command("remove_container", "mysql")
+  end
+
+  test "remove_image" do
+    assert_match "docker image rm --force mysql", run_command("remove_image", "mysql")
+  end
+
+  test "remove_service_directory" do
+    assert_match "rm -rf app-mysql", run_command("remove_service_directory", "mysql")
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Accessory.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/app_test.rb

@@ -0,0 +1,189 @@
+require_relative "cli_test_case"
+
+class CliAppTest < CliTestCase
+  test "boot" do
+    stub_running
+    run_command("boot").tap do |output|
+      assert_match "docker tag dhh/app:latest dhh/app:latest", output
+      assert_match /docker run --detach --restart unless-stopped --name app-web-latest --hostname 1.1.1.1-[0-9a-f]{12} /, output
+      assert_match "docker container ls --all --filter name=^app-web-123$ --quiet | xargs docker stop", output
+    end
+  end
+
+  test "boot will rename if same version is already running" do
+    run_command("details") # Preheat MRSK const
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--filter", "name=^app-web-latest$", "--quiet", raise_on_non_zero_exit: false)
+      .returns("12345678") # running version
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-latest$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("running") # health check
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--filter", "status=running", "--filter", "status=restarting", "--latest", "--format", "\"{{.Names}}\"", "|", "grep -oE \"\\-[^-]+$\"", "|", "cut -c 2-", raise_on_non_zero_exit: false)
+      .returns("123") # old version
+
+    run_command("boot").tap do |output|
+      assert_match /Renaming container .* to .* as already deployed on 1.1.1.1/, output # Rename
+      assert_match /docker rename app-web-latest app-web-latest_replaced_[0-9a-f]{16}/, output
+      assert_match /docker run --detach --restart unless-stopped --name app-web-latest --hostname 1.1.1.1-[0-9a-f]{12} /, output
+      assert_match "docker container ls --all --filter name=^app-web-123$ --quiet | xargs docker stop", output
+    end
+  ensure
+    Thread.report_on_exception = true
+  end
+
+  test "boot uses group strategy when specified" do
+    Mrsk::Cli::App.any_instance.stubs(:on).with("1.1.1.1").twice # acquire & release lock
+    Mrsk::Cli::App.any_instance.stubs(:on).with([ "1.1.1.1" ]) # tag container
+
+    # Strategy is used when booting the containers
+    Mrsk::Cli::App.any_instance.expects(:on).with([ "1.1.1.1" ], in: :groups, limit: 3, wait: 2).with_block_given
+
+    run_command("boot", config: :with_boot_strategy)
+  end
+
+  test "boot errors leave lock in place" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999" }
+
+    Mrsk::Cli::App.any_instance.expects(:using_version).raises(RuntimeError)
+
+    assert !MRSK.holding_lock?
+    assert_raises(RuntimeError) do
+      stderred { run_command("boot") }
+    end
+    assert MRSK.holding_lock?
+  end
+
+  test "start" do
+    run_command("start").tap do |output|
+      assert_match "docker start app-web-999", output
+    end
+  end
+
+  test "stop" do
+    run_command("stop").tap do |output|
+      assert_match "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop", output
+    end
+  end
+
+  test "stale_containers" do
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--format", "\"{{.Names}}\"", "|", "grep -oE \"\\-[^-]+$\"", "|", "cut -c 2-", raise_on_non_zero_exit: false)
+      .returns("12345678\n87654321")
+
+    run_command("stale_containers").tap do |output|
+      assert_match /Detected stale container for role web with version 87654321/, output
+    end
+  end
+
+  test "stop stale_containers" do
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--format", "\"{{.Names}}\"", "|", "grep -oE \"\\-[^-]+$\"", "|", "cut -c 2-", raise_on_non_zero_exit: false)
+      .returns("12345678\n87654321")
+
+    run_command("stale_containers", "--stop").tap do |output|
+      assert_match /Stopping stale container for role web with version 87654321/, output
+      assert_match /#{Regexp.escape("docker container ls --all --filter name=^app-web-87654321$ --quiet | xargs docker stop")}/, output
+    end
+  end
+
+  test "details" do
+    run_command("details").tap do |output|
+      assert_match "docker ps --filter label=service=app --filter label=role=web", output
+    end
+  end
+
+  test "remove" do
+    run_command("remove").tap do |output|
+      assert_match /#{Regexp.escape("docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop")}/, output
+      assert_match /#{Regexp.escape("docker container prune --force --filter label=service=app")}/, output
+      assert_match /#{Regexp.escape("docker image prune --all --force --filter label=service=app")}/, output
+    end
+  end
+
+  test "remove_container" do
+    run_command("remove_container", "1234567").tap do |output|
+      assert_match "docker container ls --all --filter name=^app-web-1234567$ --quiet | xargs docker container rm", output
+    end
+  end
+
+  test "remove_containers" do
+    run_command("remove_containers").tap do |output|
+      assert_match "docker container prune --force --filter label=service=app", output
+    end
+  end
+
+  test "remove_images" do
+    run_command("remove_images").tap do |output|
+      assert_match "docker image prune --all --force --filter label=service=app", output
+    end
+  end
+
+  test "exec" do
+    run_command("exec", "ruby -v").tap do |output|
+      assert_match "docker run --rm dhh/app:latest ruby -v", output
+    end
+  end
+
+  test "exec with reuse" do
+    run_command("exec", "--reuse", "ruby -v").tap do |output|
+      assert_match "docker ps --filter label=service=app --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | grep -oE \"\\-[^-]+$\" | cut -c 2-", output # Get current version
+      assert_match "docker exec app-web-999 ruby -v", output
+    end
+  end
+
+  test "containers" do
+    run_command("containers").tap do |output|
+      assert_match "docker container ls --all --filter label=service=app", output
+    end
+  end
+
+  test "images" do
+    run_command("images").tap do |output|
+      assert_match "docker image ls dhh/app", output
+    end
+  end
+
+  test "logs" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 'docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest| xargs docker logs --timestamps --tail 10 2>&1'")
+
+    assert_match "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --tail 100 2>&1", run_command("logs")
+  end
+
+  test "logs with follow" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 'docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1'")
+
+    assert_match "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1", run_command("logs", "--follow")
+  end
+
+  test "version" do
+    run_command("version").tap do |output|
+      assert_match "docker ps --filter label=service=app --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | grep -oE \"\\-[^-]+$\" | cut -c 2-", output
+    end
+  end
+
+
+  test "version through main" do
+    stdouted { Mrsk::Cli::Main.start(["app", "version", "-c", "test/fixtures/deploy_with_accessories.yml", "--hosts", "1.1.1.1"]) }.tap do |output|
+      assert_match "docker ps --filter label=service=app --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | grep -oE \"\\-[^-]+$\" | cut -c 2-", output
+    end
+  end
+
+  private
+    def run_command(*command, config: :with_accessories)
+      stdouted { Mrsk::Cli::App.start([*command, "-c", "test/fixtures/deploy_#{config}.yml", "--hosts", "1.1.1.1"]) }
+    end
+
+    def stub_running
+      SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info).returns("123") # old version
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-latest$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+        .returns("running") # health check
+    end
+end

test/cli/build_test.rb

@@ -0,0 +1,108 @@
+require_relative "cli_test_case"
+
+class CliBuildTest < CliTestCase
+  test "deliver" do
+    Mrsk::Cli::Build.any_instance.expects(:push)
+    Mrsk::Cli::Build.any_instance.expects(:pull)
+
+    run_command("deliver")
+  end
+
+  test "push" do
+    Mrsk::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2,1.1.1.3,1.1.1.4", command: "build", subcommand: "push" }
+
+    run_command("push").tap do |output|
+      assert_hook_ran "pre-build", output, **hook_variables
+      assert_match /docker --version && docker buildx version/, output
+      assert_match /docker buildx build --push --platform linux\/amd64,linux\/arm64 --builder mrsk-app-multiarch -t dhh\/app:999 -t dhh\/app:latest --label service="app" --file Dockerfile \. as .*@localhost/, output
+    end
+  end
+
+  test "push without builder" do
+    stub_locking
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, "--version", "&&", :docker, :buildx, "version")
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |*args| args[0..1] == [:docker, :buildx] }
+      .raises(SSHKit::Command::Failed.new("no builder"))
+      .then
+      .returns(true)
+
+    run_command("push").tap do |output|
+      assert_match /Missing compatible builder, so creating a new one first/, output
+    end
+  end
+
+  test "push with no buildx plugin" do
+    stub_locking
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, "--version", "&&", :docker, :buildx, "version")
+      .raises(SSHKit::Command::Failed.new("no buildx"))
+
+    Mrsk::Commands::Builder.any_instance.stubs(:native_and_local?).returns(false)
+    assert_raises(Mrsk::Cli::Build::BuildError) { run_command("push") }
+  end
+
+  test "push pre-build hook failure" do
+    fail_hook("pre-build")
+
+    assert_raises(Mrsk::Cli::HookError) { run_command("push") }
+
+    assert @executions.none? { |args| args[0..2] == [:docker, :buildx, :build] }
+  end
+
+  test "pull" do
+    run_command("pull").tap do |output|
+      assert_match /docker image rm --force dhh\/app:999/, output
+      assert_match /docker pull dhh\/app:999/, output
+    end
+  end
+
+  test "create" do
+    run_command("create").tap do |output|
+      assert_match /docker buildx create --use --name mrsk-app-multiarch/, output
+    end
+  end
+
+  test "create with error" do
+    stub_locking
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |arg| arg == :docker }
+      .raises(SSHKit::Command::Failed.new("stderr=error"))
+
+    run_command("create").tap do |output|
+      assert_match /Couldn't create remote builder: error/, output
+    end
+  end
+
+  test "remove" do
+    run_command("remove").tap do |output|
+      assert_match /docker buildx rm mrsk-app-multiarch/, output
+    end
+  end
+
+  test "details" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture)
+      .with(:docker, :context, :ls, "&&", :docker, :buildx, :ls)
+      .returns("docker builder info")
+
+    run_command("details").tap do |output|
+      assert_match /Builder: multiarch/, output
+      assert_match /docker builder info/, output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Build.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+
+    def stub_dependency_checks
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with(:docker, "--version", "&&", :docker, :buildx, "version")
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |*args| args[0..1] == [:docker, :buildx] }
+    end
+end

test/cli/cli_test_case.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+class CliTestCase < ActiveSupport::TestCase
+  setup do
+    ENV["VERSION"]             = "999"
+    ENV["RAILS_MASTER_KEY"]    = "123"
+    ENV["MYSQL_ROOT_PASSWORD"] = "secret123"
+    Object.send(:remove_const, :MRSK)
+    Object.const_set(:MRSK, Mrsk::Commander.new)
+  end
+
+  teardown do
+    ENV.delete("RAILS_MASTER_KEY")
+    ENV.delete("MYSQL_ROOT_PASSWORD")
+    ENV.delete("VERSION")
+  end
+
+  private
+    def fail_hook(hook)
+      @executions = []
+      Mrsk::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |*args| @executions << args; args != [".mrsk/hooks/#{hook}"] }
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |*args| args.first == ".mrsk/hooks/#{hook}" }
+        .raises(SSHKit::Command::Failed.new("failed"))
+    end
+
+    def stub_locking
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |arg1, arg2| arg1 == :mkdir && arg2 == "mrsk_lock-app" }
+      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+        .with { |arg1, arg2| arg1 == :rm && arg2 == "mrsk_lock-app/details" }
+    end
+
+    def assert_hook_ran(hook, output, version:, service_version:, hosts:, command:, subcommand: nil, runtime: nil)
+      performer = `whoami`.strip
+
+      assert_match "Running the #{hook} hook...\n", output
+
+      expected = %r{Running\s/usr/bin/env\s\.mrsk/hooks/#{hook}\sas\s#{performer}@localhost\n\s
+        DEBUG\s\[[0-9a-f]*\]\sCommand:\s\(\sexport\s
+        MRSK_RECORDED_AT=\"\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ\"\s
+        MRSK_PERFORMER=\"#{performer}\"\s
+        MRSK_VERSION=\"#{version}\"\s
+        MRSK_SERVICE_VERSION=\"#{service_version}\"\s
+        MRSK_HOSTS=\"#{hosts}\"\s
+        MRSK_COMMAND=\"#{command}\"\s
+        #{"MRSK_SUBCOMMAND=\\\"#{subcommand}\\\"\\s" if subcommand}
+        #{"MRSK_RUNTIME=\\\"#{runtime}\\\"\\s" if runtime}
+        ;\s/usr/bin/env\s\.mrsk/hooks/#{hook} }x
+
+      assert_match expected, output
+    end
+end

test/cli/healthcheck_test.rb

@@ -0,0 +1,71 @@
+require_relative "cli_test_case"
+
+class CliHealthcheckTest < CliTestCase
+  test "perform" do
+    # Prevent expected failures from outputting to terminal
+    Thread.report_on_exception = false
+
+    Mrsk::Utils::HealthcheckPoller.stubs(:sleep) # No sleeping when retrying
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :stop, raise_on_non_zero_exit: false)
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :run, "--detach", "--name", "healthcheck-app-999", "--publish", "3999:3000", "--label", "service=healthcheck-app", "-e", "MRSK_CONTAINER_NAME=\"healthcheck-app\"", "--health-cmd", "\"curl -f http://localhost:3000/up || exit 1\"", "--health-interval", "\"1s\"", "dhh/app:999")
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :container, :rm, raise_on_non_zero_exit: false)
+
+    # Fail twice to test retry logic
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("starting")
+      .then
+      .returns("unhealthy")
+      .then
+      .returns("healthy")
+
+    run_command("perform").tap do |output|
+      assert_match "container not ready (starting), retrying in 1s (attempt 1/7)...", output
+      assert_match "container not ready (unhealthy), retrying in 2s (attempt 2/7)...", output
+      assert_match "Container is healthy!", output
+    end
+  end
+
+  test "perform failing to become healthy" do
+    # Prevent expected failures from outputting to terminal
+    Thread.report_on_exception = false
+
+    Mrsk::Utils::HealthcheckPoller.stubs(:sleep) # No sleeping when retrying
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :stop, raise_on_non_zero_exit: false)
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :run, "--detach", "--name", "healthcheck-app-999", "--publish", "3999:3000", "--label", "service=healthcheck-app", "-e", "MRSK_CONTAINER_NAME=\"healthcheck-app\"", "--health-cmd", "\"curl -f http://localhost:3000/up || exit 1\"", "--health-interval", "\"1s\"", "dhh/app:999")
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :container, :rm, raise_on_non_zero_exit: false)
+
+    # Continually report unhealthy
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("unhealthy")
+
+    # Capture logs when failing
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :logs, "--tail", 50, "2>&1")
+      .returns("some log output")
+
+    # Capture container health log when failing
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_pretty_json)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^healthcheck-app-999$", "--quiet", "|", :xargs, :docker, :inspect, "--format",  "'{{json .State.Health}}'")
+      .returns('{"Status":"unhealthy","Log":[{"ExitCode": 1,"Output": "/bin/sh: 1: curl: not found\n"}]}"')
+
+    exception = assert_raises do
+      run_command("perform")
+    end
+    assert_match "container not ready (unhealthy)", exception.message
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Healthcheck.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/lock_test.rb

@@ -0,0 +1,20 @@
+require_relative "cli_test_case"
+
+class CliLockTest < CliTestCase
+  test "status" do
+    run_command("status") do |output|
+      assert_match "stat lock", output
+    end
+  end
+
+  test "release" do
+    run_command("release") do |output|
+      assert_match "rm -rf lock", output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Lock.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/main_test.rb

@@ -0,0 +1,375 @@
+require_relative "cli_test_case"
+
+class CliMainTest < CliTestCase
+  test "setup" do
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:server:bootstrap")
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:accessory:boot", [ "all" ])
+    Mrsk::Cli::Main.any_instance.expects(:deploy)
+
+    run_command("setup")
+  end
+
+  test "deploy" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:registry:login", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:build:deliver", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:traefik:boot", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:healthcheck:perform", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:stale_containers", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:boot", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:prune:all", [], invoke_options)
+
+    Mrsk::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2", command: "deploy" }
+
+    run_command("deploy").tap do |output|
+      assert_hook_ran "pre-connect", output, **hook_variables
+      assert_match /Log into image registry/, output
+      assert_match /Build and push app image/, output
+      assert_hook_ran "pre-deploy", output, **hook_variables
+      assert_match /Ensure Traefik is running/, output
+      assert_match /Ensure app can pass healthcheck/, output
+      assert_match /Detect stale containers/, output
+      assert_match /Prune old containers and images/, output
+      assert_hook_ran "post-deploy", output, **hook_variables, runtime: 0
+    end
+  end
+
+  test "deploy with skip_push" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:registry:login", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:build:pull", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:traefik:boot", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:healthcheck:perform", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:stale_containers", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:boot", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:prune:all", [], invoke_options)
+
+    run_command("deploy", "--skip_push").tap do |output|
+      assert_match /Acquiring the deploy lock/, output
+      assert_match /Log into image registry/, output
+      assert_match /Pull app image/, output
+      assert_match /Ensure Traefik is running/, output
+      assert_match /Ensure app can pass healthcheck/, output
+      assert_match /Detect stale containers/, output
+      assert_match /Prune old containers and images/, output
+      assert_match /Releasing the deploy lock/, output
+    end
+  end
+
+  test "deploy when locked" do
+    Thread.report_on_exception = false
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |*arg| arg[0..1] == [:mkdir, 'mrsk_lock-app'] }
+      .raises(RuntimeError, "mkdir: cannot create directory ‘mrsk_lock-app’: File exists")
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_debug)
+      .with(:stat, 'mrsk_lock-app', ">", "/dev/null", "&&", :cat, "mrsk_lock-app/details", "|", :base64, "-d")
+
+    assert_raises(Mrsk::Cli::LockError) do
+      run_command("deploy")
+    end
+  end
+
+  test "deploy error when locking" do
+    Thread.report_on_exception = false
+
+    SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      .with { |*arg| arg[0..1] == [:mkdir, 'mrsk_lock-app'] }
+      .raises(SocketError, "getaddrinfo: nodename nor servname provided, or not known")
+
+    assert_raises(SSHKit::Runner::ExecuteError) do
+      run_command("deploy")
+    end
+  end
+
+  test "deploy errors during outside section leave remove lock" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Mrsk::Cli::Main.any_instance.expects(:invoke)
+      .with("mrsk:cli:registry:login", [], invoke_options)
+      .raises(RuntimeError)
+
+    assert !MRSK.holding_lock?
+    assert_raises(RuntimeError) do
+      stderred { run_command("deploy") }
+    end
+    assert !MRSK.holding_lock?
+  end
+
+  test "deploy with skipped hooks" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => true }
+
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:registry:login", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:build:deliver", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:traefik:boot", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:healthcheck:perform", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:stale_containers", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:boot", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:prune:all", [], invoke_options)
+
+    run_command("deploy", "--skip_hooks") do
+      refute_match /Running the post-deploy hook.../, output
+    end
+  end
+
+  test "deploy with missing secrets" do
+    assert_raises(KeyError) do
+      run_command("deploy", config_file: "deploy_with_secrets")
+    end
+  end
+
+  test "redeploy" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:build:deliver", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:healthcheck:perform", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:stale_containers", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:boot", [], invoke_options)
+
+    Mrsk::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+
+    hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2", command: "redeploy" }
+
+    run_command("redeploy").tap do |output|
+      assert_hook_ran "pre-connect", output, **hook_variables
+      assert_match /Build and push app image/, output
+      assert_hook_ran "pre-deploy", output, **hook_variables
+      assert_match /Running the pre-deploy hook.../, output
+      assert_match /Ensure app can pass healthcheck/, output
+      assert_hook_ran "post-deploy", output, **hook_variables, runtime: "0"
+    end
+  end
+
+  test "redeploy with skip_push" do
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
+
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:build:pull", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:healthcheck:perform", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:stale_containers", [], invoke_options)
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:boot", [], invoke_options)
+
+    run_command("redeploy", "--skip_push").tap do |output|
+      assert_match /Pull app image/, output
+      assert_match /Ensure app can pass healthcheck/, output
+    end
+  end
+
+  test "rollback bad version" do
+    Thread.report_on_exception = false
+
+    run_command("details") # Preheat MRSK const
+
+    run_command("rollback", "nonsense").tap do |output|
+      assert_match /docker container ls --all --filter name=\^app-web-nonsense\$ --quiet/, output
+      assert_match /The app version 'nonsense' is not available as a container/, output
+    end
+  end
+
+  test "rollback good version" do
+    [ "web", "workers" ].each do |role|
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--filter", "name=^app-#{role}-123$", "--quiet", raise_on_non_zero_exit: false)
+        .returns("").at_least_once
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--all", "--filter", "name=^app-#{role}-123$", "--quiet")
+        .returns("version-to-rollback\n").at_least_once
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=#{role}", "--filter", "status=running", "--filter", "status=restarting", "--latest", "--format", "\"{{.Names}}\"", "|", "grep -oE \"\\-[^-]+$\"", "|", "cut -c 2-", raise_on_non_zero_exit: false)
+        .returns("version-to-rollback\n").at_least_once
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :container, :ls, "--all", "--filter", "name=^app-#{role}-123$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+        .returns("running").at_least_once # health check
+    end
+
+    Mrsk::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    hook_variables = { version: 123, service_version: "app@123", hosts: "1.1.1.1,1.1.1.2,1.1.1.3,1.1.1.4", command: "rollback" }
+
+    run_command("rollback", "123", config_file: "deploy_with_accessories").tap do |output|
+      assert_match "Start container with version 123", output
+      assert_hook_ran "pre-deploy", output, **hook_variables
+      assert_match "docker tag dhh/app:123 dhh/app:latest", output
+      assert_match "docker start app-web-123", output
+      assert_match "docker container ls --all --filter name=^app-web-version-to-rollback$ --quiet | xargs docker stop", output, "Should stop the container that was previously running"
+      assert_hook_ran "post-deploy", output, **hook_variables, runtime: "0"
+    end
+  end
+
+  test "rollback without old version" do
+    Mrsk::Cli::Main.any_instance.stubs(:container_available?).returns(true)
+
+    Mrsk::Utils::HealthcheckPoller.stubs(:sleep)
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--filter", "name=^app-web-123$", "--quiet", raise_on_non_zero_exit: false)
+      .returns("").at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :ps, "--filter", "label=service=app", "--filter", "label=role=web", "--filter", "status=running", "--filter", "status=restarting", "--latest", "--format", "\"{{.Names}}\"", "|", "grep -oE \"\\-[^-]+$\"", "|", "cut -c 2-", raise_on_non_zero_exit: false)
+      .returns("").at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-123$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
+      .returns("running").at_least_once # health check
+
+    run_command("rollback", "123").tap do |output|
+      assert_match "Start container with version 123", output
+      assert_match "docker start app-web-123 || docker run --detach --restart unless-stopped --name app-web-123", output
+      assert_no_match "docker stop", output
+    end
+  end
+
+  test "details" do
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:traefik:details")
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:app:details")
+    Mrsk::Cli::Main.any_instance.expects(:invoke).with("mrsk:cli:accessory:details", [ "all" ])
+
+    run_command("details")
+  end
+
+  test "audit" do
+    run_command("audit").tap do |output|
+      assert_match /tail -n 50 mrsk-app-audit.log on 1.1.1.1/, output
+      assert_match /App Host: 1.1.1.1/, output
+    end
+  end
+
+  test "config" do
+    run_command("config", config_file: "deploy_simple").tap do |output|
+      config = YAML.load(output)
+
+      assert_equal ["web"], config[:roles]
+      assert_equal ["1.1.1.1", "1.1.1.2"], config[:hosts]
+      assert_equal "999", config[:version]
+      assert_equal "dhh/app", config[:repository]
+      assert_equal "dhh/app:999", config[:absolute_image]
+      assert_equal "app-999", config[:service_with_version]
+    end
+  end
+
+  test "config with roles" do
+    run_command("config", config_file: "deploy_with_roles").tap do |output|
+      config = YAML.load(output)
+
+      assert_equal ["web", "workers"], config[:roles]
+      assert_equal ["1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4"], config[:hosts]
+      assert_equal "999", config[:version]
+      assert_equal "registry.digitalocean.com/dhh/app", config[:repository]
+      assert_equal "registry.digitalocean.com/dhh/app:999", config[:absolute_image]
+      assert_equal "app-999", config[:service_with_version]
+    end
+  end
+
+  test "config with destination" do
+    run_command("config", "-d", "world", config_file: "deploy_for_dest").tap do |output|
+      config = YAML.load(output)
+
+      assert_equal ["web"], config[:roles]
+      assert_equal ["1.1.1.1", "1.1.1.2"], config[:hosts]
+      assert_equal "999", config[:version]
+      assert_equal "registry.digitalocean.com/dhh/app", config[:repository]
+      assert_equal "registry.digitalocean.com/dhh/app:999", config[:absolute_image]
+      assert_equal "app-999", config[:service_with_version]
+    end
+  end
+
+  test "init" do
+    Pathname.any_instance.expects(:exist?).returns(false).times(3)
+    Pathname.any_instance.stubs(:mkpath)
+    FileUtils.stubs(:mkdir_p)
+    FileUtils.stubs(:cp_r)
+    FileUtils.stubs(:cp)
+
+    run_command("init").tap do |output|
+      assert_match /Created configuration file in config\/deploy.yml/, output
+      assert_match /Created \.env file/, output
+    end
+  end
+
+  test "init with existing config" do
+    Pathname.any_instance.expects(:exist?).returns(true).times(3)
+
+    run_command("init").tap do |output|
+      assert_match /Config file already exists in config\/deploy.yml \(remove first to create a new one\)/, output
+    end
+  end
+
+  test "init with bundle option" do
+    Pathname.any_instance.expects(:exist?).returns(false).times(4)
+    Pathname.any_instance.stubs(:mkpath)
+    FileUtils.stubs(:mkdir_p)
+    FileUtils.stubs(:cp_r)
+    FileUtils.stubs(:cp)
+
+    run_command("init", "--bundle").tap do |output|
+      assert_match /Created configuration file in config\/deploy.yml/, output
+      assert_match /Created \.env file/, output
+      assert_match /Adding MRSK to Gemfile and bundle/, output
+      assert_match /bundle add mrsk/, output
+      assert_match /bundle binstubs mrsk/, output
+      assert_match /Created binstub file in bin\/mrsk/, output
+    end
+  end
+
+  test "init with bundle option and existing binstub" do
+    Pathname.any_instance.expects(:exist?).returns(true).times(4)
+    Pathname.any_instance.stubs(:mkpath)
+    FileUtils.stubs(:mkdir_p)
+    FileUtils.stubs(:cp_r)
+    FileUtils.stubs(:cp)
+
+    run_command("init", "--bundle").tap do |output|
+      assert_match /Config file already exists in config\/deploy.yml \(remove first to create a new one\)/, output
+      assert_match /Binstub already exists in bin\/mrsk \(remove first to create a new one\)/, output
+    end
+  end
+
+  test "envify" do
+    File.expects(:read).with(".env.erb").returns("HELLO=<%= 'world' %>")
+    File.expects(:write).with(".env", "HELLO=world", perm: 0600)
+
+    run_command("envify")
+  end
+
+  test "envify with destination" do
+    File.expects(:read).with(".env.staging.erb").returns("HELLO=<%= 'world' %>")
+    File.expects(:write).with(".env.staging", "HELLO=world", perm: 0600)
+
+    run_command("envify", "-d", "staging")
+  end
+
+  test "remove with confirmation" do
+    run_command("remove", "-y", config_file: "deploy_with_accessories").tap do |output|
+      assert_match /docker container stop traefik/, output
+      assert_match /docker container prune --force --filter label=org.opencontainers.image.title=Traefik/, output
+      assert_match /docker image prune --all --force --filter label=org.opencontainers.image.title=Traefik/, output
+
+      assert_match /docker ps --quiet --filter label=service=app | xargs docker stop/, output
+      assert_match /docker container prune --force --filter label=service=app/, output
+      assert_match /docker image prune --all --force --filter label=service=app/, output
+
+      assert_match /docker container stop app-mysql/, output
+      assert_match /docker container prune --force --filter label=service=app-mysql/, output
+      assert_match /docker image rm --force mysql/, output
+      assert_match /rm -rf app-mysql/, output
+
+      assert_match /docker container stop app-redis/, output
+      assert_match /docker container prune --force --filter label=service=app-redis/, output
+      assert_match /docker image rm --force redis/, output
+      assert_match /rm -rf app-redis/, output
+
+      assert_match /docker logout/, output
+    end
+  end
+
+  test "version" do
+    version = stdouted { Mrsk::Cli::Main.new.version }
+    assert_equal Mrsk::VERSION, version
+  end
+
+  private
+    def run_command(*command, config_file: "deploy_simple")
+      stdouted { Mrsk::Cli::Main.start([*command, "-c", "test/fixtures/#{config_file}.yml"]) }
+    end
+end

test/cli/prune_test.rb

@@ -0,0 +1,28 @@
+require_relative "cli_test_case"
+
+class CliPruneTest < CliTestCase
+  test "all" do
+    Mrsk::Cli::Prune.any_instance.expects(:containers)
+    Mrsk::Cli::Prune.any_instance.expects(:images)
+
+    run_command("all")
+  end
+
+  test "images" do
+    run_command("images").tap do |output|
+      assert_match "docker image prune --force --filter label=service=app --filter dangling=true on 1.1.1.", output
+      assert_match "docker image ls --filter label=service=app --format '{{.ID}} {{.Repository}}:{{.Tag}}' | grep -v -w \"$(docker container ls -a --format '{{.Image}}\\|' --filter label=service=app | tr -d '\\n')dhh/app:latest\\|dhh/app:<none>\" | while read image tag; do docker rmi $tag; done on 1.1.1.", output
+    end
+  end
+
+  test "containers" do
+    run_command("containers").tap do |output|
+      assert_match /docker ps -q -a --filter label=service=app --filter status=created --filter status=exited --filter status=dead | tail -n +6 | while read container_id; do docker rm $container_id; done on 1.1.1.\d/, output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Prune.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/registry_test.rb

@@ -0,0 +1,21 @@
+require_relative "cli_test_case"
+
+class CliRegistryTest < CliTestCase
+  test "login" do
+    run_command("login").tap do |output|
+      assert_match /docker login -u \[REDACTED\] -p \[REDACTED\] as .*@localhost/, output
+      assert_match /docker login -u \[REDACTED\] -p \[REDACTED\] on 1.1.1.\d/, output
+    end
+  end
+
+  test "logout" do
+    run_command("logout").tap do |output|
+      assert_match /docker logout on 1.1.1.\d/, output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Registry.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/server_test.rb

@@ -0,0 +1,35 @@
+require_relative "cli_test_case"
+
+class CliServerTest < CliTestCase
+  test "bootstrap already installed" do
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "-v", raise_on_non_zero_exit: false).returns(true).at_least_once
+
+    assert_equal "", run_command("bootstrap")
+  end
+
+  test "bootstrap install as non-root user" do
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "-v", raise_on_non_zero_exit: false).returns(false).at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with('[ "${EUID:-$(id -u)}" -eq 0 ]', raise_on_non_zero_exit: false).returns(false).at_least_once
+
+    assert_raise RuntimeError, "Docker is not installed on 1.1.1.1, 1.1.1.3, 1.1.1.4, 1.1.1.2 and can't be automatically installed without having root access and the `curl` command available. Install Docker manually: https://docs.docker.com/engine/install/" do
+      run_command("bootstrap")
+    end
+  end
+
+  test "bootstrap install as root user" do
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "-v", raise_on_non_zero_exit: false).returns(false).at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with('[ "${EUID:-$(id -u)}" -eq 0 ]', raise_on_non_zero_exit: false).returns(true).at_least_once
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:curl, "-fsSL", "https://get.docker.com", "|", :sh).at_least_once
+
+    run_command("bootstrap").tap do |output|
+      ("1.1.1.1".."1.1.1.4").map do |host|
+        assert_match "Missing Docker on #{host}. Installing…", output
+      end
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Server.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/cli/traefik_test.rb

@@ -0,0 +1,94 @@
+require_relative "cli_test_case"
+
+class CliTraefikTest < CliTestCase
+  test "boot" do
+    run_command("boot").tap do |output|
+      assert_match "docker login", output
+      assert_match "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{Mrsk::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
+    end
+  end
+
+  test "reboot" do
+    Mrsk::Commands::Registry.any_instance.expects(:login).twice
+
+    run_command("reboot").tap do |output|
+      assert_match "docker container stop traefik", output
+      assert_match "docker container prune --force --filter label=org.opencontainers.image.title=Traefik", output
+      assert_match "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{Mrsk::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
+    end
+  end
+
+  test "reboot --rolling" do
+    run_command("reboot", "--rolling").tap do |output|
+      assert_match "Running docker container prune --force --filter label=org.opencontainers.image.title=Traefik on 1.1.1.1", output.lines[3]
+    end
+  end
+
+  test "start" do
+    run_command("start").tap do |output|
+      assert_match "docker container start traefik", output
+    end
+  end
+
+  test "stop" do
+    run_command("stop").tap do |output|
+      assert_match "docker container stop traefik", output
+    end
+  end
+
+  test "restart" do
+    Mrsk::Cli::Traefik.any_instance.expects(:stop)
+    Mrsk::Cli::Traefik.any_instance.expects(:start)
+
+    run_command("restart")
+  end
+
+  test "details" do
+    run_command("details").tap do |output|
+      assert_match "docker ps --filter name=^traefik$", output
+    end
+  end
+
+  test "logs" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:capture)
+      .with(:docker, :logs, "traefik", " --tail 100", "--timestamps", "2>&1")
+      .returns("Log entry")
+
+    run_command("logs").tap do |output|
+      assert_match "Traefik Host: 1.1.1.1", output
+      assert_match "Log entry", output
+    end
+  end
+
+  test "logs with follow" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 'docker logs traefik --timestamps --tail 10 --follow 2>&1'")
+
+    assert_match "docker logs traefik --timestamps --tail 10 --follow", run_command("logs", "--follow")
+  end
+
+  test "remove" do
+    Mrsk::Cli::Traefik.any_instance.expects(:stop)
+    Mrsk::Cli::Traefik.any_instance.expects(:remove_container)
+    Mrsk::Cli::Traefik.any_instance.expects(:remove_image)
+
+    run_command("remove")
+  end
+
+  test "remove_container" do
+    run_command("remove_container").tap do |output|
+      assert_match "docker container prune --force --filter label=org.opencontainers.image.title=Traefik", output
+    end
+  end
+
+  test "remove_image" do
+    run_command("remove_image").tap do |output|
+      assert_match "docker image prune --all --force --filter label=org.opencontainers.image.title=Traefik", output
+    end
+  end
+
+  private
+    def run_command(*command)
+      stdouted { Mrsk::Cli::Traefik.start([*command, "-c", "test/fixtures/deploy_with_accessories.yml"]) }
+    end
+end

test/commander_test.rb

@@ -0,0 +1,79 @@
+require "test_helper"
+
+class CommanderTest < ActiveSupport::TestCase
+  setup do
+    configure_with(:deploy_with_roles)
+  end
+
+  test "lazy configuration" do
+    assert_equal Mrsk::Configuration, @mrsk.config.class
+  end
+
+  test "overwriting hosts" do
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @mrsk.hosts
+
+    @mrsk.specific_hosts = [ "1.1.1.1", "1.1.1.2" ]
+    assert_equal [ "1.1.1.1", "1.1.1.2" ], @mrsk.hosts
+  end
+
+  test "filtering hosts by filtering roles" do
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @mrsk.hosts
+
+    @mrsk.specific_roles = [ "web" ]
+    assert_equal [ "1.1.1.1", "1.1.1.2" ], @mrsk.hosts
+  end
+
+  test "filtering roles" do
+    assert_equal [ "web", "workers" ], @mrsk.roles.map(&:name)
+
+    @mrsk.specific_roles = [ "workers" ]
+    assert_equal [ "workers" ], @mrsk.roles.map(&:name)
+  end
+
+  test "filtering roles by filtering hosts" do
+    assert_equal [ "web", "workers" ], @mrsk.roles.map(&:name)
+
+    @mrsk.specific_hosts = [ "1.1.1.3" ]
+    assert_equal [ "workers" ], @mrsk.roles.map(&:name)
+  end
+
+  test "overwriting hosts with primary" do
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @mrsk.hosts
+
+    @mrsk.specific_primary!
+    assert_equal [ "1.1.1.1" ], @mrsk.hosts
+  end
+
+  test "primary_host with specific hosts via role" do
+    @mrsk.specific_roles = "workers"
+    assert_equal "1.1.1.3", @mrsk.primary_host
+  end
+
+  test "roles_on" do
+    assert_equal [ "web" ], @mrsk.roles_on("1.1.1.1")
+    assert_equal [ "workers" ], @mrsk.roles_on("1.1.1.3")
+  end
+
+  test "default group strategy" do
+    assert_empty @mrsk.boot_strategy
+  end
+
+  test "specific limit group strategy" do
+    configure_with(:deploy_with_boot_strategy)
+
+    assert_equal({ in: :groups, limit: 3, wait: 2 }, @mrsk.boot_strategy)
+  end
+
+  test "percentage-based group strategy" do
+    configure_with(:deploy_with_percentage_boot_strategy)
+
+    assert_equal({ in: :groups, limit: 1, wait: 2 }, @mrsk.boot_strategy)
+  end
+
+  private
+    def configure_with(variant)
+      @mrsk = Mrsk::Commander.new.tap do |mrsk|
+        mrsk.configure config_file: Pathname.new(File.expand_path("fixtures/#{variant}.yml", __dir__))
+      end
+    end
+end

test/commands/accessory_test.rb

@@ -0,0 +1,151 @@
+require "test_helper"
+
+class CommandsAccessoryTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "server" => "private.registry", "username" => "dhh", "password" => "secret" },
+      servers: [ "1.1.1.1" ],
+      accessories: {
+        "mysql" => {
+          "image" => "private.registry/mysql:8.0",
+          "host" => "1.1.1.5",
+          "port" => "3306",
+          "env" => {
+            "clear" => {
+              "MYSQL_ROOT_HOST" => "%"
+            },
+            "secret" => [
+              "MYSQL_ROOT_PASSWORD"
+            ]
+          }
+        },
+        "redis" => {
+          "image" => "redis:latest",
+          "host" => "1.1.1.6",
+          "port" => "6379:6379",
+          "labels" => {
+            "cache" => true
+          },
+          "env" => {
+            "SOMETHING" => "else"
+          },
+          "volumes" => [
+            "/var/lib/redis:/data"
+          ]
+        },
+        "busybox" => {
+          "image" => "busybox:latest",
+          "host" => "1.1.1.7"
+        }
+      }
+    }
+
+    ENV["MYSQL_ROOT_PASSWORD"] = "secret123"
+  end
+
+  teardown do
+    ENV.delete("MYSQL_ROOT_PASSWORD")
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --name app-mysql --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 3306:3306 -e MYSQL_ROOT_PASSWORD=\"secret123\" -e MYSQL_ROOT_HOST=\"%\" --label service=\"app-mysql\" private.registry/mysql:8.0",
+      new_command(:mysql).run.join(" ")
+
+    assert_equal \
+      "docker run --name app-redis --detach --restart unless-stopped --log-opt max-size=\"10m\" --publish 6379:6379 -e SOMETHING=\"else\" --volume /var/lib/redis:/data --label service=\"app-redis\" --label cache=\"true\" redis:latest",
+      new_command(:redis).run.join(" ")
+
+    assert_equal \
+      "docker run --name app-busybox --detach --restart unless-stopped --log-opt max-size=\"10m\" --label service=\"app-busybox\" busybox:latest",
+      new_command(:busybox).run.join(" ")
+  end
+
+  test "run with logging config" do
+    @config[:logging] = { "driver" => "local", "options" => { "max-size" => "100m", "max-file" => "3" } }
+
+    assert_equal \
+      "docker run --name app-busybox --detach --restart unless-stopped --log-driver \"local\" --log-opt max-size=\"100m\" --log-opt max-file=\"3\" --label service=\"app-busybox\" busybox:latest",
+      new_command(:busybox).run.join(" ")
+  end
+
+  test "start" do
+    assert_equal \
+      "docker container start app-mysql",
+      new_command(:mysql).start.join(" ")
+  end
+
+  test "stop" do
+    assert_equal \
+      "docker container stop app-mysql",
+      new_command(:mysql).stop.join(" ")
+  end
+
+  test "info" do
+    assert_equal \
+      "docker ps --filter label=service=app-mysql",
+      new_command(:mysql).info.join(" ")
+  end
+
+
+  test "execute in new container" do
+    assert_equal \
+      "docker run --rm -e MYSQL_ROOT_PASSWORD=\"secret123\" -e MYSQL_ROOT_HOST=\"%\" private.registry/mysql:8.0 mysql -u root",
+      new_command(:mysql).execute_in_new_container("mysql", "-u", "root").join(" ")
+  end
+
+  test "execute in existing container" do
+    assert_equal \
+      "docker exec app-mysql mysql -u root",
+      new_command(:mysql).execute_in_existing_container("mysql", "-u", "root").join(" ")
+  end
+
+  test "execute in new container over ssh" do
+    new_command(:mysql).stub(:run_over_ssh, ->(cmd) { cmd.join(" ") }) do
+      assert_match %r|docker run -it --rm -e MYSQL_ROOT_PASSWORD=\"secret123\" -e MYSQL_ROOT_HOST=\"%\" private.registry/mysql:8.0 mysql -u root|,
+        new_command(:mysql).execute_in_new_container_over_ssh("mysql", "-u", "root")
+    end
+  end
+
+  test "execute in existing container over ssh" do
+    new_command(:mysql).stub(:run_over_ssh, ->(cmd) { cmd.join(" ") }) do
+      assert_match %r|docker exec -it app-mysql mysql -u root|,
+        new_command(:mysql).execute_in_existing_container_over_ssh("mysql", "-u", "root")
+    end
+  end
+
+
+
+  test "logs" do
+    assert_equal \
+      "docker logs app-mysql --timestamps 2>&1",
+      new_command(:mysql).logs.join(" ")
+
+    assert_equal \
+      "docker logs app-mysql  --since 5m  --tail 100 --timestamps 2>&1 | grep 'thing'",
+      new_command(:mysql).logs(since: "5m", lines: 100, grep: "thing").join(" ")
+  end
+
+  test "follow logs" do
+    assert_equal \
+      "ssh -t root@1.1.1.5 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1'",
+      new_command(:mysql).follow_logs
+  end
+
+  test "remove container" do
+    assert_equal \
+      "docker container prune --force --filter label=service=app-mysql",
+      new_command(:mysql).remove_container.join(" ")
+  end
+
+  test "remove image" do
+    assert_equal \
+      "docker image rm --force private.registry/mysql:8.0",
+      new_command(:mysql).remove_image.join(" ")
+  end
+
+  private
+    def new_command(accessory)
+      Mrsk::Commands::Accessory.new(Mrsk::Configuration.new(@config), name: accessory)
+    end
+end

test/commands/app_test.rb

@@ -0,0 +1,328 @@
+require "test_helper"
+
+class CommandsAppTest < ActiveSupport::TestCase
+  setup do
+    ENV["RAILS_MASTER_KEY"] = "456"
+
+    @config = { service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ], env: { "secret" => [ "RAILS_MASTER_KEY" ] } }
+  end
+
+  teardown do
+    ENV.delete("RAILS_MASTER_KEY")
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with hostname" do
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 --hostname myhost -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run(hostname: "myhost").join(" ")
+  end
+
+  test "run with volumes" do
+    @config[:volumes] = ["/local/path:/container/path" ]
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --volume /local/path:/container/path --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom healthcheck path" do
+    @config[:healthcheck] = { "path" => "/healthz" }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/healthz || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom healthcheck command" do
+    @config[:healthcheck] = { "cmd" => "/bin/up" }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"/bin/up\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with role-specific healthcheck options" do
+    @config[:servers] = { "web" => { "hosts" => [ "1.1.1.1" ], "healthcheck" => { "cmd" => "/bin/healthy" } } }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"/bin/healthy\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom options" do
+    @config[:servers] = { "web" => [ "1.1.1.1" ], "jobs" => { "hosts" => [ "1.1.1.2" ], "cmd" => "bin/jobs", "options" => { "mount" => "somewhere", "cap-add" => true } } }
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-jobs-999 -e MRSK_CONTAINER_NAME=\"app-jobs-999\" -e RAILS_MASTER_KEY=\"456\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"jobs\" --mount \"somewhere\" --cap-add dhh/app:999 bin/jobs",
+      new_command(role: "jobs").run.join(" ")
+  end
+
+  test "run with logging config" do
+    @config[:logging] = { "driver" => "local", "options" => { "max-size" => "100m", "max-file" => "3" } }
+
+    assert_equal \
+      "docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-driver \"local\" --log-opt max-size=\"100m\" --log-opt max-file=\"3\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.run.join(" ")
+  end
+
+  test "start" do
+    assert_equal \
+      "docker start app-web-999",
+      new_command.start.join(" ")
+  end
+
+  test "start with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker start app-web-staging-999",
+      new_command.start.join(" ")
+  end
+
+  test "start_or_run" do
+    assert_equal \
+      "docker start app-web-999 || docker run --detach --restart unless-stopped --name app-web-999 -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.start_or_run.join(" ")
+  end
+
+  test "start_or_run with hostname" do
+    assert_equal \
+      "docker start app-web-999 || docker run --detach --restart unless-stopped --name app-web-999 --hostname myhost -e MRSK_CONTAINER_NAME=\"app-web-999\" -e RAILS_MASTER_KEY=\"456\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --log-opt max-size=\"10m\" --label service=\"app\" --label role=\"web\" --label traefik.http.services.app-web.loadbalancer.server.scheme=\"http\" --label traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.middlewares.app-web-retry.retry.attempts=\"5\" --label traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\" --label traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\" dhh/app:999",
+      new_command.start_or_run(hostname: "myhost").join(" ")
+  end
+
+  test "stop" do
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop",
+      new_command.stop.join(" ")
+  end
+
+  test "stop with custom stop wait time" do
+    @config[:stop_wait_time] = 30
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker stop -t 30",
+      new_command.stop.join(" ")
+  end
+
+  test "stop with version" do
+    assert_equal \
+      "docker container ls --all --filter name=^app-web-123$ --quiet | xargs docker stop",
+      new_command.stop(version: "123").join(" ")
+  end
+
+  test "info" do
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web",
+      new_command.info.join(" ")
+  end
+
+  test "info with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.info.join(" ")
+  end
+
+
+  test "logs" do
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs 2>&1",
+      new_command.logs.join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --since 5m 2>&1",
+      new_command.logs(since: "5m").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --tail 100 2>&1",
+      new_command.logs(lines: "100").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --since 5m --tail 100 2>&1",
+      new_command.logs(since: "5m", lines: "100").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs 2>&1 | grep 'my-id'",
+      new_command.logs(grep: "my-id").join(" ")
+
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --since 5m 2>&1 | grep 'my-id'",
+      new_command.logs(since: "5m", grep: "my-id").join(" ")
+  end
+
+  test "follow logs" do
+    assert_match \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1",
+      new_command.follow_logs(host: "app-1")
+
+    assert_match \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest | xargs docker logs --timestamps --tail 10 --follow 2>&1 | grep \"Completed\"",
+      new_command.follow_logs(host: "app-1", grep: "Completed")
+  end
+
+
+  test "execute in new container" do
+    assert_equal \
+      "docker run --rm -e RAILS_MASTER_KEY=\"456\" dhh/app:999 bin/rails db:setup",
+      new_command.execute_in_new_container("bin/rails", "db:setup").join(" ")
+  end
+
+  test "execute in existing container" do
+    assert_equal \
+      "docker exec app-web-999 bin/rails db:setup",
+      new_command.execute_in_existing_container("bin/rails", "db:setup").join(" ")
+  end
+
+  test "execute in new container over ssh" do
+    assert_match %r|docker run -it --rm -e RAILS_MASTER_KEY=\"456\" dhh/app:999 bin/rails c|,
+      new_command.execute_in_new_container_over_ssh("bin/rails", "c", host: "app-1")
+  end
+
+  test "execute in existing container over ssh" do
+    assert_match %r|docker exec -it app-web-999 bin/rails c|,
+      new_command.execute_in_existing_container_over_ssh("bin/rails", "c", host: "app-1")
+  end
+
+  test "run over ssh" do
+    assert_equal "ssh -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with custom user" do
+    @config[:ssh] = { "user" => "app" }
+    assert_equal "ssh -t app@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with proxy" do
+    @config[:ssh] = { "proxy" => "2.2.2.2" }
+    assert_equal "ssh -J root@2.2.2.2 -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with proxy user" do
+    @config[:ssh] = { "proxy" => "app@2.2.2.2" }
+    assert_equal "ssh -J app@2.2.2.2 -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with custom user with proxy" do
+    @config[:ssh] = { "user" => "app", "proxy" => "2.2.2.2" }
+    assert_equal "ssh -J root@2.2.2.2 -t app@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "run over ssh with proxy_command" do
+    @config[:ssh] = { "proxy_command" => "ssh -W %h:%p user@proxy-server" }
+    assert_equal "ssh -o ProxyCommand='ssh -W %h:%p user@proxy-server' -t root@1.1.1.1 'ls'", new_command.run_over_ssh("ls", host: "1.1.1.1")
+  end
+
+  test "current_running_container_id" do
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest",
+      new_command.current_running_container_id.join(" ")
+  end
+
+  test "current_running_container_id with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker ps --quiet --filter label=service=app --filter label=destination=staging --filter label=role=web --filter status=running --filter status=restarting --latest",
+      new_command.current_running_container_id.join(" ")
+  end
+
+  test "container_id_for" do
+    assert_equal \
+      "docker container ls --all --filter name=^app-999$ --quiet",
+      new_command.container_id_for(container_name: "app-999").join(" ")
+  end
+
+  test "current_running_version" do
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | grep -oE \"\\-[^-]+$\" | cut -c 2-",
+      new_command.current_running_version.join(" ")
+  end
+
+  test "list_versions" do
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web --format \"{{.Names}}\" | grep -oE \"\\-[^-]+$\" | cut -c 2-",
+      new_command.list_versions.join(" ")
+
+    assert_equal \
+      "docker ps --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --latest --format \"{{.Names}}\" | grep -oE \"\\-[^-]+$\" | cut -c 2-",
+      new_command.list_versions("--latest", statuses: [ :running, :restarting ]).join(" ")
+  end
+
+  test "list_containers" do
+    assert_equal \
+      "docker container ls --all --filter label=service=app --filter label=role=web",
+      new_command.list_containers.join(" ")
+  end
+
+  test "list_containers with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker container ls --all --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.list_containers.join(" ")
+  end
+
+  test "list_container_names" do
+    assert_equal \
+      "docker container ls --all --filter label=service=app --filter label=role=web --format '{{ .Names }}'",
+      new_command.list_container_names.join(" ")
+  end
+
+  test "remove_container" do
+    assert_equal \
+      "docker container ls --all --filter name=^app-web-999$ --quiet | xargs docker container rm",
+      new_command.remove_container(version: "999").join(" ")
+  end
+
+  test "remove_container with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker container ls --all --filter name=^app-web-staging-999$ --quiet | xargs docker container rm",
+      new_command.remove_container(version: "999").join(" ")
+  end
+
+  test "remove_containers" do
+    assert_equal \
+      "docker container prune --force --filter label=service=app --filter label=role=web",
+      new_command.remove_containers.join(" ")
+  end
+
+  test "remove_containers with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker container prune --force --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.remove_containers.join(" ")
+  end
+
+  test "list_images" do
+    assert_equal \
+      "docker image ls dhh/app",
+      new_command.list_images.join(" ")
+  end
+
+  test "remove_images" do
+    assert_equal \
+      "docker image prune --all --force --filter label=service=app --filter label=role=web",
+      new_command.remove_images.join(" ")
+  end
+
+  test "remove_images with destination" do
+    @destination = "staging"
+    assert_equal \
+      "docker image prune --all --force --filter label=service=app --filter label=destination=staging --filter label=role=web",
+      new_command.remove_images.join(" ")
+  end
+
+  test "tag_current_as_latest" do
+    assert_equal \
+      "docker tag dhh/app:999 dhh/app:latest",
+      new_command.tag_current_as_latest.join(" ")
+  end
+
+  private
+    def new_command(role: "web")
+      Mrsk::Commands::App.new(Mrsk::Configuration.new(@config, destination: @destination, version: "999"), role: role)
+    end
+end

test/commands/auditor_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+require "active_support/testing/time_helpers"
+
+class CommandsAuditorTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::TimeHelpers
+
+  setup do
+    freeze_time
+
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ]
+    }
+
+    @auditor = new_command
+    @performer = `whoami`.strip
+    @recorded_at = Time.now.utc.iso8601
+  end
+
+  test "record" do
+    assert_equal [
+      :echo,
+      "[#{@recorded_at}] [#{@performer}]",
+      "app removed container",
+      ">>", "mrsk-app-audit.log"
+    ], @auditor.record("app removed container")
+  end
+
+  test "record with destination" do
+    new_command(destination: "staging").tap do |auditor|
+      assert_equal [
+        :echo,
+        "[#{@recorded_at}] [#{@performer}] [staging]",
+        "app removed container",
+        ">>", "mrsk-app-staging-audit.log"
+      ], auditor.record("app removed container")
+    end
+  end
+
+  test "record with command details" do
+    new_command(role: "web").tap do |auditor|
+      assert_equal [
+        :echo,
+        "[#{@recorded_at}] [#{@performer}] [web]",
+        "app removed container",
+        ">>", "mrsk-app-audit.log"
+      ], auditor.record("app removed container")
+    end
+  end
+
+  test "record with arg details" do
+    assert_equal [
+      :echo,
+      "[#{@recorded_at}] [#{@performer}] [value]",
+      "app removed container",
+      ">>", "mrsk-app-audit.log"
+    ], @auditor.record("app removed container", detail: "value")
+  end
+
+
+  private
+    def new_command(destination: nil, **details)
+      Mrsk::Commands::Auditor.new(Mrsk::Configuration.new(@config, destination: destination, version: "123"), **details)
+    end
+end

test/commands/builder_test.rb

@@ -0,0 +1,110 @@
+require "test_helper"
+
+class CommandsBuilderTest < ActiveSupport::TestCase
+  setup do
+    @config = { service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ] }
+  end
+
+  test "target multiarch by default" do
+    builder = new_builder_command(builder: { "cache" => { "type" => "gha" }})
+    assert_equal "multiarch", builder.name
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder mrsk-app-multiarch -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "target native when multiarch is off" do
+    builder = new_builder_command(builder: { "multiarch" => false })
+    assert_equal "native", builder.name
+    assert_equal \
+      "docker build -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --file Dockerfile . && docker push dhh/app:123 && docker push dhh/app:latest",
+      builder.push.join(" ")
+  end
+
+  test "target native cached when multiarch is off and cache is set" do
+    builder = new_builder_command(builder: { "multiarch" => false, "cache" => { "type" => "gha" }})
+    assert_equal "native/cached", builder.name
+    assert_equal \
+      "docker buildx build --push -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "target multiarch remote when local and remote is set" do
+    builder = new_builder_command(builder: { "local" => { }, "remote" => { }, "cache" => { "type" => "gha" } })
+    assert_equal "multiarch/remote", builder.name
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder mrsk-app-multiarch-remote -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "target native remote when only remote is set" do
+    builder = new_builder_command(builder: { "remote" => { "arch" => "amd64" }, "cache" => { "type" => "gha" } })
+    assert_equal "native/remote", builder.name
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64 --builder mrsk-app-native-remote -t dhh/app:123 -t dhh/app:latest --cache-to type=gha --cache-from type=gha --label service=\"app\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "build args" do
+    builder = new_builder_command(builder: { "args" => { "a" => 1, "b" => 2 } })
+    assert_equal \
+      "-t dhh/app:123 -t dhh/app:latest --label service=\"app\" --build-arg a=\"1\" --build-arg b=\"2\" --file Dockerfile",
+      builder.target.build_options.join(" ")
+  end
+
+  test "build secrets" do
+    builder = new_builder_command(builder: { "secrets" => ["token_a", "token_b"] })
+    assert_equal \
+      "-t dhh/app:123 -t dhh/app:latest --label service=\"app\" --secret id=\"token_a\" --secret id=\"token_b\" --file Dockerfile",
+      builder.target.build_options.join(" ")
+  end
+
+  test "build dockerfile" do
+    Pathname.any_instance.expects(:exist?).returns(true).once
+    builder = new_builder_command(builder: { "dockerfile" => "Dockerfile.xyz" })
+    assert_equal \
+      "-t dhh/app:123 -t dhh/app:latest --label service=\"app\" --file Dockerfile.xyz",
+      builder.target.build_options.join(" ")
+  end
+
+  test "missing dockerfile" do
+    Pathname.any_instance.expects(:exist?).returns(false).once
+    builder = new_builder_command(builder: { "dockerfile" => "Dockerfile.xyz" })
+    assert_raises(Mrsk::Commands::Builder::Base::BuilderError) do
+      builder.target.build_options.join(" ")
+    end
+  end
+
+  test "build context" do
+    builder = new_builder_command(builder: { "context" => ".." })
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder mrsk-app-multiarch -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --file Dockerfile ..",
+      builder.push.join(" ")
+  end
+
+  test "native push with build args" do
+    builder = new_builder_command(builder: { "multiarch" => false, "args" => { "a" => 1, "b" => 2 } })
+    assert_equal \
+      "docker build -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --build-arg a=\"1\" --build-arg b=\"2\" --file Dockerfile . && docker push dhh/app:123 && docker push dhh/app:latest",
+      builder.push.join(" ")
+  end
+
+  test "multiarch push with build args" do
+    builder = new_builder_command(builder: { "args" => { "a" => 1, "b" => 2 } })
+    assert_equal \
+      "docker buildx build --push --platform linux/amd64,linux/arm64 --builder mrsk-app-multiarch -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --build-arg a=\"1\" --build-arg b=\"2\" --file Dockerfile .",
+      builder.push.join(" ")
+  end
+
+  test "native push with build secrets" do
+    builder = new_builder_command(builder: { "multiarch" => false, "secrets" => [ "a", "b" ] })
+    assert_equal \
+      "docker build -t dhh/app:123 -t dhh/app:latest --label service=\"app\" --secret id=\"a\" --secret id=\"b\" --file Dockerfile . && docker push dhh/app:123 && docker push dhh/app:latest",
+      builder.push.join(" ")
+  end
+
+  private
+    def new_builder_command(additional_config = {})
+      Mrsk::Commands::Builder.new(Mrsk::Configuration.new(@config.merge(additional_config), version: "123"))
+    end
+end

test/commands/docker_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+class CommandsDockerTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ]
+    }
+    @docker = Mrsk::Commands::Docker.new(Mrsk::Configuration.new(@config))
+  end
+
+  test "install" do
+    assert_equal "curl -fsSL https://get.docker.com | sh", @docker.install.join(" ")
+  end
+
+  test "installed?" do
+    assert_equal "docker -v", @docker.installed?.join(" ")
+  end
+
+  test "running?" do
+    assert_equal "docker version", @docker.running?.join(" ")
+  end
+
+  test "superuser?" do
+    assert_equal '[ "${EUID:-$(id -u)}" -eq 0 ]', @docker.superuser?.join(" ")
+  end
+end

test/commands/healthcheck_test.rb

@@ -0,0 +1,106 @@
+require "test_helper"
+
+class CommandsHealthcheckTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3000 --label service=healthcheck-app -e MRSK_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom port" do
+    @config[:healthcheck] = { "port" => 3001 }
+
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3001 --label service=healthcheck-app -e MRSK_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"curl -f http://localhost:3001/up || exit 1\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker run --detach --name healthcheck-app-staging-123 --publish 3999:3000 --label service=healthcheck-app-staging -e MRSK_CONTAINER_NAME=\"healthcheck-app-staging\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom healthcheck" do
+    @config[:healthcheck] = { "cmd" => "/bin/up" }
+
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3000 --label service=healthcheck-app -e MRSK_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"/bin/up\" --health-interval \"1s\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "run with custom options" do
+    @config[:servers] = { "web" => { "hosts" => [ "1.1.1.1" ], "options" => { "mount" => "somewhere" } } }
+    assert_equal \
+      "docker run --detach --name healthcheck-app-123 --publish 3999:3000 --label service=healthcheck-app -e MRSK_CONTAINER_NAME=\"healthcheck-app\" --health-cmd \"curl -f http://localhost:3000/up || exit 1\" --health-interval \"1s\" --mount \"somewhere\" dhh/app:123",
+      new_command.run.join(" ")
+  end
+
+  test "status" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'",
+      new_command.status.join(" ")
+  end
+
+  test "container_health_log" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker inspect --format '{{json .State.Health}}'",
+      new_command.container_health_log.join(" ")
+  end
+
+  test "stop" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker stop",
+      new_command.stop.join(" ")
+  end
+
+  test "stop with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-staging-123$ --quiet | xargs docker stop",
+      new_command.stop.join(" ")
+  end
+
+  test "remove" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker container rm",
+      new_command.remove.join(" ")
+  end
+
+  test "remove with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-staging-123$ --quiet | xargs docker container rm",
+      new_command.remove.join(" ")
+  end
+
+  test "logs" do
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-123$ --quiet | xargs docker logs --tail 50 2>&1",
+      new_command.logs.join(" ")
+  end
+
+  test "logs with destination" do
+    @destination = "staging"
+
+    assert_equal \
+      "docker container ls --all --filter name=^healthcheck-app-staging-123$ --quiet | xargs docker logs --tail 50 2>&1",
+      new_command.logs.join(" ")
+  end
+
+  private
+    def new_command
+      Mrsk::Commands::Healthcheck.new(Mrsk::Configuration.new(@config, destination: @destination, version: "123"))
+    end
+end

test/commands/hook_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class CommandsHookTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::TimeHelpers
+
+  setup do
+    freeze_time
+
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+
+    @performer = `whoami`.strip
+    @recorded_at = Time.now.utc.iso8601
+  end
+
+  test "run" do
+    assert_equal [
+      ".mrsk/hooks/foo",
+      { env: {
+        "MRSK_RECORDED_AT" => @recorded_at,
+        "MRSK_PERFORMER" => @performer,
+        "MRSK_VERSION" => "123",
+        "MRSK_SERVICE_VERSION" => "app@123" } }
+    ], new_command.run("foo")
+  end
+
+  test "run with custom hooks_path" do
+    assert_equal [
+      "custom/hooks/path/foo",
+      { env: {
+        "MRSK_RECORDED_AT" => @recorded_at,
+        "MRSK_PERFORMER" => @performer,
+        "MRSK_VERSION" => "123",
+        "MRSK_SERVICE_VERSION" => "app@123" } }
+    ], new_command(hooks_path: "custom/hooks/path").run("foo")
+  end
+
+  private
+    def new_command(**extra_config)
+      Mrsk::Commands::Hook.new(Mrsk::Configuration.new(@config.merge(**extra_config), version: "123"))
+    end
+end

test/commands/lock_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class CommandsLockTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+  end
+
+  test "status" do
+    assert_equal \
+      "stat mrsk_lock-app > /dev/null && cat mrsk_lock-app/details | base64 -d",
+      new_command.status.join(" ")
+  end
+
+  test "acquire" do
+    assert_match \
+      /mkdir mrsk_lock-app && echo ".*" > mrsk_lock-app\/details/m,
+      new_command.acquire("Hello", "123").join(" ")
+  end
+
+  test "release" do
+    assert_match \
+      "rm mrsk_lock-app/details && rm -r mrsk_lock-app",
+      new_command.release.join(" ")
+  end
+
+  private
+    def new_command
+      Mrsk::Commands::Lock.new(Mrsk::Configuration.new(@config, version: "123"))
+    end
+end

test/commands/prune_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class CommandsPruneTest < ActiveSupport::TestCase
+  setup do
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+  end
+
+  test "dangling images" do
+    assert_equal \
+      "docker image prune --force --filter label=service=app --filter dangling=true",
+      new_command.dangling_images.join(" ")
+  end
+
+  test "tagged images" do
+    assert_equal \
+      "docker image ls --filter label=service=app --format '{{.ID}} {{.Repository}}:{{.Tag}}' | grep -v -w \"$(docker container ls -a --format '{{.Image}}\\|' --filter label=service=app | tr -d '\\n')dhh/app:latest\\|dhh/app:<none>\" | while read image tag; do docker rmi $tag; done",
+      new_command.tagged_images.join(" ")
+  end
+
+  test "containers" do
+    assert_equal \
+      "docker ps -q -a --filter label=service=app --filter status=created --filter status=exited --filter status=dead | tail -n +6 | while read container_id; do docker rm $container_id; done",
+      new_command.containers.join(" ")
+  end
+
+  private
+    def new_command
+      Mrsk::Commands::Prune.new(Mrsk::Configuration.new(@config, version: "123"))
+    end
+end

test/commands/registry_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class CommandsRegistryTest < ActiveSupport::TestCase
+  setup do
+    @config = { service: "app",
+      image: "dhh/app",
+      registry: { "username" => "dhh",
+        "password" => "secret",
+        "server" => "hub.docker.com"
+      },
+      servers: [ "1.1.1.1" ]
+    }
+    @registry = Mrsk::Commands::Registry.new Mrsk::Configuration.new(@config)
+  end
+
+  test "registry login" do
+    assert_equal \
+      "docker login hub.docker.com -u dhh -p secret",
+      @registry.login.join(" ")
+  end
+
+  test "registry login with ENV password" do
+    ENV["MRSK_REGISTRY_PASSWORD"] = "more-secret"
+    @config[:registry]["password"] = [ "MRSK_REGISTRY_PASSWORD" ]
+
+    assert_equal \
+      "docker login hub.docker.com -u dhh -p more-secret",
+      @registry.login.join(" ")
+  ensure
+    ENV.delete("MRSK_REGISTRY_PASSWORD")
+  end
+
+  test "registry login with ENV username" do
+    ENV["MRSK_REGISTRY_USERNAME"] = "also-secret"
+    @config[:registry]["username"] = [ "MRSK_REGISTRY_USERNAME" ]
+
+    assert_equal \
+      "docker login hub.docker.com -u also-secret -p secret",
+      @registry.login.join(" ")
+  ensure
+    ENV.delete("MRSK_REGISTRY_USERNAME")
+  end
+
+  test "registry logout" do
+    assert_equal \
+      "docker logout hub.docker.com",
+      @registry.logout.join(" ")
+  end
+end

test/commands/traefik_test.rb

@@ -0,0 +1,179 @@
+require "test_helper"
+
+class CommandsTraefikTest < ActiveSupport::TestCase
+  setup do
+    @image = "traefik:test"
+
+    @config = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" }, servers: [ "1.1.1.1" ],
+      traefik: { "image" => @image, "args" => { "accesslog.format" => "json", "api.insecure" => true, "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
+    }
+
+    ENV["EXAMPLE_API_KEY"] = "456"
+  end
+
+  teardown do
+    ENV.delete("EXAMPLE_API_KEY")
+  end
+
+  test "run" do
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+
+    @config[:traefik]["host_port"] = "8080"
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 8080:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with ports configured" do
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+
+    @config[:traefik]["options"] = {"publish" => %w[9000:9000 9001:9001]}
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" --publish \"9000:9000\" --publish \"9001:9001\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with volumes configured" do
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+
+    @config[:traefik]["options"] = {"volume" => %w[./letsencrypt/acme.json:/letsencrypt/acme.json] }
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" --volume \"./letsencrypt/acme.json:/letsencrypt/acme.json\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with several options configured" do
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+
+    @config[:traefik]["options"] = {"volume" => %w[./letsencrypt/acme.json:/letsencrypt/acme.json], "publish" => %w[8080:8080], "memory" => "512m"}
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" --volume \"./letsencrypt/acme.json:/letsencrypt/acme.json\" --publish \"8080:8080\" --memory \"512m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with labels configured" do
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+
+    @config[:traefik]["labels"] = { "traefik.http.routers.dashboard.service" => "api@internal", "traefik.http.routers.dashboard.middlewares" => "auth" }
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" --label traefik.http.routers.dashboard.service=\"api@internal\" --label traefik.http.routers.dashboard.middlewares=\"auth\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with env configured" do
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+
+    @config[:traefik]["env"] = { "secret" => %w[EXAMPLE_API_KEY] }
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock -e EXAMPLE_API_KEY=\"456\" --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run without configuration" do
+    @config.delete(:traefik)
+
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{Mrsk::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with logging config" do
+    @config[:logging] = { "driver" => "local", "options" => { "max-size" => "100m", "max-file" => "3" } }
+
+    assert_equal \
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-driver \"local\" --log-opt max-size=\"100m\" --log-opt max-file=\"3\" #{@image} --providers.docker --log.level=\"DEBUG\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "run with default args overriden" do
+    @config[:traefik]["args"]["log.level"] = "ERROR"
+
+    assert_equal \
+    "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --log-opt max-size=\"10m\" #{@image} --providers.docker --log.level=\"ERROR\" --accesslog.format=\"json\" --api.insecure --metrics.prometheus.buckets=\"0.1,0.3,1.2,5.0\"",
+      new_command.run.join(" ")
+  end
+
+  test "traefik start" do
+    assert_equal \
+      "docker container start traefik",
+      new_command.start.join(" ")
+  end
+
+  test "traefik stop" do
+    assert_equal \
+      "docker container stop traefik",
+      new_command.stop.join(" ")
+  end
+
+  test "traefik info" do
+    assert_equal \
+      "docker ps --filter name=^traefik$",
+      new_command.info.join(" ")
+  end
+
+  test "traefik logs" do
+    assert_equal \
+      "docker logs traefik --timestamps 2>&1",
+      new_command.logs.join(" ")
+  end
+
+  test "traefik logs since 2h" do
+    assert_equal \
+      "docker logs traefik  --since 2h --timestamps 2>&1",
+      new_command.logs(since: '2h').join(" ")
+  end
+
+  test "traefik logs last 10 lines" do
+    assert_equal \
+      "docker logs traefik  --tail 10 --timestamps 2>&1",
+      new_command.logs(lines: 10).join(" ")
+  end
+
+  test "traefik logs with grep hello!" do
+    assert_equal \
+      "docker logs traefik --timestamps 2>&1 | grep 'hello!'",
+      new_command.logs(grep: 'hello!').join(" ")
+  end
+
+  test "traefik remove container" do
+    assert_equal \
+      "docker container prune --force --filter label=org.opencontainers.image.title=Traefik",
+      new_command.remove_container.join(" ")
+  end
+
+  test "traefik remove image" do
+    assert_equal \
+      "docker image prune --all --force --filter label=org.opencontainers.image.title=Traefik",
+      new_command.remove_image.join(" ")
+  end
+
+  test "traefik follow logs" do
+    assert_equal \
+      "ssh -t root@1.1.1.1 'docker logs traefik --timestamps --tail 10 --follow 2>&1'",
+      new_command.follow_logs(host: @config[:servers].first)
+  end
+
+  test "traefik follow logs with grep hello!" do
+    assert_equal \
+      "ssh -t root@1.1.1.1 'docker logs traefik --timestamps --tail 10 --follow 2>&1 | grep \"hello!\"'",
+      new_command.follow_logs(host: @config[:servers].first, grep: 'hello!')
+  end
+
+  private
+    def new_command
+      Mrsk::Commands::Traefik.new(Mrsk::Configuration.new(@config, version: "123"))
+    end
+end

test/configuration/accessory_test.rb

@@ -0,0 +1,148 @@
+require "test_helper"
+
+class ConfigurationAccessoryTest < ActiveSupport::TestCase
+  setup do
+    @deploy = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" },
+      servers: {
+        "web" => [ "1.1.1.1", "1.1.1.2" ],
+        "workers" => [ "1.1.1.3", "1.1.1.4" ]
+      },
+      env: { "REDIS_URL" => "redis://x/y" },
+      accessories: {
+        "mysql" => {
+          "image" => "mysql:8.0",
+          "host" => "1.1.1.5",
+          "port" => "3306",
+          "env" => {
+            "clear" => {
+              "MYSQL_ROOT_HOST" => "%"
+            },
+            "secret" => [
+              "MYSQL_ROOT_PASSWORD"
+            ],
+          },
+          "files" => [
+            "config/mysql/my.cnf:/etc/mysql/my.cnf",
+            "db/structure.sql:/docker-entrypoint-initdb.d/structure.sql"
+          ],
+          "directories" => [
+            "data:/var/lib/mysql"
+          ]
+        },
+        "redis" => {
+          "image" => "redis:latest",
+          "hosts" => [ "1.1.1.6", "1.1.1.7" ],
+          "port" => "6379:6379",
+          "labels" => {
+            "cache" => true
+          },
+          "env" => {
+            "SOMETHING" => "else"
+          },
+          "volumes" => [
+            "/var/lib/redis:/data"
+          ],
+          "options" => {
+            "cpus" => 4,
+            "memory" => "2GB"
+          }
+        },
+        "monitoring" => {
+          "image" => "monitoring:latest",
+          "roles" => [ "web" ],
+          "port" => "4321:4321",
+          "labels" => {
+            "cache" => true
+          },
+          "env" => {
+            "STATSD_PORT" => "8126"
+          },
+          "options" => {
+            "cpus" => 4,
+            "memory" => "2GB"
+          }
+        }
+      }
+    }
+
+    @config = Mrsk::Configuration.new(@deploy)
+  end
+
+  test "service name" do
+    assert_equal "app-mysql", @config.accessory(:mysql).service_name
+    assert_equal "app-redis", @config.accessory(:redis).service_name
+  end
+
+  test "port" do
+    assert_equal "3306:3306", @config.accessory(:mysql).port
+    assert_equal "6379:6379", @config.accessory(:redis).port
+  end
+
+  test "host" do
+    assert_equal ["1.1.1.5"], @config.accessory(:mysql).hosts
+    assert_equal ["1.1.1.6", "1.1.1.7"], @config.accessory(:redis).hosts
+    assert_equal ["1.1.1.1", "1.1.1.2"], @config.accessory(:monitoring).hosts
+  end
+
+  test "missing host" do
+    @deploy[:accessories]["mysql"]["host"] = nil
+    @config = Mrsk::Configuration.new(@deploy)
+
+    assert_raises(ArgumentError) do
+      @config.accessory(:mysql).hosts
+    end
+  end
+
+  test "setting host, hosts and roles" do
+    @deploy[:accessories]["mysql"]["hosts"] = true
+    @deploy[:accessories]["mysql"]["roles"] = true
+    @config = Mrsk::Configuration.new(@deploy)
+
+    exception = assert_raises(ArgumentError) do
+      @config.accessory(:mysql).hosts
+    end
+    assert_equal "Specify one of `host`, `hosts` or `roles` for accessory `mysql`", exception.message
+  end
+
+  test "label args" do
+    assert_equal ["--label", "service=\"app-mysql\""], @config.accessory(:mysql).label_args
+    assert_equal ["--label", "service=\"app-redis\"", "--label", "cache=\"true\""], @config.accessory(:redis).label_args
+  end
+
+  test "env args with secret" do
+    ENV["MYSQL_ROOT_PASSWORD"] = "secret123"
+
+    @config.accessory(:mysql).env_args.tap do |env_args|
+      assert_equal ["-e", "MYSQL_ROOT_PASSWORD=\"secret123\"", "-e", "MYSQL_ROOT_HOST=\"%\""], Mrsk::Utils.unredacted(env_args)
+      assert_equal ["-e", "MYSQL_ROOT_PASSWORD=[REDACTED]", "-e", "MYSQL_ROOT_HOST=\"%\""], Mrsk::Utils.redacted(env_args)
+    end
+  ensure
+    ENV["MYSQL_ROOT_PASSWORD"] = nil
+  end
+
+  test "env args without secret" do
+    assert_equal ["-e", "SOMETHING=\"else\""], @config.accessory(:redis).env_args
+  end
+
+  test "volume args" do
+    assert_equal ["--volume", "$PWD/app-mysql/etc/mysql/my.cnf:/etc/mysql/my.cnf", "--volume", "$PWD/app-mysql/docker-entrypoint-initdb.d/structure.sql:/docker-entrypoint-initdb.d/structure.sql", "--volume", "$PWD/app-mysql/data:/var/lib/mysql"], @config.accessory(:mysql).volume_args
+    assert_equal ["--volume", "/var/lib/redis:/data"], @config.accessory(:redis).volume_args
+  end
+
+  test "dynamic file expansion" do
+    @deploy[:accessories]["mysql"]["files"] << "test/fixtures/files/structure.sql.erb:/docker-entrypoint-initdb.d/structure.sql"
+    @config = Mrsk::Configuration.new(@deploy)
+
+    assert_match "This was dynamically expanded", @config.accessory(:mysql).files.keys[2].read
+    assert_match "%", @config.accessory(:mysql).files.keys[2].read
+  end
+
+  test "directories" do
+    assert_equal({"$PWD/app-mysql/data"=>"/var/lib/mysql"}, @config.accessory(:mysql).directories)
+  end
+
+  test "options" do
+    assert_equal ["--cpus", "\"4\"", "--memory", "\"2GB\""], @config.accessory(:redis).option_args
+  end
+end

test/configuration/builder_test.rb

@@ -0,0 +1,151 @@
+require "test_helper"
+
+class ConfigurationBuilderTest < ActiveSupport::TestCase
+  setup do
+    @deploy = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" },
+      servers: [ "1.1.1.1" ]
+    }
+
+    @config = Mrsk::Configuration.new(@deploy)
+
+    @deploy_with_builder_option = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" },
+      servers: [ "1.1.1.1" ],
+      builder: {}
+    }
+
+    @config_with_builder_option = Mrsk::Configuration.new(@deploy_with_builder_option)
+  end
+
+  test "multiarch?" do
+    assert_equal true, @config.builder.multiarch?
+  end
+
+  test "setting multiarch to false" do
+    @deploy_with_builder_option[:builder] = { "multiarch" => false }
+
+    assert_equal false, @config_with_builder_option.builder.multiarch?
+  end
+
+  test "local?" do
+    assert_equal false, @config.builder.local?
+  end
+
+  test "remote?" do
+    assert_equal false, @config.builder.remote?
+  end
+
+  test "remote_arch" do
+    assert_nil @config.builder.remote_arch
+  end
+
+  test "remote_host" do
+    assert_nil @config.builder.remote_host
+  end
+
+  test "remote config is missing when local is specified" do
+    @deploy_with_builder_option[:builder] = { "local" => { "arch" => "arm64", "host" => "unix:///Users/<%= `whoami`.strip %>/.docker/run/docker.sock" } }
+
+    assert_raises(ArgumentError) do
+      @config_with_builder_option.builder
+    end
+  end
+
+  test "setting both local and remote configs" do
+    @deploy_with_builder_option[:builder] = {
+      "local" => { "arch" => "arm64", "host" => "unix:///Users/<%= `whoami`.strip %>/.docker/run/docker.sock" },
+      "remote" => { "arch" => "amd64", "host" => "ssh://root@192.168.0.1" }
+    }
+
+    assert_equal true, @config_with_builder_option.builder.local?
+    assert_equal true, @config_with_builder_option.builder.remote?
+
+    assert_equal "amd64", @config_with_builder_option.builder.remote_arch
+    assert_equal "ssh://root@192.168.0.1", @config_with_builder_option.builder.remote_host
+
+    assert_equal "arm64", @config_with_builder_option.builder.local_arch
+    assert_equal "unix:///Users/<%= `whoami`.strip %>/.docker/run/docker.sock", @config_with_builder_option.builder.local_host
+  end
+
+  test "cached?" do
+    assert_equal false, @config.builder.cached?
+  end
+
+  test "invalid cache type specified" do
+    @deploy_with_builder_option[:builder] = { "cache" => { "type" => "invalid" } }
+
+    assert_raises(ArgumentError) do
+      @config_with_builder_option.builder
+    end
+  end
+
+  test "cache_from" do
+    assert_nil @config.builder.cache_from
+  end
+
+  test "cache_to" do
+    assert_nil @config.builder.cache_to
+  end
+
+  test "setting gha cache" do
+    @deploy_with_builder_option[:builder] = { "cache" => { "type" => "gha", "options" => "mode=max" } }
+
+    assert_equal "type=gha", @config_with_builder_option.builder.cache_from
+    assert_equal "type=gha,mode=max", @config_with_builder_option.builder.cache_to
+  end
+
+  test "setting registry cache" do
+    @deploy_with_builder_option[:builder] = { "cache" => { "type" => "registry", "options" => "mode=max,image-manifest=true,oci-mediatypes=true" } }
+
+    assert_equal "type=registry,ref=/dhh/app-build-cache", @config_with_builder_option.builder.cache_from
+    assert_equal "type=registry,mode=max,image-manifest=true,oci-mediatypes=true,ref=/dhh/app-build-cache", @config_with_builder_option.builder.cache_to
+  end
+
+  test "setting registry cache with image" do
+    @deploy_with_builder_option[:builder] = { "cache" => { "type" => "registry", "image" => "mrsk", "options" => "mode=max" } }
+
+    assert_equal "type=registry,ref=/mrsk", @config_with_builder_option.builder.cache_from
+    assert_equal "type=registry,mode=max,ref=/mrsk", @config_with_builder_option.builder.cache_to
+  end
+
+  test "args" do
+    assert_equal({}, @config.builder.args)
+  end
+
+  test "setting args" do
+    @deploy_with_builder_option[:builder] = { "args" => { "key" => "value" } }
+
+    assert_equal({ "key" => "value" }, @config_with_builder_option.builder.args)
+  end
+
+  test "secrets" do
+    assert_equal [], @config.builder.secrets
+  end
+
+  test "setting secrets" do
+    @deploy_with_builder_option[:builder] = { "secrets" => ["GITHUB_TOKEN"] }
+
+    assert_equal ["GITHUB_TOKEN"], @config_with_builder_option.builder.secrets
+  end
+
+  test "dockerfile" do
+    assert_equal "Dockerfile", @config.builder.dockerfile
+  end
+
+  test "setting dockerfile" do
+    @deploy_with_builder_option[:builder] = { "dockerfile" => "Dockerfile.dev" }
+
+    assert_equal "Dockerfile.dev", @config_with_builder_option.builder.dockerfile
+  end
+
+  test "context" do
+    assert_equal ".", @config.builder.context
+  end
+
+  test "setting context" do
+    @deploy_with_builder_option[:builder] = { "context" => ".." }
+
+    assert_equal "..", @config_with_builder_option.builder.context
+  end
+end

test/configuration/role_test.rb

@@ -0,0 +1,149 @@
+require "test_helper"
+
+class ConfigurationRoleTest < ActiveSupport::TestCase
+  setup do
+    @deploy = {
+      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" },
+      servers: [ "1.1.1.1", "1.1.1.2" ],
+      env: { "REDIS_URL" => "redis://x/y" }
+    }
+
+    @config = Mrsk::Configuration.new(@deploy)
+
+    @deploy_with_roles = @deploy.dup.merge({
+      servers: {
+        "web" => [ "1.1.1.1", "1.1.1.2" ],
+        "workers" => {
+          "hosts" => [ "1.1.1.3", "1.1.1.4" ],
+          "cmd" => "bin/jobs",
+          "env" => {
+            "REDIS_URL" => "redis://a/b",
+            "WEB_CONCURRENCY" => 4
+          }
+        }
+      }
+    })
+
+    @config_with_roles = Mrsk::Configuration.new(@deploy_with_roles)
+  end
+
+  test "hosts" do
+    assert_equal [ "1.1.1.1", "1.1.1.2" ], @config.role(:web).hosts
+    assert_equal [ "1.1.1.3", "1.1.1.4" ], @config_with_roles.role(:workers).hosts
+  end
+
+  test "cmd" do
+    assert_nil @config.role(:web).cmd
+    assert_equal "bin/jobs", @config_with_roles.role(:workers).cmd
+  end
+
+  test "label args" do
+    assert_equal [ "--label", "service=\"app\"", "--label", "role=\"workers\"" ], @config_with_roles.role(:workers).label_args
+  end
+
+  test "special label args for web" do
+    assert_equal [ "--label", "service=\"app\"", "--label", "role=\"web\"", "--label", "traefik.http.services.app-web.loadbalancer.server.scheme=\"http\"", "--label", "traefik.http.routers.app-web.rule=\"PathPrefix(\\`/\\`)\"", "--label", "traefik.http.middlewares.app-web-retry.retry.attempts=\"5\"", "--label", "traefik.http.middlewares.app-web-retry.retry.initialinterval=\"500ms\"", "--label", "traefik.http.routers.app-web.middlewares=\"app-web-retry@docker\"" ], @config.role(:web).label_args
+  end
+
+  test "custom labels" do
+    @deploy[:labels] = { "my.custom.label" => "50" }
+    assert_equal "50", @config.role(:web).labels["my.custom.label"]
+  end
+
+  test "custom labels via role specialization" do
+    @deploy_with_roles[:labels] = { "my.custom.label" => "50" }
+    @deploy_with_roles[:servers]["workers"]["labels"] = { "my.custom.label" => "70" }
+    assert_equal "70", @config_with_roles.role(:workers).labels["my.custom.label"]
+  end
+
+  test "overwriting default traefik label" do
+    @deploy[:labels] = { "traefik.http.routers.app-web.rule" => "\"Host(\\`example.com\\`) || (Host(\\`example.org\\`) && Path(\\`/traefik\\`))\"" }
+    assert_equal "\"Host(\\`example.com\\`) || (Host(\\`example.org\\`) && Path(\\`/traefik\\`))\"", @config.role(:web).labels["traefik.http.routers.app-web.rule"]
+  end
+
+  test "default traefik label on non-web role" do
+    config = Mrsk::Configuration.new(@deploy_with_roles.tap { |c|
+      c[:servers]["beta"] = { "traefik" => "true", "hosts" => [ "1.1.1.5" ] }
+    })
+
+    assert_equal [ "--label", "service=\"app\"", "--label", "role=\"beta\"", "--label", "traefik.http.services.app-beta.loadbalancer.server.scheme=\"http\"", "--label", "traefik.http.routers.app-beta.rule=\"PathPrefix(\\`/\\`)\"", "--label", "traefik.http.middlewares.app-beta-retry.retry.attempts=\"5\"", "--label", "traefik.http.middlewares.app-beta-retry.retry.initialinterval=\"500ms\"", "--label", "traefik.http.routers.app-beta.middlewares=\"app-beta-retry@docker\"" ], config.role(:beta).label_args
+  end
+
+  test "env overwritten by role" do
+    assert_equal "redis://a/b", @config_with_roles.role(:workers).env["REDIS_URL"]
+    assert_equal ["-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], @config_with_roles.role(:workers).env_args
+  end
+
+  test "env secret overwritten by role" do
+    @deploy_with_roles[:env] = {
+      "clear" => {
+        "REDIS_URL" => "redis://a/b"
+      },
+      "secret" => [
+        "REDIS_PASSWORD"
+      ]
+    }
+
+    @deploy_with_roles[:servers]["workers"]["env"] = {
+      "clear" => {
+        "REDIS_URL" => "redis://a/b",
+        "WEB_CONCURRENCY" => 4
+      },
+      "secret" => [
+        "DB_PASSWORD"
+      ]
+    }
+
+    ENV["REDIS_PASSWORD"] = "secret456"
+    ENV["DB_PASSWORD"] = "secret&\"123"
+
+    @config_with_roles.role(:workers).env_args.tap do |env_args|
+      assert_equal ["-e", "REDIS_PASSWORD=\"secret456\"", "-e", "DB_PASSWORD=\"secret&\\\"123\"", "-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], Mrsk::Utils.unredacted(env_args)
+      assert_equal ["-e", "REDIS_PASSWORD=[REDACTED]", "-e", "DB_PASSWORD=[REDACTED]", "-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], Mrsk::Utils.redacted(env_args)
+    end
+  ensure
+    ENV["REDIS_PASSWORD"] = nil
+    ENV["DB_PASSWORD"] = nil
+  end
+
+  test "env secrets only in role" do
+    @deploy_with_roles[:servers]["workers"]["env"] = {
+      "clear" => {
+        "REDIS_URL" => "redis://a/b",
+        "WEB_CONCURRENCY" => 4
+      },
+      "secret" => [
+        "DB_PASSWORD"
+      ]
+    }
+
+    ENV["DB_PASSWORD"] = "secret123"
+
+    @config_with_roles.role(:workers).env_args.tap do |env_args|
+      assert_equal ["-e", "DB_PASSWORD=\"secret123\"", "-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], Mrsk::Utils.unredacted(env_args)
+      assert_equal ["-e", "DB_PASSWORD=[REDACTED]", "-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], Mrsk::Utils.redacted(env_args)
+    end
+  ensure
+    ENV["DB_PASSWORD"] = nil
+  end
+
+  test "env secrets only at top level" do
+    @deploy_with_roles[:env] = {
+      "clear" => {
+        "REDIS_URL" => "redis://a/b"
+      },
+      "secret" => [
+        "REDIS_PASSWORD"
+      ]
+    }
+
+    ENV["REDIS_PASSWORD"] = "secret456"
+
+    @config_with_roles.role(:workers).env_args.tap do |env_args|
+      assert_equal ["-e", "REDIS_PASSWORD=\"secret456\"", "-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], Mrsk::Utils.unredacted(env_args)
+      assert_equal ["-e", "REDIS_PASSWORD=[REDACTED]", "-e", "REDIS_URL=\"redis://a/b\"", "-e", "WEB_CONCURRENCY=\"4\""], Mrsk::Utils.redacted(env_args)
+    end
+  ensure
+    ENV["REDIS_PASSWORD"] = nil
+  end
+end

test/configuration_role_test.rb

@@ -1,45 +0,0 @@
-require "test_helper"
-require "mrsk/configuration"
-
-ENV["VERSION"] = "123"
-
-class ConfigurationRoleTest < ActiveSupport::TestCase
-  setup do
-    @deploy = {
-      service: "app", image: "dhh/app", registry: { "username" => "dhh", "password" => "secret" },
-      servers: [ "1.1.1.1", "1.1.1.2" ]
-    }
-
-    @config = Mrsk::Configuration.new(@deploy)
-
-    @deploy_with_roles = @deploy.dup.merge({
-      servers: {
-        "web" => [ "1.1.1.1", "1.1.1.2" ],
-        "workers" => {
-          "hosts" => [ "1.1.1.3", "1.1.1.4" ],
-          "cmd" => "bin/jobs"
-        }
-      }
-    })
-
-    @config_with_roles = Mrsk::Configuration.new(@deploy_with_roles)
-  end
-
-  test "hosts" do
-    assert_equal [ "1.1.1.1", "1.1.1.2" ], @config.role(:web).hosts
-    assert_equal [ "1.1.1.3", "1.1.1.4" ], @config_with_roles.role(:workers).hosts
-  end
-
-  test "label args" do
-    assert_equal [ "--label", "service=app", "--label", "role=workers" ], @config_with_roles.role(:workers).label_args
-  end
-
-  test "special label args for web" do
-    assert_equal [ "--label", "service=app", "--label", "role=web", "--label", "traefik.http.routers.app.rule='PathPrefix(`/`)'", "--label", "traefik.http.services.app.loadbalancer.healthcheck.path=/up", "--label", "traefik.http.services.app.loadbalancer.healthcheck.interval=1s", "--label", "traefik.http.middlewares.app.retry.attempts=3", "--label", "traefik.http.middlewares.app.retry.initialinterval=500ms"], @config.role(:web).label_args
-  end
-
-  test "cmd" do
-    assert_nil @config.role(:web).cmd
-    assert_equal "bin/jobs", @config_with_roles.role(:workers).cmd
-  end
-end

test/configuration_test.rb

@@ -1,34 +1,44 @@
 require "test_helper"
-require "mrsk/configuration"
-
-ENV["VERSION"] = "123"
-ENV["RAILS_MASTER_KEY"] = "456"
 
 class ConfigurationTest < ActiveSupport::TestCase
   setup do
+    ENV["RAILS_MASTER_KEY"] = "456"
+    ENV["VERSION"] = "missing"
+
     @deploy = {
       service: "app", image: "dhh/app",
       registry: { "username" => "dhh", "password" => "secret" },
       env: { "REDIS_URL" => "redis://x/y" },
-      servers: [ "1.1.1.1", "1.1.1.2" ]
+      servers: [ "1.1.1.1", "1.1.1.2" ],
+      volumes: ["/local/path:/container/path"]
     }
 
     @config = Mrsk::Configuration.new(@deploy)
 
     @deploy_with_roles = @deploy.dup.merge({
-      servers: { "web" => [ "1.1.1.1", "1.1.1.2" ], "workers" => { "hosts" => [ "1.1.1.3", "1.1.1.4" ] } } })
+      servers: { "web" => [ "1.1.1.1", "1.1.1.2" ], "workers" => { "hosts" => [ "1.1.1.1", "1.1.1.3" ] } } })
 
     @config_with_roles = Mrsk::Configuration.new(@deploy_with_roles)
   end
 
-  test "ensure valid keys" do
-    assert_raise(ArgumentError) do
-      Mrsk::Configuration.new(@deploy.tap { _1.delete(:service) })
-      Mrsk::Configuration.new(@deploy.tap { _1.delete(:image) })
-      Mrsk::Configuration.new(@deploy.tap { _1.delete(:registry) })
+  teardown do
+    ENV.delete("RAILS_MASTER_KEY")
+    ENV.delete("VERSION")
+  end
 
-      Mrsk::Configuration.new(@deploy.tap { _1[:registry].delete("username") })
-      Mrsk::Configuration.new(@deploy.tap { _1[:registry].delete("password") })
+  %i[ service image registry ].each do |key|
+    test "#{key} config required" do
+      assert_raise(ArgumentError) do
+        Mrsk::Configuration.new @deploy.tap { _1.delete key }
+      end
+    end
+  end
+
+  %w[ username password ].each do |key|
+    test "registry #{key} required" do
+      assert_raise(ArgumentError) do
+        Mrsk::Configuration.new @deploy.tap { _1[:registry].delete key }
+      end
     end
   end
 
@@ -38,41 +48,62 @@ class ConfigurationTest < ActiveSupport::TestCase
   end
 
   test "role" do
-    assert_equal "web", @config.role(:web).name
+    assert @config.role(:web).name.web?
     assert_equal "workers", @config_with_roles.role(:workers).name
     assert_nil @config.role(:missing)
   end
 
-  test "hosts" do
-    assert_equal [ "1.1.1.1", "1.1.1.2"], @config.hosts
-    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @config_with_roles.hosts
+  test "all hosts" do
+    assert_equal [ "1.1.1.1", "1.1.1.2"], @config.all_hosts
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3" ], @config_with_roles.all_hosts
   end
 
-  test "hosts from ENV" do
-    ENV["HOSTS"] = "1.1.1.5,1.1.1.6"
-    assert_equal [ "1.1.1.5", "1.1.1.6"], @config.hosts
-  ensure
-    ENV["HOSTS"] = nil
+  test "primary web host" do
+    assert_equal "1.1.1.1", @config.primary_web_host
+    assert_equal "1.1.1.1", @config_with_roles.primary_web_host
   end
 
-  test "hosts from ENV roles" do
-    ENV["ROLES"] = "web,workers"
-    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3", "1.1.1.4" ], @config_with_roles.hosts
+  test "traefik hosts" do
+    assert_equal [ "1.1.1.1", "1.1.1.2" ], @config_with_roles.traefik_hosts
 
-    ENV["ROLES"] = "workers"
-    assert_equal [ "1.1.1.3", "1.1.1.4" ], @config_with_roles.hosts
-  ensure
-    ENV["ROLES"] = nil
+    @deploy_with_roles[:servers]["workers"]["traefik"] = true
+    config = Mrsk::Configuration.new(@deploy_with_roles)
+
+    assert_equal [ "1.1.1.1", "1.1.1.2", "1.1.1.3" ], config.traefik_hosts
   end
 
-  test "primary host" do
-    assert_equal "1.1.1.1", @config.primary_host
-    assert_equal "1.1.1.1", @config_with_roles.primary_host
+  test "version no git repo" do
+    ENV.delete("VERSION")
+
+    @config.expects(:system).with("git rev-parse").returns(nil)
+    error = assert_raises(RuntimeError) { @config.version}
+    assert_match /no git repository found/, error.message
   end
 
+  test "version from git committed" do
+    ENV.delete("VERSION")
 
-  test "version" do
-    assert_equal "123", @config.version
+    @config.expects(:`).with("git rev-parse HEAD").returns("git-version")
+    @config.expects(:`).with("git status --porcelain").returns("")
+    assert_equal "git-version", @config.version
+  end
+
+  test "version from git uncommitted" do
+    ENV.delete("VERSION")
+
+    @config.expects(:`).with("git rev-parse HEAD").returns("git-version")
+    @config.expects(:`).with("git status --porcelain").returns("M   file\n")
+    assert_match /^git-version_uncommitted_[0-9a-f]{16}$/, @config.version
+  end
+
+  test "version from env" do
+    ENV["VERSION"] = "env-version"
+    assert_equal "env-version", @config.version
+  end
+
+  test "version from arg" do
+    @config.version = "arg-version"
+    assert_equal "arg-version", @config.version
   end
 
   test "repository" do
@@ -83,35 +114,174 @@ class ConfigurationTest < ActiveSupport::TestCase
   end
 
   test "absolute image" do
-    assert_equal "dhh/app:123", @config.absolute_image
+    assert_equal "dhh/app:missing", @config.absolute_image
 
     config = Mrsk::Configuration.new(@deploy.tap { |c| c[:registry].merge!({ "server" => "ghcr.io" }) })
-    assert_equal "ghcr.io/dhh/app:123", config.absolute_image
+    assert_equal "ghcr.io/dhh/app:missing", config.absolute_image
   end
 
   test "service with version" do
-    assert_equal "app-123", @config.service_with_version
+    assert_equal "app-missing", @config.service_with_version
   end
 
-
   test "env args" do
-    assert_equal [ "-e", "REDIS_URL=redis://x/y" ], @config.env_args
+    assert_equal [ "-e", "REDIS_URL=\"redis://x/y\"" ], @config.env_args
+  end
+
+  test "env args with clear and secrets" do
+    ENV["PASSWORD"] = "secret123"
+
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!({
+      env: { "clear" => { "PORT" => "3000" }, "secret" => [ "PASSWORD" ] }
+    }) })
+
+    assert_equal [ "-e", "PASSWORD=\"secret123\"", "-e", "PORT=\"3000\"" ], Mrsk::Utils.unredacted(config.env_args)
+    assert_equal [ "-e", "PASSWORD=[REDACTED]", "-e", "PORT=\"3000\"" ], Mrsk::Utils.redacted(config.env_args)
+  ensure
+    ENV["PASSWORD"] = nil
+  end
+
+  test "env args with only clear" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!({
+      env: { "clear" => { "PORT" => "3000" } }
+    }) })
+
+    assert_equal [ "-e", "PORT=\"3000\"" ], config.env_args
+  end
+
+  test "env args with only secrets" do
+    ENV["PASSWORD"] = "secret123"
+
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!({
+      env: { "secret" => [ "PASSWORD" ] }
+    }) })
+
+    assert_equal [ "-e", "PASSWORD=\"secret123\"" ], Mrsk::Utils.unredacted(config.env_args)
+    assert_equal [ "-e", "PASSWORD=[REDACTED]" ], Mrsk::Utils.redacted(config.env_args)
+  ensure
+    ENV["PASSWORD"] = nil
+  end
+
+  test "env args with missing secret" do
+    assert_raises(KeyError) do
+      config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!({
+        env: { "secret" => [ "PASSWORD" ] }
+      }) }).ensure_env_available
+    end
+  end
+
+  test "valid config" do
+    assert @config.valid?
+    assert @config_with_roles.valid?
+  end
+
+  test "hosts required for all roles" do
+    # Empty server list for implied web role
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new @deploy.merge(servers: [])
+    end
+
+    # Empty server list
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new @deploy.merge(servers: { "web" => [] })
+    end
+
+    # Missing hosts key
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new @deploy.merge(servers: { "web" => {} })
+    end
+
+    # Empty hosts list
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new @deploy.merge(servers: { "web" => { "hosts" => [] } })
+    end
+
+    # Nil hosts
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new @deploy.merge(servers: { "web" => { "hosts" => nil } })
+    end
+
+    # One role with hosts, one without
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new @deploy.merge(servers: { "web" => %w[ web ], "workers" => { "hosts" => %w[ ] } })
+    end
   end
 
   test "ssh options" do
     assert_equal "root", @config.ssh_options[:user]
 
-    config = Mrsk::Configuration.new(@deploy.tap { |c| c[:ssh_user] = "app" })
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(ssh: { "user" => "app" }) })
     assert_equal "app", @config.ssh_options[:user]
   end
 
-  test "master key" do
-    assert_equal "456", @config.master_key
+  test "ssh options with proxy host" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(ssh: { "proxy" => "1.2.3.4" }) })
+    assert_equal "root@1.2.3.4", @config.ssh_options[:proxy].jump_proxies
   end
 
+  test "ssh options with proxy host and user" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(ssh: { "proxy" => "app@1.2.3.4" }) })
+    assert_equal "app@1.2.3.4", @config.ssh_options[:proxy].jump_proxies
+  end
+
+  test "volume_args" do
+    assert_equal ["--volume", "/local/path:/container/path"], @config.volume_args
+  end
+
+  test "logging args default" do
+    assert_equal ["--log-opt", "max-size=\"10m\""], @config.logging_args
+  end
+
+  test "logging args with configured options" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(logging: { "options" => { "max-size" => "100m", "max-file" => 5 } }) })
+    assert_equal ["--log-opt", "max-size=\"100m\"", "--log-opt", "max-file=\"5\""], @config.logging_args
+  end
+
+  test "logging args with configured driver and options" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(logging: { "driver" => "local", "options" => { "max-size" => "100m", "max-file" => 5 } }) })
+    assert_equal ["--log-driver", "\"local\"", "--log-opt", "max-size=\"100m\"", "--log-opt", "max-file=\"5\""], @config.logging_args
+  end
 
   test "erb evaluation of yml config" do
-    config = Mrsk::Configuration.load_file Pathname.new(File.expand_path("fixtures/deploy.erb.yml", __dir__))
+    config = Mrsk::Configuration.create_from config_file: Pathname.new(File.expand_path("fixtures/deploy.erb.yml", __dir__))
     assert_equal "my-user", config.registry["username"]
   end
+
+  test "destination yml config merge" do
+    dest_config_file = Pathname.new(File.expand_path("fixtures/deploy_for_dest.yml", __dir__))
+
+    config = Mrsk::Configuration.create_from config_file: dest_config_file, destination: "world"
+    assert_equal "1.1.1.1", config.all_hosts.first
+
+    config = Mrsk::Configuration.create_from config_file: dest_config_file, destination: "mars"
+    assert_equal "1.1.1.3", config.all_hosts.first
+  end
+
+  test "destination yml config file missing" do
+    dest_config_file = Pathname.new(File.expand_path("fixtures/deploy_for_dest.yml", __dir__))
+
+    assert_raises(RuntimeError) do
+      config = Mrsk::Configuration.create_from config_file: dest_config_file, destination: "missing"
+    end
+  end
+
+  test "to_h" do
+    assert_equal({ :roles=>["web"], :hosts=>["1.1.1.1", "1.1.1.2"], :primary_host=>"1.1.1.1", :version=>"missing", :repository=>"dhh/app", :absolute_image=>"dhh/app:missing", :service_with_version=>"app-missing", :env_args=>["-e", "REDIS_URL=\"redis://x/y\""], :ssh_options=>{:user=>"root", :auth_methods=>["publickey"]}, :volume_args=>["--volume", "/local/path:/container/path"], :builder=>{}, :logging=>["--log-opt", "max-size=\"10m\""], :healthcheck=>{"path"=>"/up", "port"=>3000, "max_attempts" => 7 }}, @config.to_h)
+  end
+
+  test "min version is lower" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(minimum_version: "0.0.1") })
+    assert_equal "0.0.1", config.minimum_version
+  end
+
+  test "min version is equal" do
+    config = Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(minimum_version: Mrsk::VERSION) })
+    assert_equal Mrsk::VERSION, config.minimum_version
+  end
+
+  test "min version is higher" do
+    assert_raises(ArgumentError) do
+      Mrsk::Configuration.new(@deploy.tap { |c| c.merge!(minimum_version: "10000.0.0") })
+    end
+  end
 end