Fix typo

Instead of using `kamal envify` to generate the .env file, we now assume
that it will be in place for us.

Options in place of `kamal envify`:
1. Pre-generate the .env file
2. Create the env file in the `.pre-init` hook
3. Log into a secret store/check you are logged in in the pre-init hook
   Then use .dotenv command and variable substitution to interpolate the
   secrets.

.github/workflows/ci.yml

@@ -24,25 +24,12 @@ jobs:
     strategy:
       matrix:
         ruby-version:
-          - "2.7"
           - "3.1"
           - "3.2"
           - "3.3"
         gemfile:
           - Gemfile
-          - gemfiles/ruby_2.7.gemfile
           - gemfiles/rails_edge.gemfile
-        exclude:
-          - ruby-version: "2.7"
-            gemfile: Gemfile
-          - ruby-version: "2.7"
-            gemfile: gemfiles/rails_edge.gemfile
-          - ruby-version: "3.1"
-            gemfile: gemfiles/ruby_2.7.gemfile
-          - ruby-version: "3.2"
-            gemfile: gemfiles/ruby_2.7.gemfile
-          - ruby-version: "3.3"
-            gemfile: gemfiles/ruby_2.7.gemfile
     name: ${{ format('Tests (Ruby {0})', matrix.ruby-version) }}
     runs-on: ubuntu-latest
     continue-on-error: true

Dockerfile

@@ -1,7 +1,7 @@
 # Use the official Ruby 3.2.0 Alpine image as the base image
 FROM ruby:3.2.0-alpine
 
-# Install  docker/buildx-bin
+# Install docker/buildx-bin
 COPY --from=docker/buildx-bin /buildx /usr/libexec/docker/cli-plugins/docker-buildx
 
 # Set the working directory to /kamal
@@ -14,7 +14,7 @@ COPY Gemfile Gemfile.lock kamal.gemspec ./
 COPY lib/kamal/version.rb /kamal/lib/kamal/version.rb
 
 # Install system dependencies
-RUN apk add --no-cache --update build-base git docker openrc openssh-client-default \
+RUN apk add --no-cache build-base git docker openrc openssh-client-default \
     && rc-update add docker boot \
     && gem install bundler --version=2.4.3 \
     && bundle install

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kamal (1.5.2)
+    kamal (1.8.1)
       activesupport (>= 7.0)
       base64 (~> 0.2)
       bcrypt_pbkdf (~> 1.0)
@@ -9,7 +9,7 @@ PATH
       dotenv (~> 2.8)
       ed25519 (~> 1.2)
       net-ssh (~> 7.0)
-      sshkit (>= 1.22.2, < 2.0)
+      sshkit (>= 1.23.0, < 2.0)
       thor (~> 1.2)
       zeitwerk (~> 2.5)
 
@@ -153,9 +153,8 @@ GEM
       rubocop-rails
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)
-    sshkit (1.22.2)
+    sshkit (1.23.0)
       base64
-      mutex_m
       net-scp (>= 1.1.2)
       net-sftp (>= 2.1.2)
       net-ssh (>= 2.8.0)

bin/docs

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+require "stringio"
+
+def usage
+  puts "Usage: #{$0} <kamal_site_repo>"
+  exit 1
+end
+
+usage if ARGV.size != 1
+
+kamal_site_repo = ARGV[0]
+
+if !File.directory?(kamal_site_repo)
+  puts "Error: #{kamal_site_repo} is not a directory"
+  exit 1
+end
+
+DOCS = {
+  "accessory" => "Accessories",
+  "boot" => "Booting",
+  "builder" => "Builders",
+  "configuration" => "Configuration overview",
+  "env" => "Environment variables",
+  "healthcheck" => "Healthchecks",
+  "logging" => "Logging",
+  "registry" => "Docker Registry",
+  "role" => "Roles",
+  "servers" => "Servers",
+  "ssh" => "SSH",
+  "sshkit" => "SSHKit",
+  "traefik" => "Traefik"
+}
+
+class DocWriter
+  attr_reader :from_file, :to_file, :key, :heading, :body, :output, :in_yaml
+
+  def initialize(from_file, to_dir)
+    @from_file = from_file
+    @key = File.basename(from_file, ".yml")
+    @to_file = File.join(to_dir, "#{linkify(DOCS[key])}.md")
+    @body = File.readlines(from_file)
+    @heading = body.shift.chomp("\n")
+    @output = nil
+  end
+
+  def write
+    puts "Writing #{to_file}"
+    generate_markdown
+    File.write(to_file, output.string)
+  end
+
+  private
+    def generate_markdown
+      @output = StringIO.new
+
+      generate_header
+
+      place = :in_section
+
+      loop do
+        line = body.shift&.chomp("\n")
+        break if line.nil?
+
+        case place
+        when :new_section, :in_section
+          if line.empty?
+            output.puts
+            place = :new_section
+          elsif line =~ /^ *#/
+            generate_line(line, place: place)
+            place = :in_section
+          else
+            output.puts "```yaml"
+            output.print line
+            place = :in_yaml
+          end
+        when :in_yaml
+          if line =~ /^ *#/
+            output.puts "```"
+            generate_line(line, place: :new_section)
+            place = :in_section
+          else
+            output.puts
+            output.print line
+          end
+        end
+      end
+
+      output.puts "\n```" if place == :in_yaml
+    end
+
+    def generate_header
+      output.puts "---"
+      output.puts "title: #{heading[2..-1]}"
+      output.puts "---"
+      output.puts
+      output.puts heading
+      output.puts
+    end
+
+    def generate_line(line, place: :in_section)
+      line = line.gsub(/^ *#\s?/, "")
+
+      if line =~ /(.*)kamal docs ([a-z]*)(.*)/
+        line = "#{$1}[#{DOCS[$2]}](../#{linkify(DOCS[$2])})#{$3}"
+      end
+
+      if line =~ /(.*)https:\/\/kamal-deploy.org([a-z\/-]*)(.*)/
+        line = "#{$1}[#{titlify($2.split("/").last)}](#{$2})#{$3}"
+      end
+
+      if place == :new_section
+        output.puts "## [#{line}](##{linkify(line)})"
+      else
+        output.puts line
+      end
+    end
+
+    def linkify(text)
+      text.downcase.gsub(" ", "-")
+    end
+
+    def titlify(text)
+      text.capitalize.gsub("-", " ")
+    end
+end
+
+from_dir = File.join(File.dirname(__FILE__), "../lib/kamal/configuration/docs")
+to_dir = File.join(kamal_site_repo, "docs/configuration")
+Dir.glob("#{from_dir}/*") do |from_file|
+  key = File.basename(from_file, ".yml")
+
+  DocWriter.new(from_file, to_dir).write
+end

gemfiles/ruby_2.7.gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-git_source(:github) { |repo| "https://github.com/#{repo}.git" }
-
-gemspec path: "../"
-
-gem "nokogiri", "~> 1.15.0"

kamal.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.executables = %w[ kamal ]
 
   spec.add_dependency "activesupport", ">= 7.0"
-  spec.add_dependency "sshkit", ">= 1.22.2", "< 2.0"
+  spec.add_dependency "sshkit", ">= 1.23.0", "< 2.0"
   spec.add_dependency "net-ssh", "~> 7.0"
   spec.add_dependency "thor", "~> 1.2"
   spec.add_dependency "dotenv", "~> 2.8"

lib/kamal.rb

@@ -1,8 +1,10 @@
 module Kamal
+  class ConfigurationError < StandardError; end
 end
 
 require "active_support"
 require "zeitwerk"
+require "yaml"
 
 loader = Zeitwerk::Loader.for_gem
 loader.ignore(File.join(__dir__, "kamal", "sshkit_with_ext.rb"))

lib/kamal/cli.rb

@@ -1,6 +1,6 @@
 module Kamal::Cli
-  class LockError < StandardError; end
   class HookError < StandardError; end
+  class LockError < StandardError; end
 end
 
 # SSHKit uses instance eval, so we need a global const for ergonomics

lib/kamal/cli/accessory.rb

@@ -149,23 +149,25 @@ class Kamal::Cli::Accessory < Kamal::Cli::Base
   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 :grep_options, aliases: "-o", desc: "Additional options supplied to grep"
   option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
   def logs(name)
     with_accessory(name) do |accessory, hosts|
       grep = options[:grep]
+      grep_options = options[:grep_options]
 
       if options[:follow]
         run_locally do
           info "Following logs on #{hosts}..."
-          info accessory.follow_logs(grep: grep)
+          info accessory.follow_logs(grep: grep, grep_options: grep_options)
-          exec accessory.follow_logs(grep: grep)
+          exec accessory.follow_logs(grep: grep, grep_options: grep_options)
         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(hosts) do
-          puts capture_with_info(*accessory.logs(since: since, lines: lines, grep: grep))
+          puts capture_with_info(*accessory.logs(since: since, lines: lines, grep: grep, grep_options: grep_options))
         end
       end
     end

lib/kamal/cli/app.rb

@@ -14,7 +14,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
         end
 
         # Primary hosts and roles are returned first, so they can open the barrier
-        barrier = Kamal::Cli::Healthcheck::Barrier.new if KAMAL.roles.many?
+        barrier = Kamal::Cli::Healthcheck::Barrier.new
 
         on(KAMAL.hosts, **KAMAL.boot_strategy) do |host|
           KAMAL.roles_on(host).each do |role|
@@ -166,12 +166,15 @@ class Kamal::Cli::App < Kamal::Cli::Base
   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 :grep_options, aliases: "-o", desc: "Additional options supplied to grep"
   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]
+    grep_options = options[:grep_options]
     since = options[:since]
+
     if options[:follow]
       lines = options[:lines].presence || ((since || grep) ? nil : 10) # Default to 10 lines if since or grep isn't set
 
@@ -182,8 +185,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
         role = KAMAL.roles_on(KAMAL.primary_host).first
 
         app = KAMAL.app(role: role, host: host)
-        info app.follow_logs(host: KAMAL.primary_host, lines: lines, grep: grep)
+        info app.follow_logs(host: KAMAL.primary_host, lines: lines, grep: grep, grep_options: grep_options)
-        exec app.follow_logs(host: KAMAL.primary_host, lines: lines, grep: grep)
+        exec app.follow_logs(host: KAMAL.primary_host, lines: lines, grep: grep, grep_options: grep_options)
       end
     else
       lines = options[:lines].presence || ((since || grep) ? nil : 100) # Default to 100 lines if since or grep isn't set
@@ -193,7 +196,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
 
         roles.each do |role|
           begin
-            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).logs(since: since, lines: lines, grep: grep))
+            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).logs(since: since, lines: lines, grep: grep, grep_options: grep_options))
           rescue SSHKit::Command::Failed
             puts_by_host host, "Nothing found"
           end

lib/kamal/cli/app/boot.rb

@@ -72,7 +72,7 @@ class Kamal::Cli::App::Boot
 
     def release_barrier
       if barrier.open
-        info "First #{KAMAL.primary_role} container is healthy on #{host}, booting other roles"
+        info "First #{KAMAL.primary_role} container is healthy on #{host}, booting any other roles"
       end
     end
 
@@ -87,7 +87,7 @@ class Kamal::Cli::App::Boot
 
     def close_barrier
       if barrier.close
-        info "First #{KAMAL.primary_role} container is unhealthy on #{host}, not booting other roles"
+        info "First #{KAMAL.primary_role} container is unhealthy on #{host}, not booting any other roles"
         error capture_with_info(*app.logs(version: version))
         error capture_with_info(*app.container_health_log(version: version))
       end

lib/kamal/cli/base.rb

@@ -22,28 +22,48 @@ module Kamal::Cli
 
     class_option :skip_hooks, aliases: "-H", type: :boolean, default: false, desc: "Don't run hooks"
 
+    @@ran_pre_init_hook = false
+    class << self
+      def ran_pre_init_hook
+        @@ran_pre_init_hook
+      end
+
+      def ran_pre_init_hook=(value)
+        @@ran_pre_init_hook = value
+      end
+    end
+
     def initialize(*)
       super
       @original_env = ENV.to_h.dup
-      load_envs
+      run_pre_init_hook
+      load_env
       initialize_commander(options_with_subcommand_class_options)
     end
 
     private
-      def load_envs
+      def load_env
         if destination = options[:destination]
-          Dotenv.load(".env.#{destination}", ".env")
+          if File.exist?(".kamal/.env.#{destination}") || File.exist?(".kamal/.env")
+            Dotenv.load(".kamal/.env.#{destination}", ".kamal/.env")
+          else
+            loading_files = [ (".env" if File.exist?(".env")), (".env.#{destination}" if File.exist?(".env.#{destination}")) ].compact
+            if loading_files.any?
+              warn "Loading #{loading_files.join(" and ")} from the project root, in future they will be loaded from .kamal/"
+              Dotenv.load(".env.#{destination}", ".env")
+            end
+          end
         else
-          Dotenv.load(".env")
+          if File.exist?(".kamal/.env")
+            Dotenv.load(".kamal/.env")
+          elsif File.exist?(".env")
+            $stderr.puts caller
+            warn "Loading .env from the project root, in future it will be loaded then from .kamal/.env"
+            Dotenv.load(".env")
+          end
         end
       end
 
-      def reload_envs
-        ENV.clear
-        ENV.update(@original_env)
-        load_envs
-      end
-
       def options_with_subcommand_class_options
         options.merge(@_initializer.last[:class_options] || {})
       end
@@ -140,8 +160,23 @@ module Kamal::Cli
         end
       end
 
+      def run_pre_init_hook
+        unless self.class.ran_pre_init_hook
+          hook = "pre-init"
+          if run_hook?(hook)
+            say "Running the #{hook} hook...", :magenta
+            run_locally do
+              execute *Kamal::Hooks.file(hook), verbosity: :debug
+            rescue SSHKit::Command::Failed => e
+              raise HookError.new("Hook `#{hook}` failed:\n#{e.message}")
+            end
+          end
+          self.class.ran_pre_init_hook = true
+        end
+      end
+
       def run_hook(hook, **extra_details)
-        if !options[:skip_hooks] && KAMAL.hook.hook_exists?(hook)
+        if run_hook?(hook)
           details = { hosts: KAMAL.hosts.join(","), command: command, subcommand: subcommand }
 
           say "Running the #{hook} hook...", :magenta
@@ -153,6 +188,10 @@ module Kamal::Cli
         end
       end
 
+      def run_hook?(hook)
+        !options[:skip_hooks] && Kamal::Hooks.exists?(hook)
+      end
+
       def on(*args, &block)
         if !KAMAL.connected?
           run_hook "pre-connect"

lib/kamal/cli/build.rb

@@ -23,7 +23,9 @@ class Kamal::Cli::Build < Kamal::Cli::Base
         say "Building from a local git clone, so ignoring these uncommitted changes:\n #{uncommitted_changes}", :yellow
       end
 
-      prepare_clone
+      run_locally do
+        Clone.new(self).prepare
+      end
     elsif uncommitted_changes.present?
       say "Building with uncommitted changes:\n #{uncommitted_changes}", :yellow
     end
@@ -33,32 +35,38 @@ class Kamal::Cli::Build < Kamal::Cli::Base
 
     run_locally do
       begin
-        KAMAL.with_verbosity(:debug) do
+        context_hosts = capture_with_info(*KAMAL.builder.context_hosts).split("\n")
-          Dir.chdir(KAMAL.config.builder.build_directory) { execute *push }
+
+        if context_hosts != KAMAL.builder.config_context_hosts
+          warn "Context hosts have changed, so re-creating builder, was: #{context_hosts.join(", ")}], now: #{KAMAL.builder.config_context_hosts.join(", ")}"
+          cli.remove
+          cli.create
         end
       rescue SSHKit::Command::Failed => e
-        if e.message =~ /(no builder)|(no such file or directory)/
+        if e.message =~ /(context not found|no builder|does not exist)/
           warn "Missing compatible builder, so creating a new one first"
-
+          cli.create
-          if cli.create
-            KAMAL.with_verbosity(:debug) do
-              Dir.chdir(KAMAL.config.builder.build_directory) { execute *push }
-            end
-          end
         else
           raise
         end
       end
+
+      KAMAL.with_verbosity(:debug) do
+        Dir.chdir(KAMAL.config.builder.build_directory) { execute *push }
+      end
     end
   end
 
   desc "pull", "Pull app image from registry onto servers"
   def pull
-    on(KAMAL.hosts) do
+    if (first_hosts = mirror_hosts).any?
-      execute *KAMAL.auditor.record("Pulled image with version #{KAMAL.config.version}"), verbosity: :debug
+      #  Pull on a single host per mirror first to seed them
-      execute *KAMAL.builder.clean, raise_on_non_zero_exit: false
+      say "Pulling image on #{first_hosts.join(", ")} to seed the #{"mirror".pluralize(first_hosts.count)}...", :magenta
-      execute *KAMAL.builder.pull
+      pull_on_hosts(first_hosts)
-      execute *KAMAL.builder.validate_image
+      say "Pulling image on remaining hosts...", :magenta
+      pull_on_hosts(KAMAL.hosts - first_hosts)
+    else
+      pull_on_hosts(KAMAL.hosts)
     end
   end
 
@@ -127,22 +135,27 @@ class Kamal::Cli::Build < Kamal::Cli::Base
       end
     end
 
-    def prepare_clone
+    def mirror_hosts
-      run_locally do
+      if KAMAL.hosts.many?
-        begin
+        mirror_hosts = Concurrent::Hash.new
-          info "Cloning repo into build directory `#{KAMAL.config.builder.build_directory}`..."
+        on(KAMAL.hosts) do |host|
-
+          first_mirror = capture_with_info(*KAMAL.builder.first_mirror).strip.presence
-          execute *KAMAL.builder.create_clone_directory
+          mirror_hosts[first_mirror] ||= host.to_s if first_mirror
-          execute *KAMAL.builder.clone
         rescue SSHKit::Command::Failed => e
-          if e.message =~ /already exists and is not an empty directory/
+          raise unless e.message =~ /error calling index: reflect: slice index out of range/
-            info "Resetting local clone as `#{KAMAL.config.builder.build_directory}` already exists..."
-
-            KAMAL.builder.clone_reset_steps.each { |step| execute *step }
-          else
-            raise
-          end
         end
+        mirror_hosts.values
+      else
+        []
+      end
+    end
+
+    def pull_on_hosts(hosts)
+      on(hosts) do
+        execute *KAMAL.auditor.record("Pulled image with version #{KAMAL.config.version}"), verbosity: :debug
+        execute *KAMAL.builder.clean, raise_on_non_zero_exit: false
+        execute *KAMAL.builder.pull
+        execute *KAMAL.builder.validate_image
       end
     end
 end

lib/kamal/cli/build/clone.rb

@@ -0,0 +1,61 @@
+require "uri"
+
+class Kamal::Cli::Build::Clone
+  attr_reader :sshkit
+  delegate :info, :error, :execute, :capture_with_info, to: :sshkit
+
+  def initialize(sshkit)
+    @sshkit = sshkit
+  end
+
+  def prepare
+    begin
+      clone_repo
+    rescue SSHKit::Command::Failed => e
+      if e.message =~ /already exists and is not an empty directory/
+        reset
+      else
+        raise Kamal::Cli::Build::BuildError, "Failed to clone repo: #{e.message}"
+      end
+    end
+
+    validate!
+  rescue Kamal::Cli::Build::BuildError => e
+    error "Error preparing clone: #{e.message}, deleting and retrying..."
+
+    FileUtils.rm_rf KAMAL.config.builder.clone_directory
+    clone_repo
+    validate!
+  end
+
+  private
+    def clone_repo
+      info "Cloning repo into build directory `#{KAMAL.config.builder.build_directory}`..."
+
+      FileUtils.mkdir_p KAMAL.config.builder.clone_directory
+      execute *KAMAL.builder.clone
+    end
+
+    def reset
+      info "Resetting local clone as `#{KAMAL.config.builder.build_directory}` already exists..."
+
+      KAMAL.builder.clone_reset_steps.each { |step| execute *step }
+    rescue SSHKit::Command::Failed => e
+      raise Kamal::Cli::Build::BuildError, "Failed to clone repo: #{e.message}"
+    end
+
+    def validate!
+      status = capture_with_info(*KAMAL.builder.clone_status).strip
+
+      unless status.empty?
+        raise Kamal::Cli::Build::BuildError, "Clone in #{KAMAL.config.builder.build_directory} is dirty, #{status}"
+      end
+
+      revision = capture_with_info(*KAMAL.builder.clone_revision).strip
+      if revision != Kamal::Git.revision
+        raise Kamal::Cli::Build::BuildError, "Clone in #{KAMAL.config.builder.build_directory} is not on the correct revision, expected `#{Kamal::Git.revision}` but got `#{revision}`"
+      end
+    rescue SSHKit::Command::Failed => e
+      raise Kamal::Cli::Build::BuildError, "Failed to validate clone: #{e.message}"
+    end
+end

lib/kamal/cli/healthcheck/poller.rb

@@ -6,7 +6,7 @@ module Kamal::Cli::Healthcheck::Poller
 
   def wait_for_healthy(pause_after_ready: false, &block)
     attempt = 1
-    max_attempts = KAMAL.config.healthcheck["max_attempts"]
+    max_attempts = KAMAL.config.healthcheck.max_attempts
 
     begin
       case status = block.call
@@ -33,7 +33,7 @@ module Kamal::Cli::Healthcheck::Poller
 
   def wait_for_unhealthy(pause_after_ready: false, &block)
     attempt = 1
-    max_attempts = KAMAL.config.healthcheck["max_attempts"]
+    max_attempts = KAMAL.config.healthcheck.max_attempts
 
     begin
       case status = block.call

lib/kamal/cli/main.rb

@@ -10,7 +10,7 @@ class Kamal::Cli::Main < Kamal::Cli::Base
         invoke "kamal:cli:server:bootstrap", [], invoke_options
 
         say "Evaluate and push env files...", :magenta
-        invoke "kamal:cli:main:envify", [], invoke_options
+        invoke "kamal:cli:env:push", [], invoke_options
 
         invoke "kamal:cli:accessory:boot", [ "all" ], invoke_options
         deploy
@@ -25,7 +25,7 @@ class Kamal::Cli::Main < Kamal::Cli::Base
       invoke_options = deploy_options
 
       say "Log into image registry...", :magenta
-      invoke "kamal:cli:registry:login", [], invoke_options
+      invoke "kamal:cli:registry:login", [], invoke_options.merge(skip_local: options[:skip_push])
 
       if options[:skip_push]
         say "Pull app image...", :magenta
@@ -126,6 +126,18 @@ class Kamal::Cli::Main < Kamal::Cli::Base
     end
   end
 
+  desc "docs", "Show Kamal documentation for configuration setting"
+  def docs(section = nil)
+    case section
+    when NilClass
+      puts Kamal::Configuration.validation_doc
+    else
+      puts Kamal::Configuration.const_get(section.titlecase.to_sym).validation_doc
+    end
+  rescue NameError
+    puts "No documentation found for #{section}"
+  end
+
   desc "init", "Create config stub in config/deploy.yml and env stub in .env"
   option :bundle, type: :boolean, default: false, desc: "Add Kamal to the Gemfile and create a bin/kamal binstub"
   def init
@@ -166,29 +178,6 @@ class Kamal::Cli::Main < Kamal::Cli::Base
     end
   end
 
-  desc "envify", "Create .env by evaluating .env.erb (or .env.staging.erb -> .env.staging when using -d staging)"
-  option :skip_push, aliases: "-P", type: :boolean, default: false, desc: "Skip .env file push"
-  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
-
-    if Pathname.new(File.expand_path(env_template_path)).exist?
-      File.write(env_path, ERB.new(File.read(env_template_path), trim_mode: "-").result, perm: 0600)
-
-      unless options[:skip_push]
-        reload_envs
-        invoke "kamal:cli:env:push", options
-      end
-    else
-      puts "Skipping envify (no #{env_template_path} exist)"
-    end
-  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
@@ -197,7 +186,7 @@ class Kamal::Cli::Main < Kamal::Cli::Base
         invoke "kamal:cli:traefik:remove", [], options.without(:confirmed)
         invoke "kamal:cli:app:remove", [], options.without(:confirmed)
         invoke "kamal:cli:accessory:remove", [ "all" ], options
-        invoke "kamal:cli:registry:logout", [], options.without(:confirmed)
+        invoke "kamal:cli:registry:logout", [], options.without(:confirmed).merge(skip_local: true)
       end
     end
   end

lib/kamal/cli/registry.rb

@@ -1,18 +1,17 @@
 class Kamal::Cli::Registry < Kamal::Cli::Base
   desc "login", "Log in to registry locally and remotely"
+  option :skip_local, aliases: "-L", type: :boolean, default: false, desc: "Skip local login"
+  option :skip_remote, aliases: "-R", type: :boolean, default: false, desc: "Skip remote login"
   def login
-    run_locally    { execute *KAMAL.registry.login }
+    run_locally    { execute *KAMAL.registry.login } unless options[:skip_local]
-    on(KAMAL.hosts) { execute *KAMAL.registry.login }
+    on(KAMAL.hosts) { execute *KAMAL.registry.login } unless options[:skip_remote]
-  # FIXME: This rescue needed?
-  rescue ArgumentError => e
-    puts e.message
   end
 
-  desc "logout", "Log out of registry remotely"
+  desc "logout", "Log out of registry locally and remotely"
+  option :skip_local, aliases: "-L", type: :boolean, default: false, desc: "Skip local login"
+  option :skip_remote, aliases: "-R", type: :boolean, default: false, desc: "Skip remote login"
   def logout
-    on(KAMAL.hosts) { execute *KAMAL.registry.logout }
+    run_locally    { execute *KAMAL.registry.logout } unless options[:skip_local]
-  # FIXME: This rescue needed?
+    on(KAMAL.hosts) { execute *KAMAL.registry.logout } unless options[:skip_remote]
-  rescue ArgumentError => e
-    puts e.message
   end
 end

lib/kamal/cli/templates/sample_hooks/docker-setup.sample

@@ -2,6 +2,12 @@
 
 # A sample docker-setup hook
 #
-# Sets up a Docker network which can then be used by the application’s containers
+# Sets up a Docker network on defined hosts which can then be used by the application’s containers
 
-ssh user@example.com docker network create kamal
+hosts = ENV["KAMAL_HOSTS"].split(",")
+
+hosts.each do |ip|
+  destination = "root@#{ip}"
+  puts "Creating a Docker network \"kamal\" on #{destination}"
+  `ssh #{destination} docker network create kamal`
+end

lib/kamal/cli/traefik.rb

@@ -69,22 +69,24 @@ class Kamal::Cli::Traefik < Kamal::Cli::Base
   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 :grep_options, aliases: "-o", desc: "Additional options supplied to grep"
   option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
   def logs
     grep = options[:grep]
+    grep_options = options[:grep_options]
 
     if options[:follow]
       run_locally do
         info "Following logs on #{KAMAL.primary_host}..."
-        info KAMAL.traefik.follow_logs(host: KAMAL.primary_host, grep: grep)
+        info KAMAL.traefik.follow_logs(host: KAMAL.primary_host, grep: grep, grep_options: grep_options)
-        exec KAMAL.traefik.follow_logs(host: KAMAL.primary_host, grep: grep)
+        exec KAMAL.traefik.follow_logs(host: KAMAL.primary_host, grep: grep, grep_options: grep_options)
       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(KAMAL.traefik_hosts) do |host|
-        puts_by_host host, capture(*KAMAL.traefik.logs(since: since, lines: lines, grep: grep)), type: "Traefik"
+        puts_by_host host, capture(*KAMAL.traefik.logs(since: since, lines: lines, grep: grep, grep_options: grep_options)), type: "Traefik"
       end
     end
   end

lib/kamal/commands/accessory.rb

@@ -36,17 +36,17 @@ class Kamal::Commands::Accessory < Kamal::Commands::Base
   end
 
 
-  def logs(since: nil, lines: nil, grep: nil)
+  def logs(since: nil, lines: nil, grep: nil, grep_options: nil)
     pipe \
       docker(:logs, service_name, (" --since #{since}" if since), (" --tail #{lines}" if lines), "--timestamps", "2>&1"),
-      ("grep '#{grep}'" if grep)
+      ("grep '#{grep}'#{" #{grep_options}" if grep_options}" if grep)
   end
 
-  def follow_logs(grep: nil)
+  def follow_logs(grep: nil, grep_options: nil)
     run_over_ssh \
       pipe \
         docker(:logs, service_name, "--timestamps", "--tail", "10", "--follow", "2>&1"),
-        (%(grep "#{grep}") if grep)
+        (%(grep "#{grep}"#{" #{grep_options}" if grep_options}) if grep)
   end
 
 

lib/kamal/commands/app/logging.rb

@@ -1,17 +1,17 @@
 module Kamal::Commands::App::Logging
-  def logs(version: nil, since: nil, lines: nil, grep: nil)
+  def logs(version: nil, since: nil, lines: nil, grep: nil, grep_options: nil)
     pipe \
       version ? container_id_for_version(version) : current_running_container_id,
       "xargs docker logs#{" --since #{since}" if since}#{" --tail #{lines}" if lines} 2>&1",
-      ("grep '#{grep}'" if grep)
+      ("grep '#{grep}'#{" #{grep_options}" if grep_options}" if grep)
   end
 
-  def follow_logs(host:, lines: nil, grep: nil)
+  def follow_logs(host:, lines: nil, grep: nil, grep_options: nil)
     run_over_ssh \
       pipe(
         current_running_container_id,
         "xargs docker logs --timestamps#{" --tail #{lines}" if lines} --follow 2>&1",
-        (%(grep "#{grep}") if grep)
+        (%(grep "#{grep}"#{" #{grep_options}" if grep_options}) if grep)
       ),
       host: host
   end

lib/kamal/commands/auditor.rb

@@ -9,7 +9,7 @@ class Kamal::Commands::Auditor < Kamal::Commands::Base
   # Runs remotely
   def record(line, **details)
     append \
-      [ :echo, audit_tags(**details).except(:version, :service_version).to_s, line ],
+      [ :echo, audit_tags(**details).except(:version, :service_version, :service).to_s, line ],
       audit_log_file
   end
 

lib/kamal/commands/builder.rb

@@ -1,25 +1,32 @@
 require "active_support/core_ext/string/filters"
 
 class Kamal::Commands::Builder < Kamal::Commands::Base
-  delegate :create, :remove, :push, :clean, :pull, :info, :validate_image, to: :target
+  delegate :create, :remove, :push, :clean, :pull, :info, :context_hosts, :config_context_hosts, :validate_image,
-  delegate :clone_directory, :build_directory, to: :"config.builder"
+           :first_mirror, to: :target
+
+  include Clone
 
   def name
     target.class.to_s.remove("Kamal::Commands::Builder::").underscore.inquiry
   end
 
   def target
-    case
+    if config.builder.multiarch?
-    when !config.builder.multiarch? && !config.builder.cached?
+      if config.builder.remote?
-      native
+        if config.builder.local?
-    when !config.builder.multiarch? && config.builder.cached?
+          multiarch_remote
-      native_cached
+        else
-    when config.builder.local? && config.builder.remote?
+          native_remote
-      multiarch_remote
+        end
-    when config.builder.remote?
+      else
-      native_remote
+        multiarch
+      end
     else
-      multiarch
+      if config.builder.cached?
+        native_cached
+      else
+        native
+      end
     end
   end
 
@@ -54,23 +61,6 @@ class Kamal::Commands::Builder < Kamal::Commands::Base
     end
   end
 
-  def create_clone_directory
-    make_directory clone_directory
-  end
-
-  def clone
-    git :clone, Kamal::Git.root, path: clone_directory
-  end
-
-  def clone_reset_steps
-    [
-      git(:remote, "set-url", :origin, Kamal::Git.root, path: build_directory),
-      git(:fetch, :origin, path: build_directory),
-      git(:reset, "--hard", Kamal::Git.revision, path: build_directory),
-      git(:clean, "-fdx", path: build_directory)
-    ]
-  end
-
   private
     def ensure_local_docker_installed
       docker "--version"

lib/kamal/commands/builder/base.rb

@@ -2,6 +2,8 @@
 class Kamal::Commands::Builder::Base < Kamal::Commands::Base
   class BuilderError < StandardError; end
 
+  ENDPOINT_DOCKER_HOST_INSPECT = "'{{.Endpoints.docker.Host}}'"
+
   delegate :argumentize, to: Kamal::Utils
   delegate :args, :secrets, :dockerfile, :target, :local_arch, :local_host, :remote_arch, :remote_host, :cache_from, :cache_to, :ssh, to: :builder_config
 
@@ -30,6 +32,17 @@ class Kamal::Commands::Builder::Base < Kamal::Commands::Base
       )
   end
 
+  def context_hosts
+    :true
+  end
+
+  def config_context_hosts
+    []
+  end
+
+  def first_mirror
+    docker(:info, "--format '{{index .RegistryConfig.Mirrors 0}}'")
+  end
 
   private
     def build_tags
@@ -74,4 +87,8 @@ class Kamal::Commands::Builder::Base < Kamal::Commands::Base
     def builder_config
       config.builder
     end
+
+    def context_host(builder_name)
+      docker :context, :inspect, builder_name, "--format", ENDPOINT_DOCKER_HOST_INSPECT
+    end
 end

lib/kamal/commands/builder/clone.rb

@@ -0,0 +1,28 @@
+module Kamal::Commands::Builder::Clone
+  extend ActiveSupport::Concern
+
+  included do
+    delegate :clone_directory, :build_directory, to: :"config.builder"
+  end
+
+  def clone
+    git :clone, Kamal::Git.root, path: clone_directory
+  end
+
+  def clone_reset_steps
+    [
+      git(:remote, "set-url", :origin, Kamal::Git.root, path: build_directory),
+      git(:fetch, :origin, path: build_directory),
+      git(:reset, "--hard", Kamal::Git.revision, path: build_directory),
+      git(:clean, "-fdx", path: build_directory)
+    ]
+  end
+
+  def clone_status
+    git :status, "--porcelain", path: build_directory
+  end
+
+  def clone_revision
+    git :"rev-parse", :HEAD, path: build_directory
+  end
+end

lib/kamal/commands/builder/multiarch.rb

@@ -22,6 +22,10 @@ class Kamal::Commands::Builder::Multiarch < Kamal::Commands::Builder::Base
       build_context
   end
 
+  def context_hosts
+    docker :buildx, :inspect, builder_name, "> /dev/null"
+  end
+
   private
     def builder_name
       "kamal-#{config.service}-multiarch"

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

@@ -12,6 +12,16 @@ class Kamal::Commands::Builder::Multiarch::Remote < Kamal::Commands::Builder::Mu
       super
   end
 
+  def context_hosts
+    chain \
+      context_host(builder_name_with_arch(local_arch)),
+      context_host(builder_name_with_arch(remote_arch))
+  end
+
+  def config_context_hosts
+    [ local_host, remote_host ].compact
+  end
+
   private
     def builder_name
       super + "-remote"

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

@@ -1,6 +1,6 @@
 class Kamal::Commands::Builder::Native::Cached < Kamal::Commands::Builder::Native
   def create
-    docker :buildx, :create, "--use", "--driver=docker-container"
+    docker :buildx, :create, "--name", builder_name, "--use", "--driver=docker-container"
   end
 
   def remove
@@ -13,4 +13,13 @@ class Kamal::Commands::Builder::Native::Cached < Kamal::Commands::Builder::Nativ
       *build_options,
       build_context
   end
+
+  def context_hosts
+    docker :buildx, :inspect, builder_name, "> /dev/null"
+  end
+
+  private
+    def builder_name
+      "kamal-#{config.service}-native-cached"
+    end
 end

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

@@ -26,6 +26,14 @@ class Kamal::Commands::Builder::Native::Remote < Kamal::Commands::Builder::Nativ
     build_context
   end
 
+  def context_hosts
+    context_host(builder_name_with_arch)
+  end
+
+  def config_context_hosts
+    [ remote_host ]
+  end
+
 
   private
     def builder_name

lib/kamal/commands/hook.rb

@@ -1,14 +1,5 @@
 class Kamal::Commands::Hook < Kamal::Commands::Base
   def run(hook, **details)
-    [ hook_file(hook), env: tags(**details).env ]
+    [ Kamal::Hooks.file(hook), env: tags(**details).env ]
   end
-
-  def hook_exists?(hook)
-    Pathname.new(hook_file(hook)).exist?
-  end
-
-  private
-    def hook_file(hook)
-      File.join(config.hooks_path, hook)
-    end
 end

lib/kamal/commands/registry.rb

@@ -3,21 +3,12 @@ class Kamal::Commands::Registry < Kamal::Commands::Base
 
   def login
     docker :login,
-      registry["server"],
+      registry.server,
-      "-u", sensitive(Kamal::Utils.escape_shell_value(lookup("username"))),
+      "-u", sensitive(Kamal::Utils.escape_shell_value(registry.username)),
-      "-p", sensitive(Kamal::Utils.escape_shell_value(lookup("password")))
+      "-p", sensitive(Kamal::Utils.escape_shell_value(registry.password))
   end
 
   def logout
-    docker :logout, registry["server"]
+    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/kamal/commands/traefik.rb

@@ -1,19 +1,6 @@
 class Kamal::Commands::Traefik < Kamal::Commands::Base
   delegate :argumentize, :optionize, to: Kamal::Utils
-
+  delegate :port, :publish?, :labels, :env, :image, :options, :args, to: :"config.traefik"
-  DEFAULT_IMAGE = "traefik:v2.10"
-  CONTAINER_PORT = 80
-  DEFAULT_ARGS = {
-    "log.level" => "DEBUG"
-  }
-  DEFAULT_LABELS = {
-    # These ensure we serve a 502 rather than a 404 if no containers are available
-    "traefik.http.routers.catchall.entryPoints" => "http",
-    "traefik.http.routers.catchall.rule" => "PathPrefix(`/`)",
-    "traefik.http.routers.catchall.service" => "unavailable",
-    "traefik.http.routers.catchall.priority" => 1,
-    "traefik.http.services.unavailable.loadbalancer.server.port" => "0"
-  }
 
   def run
     docker :run, "--name traefik",
@@ -46,16 +33,16 @@ class Kamal::Commands::Traefik < Kamal::Commands::Base
     docker :ps, "--filter", "name=^traefik$"
   end
 
-  def logs(since: nil, lines: nil, grep: nil)
+  def logs(since: nil, lines: nil, grep: nil, grep_options: nil)
     pipe \
       docker(:logs, "traefik", (" --since #{since}" if since), (" --tail #{lines}" if lines), "--timestamps", "2>&1"),
-      ("grep '#{grep}'" if grep)
+      ("grep '#{grep}'#{" #{grep_options}" if grep_options}" if grep)
   end
 
-  def follow_logs(host:, grep: nil)
+  def follow_logs(host:, grep: nil, grep_options: nil)
     run_over_ssh pipe(
       docker(:logs, "traefik", "--timestamps", "--tail", "10", "--follow", "2>&1"),
-      (%(grep "#{grep}") if grep)
+      (%(grep "#{grep}"#{" #{grep_options}" if grep_options}) if grep)
     ).join(" "), host: host
   end
 
@@ -67,16 +54,6 @@ class Kamal::Commands::Traefik < Kamal::Commands::Base
     docker :image, :prune, "--all", "--force", "--filter", "label=org.opencontainers.image.title=Traefik"
   end
 
-  def port
-    "#{host_port}:#{CONTAINER_PORT}"
-  end
-
-  def env
-    Kamal::Configuration::Env.from_config \
-      config: config.traefik.fetch("env", {}),
-      secrets_file: File.join(config.host_env_directory, "traefik", "traefik.env")
-  end
-
   def make_env_directory
     make_directory(env.secrets_directory)
   end
@@ -87,7 +64,7 @@ class Kamal::Commands::Traefik < Kamal::Commands::Base
 
   private
     def publish_args
-      argumentize "--publish", port unless config.traefik["publish"] == false
+      argumentize "--publish", port if publish?
     end
 
     def label_args
@@ -98,27 +75,11 @@ class Kamal::Commands::Traefik < Kamal::Commands::Base
       env.args
     end
 
-    def labels
-      DEFAULT_LABELS.merge(config.traefik["labels"] || {})
-    end
-
-    def image
-      config.traefik.fetch("image") { DEFAULT_IMAGE }
-    end
-
     def docker_options_args
-      optionize(config.traefik["options"] || {})
+      optionize(options)
     end
 
     def cmd_option_args
-      if args = config.traefik["args"]
+      optionize args, with: "="
-        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/kamal/configuration.rb

@@ -1,15 +1,19 @@
 require "active_support/ordered_options"
 require "active_support/core_ext/string/inquiry"
 require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/hash/keys"
 require "pathname"
 require "erb"
 require "net/ssh/proxy/jump"
 
 class Kamal::Configuration
-  delegate :service, :image, :servers, :labels, :registry, :stop_wait_time, :hooks_path, :logging, to: :raw_config, allow_nil: true
+  delegate :service, :image, :labels, :stop_wait_time, to: :raw_config, allow_nil: true
   delegate :argumentize, :optionize, to: Kamal::Utils
 
   attr_reader :destination, :raw_config
+  attr_reader :accessories, :boot, :builder, :env, :healthcheck, :logging, :traefik, :servers, :ssh, :sshkit, :registry
+
+  include Validation
 
   class << self
     def create_from(config_file:, destination: nil, version: nil)
@@ -42,7 +46,29 @@ class Kamal::Configuration
     @raw_config = ActiveSupport::InheritableOptions.new(raw_config)
     @destination = destination
     @declared_version = version
-    valid? if validate
+
+    validate! raw_config, example: validation_yml.symbolize_keys, context: "", with: Kamal::Configuration::Validator::Configuration
+
+    # Eager load config to validate it, these are first as they have dependencies later on
+    @servers = Servers.new(config: self)
+    @registry = Registry.new(config: self)
+
+    @accessories = @raw_config.accessories&.keys&.collect { |name| Accessory.new(name, config: self) } || []
+    @boot = Boot.new(config: self)
+    @builder = Builder.new(config: self)
+    @env = Env.new(config: @raw_config.env || {})
+
+    @healthcheck = Healthcheck.new(healthcheck_config: @raw_config.healthcheck)
+    @logging = Logging.new(logging_config: @raw_config.logging)
+    @traefik = Traefik.new(config: self)
+    @ssh = Ssh.new(config: self)
+    @sshkit = Sshkit.new(config: self)
+
+    ensure_destination_if_required
+    ensure_required_keys_present
+    ensure_valid_kamal_version
+    ensure_retain_containers_valid
+    ensure_valid_service_name
   end
 
 
@@ -71,17 +97,13 @@ class Kamal::Configuration
 
 
   def roles
-    @roles ||= role_names.collect { |role_name| Role.new(role_name, config: self) }
+    servers.roles
   end
 
   def role(name)
     roles.detect { |r| r.name == name.to_s }
   end
 
-  def accessories
-    @accessories ||= raw_config.accessories&.keys&.collect { |name| Kamal::Configuration::Accessory.new(name, config: self) } || []
-  end
-
   def accessory(name)
     accessories.detect { |a| a.name == name.to_s }
   end
@@ -120,7 +142,7 @@ class Kamal::Configuration
   end
 
   def repository
-    [ raw_config.registry["server"], image ].compact.join("/")
+    [ registry.server, image ].compact.join("/")
   end
 
   def absolute_image
@@ -157,40 +179,10 @@ class Kamal::Configuration
   end
 
   def logging_args
-    if logging.present?
+    logging.args
-      optionize({ "log-driver" => logging["driver"] }.compact) +
-        argumentize("--log-opt", logging["options"])
-    else
-      argumentize("--log-opt", { "max-size" => "10m" })
-    end
   end
 
 
-  def boot
-    Kamal::Configuration::Boot.new(config: self)
-  end
-
-  def builder
-    Kamal::Configuration::Builder.new(config: self)
-  end
-
-  def traefik
-    raw_config.traefik || {}
-  end
-
-  def ssh
-    Kamal::Configuration::Ssh.new(config: self)
-  end
-
-  def sshkit
-    Kamal::Configuration::Sshkit.new(config: self)
-  end
-
-
-  def healthcheck
-    { "path" => "/up", "port" => 3000, "max_attempts" => 7, "cord" => "/tmp/kamal-cord", "log_lines" => 50 }.merge(raw_config.healthcheck || {})
-  end
-
   def healthcheck_service
     [ "healthcheck", service, destination ].compact.join("-")
   end
@@ -216,10 +208,6 @@ class Kamal::Configuration
     end
   end
 
-  def hooks_path
-    raw_config.hooks_path || ".kamal/hooks"
-  end
-
   def asset_path
     raw_config.asset_path
   end
@@ -229,13 +217,9 @@ class Kamal::Configuration
     File.join(run_directory, "env")
   end
 
-  def env
-    raw_config.env || {}
-  end
-
   def env_tags
     @env_tags ||= if (tags = raw_config.env["tags"])
-      tags.collect { |name, config| Kamal::Configuration::Env::Tag.new(name, config: config) }
+      tags.collect { |name, config| Env::Tag.new(name, config: config) }
     else
       []
     end
@@ -246,10 +230,6 @@ class Kamal::Configuration
   end
 
 
-  def valid?
-    ensure_destination_if_required && ensure_required_keys_present && ensure_valid_kamal_version && ensure_retain_containers_valid && ensure_valid_service_name
-  end
-
   def to_h
     {
       roles: role_names,
@@ -265,11 +245,10 @@ class Kamal::Configuration
       builder: builder.to_h,
       accessories: raw_config.accessories,
       logging: logging_args,
-      healthcheck: healthcheck
+      healthcheck: healthcheck.to_h
     }.compact
   end
 
-
   private
     # Will raise ArgumentError if any required config keys are missing
     def ensure_destination_if_required
@@ -282,29 +261,21 @@ class Kamal::Configuration
 
     def ensure_required_keys_present
       %i[ service image registry servers ].each do |key|
-        raise ArgumentError, "Missing required configuration for #{key}" unless raw_config[key].present?
+        raise Kamal::ConfigurationError, "Missing required configuration for #{key}" unless raw_config[key].present?
       end
 
-      if raw_config.registry["username"].blank?
+      unless role(primary_role_name).present?
-        raise ArgumentError, "You must specify a username for the registry in config/deploy.yml"
+        raise Kamal::ConfigurationError, "The primary_role #{primary_role_name} isn't defined"
-      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
-
-      unless role_names.include?(primary_role_name)
-        raise ArgumentError, "The primary_role #{primary_role_name} isn't defined"
       end
 
       if primary_role.hosts.empty?
-        raise ArgumentError, "No servers specified for the #{primary_role.name} primary_role"
+        raise Kamal::ConfigurationError, "No servers specified for the #{primary_role.name} primary_role"
       end
 
       unless allow_empty_roles?
         roles.each do |role|
           if role.hosts.empty?
-            raise ArgumentError, "No servers specified for the #{role.name} role. You can ignore this with allow_empty_roles: true"
+            raise Kamal::ConfigurationError, "No servers specified for the #{role.name} role. You can ignore this with allow_empty_roles: true"
           end
         end
       end
@@ -313,21 +284,21 @@ class Kamal::Configuration
     end
 
     def ensure_valid_service_name
-      raise ArgumentError, "Service name can only include alphanumeric characters, hyphens, and underscores" unless raw_config[:service] =~ /^[a-z0-9_-]+$/i
+      raise Kamal::ConfigurationError, "Service name can only include alphanumeric characters, hyphens, and underscores" unless raw_config[:service] =~ /^[a-z0-9_-]+$/i
 
       true
     end
 
     def ensure_valid_kamal_version
       if minimum_version && Gem::Version.new(minimum_version) > Gem::Version.new(Kamal::VERSION)
-        raise ArgumentError, "Current version is #{Kamal::VERSION}, minimum required is #{minimum_version}"
+        raise Kamal::ConfigurationError, "Current version is #{Kamal::VERSION}, minimum required is #{minimum_version}"
       end
 
       true
     end
 
     def ensure_retain_containers_valid
-      raise ArgumentError, "Must retain at least 1 container" if retain_containers < 1
+      raise Kamal::ConfigurationError, "Must retain at least 1 container" if retain_containers < 1
 
       true
     end

lib/kamal/configuration/accessory.rb

@@ -1,30 +1,39 @@
 class Kamal::Configuration::Accessory
+  include Kamal::Configuration::Validation
+
   delegate :argumentize, :optionize, to: Kamal::Utils
 
-  attr_accessor :name, :specifics
+  attr_reader :name, :accessory_config, :env
 
   def initialize(name, config:)
-    @name, @config, @specifics = name.inquiry, config, config.raw_config["accessories"][name]
+    @name, @config, @accessory_config = name.inquiry, config, config.raw_config["accessories"][name]
+
+    validate! \
+      accessory_config,
+      example: validation_yml["accessories"]["mysql"],
+      context: "accessories/#{name}",
+      with: Kamal::Configuration::Validator::Accessory
+
+    @env = Kamal::Configuration::Env.new \
+      config: accessory_config.fetch("env", {}),
+      secrets_file: File.join(config.host_env_directory, "accessories", "#{service_name}.env"),
+      context: "accessories/#{name}/env"
   end
 
   def service_name
-    specifics["service"] || "#{config.service}-#{name}"
+    accessory_config["service"] || "#{config.service}-#{name}"
   end
 
   def image
-    specifics["image"]
+    accessory_config["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
+    if port = accessory_config["port"]&.to_s
       port.include?(":") ? port : "#{port}:#{port}"
     end
   end
@@ -34,32 +43,26 @@ class Kamal::Configuration::Accessory
   end
 
   def labels
-    default_labels.merge(specifics["labels"] || {})
+    default_labels.merge(accessory_config["labels"] || {})
   end
 
   def label_args
     argumentize "--label", labels
   end
 
-  def env
-    Kamal::Configuration::Env.from_config \
-      config: specifics.fetch("env", {}),
-      secrets_file: File.join(config.host_env_directory, "accessories", "#{service_name}.env")
-  end
-
   def env_args
     env.args
   end
 
   def files
-    specifics["files"]&.to_h do |local_to_remote_mapping|
+    accessory_config["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|
+    accessory_config["directories"]&.to_h do |host_to_container_mapping|
       host_path, container_path = host_to_container_mapping.split(":")
       [ expand_host_path(host_path), container_path ]
     end || {}
@@ -74,7 +77,7 @@ class Kamal::Configuration::Accessory
   end
 
   def option_args
-    if args = specifics["options"]
+    if args = accessory_config["options"]
       optionize args
     else
       []
@@ -82,7 +85,7 @@ class Kamal::Configuration::Accessory
   end
 
   def cmd
-    specifics["cmd"]
+    accessory_config["cmd"]
   end
 
   private
@@ -116,18 +119,18 @@ class Kamal::Configuration::Accessory
     end
 
     def specific_volumes
-      specifics["volumes"] || []
+      accessory_config["volumes"] || []
     end
 
     def remote_files_as_volumes
-      specifics["files"]&.collect do |local_to_remote_mapping|
+      accessory_config["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|
+      accessory_config["directories"]&.collect do |host_to_container_mapping|
         host_path, container_path = host_to_container_mapping.split(":")
         [ expand_host_path(host_path), container_path ].join(":")
       end || []
@@ -146,30 +149,16 @@ class Kamal::Configuration::Accessory
     end
 
     def hosts_from_host
-      if specifics.key?("host")
+      [ accessory_config["host"] ] if accessory_config.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")
+      accessory_config["hosts"] if accessory_config.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")
+      if accessory_config.key?("roles")
-        specifics["roles"].flat_map { |role| config.role(role).hosts }
+        accessory_config["roles"].flat_map { |role| config.role(role).hosts }
       end
     end
 end

lib/kamal/configuration/boot.rb

@@ -1,20 +1,25 @@
 class Kamal::Configuration::Boot
+  include Kamal::Configuration::Validation
+
+  attr_reader :boot_config, :host_count
+
   def initialize(config:)
-    @options = config.raw_config.boot || {}
+    @boot_config = config.raw_config.boot || {}
     @host_count = config.all_hosts.count
+    validate! boot_config
   end
 
   def limit
-    limit = @options["limit"]
+    limit = boot_config["limit"]
 
     if limit.to_s.end_with?("%")
-      [ @host_count * limit.to_i / 100, 1 ].max
+      [ host_count * limit.to_i / 100, 1 ].max
     else
       limit
     end
   end
 
   def wait
-    @options["wait"]
+    boot_config["wait"]
   end
 end

lib/kamal/configuration/builder.rb

@@ -1,73 +1,79 @@
 class Kamal::Configuration::Builder
-  def initialize(config:)
+  include Kamal::Configuration::Validation
-    @options = config.raw_config.builder || {}
-    @image = config.image
-    @server = config.registry["server"]
-    @service = config.service
-    @destination = config.destination
 
-    valid?
+  attr_reader :config, :builder_config
+  delegate :image, :service, to: :config
+  delegate :server, to: :"config.registry"
+
+  def initialize(config:)
+    @config = config
+    @builder_config = config.raw_config.builder || {}
+    @image = config.image
+    @server = config.registry.server
+    @service = config.service
+
+    validate! builder_config, with: Kamal::Configuration::Validator::Builder
   end
 
   def to_h
-    @options
+    builder_config
   end
 
   def multiarch?
-    @options["multiarch"] != false
+    builder_config["multiarch"] != false
   end
 
   def local?
-    !!@options["local"]
+    !!builder_config["local"]
   end
 
   def remote?
-    !!@options["remote"]
+    !!builder_config["remote"]
   end
 
   def cached?
-    !!@options["cache"]
+    !!builder_config["cache"]
   end
 
   def args
-    @options["args"] || {}
+    builder_config["args"] || {}
   end
 
   def secrets
-    @options["secrets"] || []
+    builder_config["secrets"] || []
   end
 
   def dockerfile
-    @options["dockerfile"] || "Dockerfile"
+    builder_config["dockerfile"] || "Dockerfile"
   end
 
   def target
-    @options["target"]
+    builder_config["target"]
   end
 
   def context
-    @options["context"] || "."
+    builder_config["context"] || "."
   end
 
   def local_arch
-    @options["local"]["arch"] if local?
+    builder_config["local"]["arch"] if local?
   end
 
   def local_host
-    @options["local"]["host"] if local?
+    builder_config["local"]["host"] if local?
   end
 
   def remote_arch
-    @options["remote"]["arch"] if remote?
+    builder_config["remote"]["arch"] if remote?
   end
 
   def remote_host
-    @options["remote"]["host"] if remote?
+    builder_config["remote"]["host"] if remote?
   end
 
   def cache_from
     if cached?
-      case @options["cache"]["type"]
+      case builder_config["cache"]["type"]
       when "gha"
         cache_from_config_for_gha
       when "registry"
@@ -78,7 +84,7 @@ class Kamal::Configuration::Builder
 
   def cache_to
     if cached?
-      case @options["cache"]["type"]
+      case builder_config["cache"]["type"]
       when "gha"
         cache_to_config_for_gha
       when "registry"
@@ -88,15 +94,15 @@ class Kamal::Configuration::Builder
   end
 
   def ssh
-    @options["ssh"]
+    builder_config["ssh"]
   end
 
   def git_clone?
-    Kamal::Git.used? && @options["context"].nil?
+    Kamal::Git.used? && builder_config["context"].nil?
   end
 
   def clone_directory
-    @clone_directory ||= File.join Dir.tmpdir, "kamal-clones", [ @service, pwd_sha ].compact.join("-")
+    @clone_directory ||= File.join Dir.tmpdir, "kamal-clones", [ service, pwd_sha ].compact.join("-")
   end
 
   def build_directory
@@ -109,18 +115,12 @@ class Kamal::Configuration::Builder
   end
 
   private
-    def valid?
-      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"
+      builder_config["cache"]&.fetch("image", nil) || "#{image}-build-cache"
     end
 
     def cache_image_ref
-      [ @server, cache_image ].compact.join("/")
+      [ server, cache_image ].compact.join("/")
     end
 
     def cache_from_config_for_gha
@@ -132,11 +132,11 @@ class Kamal::Configuration::Builder
     end
 
     def cache_to_config_for_gha
-      [ "type=gha", @options["cache"]&.fetch("options", nil) ].compact.join(",")
+      [ "type=gha", builder_config["cache"]&.fetch("options", nil) ].compact.join(",")
     end
 
     def cache_to_config_for_registry
-      [ "type=registry", @options["cache"]&.fetch("options", nil), "ref=#{cache_image_ref}" ].compact.join(",")
+      [ "type=registry", builder_config["cache"]&.fetch("options", nil), "ref=#{cache_image_ref}" ].compact.join(",")
     end
 
     def repo_basename

lib/kamal/configuration/docs/accessory.yml

@@ -0,0 +1,90 @@
+# Accessories
+#
+# Accessories can be booted on a single host, a list of hosts, or on specific roles.
+# The hosts do not need to be defined in the Kamal servers configuration.
+#
+# Accessories are managed separately from the main service - they are not updated
+# when you deploy and they do not have zero-downtime deployments.
+#
+# Run `kamal accessory boot <accessory>` to boot an accessory.
+# See `kamal accessory --help` for more information.
+
+# Configuring accessories
+#
+# First define the accessory in the `accessories`
+accessories:
+  mysql:
+
+    # Service name
+    #
+    # This is used in the service label and defaults to `<service>-<accessory>`
+    # where `<service>` is the main service name from the root configuration
+    service: mysql
+
+    # Image
+    #
+    # The Docker image to use, prefix with a registry if not using Docker hub
+    image: mysql:8.0
+
+    # Accessory hosts
+    #
+    # Specify one  of `host`, `hosts` or `roles`
+    host: mysql-db1
+    hosts:
+      - mysql-db1
+      - mysql-db2
+    roles:
+      - mysql
+
+    # Custom command
+    #
+    # You can set a custom command to run in the container, if you do not want to use the default
+    cmd: "bin/mysqld"
+
+    # Port mappings
+    #
+    # See https://docs.docker.com/network/, especially note the warning about the security
+    # implications of exposing ports publicly.
+    port: "127.0.0.1:3306:3306"
+
+    # Labels
+    labels:
+      app: myapp
+
+    # Options
+    # These are passed to the Docker run command in the form `--<name> <value>`
+    options:
+      restart: always
+      cpus: 2
+
+    # Environment variables
+    # See kamal docs env for more information
+    env:
+      ...
+
+    # Copying files
+    #
+    # You can specify files to mount into the container.
+    # The format is `local:remote` where `local` is the path to the file on the local machine
+    # and `remote` is the path to the file in the container.
+    #
+    # They will be uploaded from the local repo to the host and then mounted.
+    #
+    # ERB files will be evaluated before being copied.
+    files:
+      - config/my.cnf.erb:/etc/mysql/my.cnf
+      - config/myoptions.cnf:/etc/mysql/myoptions.cnf
+
+    # Directories
+    #
+    # You can specify directories to mount into the container. They will be created on the host
+    # before being mounted
+    directories:
+      - mysql-logs:/var/log/mysql
+
+    # Volumes
+    #
+    # Any other volumes to mount, in addition to the files and directories.
+    # They are not created or copied before mounting
+    volumes:
+      - /path/to/mysql-logs:/var/log/mysql

lib/kamal/configuration/docs/boot.yml

@@ -0,0 +1,19 @@
+# Booting
+#
+# When deploying to large numbers of hosts, you might prefer not to restart your services on every host at the same time.
+#
+# Kamal’s default is to boot new containers on all hosts in parallel. But you can control this with the boot configuration.
+
+# Fixed group sizes
+#
+# Here we boot 2 hosts at a time with a 10 second gap between each group.
+boot:
+  limit: 2
+  wait: 10
+
+# Percentage of hosts
+#
+# Here we boot 25% of the hosts at a time with a 2 second gap between each group.
+boot:
+  limit: 25%
+  wait: 2

lib/kamal/configuration/docs/builder.yml

@@ -0,0 +1,107 @@
+# Builder
+#
+# The builder configuration controls how the application is built with `docker build` or `docker buildx build`
+#
+# If no configuration is specified, Kamal will:
+# 1. Create a buildx context called `kamal-<service>-multiarch`
+# 2. Use `docker buildx build` to build a multiarch image for linux/amd64,linux/arm64 with that context
+#
+# See https://kamal-deploy.org/docs/configuration/builder-examples/ for more information
+
+# Builder options
+#
+# Options go under the builder key in the root configuration.
+builder:
+
+  # Multiarch
+  #
+  # Enables multiarch builds, defaults to `true`
+  multiarch: false
+
+  # Local configuration
+  #
+  # The build configuration for local builds, only used if multiarch is enabled (the default)
+  #
+  # If there is no remote configuration, by default we build for amd64 and arm64.
+  # If you only want to build for one architecture, you can specify it here.
+  # The docker socket is optional and uses the default docker host socket when not specified
+  local:
+    arch: amd64
+    host: /var/run/docker.sock
+
+  # Remote configuration
+  #
+  # The build configuration for remote builds, also only used if multiarch is enabled.
+  # The arch is required and can be either amd64 or arm64.
+  remote:
+    arch: arm64
+    host: ssh://docker@docker-builder
+
+  # Builder cache
+  #
+  # The type must be either 'gha' or 'registry'
+  #
+  # The image is only used for registry cache
+  cache:
+    type: registry
+    options: mode=max
+    image: kamal-app-build-cache
+
+  # Build context
+  #
+  # If this is not set, then a local git clone of the repo is used.
+  # This ensures a clean build with no uncommitted changes.
+  #
+  # To use the local checkout instead you can set the context to `.`, or a path to another directory.
+  context: .
+
+  # Dockerfile
+  #
+  # The Dockerfile to use for building, defaults to `Dockerfile`
+  dockerfile: Dockerfile.production
+
+  # Build target
+  #
+  # If not set, then the default target is used
+  target: production
+
+  # Build Arguments
+  #
+  # Any additional build arguments, passed to `docker build` with `--build-arg <key>=<value>`
+  args:
+    ENVIRONMENT: production
+
+  # Referencing build arguments
+  #
+  # ```shell
+  # ARG RUBY_VERSION
+  # FROM ruby:$RUBY_VERSION-slim as base
+  # ```
+
+  # Build secrets
+  #
+  # Values are read from the environment.
+  #
+  secrets:
+    - SECRET1
+    - SECRET2
+
+  # Referencing Build Secrets
+  #
+  # ```shell
+  # # Copy Gemfiles
+  # COPY Gemfile Gemfile.lock ./
+  #
+  # # Install dependencies, including private repositories via access token
+  # # Then remove bundle cache with exposed GITHUB_TOKEN)
+  # RUN --mount=type=secret,id=GITHUB_TOKEN \
+  #   BUNDLE_GITHUB__COM=x-access-token:$(cat /run/secrets/GITHUB_TOKEN) \
+  #   bundle install && \
+  #   rm -rf /usr/local/bundle/cache
+  # ```
+
+
+  # SSH
+  #
+  # SSH agent socket or keys to expose to the build
+  ssh: default=$SSH_AUTH_SOCK

lib/kamal/configuration/docs/configuration.yml

@@ -0,0 +1,164 @@
+# Kamal Configuration
+#
+# Configuration is read from the `config/deploy.yml`
+#
+
+# Destinations
+#
+# When running commands, you can specify a destination with the `-d` flag,
+# e.g. `kamal deploy -d staging`
+#
+# In this case the configuration will also be read from `config/deploy.staging.yml`
+# and merged with the base configuration.
+
+# Extensions
+#
+# Kamal will not accept unrecognized keys in the configuration file.
+#
+# However, you might want to declare a configuration block using YAML anchors
+# and aliases to avoid repetition.
+#
+# You can use prefix a configuration section with `x-` to indicate that it is an
+# extension. Kamal will ignore the extension and not raise an error.
+
+# The service name
+# This is a required value. It is used as the container name prefix.
+service: myapp
+
+# The Docker image name
+#
+# The image will be pushed to the configured registry.
+image: my-image
+
+# Labels
+#
+# Additional labels to add to the container
+labels:
+  my-label: my-value
+
+# Additional volumes to mount into the container
+volumes:
+  - /path/on/host:/path/in/container:ro
+
+# Registry
+#
+# The Docker registry configuration, see kamal docs registry
+registry:
+  ...
+
+# Servers
+#
+# The servers to deploy to, optionally with custom roles, see kamal docs servers
+servers:
+  ...
+
+# Environment variables
+#
+# See kamal docs env
+env:
+  ...
+
+# Asset Bridging
+#
+# Used for asset bridging across deployments, default to `nil`
+#
+# If there are changes to CSS or JS files, we may get requests
+# for the old versions on the new container and vice-versa.
+#
+# To avoid 404s we can specify an asset path.
+# Kamal will replace that path in the container with a mapped
+# volume containing both sets of files.
+# This requires that file names change when the contents change
+# (e.g. by including a hash of the contents in the name).
+
+# To configure this, set the path to the assets:
+asset_path: /path/to/assets
+
+# Require destinations
+#
+# Whether deployments require a destination to be specified, defaults to `false`
+require_destination: true
+
+# The primary role
+#
+# This defaults to `web`, but if you have no web role, you can change this
+primary_role: workers
+
+# Allowing empty roles
+#
+# Whether roles with no servers are allowed. Defaults to `false`.
+allow_empty_roles: false
+
+# Stop wait time
+#
+# How long we wait for a container to stop before killing it, defaults to 30 seconds
+stop_wait_time: 60
+
+# Retain containers
+#
+# How many old containers and images we retain, defaults to 5
+retain_containers: 3
+
+# Minimum version
+#
+# The minimum version of Kamal required to deploy this configuration, defaults to nil
+minimum_version: 1.3.0
+
+# Readiness delay
+#
+# Seconds to wait for a container to boot after is running, default 7
+# This only applies to containers that do not specify a healthcheck
+readiness_delay: 4
+
+# Run directory
+#
+# Directory to store kamal runtime files in on the host, default `.kamal`
+run_directory: /etc/kamal
+
+# SSH options
+#
+# See kamal docs ssh
+ssh:
+  ...
+
+# Builder options
+#
+# See kamal docs builder
+builder:
+  ...
+
+# Accessories
+#
+# Additionals services to run in Docker, see kamal docs accessory
+accessories:
+  ...
+
+# Traefik
+#
+# The Traefik proxy is used for zero-downtime deployments, see kamal docs traefik
+traefik:
+  ...
+
+# SSHKit
+#
+# See kamal docs sshkit
+sshkit:
+  ...
+
+# Boot options
+#
+# See kamal docs boot
+boot:
+  ...
+
+# Healthcheck
+#
+# Configuring healthcheck commands, intervals and timeouts, see kamal docs healthcheck
+healthcheck:
+  ...
+
+# Logging
+#
+# Docker logging configuration, see kamal docs logging
+logging:
+  ...

lib/kamal/configuration/docs/env.yml

@@ -0,0 +1,72 @@
+# Environment variables
+#
+# Environment variables can be set directory in the Kamal configuration or
+# for loaded from a .env file, for secrets that should not be checked into Git.
+
+# Reading environment variables from the configuration
+#
+# Environment variables can be set directly in the configuration file.
+#
+# These are passed to the docker run command when deploying.
+env:
+  DATABASE_HOST: mysql-db1
+  DATABASE_PORT: 3306
+
+# Using .env file to load required environment variables
+#
+# Kamal uses dotenv to automatically load environment variables set in the .env file present
+# in the application root.
+#
+# This file can be used to set variables like KAMAL_REGISTRY_PASSWORD or database passwords.
+# But for this reason you must ensure that .env files are not checked into Git or included
+# in your Dockerfile! The format is just key-value like:
+# ```
+# KAMAL_REGISTRY_PASSWORD=pw
+# DB_PASSWORD=secret123
+# ```
+# See https://kamal-deploy.org/docs/commands/env/ for how to use generated .env files.
+#
+# To pass the secrets you should list them under the `secret` key. When you do this the
+# other variables need to be moved under the `clear` key.
+#
+# Unlike clear values, secrets are not passed directly to the container,
+# but are stored in an env file on the host
+# The file is not updated when deploying, only when running `kamal env push`.
+env:
+  clear:
+    DB_USER: app
+  secret:
+    - DB_PASSWORD
+
+# Tags
+#
+# Tags are used to add extra env variables to specific hosts.
+# See kamal docs servers for how to tag hosts.
+#
+# Tags are only allowed in the top level env configuration (i.e not under a role specific env).
+#
+# The env variables can be specified with secret and clear values as explained above.
+env:
+  tags:
+    <tag1>:
+      MYSQL_USER: monitoring
+    <tag2>:
+      clear:
+        MYSQL_USER: readonly
+      secret:
+        - MYSQL_PASSWORD
+
+# Example configuration
+env:
+  clear:
+    MYSQL_USER: app
+  secret:
+    - MYSQL_PASSWORD
+  tags:
+    monitoring:
+      MYSQL_USER: monitoring
+    replica:
+      clear:
+        MYSQL_USER: readonly
+      secret:
+        - READONLY_PASSWORD

lib/kamal/configuration/docs/healthcheck.yml

@@ -0,0 +1,59 @@
+# Healthcheck configuration
+#
+# On roles that are running Traefik, Kamal will supply a default healthcheck to `docker run`.
+# For other roles, by default no healthcheck is supplied.
+#
+# If no healthcheck is supplied and the image does not define one, they we wait for the container
+# to reach a running state and then pause for the readiness delay.
+#
+# The default healthcheck is `curl -f http://localhost:<port>/<path>`, so it assumes that `curl`
+# is available within the container.
+
+# Healthcheck options
+#
+# These go under the `healthcheck` key in the root or role configuration.
+healthcheck:
+
+  # Command
+  #
+  # The command to run, defaults to `curl -f http://localhost:<port>/<path>` on roles running Traefik
+  cmd: "curl -f http://localhost"
+
+  # Interval
+  #
+  # The Docker healthcheck interval, defaults to `1s`
+  interval: 10s
+
+  # Max attempts
+  #
+  # The maximum number of times we poll the container to see if it is healthy, defaults to `7`
+  # Each check is separated by an increasing interval starting with 1 second.
+  max_attempts: 3
+
+  # Port
+  #
+  # The port to use in the healthcheck, defaults to `3000`
+  port: "80"
+
+  # Path
+  #
+  # The path to use in the healthcheck, defaults to `/up`
+  path: /health
+
+  # Cords for zero-downtime deployments
+  #
+  # The cord file is used for zero-downtime deployments. The healthcheck is augmented with a check
+  # for the existance of the file. This allows us to delete the file and force the container to
+  # become unhealthy, causing Traefik to stop routing traffic to it.
+  #
+  # Kamal mounts a volume at this location and creates the file before starting the container.
+  # You can set the value to `false` to disable the cord file, but this loses the zero-downtime
+  # guarantee.
+  #
+  # The default value is `/tmp/kamal-cord`
+  cord: /cord
+
+  # Log lines
+  #
+  # Number of lines to log from the container when the healthcheck fails, defaults to `50`
+  log_lines: 100

lib/kamal/configuration/docs/logging.yml

@@ -0,0 +1,21 @@
+# Custom logging configuration
+#
+# Set these to control the Docker logging driver and options.
+
+# Logging settings
+#
+# These go under the logging key in the configuration file.
+#
+# This can be specified in the root level or for a specific role.
+logging:
+
+  # Driver
+  #
+  # The logging driver to use, passed to Docker via `--log-driver`
+  driver: json-file
+
+  # Options
+  #
+  # Any logging options to pass to the driver, passed to Docker via `--log-opt`
+  options:
+    max-size: 100m

lib/kamal/configuration/docs/registry.yml

@@ -0,0 +1,49 @@
+# Registry
+#
+# The default registry is Docker Hub, but you can change it using registry/server:
+#
+# A reference to secret (in this case DOCKER_REGISTRY_TOKEN) will look up the secret
+# in the local environment.
+
+registry:
+  server: registry.digitalocean.com
+  username:
+    - DOCKER_REGISTRY_TOKEN
+  password:
+    - DOCKER_REGISTRY_TOKEN
+
+# Using AWS ECR as the container registry
+# You will need to have the aws CLI installed locally for this to work.
+# AWS ECR’s access token is only valid for 12hrs. In order to not have to manually regenerate the token every time, you can use ERB in the deploy.yml file to shell out to the aws cli command, and obtain the token:
+
+registry:
+  server: <your aws account id>.dkr.ecr.<your aws region id>.amazonaws.com
+  username: AWS
+  password: <%= %x(aws ecr get-login-password) %>
+
+# Using GCP Artifact Registry as the container registry
+# To sign into Artifact Registry, you would need to
+# [create a service account](https://cloud.google.com/iam/docs/service-accounts-create#creating)
+# and [set up roles and permissions](https://cloud.google.com/artifact-registry/docs/access-control#permissions).
+# Normally, assigning a roles/artifactregistry.writer role should be sufficient.
+#
+# Once the service account is ready, you need to generate and download a JSON key, base64 encode it and add to .env:
+#
+# ```shell
+# echo "KAMAL_REGISTRY_PASSWORD=$(base64 -i /path/to/key.json)" | tr -d "\\n"  >> .env
+# ```
+# Use the env variable as password along with _json_key_base64 as username.
+# Here’s the final configuration:
+
+registry:
+  server: <your registry region>-docker.pkg.dev
+  username: _json_key_base64
+  password:
+    - KAMAL_REGISTRY_PASSWORD
+
+# Validating the configuration
+#
+# You can validate the configuration by running:
+# ```shell
+# kamal registry login
+# ```

lib/kamal/configuration/docs/role.yml

@@ -0,0 +1,52 @@
+# Roles
+#
+# Roles are used to configure different types of servers in the deployment.
+# The most common use for this is to run a web servers and job servers.
+#
+# Kamal expects there to be a `web` role, unless you set a different `primary_role`
+# in the root configuration.
+
+# Role configuration
+#
+# Roles are specified under the servers key
+servers:
+
+  # Simple role configuration
+  #
+  #
+  # This can be a list of hosts, if you don't need custom configuration for the role.
+  #
+  # You can set tags on the hosts for custom env variables (see kamal docs env)
+  web:
+    - 172.1.0.1
+    - 172.1.0.2: experiment1
+    - 172.1.0.2: [ experiment1, experiment2 ]
+
+  # Custom role configuration
+  #
+  # When there are other options to set, the list of hosts goes under the `hosts` key
+  #
+  # By default only the primary role uses Traefik, but you can set `traefik` to change
+  # it.
+  #
+  # You can also set a custom cmd to run in the container, and overwrite other settings
+  # from the root configuration.
+  workers:
+    hosts:
+      - 172.1.0.3
+      - 172.1.0.4: experiment1
+    traefik: true
+    cmd: "bin/jobs"
+    options:
+      memory: 2g
+      cpus: 4
+    healthcheck:
+      ...
+    logging:
+      ...
+    labels:
+      my-label: workers
+    env:
+      ...
+    asset_path: /public
+

lib/kamal/configuration/docs/servers.yml

@@ -0,0 +1,27 @@
+# Servers
+#
+# Servers are split into different roles, with each role having its own configuration.
+#
+# For simpler deployments though where all servers are identical, you can just specify a list of servers
+# They will be implicitly assigned to the `web` role.
+servers:
+  - 172.0.0.1
+  - 172.0.0.2
+  - 172.0.0.3
+
+# Tagging servers
+#
+# Servers can be tagged, with the tags used to add custom env variables (see kamal docs env).
+servers:
+  - 172.0.0.1
+  - 172.0.0.2: experiments
+  - 172.0.0.3: [ experiments, three ]
+
+# Roles
+#
+# For more complex deployments (e.g. if you are running job hosts), you can specify roles, and configure each separately (see kamal docs role)
+servers:
+  web:
+    ...
+  workers:
+    ...

lib/kamal/configuration/docs/ssh.yml

@@ -0,0 +1,66 @@
+# SSH configuration
+#
+# Kamal uses SSH to connect run commands on your hosts.
+# By default it will attempt to connect to the root user on port 22
+#
+# If you are using non-root user, you may need to bootstrap your servers manually, before using them with Kamal. On Ubuntu, you’d do:
+#
+# ```shell
+# sudo apt update
+# sudo apt upgrade -y
+# sudo apt install -y docker.io curl git
+# sudo usermod -a -G docker app
+# ```
+
+
+# SSH options
+#
+# The options are specified under the ssh key in the configuration file.
+ssh:
+
+  # The SSH user
+  #
+  # Defaults to `root`
+  #
+  user: app
+
+  # The SSH port
+  #
+  # Defaults to 22
+  port: "2222"
+
+  # Proxy host
+  #
+  # Specified in the form <host> or <user>@<host>
+  proxy: root@proxy-host
+
+  # Proxy command
+  #
+  # A custom proxy command, required for older versions of SSH
+  proxy_command: "ssh -W %h:%p user@proxy"
+
+  # Log level
+  #
+  # Defaults to `fatal`. Set this to debug if you are having
+  # SSH connection issues.
+  log_level: debug
+
+  # Keys Only
+  #
+  # Set to true to use only private keys from keys and key_data parameters, 
+  # even if ssh-agent offers more identities. This option is intended for 
+  # situations where ssh-agent offers many different identites or you have 
+  # a need to overwrite all identites and force a single one.
+  keys_only: false
+
+  # Keys
+  #
+  # An array of file names of private keys to use for publickey
+  # and hostbased authentication
+  keys: [ "~/.ssh/id.pem" ]
+
+  # Key Data
+  #
+  # An array of strings, with each element of the array being
+  # a raw private key in PEM format.
+  key_data: [ "-----BEGIN OPENSSH PRIVATE KEY-----" ]

lib/kamal/configuration/docs/sshkit.yml

@@ -0,0 +1,23 @@
+# SSHKit
+#
+# [SSHKit](https://github.com/capistrano/sshkit) is the SSH toolkit used by Kamal.
+#
+# The default settings should be sufficient for most use cases, but
+# when connecting to a large number of hosts you may need to adjust
+
+# SSHKit options
+#
+# The options are specified under the sshkit key in the configuration file.
+sshkit:
+
+  # Max concurrent starts
+  #
+  # Creating SSH connections concurrently can be an issue when deploying to many servers.
+  # By default Kamal will limit concurrent connection starts to 30 at a time.
+  max_concurrent_starts: 10
+
+  # Pool idle timeout
+  #
+  # Kamal sets a long idle timeout of 900 seconds on connections to try to avoid
+  # re-connection storms after an idle period, like building an image or waiting for CI.
+  pool_idle_timeout: 300

lib/kamal/configuration/docs/traefik.yml

@@ -0,0 +1,62 @@
+# Traefik
+#
+# Traefik is a reverse proxy, used by Kamal for zero-downtime deployments.
+#
+# We start an instance on the hosts in it's own container.
+#
+# During a deployment:
+# 1. We start a new container which Traefik automatically detects due to the labels we have applied
+# 2. Traefik starts routing traffic to the new container
+# 3. We force the old container to fail it's healthcheck, causing Traefik to stop routing traffic to it
+# 4. We stop the old container
+
+# Traefik settings
+#
+# Traekik is configured in the root configuration under `traefik`.
+traefik:
+
+  # Image
+  #
+  # The Traefik image to use, defaults to `traefik:v2.10`
+  image: traefik:v2.9
+
+  # Host port
+  #
+  # The host port to publish the Traefik container on, defaults to `80`
+  host_port: "8080"
+
+  # Disabling publishing
+  #
+  # To avoid publishing the Traefik container, set this to `false`
+  publish: false
+
+  # Labels
+  #
+  # Additional labels to apply to the Traefik container
+  labels:
+    traefik.http.routers.catchall.entryPoints: http
+    traefik.http.routers.catchall.rule: PathPrefix(`/`)
+    traefik.http.routers.catchall.service: unavailable
+    traefik.http.routers.catchall.priority: "1"
+    traefik.http.services.unavailable.loadbalancer.server.port: "0"
+
+  # Arguments
+  #
+  # Additional arguments to pass to the Traefik container
+  args:
+    entryPoints.http.address: ":80"
+    entryPoints.http.forwardedHeaders.insecure: true
+    accesslog: true
+    accesslog.format: json
+
+  # Options
+  #
+  # Additional options to pass to `docker run`
+  options:
+    cpus: 2
+
+  # Environment variables
+  #
+  # See kamal docs env
+  env:
+    ...

lib/kamal/configuration/env.rb

@@ -1,18 +1,15 @@
 class Kamal::Configuration::Env
-  attr_reader :secrets_keys, :clear, :secrets_file
+  include Kamal::Configuration::Validation
+
+  attr_reader :secrets_keys, :clear, :secrets_file, :context
   delegate :argumentize, to: Kamal::Utils
 
-  def self.from_config(config:, secrets_file: nil)
+  def initialize(config:, secrets_file: nil, context: "env")
-    secrets_keys = config.fetch("secret", [])
+    @clear = config.fetch("clear", config.key?("secret") || config.key?("tags") ? {} : config)
-    clear = config.fetch("clear", config.key?("secret") || config.key?("tags") ? {} : config)
+    @secrets_keys = config.fetch("secret", [])
-
-    new clear: clear, secrets_keys: secrets_keys, secrets_file: secrets_file
-  end
-
-  def initialize(clear:, secrets_keys:, secrets_file:)
-    @clear = clear
-    @secrets_keys = secrets_keys
     @secrets_file = secrets_file
+    @context = context
+    validate! config, context: context, with: Kamal::Configuration::Validator::Env
   end
 
   def args
@@ -33,8 +30,7 @@ class Kamal::Configuration::Env
 
   def merge(other)
     self.class.new \
-      clear: @clear.merge(other.clear),
+      config: { "clear" => clear.merge(other.clear), "secret" => secrets_keys | other.secrets_keys },
-      secrets_keys: @secrets_keys | other.secrets_keys,
+      secrets_file: secrets_file || other.secrets_file
-      secrets_file: secrets_file
   end
 end

lib/kamal/configuration/env/tag.rb

@@ -7,6 +7,6 @@ class Kamal::Configuration::Env::Tag
   end
 
   def env
-    Kamal::Configuration::Env.from_config(config: config)
+    Kamal::Configuration::Env.new(config: config)
   end
 end

lib/kamal/configuration/healthcheck.rb

@@ -0,0 +1,63 @@
+class Kamal::Configuration::Healthcheck
+  include Kamal::Configuration::Validation
+
+  attr_reader :healthcheck_config
+
+  def initialize(healthcheck_config:, context: "healthcheck")
+    @healthcheck_config = healthcheck_config || {}
+    validate! @healthcheck_config, context: context
+  end
+
+  def merge(other)
+    self.class.new healthcheck_config: healthcheck_config.deep_merge(other.healthcheck_config)
+  end
+
+  def cmd
+    healthcheck_config.fetch("cmd", http_health_check)
+  end
+
+  def port
+    healthcheck_config.fetch("port", 3000)
+  end
+
+  def path
+    healthcheck_config.fetch("path", "/up")
+  end
+
+  def max_attempts
+    healthcheck_config.fetch("max_attempts", 7)
+  end
+
+  def interval
+    healthcheck_config.fetch("interval", "1s")
+  end
+
+  def cord
+    healthcheck_config.fetch("cord", "/tmp/kamal-cord")
+  end
+
+  def log_lines
+    healthcheck_config.fetch("log_lines", 50)
+  end
+
+  def set_port_or_path?
+    healthcheck_config["port"].present? || healthcheck_config["path"].present?
+  end
+
+  def to_h
+    {
+      "cmd" => cmd,
+      "interval" => interval,
+      "max_attempts" => max_attempts,
+      "port" => port,
+      "path" => path,
+      "cord" => cord,
+      "log_lines" => log_lines
+    }
+  end
+
+  private
+    def http_health_check
+      "curl -f #{URI.join("http://localhost:#{port}", path)} || exit 1" if path.present? || port.present?
+    end
+end

lib/kamal/configuration/logging.rb

@@ -0,0 +1,33 @@
+class Kamal::Configuration::Logging
+  delegate :optionize, :argumentize, to: Kamal::Utils
+
+  include Kamal::Configuration::Validation
+
+  attr_reader :logging_config
+
+  def initialize(logging_config:, context: "logging")
+    @logging_config = logging_config || {}
+    validate! @logging_config, context: context
+  end
+
+  def driver
+    logging_config["driver"]
+  end
+
+  def options
+    logging_config.fetch("options", {})
+  end
+
+  def merge(other)
+    self.class.new logging_config: logging_config.deep_merge(other.logging_config)
+  end
+
+  def args
+    if driver.present? || options.present?
+      optionize({ "log-driver" => driver }.compact) +
+        argumentize("--log-opt", options)
+    else
+      argumentize("--log-opt", { "max-size" => "10m" })
+    end
+  end
+end

lib/kamal/configuration/registry.rb

@@ -0,0 +1,31 @@
+class Kamal::Configuration::Registry
+  include Kamal::Configuration::Validation
+
+  attr_reader :registry_config
+
+  def initialize(config:)
+    @registry_config = config.raw_config.registry || {}
+    validate! registry_config, with: Kamal::Configuration::Validator::Registry
+  end
+
+  def server
+    registry_config["server"]
+  end
+
+  def username
+    lookup("username")
+  end
+
+  def password
+    lookup("password")
+  end
+
+  private
+    def lookup(key)
+      if registry_config[key].is_a?(Array)
+        ENV.fetch(registry_config[key].first).dup
+      else
+        registry_config[key]
+      end
+    end
+end

lib/kamal/configuration/role.rb

@@ -1,13 +1,33 @@
 class Kamal::Configuration::Role
+  include Kamal::Configuration::Validation
+
   CORD_FILE = "cord"
   delegate :argumentize, :optionize, to: Kamal::Utils
 
-  attr_accessor :name
+  attr_reader :name, :config, :specialized_env, :specialized_logging, :specialized_healthcheck
+
   alias to_s name
 
   def initialize(name, config:)
     @name, @config = name.inquiry, config
-    @tagged_hosts ||= extract_tagged_hosts_from_config
+    validate! \
+      specializations,
+      example: validation_yml["servers"]["workers"],
+      context: "servers/#{name}",
+      with: Kamal::Configuration::Validator::Role
+
+    @specialized_env = Kamal::Configuration::Env.new \
+      config: specializations.fetch("env", {}),
+      secrets_file: File.join(config.host_env_directory, "roles", "#{container_prefix}.env"),
+      context: "servers/#{name}/env"
+
+    @specialized_logging = Kamal::Configuration::Logging.new \
+      logging_config: specializations.fetch("logging", {}),
+      context: "servers/#{name}/logging"
+
+    @specialized_healthcheck = Kamal::Configuration::Healthcheck.new \
+      healthcheck_config: specializations.fetch("healthcheck", {}),
+      context: "servers/#{name}/healthcheck"
   end
 
   def primary_host
@@ -43,21 +63,17 @@ class Kamal::Configuration::Role
   end
 
   def logging_args
-    args = config.logging || {}
+    logging.args
-    args.deep_merge!(specializations["logging"]) if specializations["logging"].present?
+  end
 
-    if args.any?
+  def logging
-      optionize({ "log-driver" => args["driver"] }.compact) +
+    @logging ||= config.logging.merge(specialized_logging)
-        argumentize("--log-opt", args["options"])
-    else
-      config.logging_args
-    end
   end
 
 
   def env(host)
     @envs ||= {}
-    @envs[host] ||= [ base_env, specialized_env, *env_tags(host).map(&:env) ].reduce(:merge)
+    @envs[host] ||= [ config.env, specialized_env, *env_tags(host).map(&:env) ].reduce(:merge)
   end
 
   def env_args(host)
@@ -70,28 +86,29 @@ class Kamal::Configuration::Role
 
 
   def health_check_args(cord: true)
-    if health_check_cmd.present?
+    if running_traefik? || healthcheck.set_port_or_path?
       if cord && uses_cord?
-        optionize({ "health-cmd" => health_check_cmd_with_cord, "health-interval" => health_check_interval })
+        optionize({ "health-cmd" => health_check_cmd_with_cord, "health-interval" => healthcheck.interval })
           .concat(cord_volume.docker_args)
       else
-        optionize({ "health-cmd" => health_check_cmd, "health-interval" => health_check_interval })
+        optionize({ "health-cmd" => healthcheck.cmd, "health-interval" => healthcheck.interval })
       end
     else
       []
     end
   end
 
-  def health_check_cmd
+  def healthcheck
-    health_check_options["cmd"] || http_health_check(port: health_check_options["port"], path: health_check_options["path"])
+    @healthcheck ||=
+      if running_traefik?
+        config.healthcheck.merge(specialized_healthcheck)
+      else
+        specialized_healthcheck
+      end
   end
 
   def health_check_cmd_with_cord
-    "(#{health_check_cmd}) && (stat #{cord_container_file} > /dev/null || exit 1)"
+    "(#{healthcheck.cmd}) && (stat #{cord_container_file} > /dev/null || exit 1)"
-  end
-
-  def health_check_interval
-    health_check_options["interval"] || "1s"
   end
 
 
@@ -109,7 +126,7 @@ class Kamal::Configuration::Role
 
 
   def uses_cord?
-    running_traefik? && cord_volume && health_check_cmd.present?
+    running_traefik? && cord_volume && healthcheck.cmd.present?
   end
 
   def cord_host_directory
@@ -117,7 +134,7 @@ class Kamal::Configuration::Role
   end
 
   def cord_volume
-    if (cord = health_check_options["cord"])
+    if (cord = healthcheck.cord)
       @cord_volume ||= Kamal::Configuration::Volume.new \
         host_path: File.join(config.run_directory, "cords", [ container_prefix, config.run_id ].join("-")),
         container_path: cord
@@ -170,30 +187,24 @@ class Kamal::Configuration::Role
   end
 
   private
-    attr_accessor :config, :tagged_hosts
+    def tagged_hosts
-
-    def extract_tagged_hosts_from_config
       {}.tap do |tagged_hosts|
         extract_hosts_from_config.map do |host_config|
           if host_config.is_a?(Hash)
-            raise ArgumentError, "Multiple hosts found: #{host_config.inspect}" unless host_config.size == 1
-
             host, tags = host_config.first
             tagged_hosts[host] = Array(tags)
-          elsif host_config.is_a?(String) || host_config.is_a?(Symbol)
+          elsif host_config.is_a?(String)
             tagged_hosts[host_config] = []
-          else
-            raise ArgumentError, "Invalid host config: #{host_config.inspect}"
           end
         end
       end
     end
 
     def extract_hosts_from_config
-      if config.servers.is_a?(Array)
+      if config.raw_config.servers.is_a?(Array)
-        config.servers
+        config.raw_config.servers
       else
-        servers = config.servers[name]
+        servers = config.raw_config.servers[name]
         servers.is_a?(Array) ? servers : Array(servers["hosts"])
       end
     end
@@ -202,6 +213,14 @@ class Kamal::Configuration::Role
       { "service" => config.service, "role" => name, "destination" => config.destination }
     end
 
+    def specializations
+      if config.raw_config.servers.is_a?(Array) || config.raw_config.servers[name].is_a?(Array)
+        {}
+      else
+        config.raw_config.servers[name]
+      end
+    end
+
     def traefik_labels
       if running_traefik?
         {
@@ -229,35 +248,4 @@ class Kamal::Configuration::Role
         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].except("hosts")
-      end
-    end
-
-    def specialized_env
-      Kamal::Configuration::Env.from_config config: specializations.fetch("env", {})
-    end
-
-    # Secrets are stored in an array, which won't merge by default, so have to do it by hand.
-    def base_env
-      Kamal::Configuration::Env.from_config \
-        config: config.env,
-        secrets_file: File.join(config.host_env_directory, "roles", "#{container_prefix}.env")
-    end
-
-    def http_health_check(port:, path:)
-      "curl -f #{URI.join("http://localhost:#{port}", path)} || exit 1" if path.present? || port.present?
-    end
-
-    def health_check_options
-      @health_check_options ||= begin
-        options = specializations["healthcheck"] || {}
-        options = config.healthcheck.merge(options) if running_traefik?
-        options
-      end
-    end
 end

lib/kamal/configuration/servers.rb

@@ -0,0 +1,18 @@
+class Kamal::Configuration::Servers
+  include Kamal::Configuration::Validation
+
+  attr_reader :config, :servers_config, :roles
+
+  def initialize(config:)
+    @config = config
+    @servers_config = config.raw_config.servers
+    validate! servers_config, with: Kamal::Configuration::Validator::Servers
+
+    @roles = role_names.map { |role_name| Kamal::Configuration::Role.new role_name, config: config }
+  end
+
+  private
+    def role_names
+      servers_config.is_a?(Array) ? [ "web" ] : servers_config.keys.sort
+    end
+end

lib/kamal/configuration/ssh.rb

@@ -1,28 +1,45 @@
 class Kamal::Configuration::Ssh
   LOGGER = ::Logger.new(STDERR)
 
+  include Kamal::Configuration::Validation
+
+  attr_reader :ssh_config
+
   def initialize(config:)
-    @config = config.raw_config.ssh || {}
+    @ssh_config = config.raw_config.ssh || {}
+    validate! ssh_config
   end
 
   def user
-    config.fetch("user", "root")
+    ssh_config.fetch("user", "root")
   end
 
   def port
-    config.fetch("port", 22)
+    ssh_config.fetch("port", 22)
   end
 
   def proxy
-    if (proxy = config["proxy"])
+    if (proxy = ssh_config["proxy"])
       Net::SSH::Proxy::Jump.new(proxy.include?("@") ? proxy : "root@#{proxy}")
-    elsif (proxy_command = config["proxy_command"])
+    elsif (proxy_command = ssh_config["proxy_command"])
       Net::SSH::Proxy::Command.new(proxy_command)
     end
   end
 
+  def keys_only
+    ssh_config["keys_only"]
+  end
+
+  def keys
+    ssh_config["keys"]
+  end
+
+  def key_data
+    ssh_config["key_data"]
+  end
+
   def options
-    { user: user, port: port, proxy: proxy, logger: logger, keepalive: true, keepalive_interval: 30 }.compact
+    { user: user, port: port, proxy: proxy, logger: logger, keepalive: true, keepalive_interval: 30, keys_only: keys_only, keys: keys, key_data: key_data }.compact
   end
 
   def to_h
@@ -30,13 +47,11 @@ class Kamal::Configuration::Ssh
   end
 
   private
-    attr_accessor :config
-
     def logger
       LOGGER.tap { |logger| logger.level = log_level }
     end
 
     def log_level
-      config.fetch("log_level", :fatal)
+      ssh_config.fetch("log_level", :fatal)
     end
 end

lib/kamal/configuration/sshkit.rb

@@ -1,20 +1,22 @@
 class Kamal::Configuration::Sshkit
+  include Kamal::Configuration::Validation
+
+  attr_reader :sshkit_config
+
   def initialize(config:)
-    @options = config.raw_config.sshkit || {}
+    @sshkit_config = config.raw_config.sshkit || {}
+    validate! sshkit_config
   end
 
   def max_concurrent_starts
-    options.fetch("max_concurrent_starts", 30)
+    sshkit_config.fetch("max_concurrent_starts", 30)
   end
 
   def pool_idle_timeout
-    options.fetch("pool_idle_timeout", 900)
+    sshkit_config.fetch("pool_idle_timeout", 900)
   end
 
   def to_h
-    options
+    sshkit_config
   end
-
-  private
-    attr_accessor :options
 end

lib/kamal/configuration/traefik.rb

@@ -0,0 +1,60 @@
+class Kamal::Configuration::Traefik
+  DEFAULT_IMAGE = "traefik:v2.10"
+  CONTAINER_PORT = 80
+  DEFAULT_ARGS = {
+    "log.level" => "DEBUG"
+  }
+  DEFAULT_LABELS = {
+    # These ensure we serve a 502 rather than a 404 if no containers are available
+    "traefik.http.routers.catchall.entryPoints" => "http",
+    "traefik.http.routers.catchall.rule" => "PathPrefix(`/`)",
+    "traefik.http.routers.catchall.service" => "unavailable",
+    "traefik.http.routers.catchall.priority" => 1,
+    "traefik.http.services.unavailable.loadbalancer.server.port" => "0"
+  }
+
+  include Kamal::Configuration::Validation
+
+  attr_reader :config, :traefik_config
+
+  def initialize(config:)
+    @config = config
+    @traefik_config = config.raw_config.traefik || {}
+    validate! traefik_config
+  end
+
+  def publish?
+    traefik_config["publish"] != false
+  end
+
+  def labels
+    DEFAULT_LABELS.merge(traefik_config["labels"] || {})
+  end
+
+  def env
+    Kamal::Configuration::Env.new \
+      config: traefik_config.fetch("env", {}),
+      secrets_file: File.join(config.host_env_directory, "traefik", "traefik.env"),
+      context: "traefik/env"
+  end
+
+  def host_port
+    traefik_config.fetch("host_port", CONTAINER_PORT)
+  end
+
+  def options
+    traefik_config.fetch("options", {})
+  end
+
+  def port
+    "#{host_port}:#{CONTAINER_PORT}"
+  end
+
+  def args
+    DEFAULT_ARGS.merge(traefik_config.fetch("args", {}))
+  end
+
+  def image
+    traefik_config.fetch("image", DEFAULT_IMAGE)
+  end
+end

lib/kamal/configuration/validation.rb

@@ -0,0 +1,27 @@
+require "yaml"
+require "active_support/inflector"
+
+module Kamal::Configuration::Validation
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def validation_doc
+      @validation_doc ||= File.read(File.join(File.dirname(__FILE__), "docs", "#{validation_config_key}.yml"))
+    end
+
+    def validation_config_key
+      @validation_config_key ||= name.demodulize.underscore
+    end
+  end
+
+  def validate!(config, example: nil, context: nil, with: Kamal::Configuration::Validator)
+    context ||= self.class.validation_config_key
+    example ||= validation_yml[self.class.validation_config_key]
+
+    with.new(config, example: example, context: context).validate!
+  end
+
+  def validation_yml
+    @validation_yml ||= YAML.load(self.class.validation_doc)
+  end
+end

lib/kamal/configuration/validator.rb

@@ -0,0 +1,153 @@
+class Kamal::Configuration::Validator
+  attr_reader :config, :example, :context
+
+  def initialize(config, example:, context:)
+    @config = config
+    @example = example
+    @context = context
+  end
+
+  def validate!
+    validate_against_example! config, example
+  end
+
+  private
+    def validate_against_example!(validation_config, example)
+      validate_type! validation_config, Hash
+
+      check_unknown_keys! validation_config, example
+
+      validation_config.each do |key, value|
+        next if extension?(key)
+        with_context(key) do
+          example_value = example[key]
+
+          if example_value == "..."
+            validate_type! value, *(Array if key == :servers), Hash
+          elsif key == "hosts"
+            validate_servers! value
+          elsif example_value.is_a?(Array)
+            validate_array_of! value, example_value.first.class
+          elsif example_value.is_a?(Hash)
+            case key.to_s
+            when "options", "args"
+              validate_type! value, Hash
+            when "labels"
+              validate_hash_of! value, example_value.first[1].class
+            else
+              validate_against_example! value, example_value
+            end
+          else
+            validate_type! value, example_value.class
+          end
+        end
+      end
+    end
+
+
+    def valid_type?(value, type)
+      value.is_a?(type) ||
+        (type == String && stringish?(value)) ||
+        (boolean?(type) && boolean?(value.class))
+    end
+
+    def type_description(type)
+      if type == Integer || type == Array
+        "an #{type.name.downcase}"
+      elsif type == TrueClass || type == FalseClass
+        "a boolean"
+      else
+        "a #{type.name.downcase}"
+      end
+    end
+
+    def boolean?(type)
+      type == TrueClass || type == FalseClass
+    end
+
+    def stringish?(value)
+      value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    end
+
+    def validate_array_of!(array, type)
+      validate_type! array, Array
+
+      array.each_with_index do |value, index|
+        with_context(index) do
+          validate_type! value, type
+        end
+      end
+    end
+
+    def validate_hash_of!(hash, type)
+      validate_type! hash, Hash
+
+      hash.each do |key, value|
+        with_context(key) do
+          validate_type! value, type
+        end
+      end
+    end
+
+    def validate_servers!(servers)
+      validate_type! servers, Array
+
+      servers.each_with_index do |server, index|
+        with_context(index) do
+          validate_type! server, String, Hash
+
+          if server.is_a?(Hash)
+            error "multiple hosts found" unless server.size == 1
+            host, tags = server.first
+
+            with_context(host) do
+              validate_type! tags, String, Array
+              validate_array_of! tags, String if tags.is_a?(Array)
+            end
+          end
+        end
+      end
+    end
+
+    def validate_type!(value, *types)
+      type_error(*types) unless types.any? { |type| valid_type?(value, type) }
+    end
+
+    def error(message)
+      raise Kamal::ConfigurationError, "#{error_context}#{message}"
+    end
+
+    def type_error(*expected_types)
+      error "should be #{expected_types.map { |type| type_description(type) }.join(" or ")}"
+    end
+
+    def unknown_keys_error(unknown_keys)
+      error "unknown #{"key".pluralize(unknown_keys.count)}: #{unknown_keys.join(", ")}"
+    end
+
+    def error_context
+      "#{context}: " if context.present?
+    end
+
+    def with_context(context)
+      old_context = @context
+      @context = [ @context, context ].select(&:present?).join("/")
+      yield
+    ensure
+      @context = old_context
+    end
+
+    def allow_extensions?
+      false
+    end
+
+    def extension?(key)
+      key.to_s.start_with?("x-")
+    end
+
+    def check_unknown_keys!(config, example)
+      unknown_keys = config.keys - example.keys
+      unknown_keys.reject! { |key| extension?(key) } if allow_extensions?
+      unknown_keys_error unknown_keys if unknown_keys.present?
+    end
+end

lib/kamal/configuration/validator/accessory.rb

@@ -0,0 +1,9 @@
+class Kamal::Configuration::Validator::Accessory < Kamal::Configuration::Validator
+  def validate!
+    super
+
+    if (config.keys & [ "host", "hosts", "roles" ]).size != 1
+      error "specify one of `host`, `hosts` or `roles`"
+    end
+  end
+end

lib/kamal/configuration/validator/builder.rb

@@ -0,0 +1,9 @@
+class Kamal::Configuration::Validator::Builder < Kamal::Configuration::Validator
+  def validate!
+    super
+
+    if config["cache"] && config["cache"]["type"]
+      error "Invalid cache type: #{config["cache"]["type"]}" unless [ "gha", "registry" ].include?(config["cache"]["type"])
+    end
+  end
+end

lib/kamal/configuration/validator/configuration.rb

@@ -0,0 +1,6 @@
+class Kamal::Configuration::Validator::Configuration < Kamal::Configuration::Validator
+  private
+    def allow_extensions?
+      true
+    end
+end

lib/kamal/configuration/validator/env.rb

@@ -0,0 +1,54 @@
+class Kamal::Configuration::Validator::Env < Kamal::Configuration::Validator
+  SPECIAL_KEYS = [ "clear", "secret", "tags" ]
+
+  def validate!
+    if known_keys.any?
+      validate_complex_env!
+    else
+      validate_simple_env!
+    end
+  end
+
+  private
+    def validate_simple_env!
+      validate_hash_of!(config, String)
+    end
+
+    def validate_complex_env!
+      unknown_keys_error unknown_keys if unknown_keys.any?
+
+      with_context("clear") { validate_hash_of!(config["clear"], String) } if config.key?("clear")
+      with_context("secret") { validate_array_of!(config["secret"], String) } if config.key?("secret")
+      validate_tags! if config.key?("tags")
+    end
+
+    def known_keys
+      @known_keys ||= config.keys & SPECIAL_KEYS
+    end
+
+    def unknown_keys
+      @unknown_keys ||= config.keys - SPECIAL_KEYS
+    end
+
+    def validate_tags!
+      if context == "env"
+        with_context("tags") do
+          validate_type! config["tags"], Hash
+
+          config["tags"].each do |tag, value|
+            with_context(tag) do
+              validate_type! value, Hash
+
+              Kamal::Configuration::Validator::Env.new(
+                value,
+                example: example["tags"].values[1],
+                context: context
+              ).validate!
+            end
+          end
+        end
+      else
+        error "tags are only allowed in the root env"
+      end
+    end
+end

lib/kamal/configuration/validator/registry.rb

@@ -0,0 +1,25 @@
+class Kamal::Configuration::Validator::Registry < Kamal::Configuration::Validator
+  STRING_OR_ONE_ITEM_ARRAY_KEYS = [ "username", "password" ]
+
+  def validate!
+    validate_against_example! \
+      config.except(*STRING_OR_ONE_ITEM_ARRAY_KEYS),
+      example.except(*STRING_OR_ONE_ITEM_ARRAY_KEYS)
+
+    validate_string_or_one_item_array! "username"
+    validate_string_or_one_item_array! "password"
+  end
+
+  private
+    def validate_string_or_one_item_array!(key)
+      with_context(key) do
+        value = config[key]
+
+        error "is required" unless value.present?
+
+        unless value.is_a?(String) || (value.is_a?(Array) && value.size == 1 && value.first.is_a?(String))
+          error "should be a string or an array with one string (for secret lookup)"
+        end
+      end
+    end
+end

lib/kamal/configuration/validator/role.rb

@@ -0,0 +1,11 @@
+class Kamal::Configuration::Validator::Role < Kamal::Configuration::Validator
+  def validate!
+    validate_type! config, Array, Hash
+
+    if config.is_a?(Array)
+      validate_servers! "servers", config
+    else
+      super
+    end
+  end
+end

lib/kamal/configuration/validator/servers.rb

@@ -0,0 +1,7 @@
+class Kamal::Configuration::Validator::Servers < Kamal::Configuration::Validator
+  def validate!
+    validate_type! config, Array, Hash
+
+    validate_servers! config if config.is_a?(Array)
+  end
+end

lib/kamal/git.rb

@@ -9,6 +9,10 @@ module Kamal::Git
     `git config user.name`.strip
   end
 
+  def email
+    `git config user.email`.strip
+  end
+
   def revision
     `git rev-parse HEAD`.strip
   end

lib/kamal/tags.rb

@@ -10,10 +10,11 @@ class Kamal::Tags
 
     def default_tags(config)
       { recorded_at: Time.now.utc.iso8601,
-        performer: `whoami`.chomp,
+        performer: Kamal::Git.email.presence || `whoami`.chomp,
         destination: config.destination,
         version: config.version,
-        service_version: service_version(config) }
+        service_version: service_version(config),
+        service: config.service }
     end
 
     def service_version(config)

lib/kamal/version.rb

@@ -1,3 +1,3 @@
 module Kamal
-  VERSION = "1.5.2"
+  VERSION = "1.8.1"
 end

test/cli/accessory_test.rb

@@ -116,6 +116,20 @@ class CliAccessoryTest < CliTestCase
     assert_match "docker logs app-mysql  --tail 100 --timestamps 2>&1", run_command("logs", "mysql")
   end
 
+  test "logs with grep" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 'docker logs app-mysql --timestamps 2>&1 | grep \'hey\''")
+
+    assert_match "docker logs app-mysql --timestamps 2>&1 | grep 'hey'", run_command("logs", "mysql", "--grep", "hey")
+  end
+
+  test "logs with grep and grep options" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 'docker logs app-mysql --timestamps 2>&1 | grep \'hey\' -C 2'")
+
+    assert_match "docker logs app-mysql --timestamps 2>&1 | grep 'hey' -C 2", run_command("logs", "mysql", "--grep", "hey", "--grep-options", "-C 2")
+  end
+
   test "logs with follow" do
     SSHKit::Backend::Abstract.any_instance.stubs(:exec)
       .with("ssh -t root@1.1.1.3 -p 22 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1'")
@@ -123,6 +137,20 @@ class CliAccessoryTest < CliTestCase
     assert_match "docker logs app-mysql --timestamps --tail 10 --follow 2>&1", run_command("logs", "mysql", "--follow")
   end
 
+  test "logs with follow and grep" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 -p 22 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1 | grep \"hey\"'")
+
+    assert_match "docker logs app-mysql --timestamps --tail 10 --follow 2>&1 | grep \"hey\"", run_command("logs", "mysql", "--follow", "--grep", "hey")
+  end
+
+  test "logs with follow, grep, and grep options" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.3 -p 22 'docker logs app-mysql --timestamps --tail 10 --follow 2>&1 | grep \"hey\" -C 2'")
+
+    assert_match "docker logs app-mysql --timestamps --tail 10 --follow 2>&1 | grep \"hey\" -C 2", run_command("logs", "mysql", "--follow", "--grep", "hey", "--grep-options", "-C 2")
+  end
+
   test "remove with confirmation" do
     Kamal::Cli::Accessory.any_instance.expects(:stop).with("mysql")
     Kamal::Cli::Accessory.any_instance.expects(:remove_container).with("mysql")

test/cli/app_test.rb

@@ -290,6 +290,10 @@ class CliAppTest < CliTestCase
       .with("ssh -t root@1.1.1.1 'sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1| xargs docker logs --timestamps --tail 10 2>&1'")
 
     assert_match "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs --tail 100 2>&1", run_command("logs")
+
+    assert_match "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs 2>&1 | grep 'hey'", run_command("logs", "--grep", "hey")
+
+    assert_match "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs 2>&1 | grep 'hey' -C 2", run_command("logs", "--grep", "hey", "--grep-options", "-C 2")
   end
 
   test "logs with follow" do
@@ -299,6 +303,20 @@ class CliAppTest < CliTestCase
     assert_match "sh -c '\\''docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''\\'\\'''\\''{{.ID}}'\\''\\'\\'''\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting'\\'' | head -1 | xargs docker logs --timestamps --tail 10 --follow 2>&1", run_command("logs", "--follow")
   end
 
+  test "logs with follow and grep" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 -p 22 'sh -c '\\''docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''\\'\\'''\\''{{.ID}}'\\''\\'\\'''\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting'\\'' | head -1 | xargs docker logs --timestamps --follow 2>&1 | grep \"hey\"'")
+
+    assert_match "sh -c '\\''docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''\\'\\'''\\''{{.ID}}'\\''\\'\\'''\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting'\\'' | head -1 | xargs docker logs --timestamps --follow 2>&1 | grep \"hey\"", run_command("logs", "--follow", "--grep", "hey")
+  end
+
+  test "logs with follow, grep and grep options" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 -p 22 'sh -c '\\''docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''\\'\\'''\\''{{.ID}}'\\''\\'\\'''\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting'\\'' | head -1 | xargs docker logs --timestamps --follow 2>&1 | grep \"hey\" -C 2'")
+
+    assert_match "sh -c '\\''docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''\\'\\'''\\''{{.ID}}'\\''\\'\\'''\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting'\\'' | head -1 | xargs docker logs --timestamps --follow 2>&1 | grep \"hey\" -C 2", run_command("logs", "--follow", "--grep", "hey", "--grep-options", "-C 2")
+  end
+
   test "version" do
     run_command("version").tap do |output|
       assert_match "sh -c 'docker ps --latest --format '\\''{{.Names}}'\\'' --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --format '\\''{{.Names}}'\\'' --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | while read line; do echo ${line#app-web-}; done", output

test/cli/build_test.rb

@@ -9,10 +9,22 @@ class CliBuildTest < CliTestCase
   end
 
   test "push" do
-    with_build_directory do
+    with_build_directory do |build_directory|
-      Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+      Kamal::Hooks.stubs(: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" }
 
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :"rev-parse", :HEAD)
+        .returns(Kamal::Git.revision)
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :status, "--porcelain")
+        .returns("")
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :buildx, :inspect, "kamal-app-multiarch", "> /dev/null")
+        .returns("")
+
       run_command("push", "--verbose").tap do |output|
         assert_hook_ran "pre-build", output, **hook_variables
         assert_match /Cloning repo into build directory/, output
@@ -23,28 +35,33 @@ class CliBuildTest < CliTestCase
     end
   end
 
-  test "push reseting clone" do
+  test "push resetting clone" do
-    with_build_directory do
+    with_build_directory do |build_directory|
       stub_setup
-      build_dir = "#{Dir.tmpdir}/kamal-clones/app-#{pwd_sha}/kamal/"
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:docker, "--version", "&&", :docker, :buildx, "version")
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "--version", "&&", :docker, :buildx, "version")
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:docker, :buildx, :create, "--use", "--name", "kamal-app-multiarch")
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:mkdir, "-p", "#{Dir.tmpdir}/kamal-clones/app-#{pwd_sha}")
+      SSHKit::Backend::Abstract.any_instance.expects(:execute)
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
         .with(:git, "-C", "#{Dir.tmpdir}/kamal-clones/app-#{pwd_sha}", :clone, Dir.pwd)
         .raises(SSHKit::Command::Failed.new("fatal: destination path 'kamal' already exists and is not an empty directory"))
         .then
         .returns(true)
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:git, "-C", build_dir, :remote, "set-url", :origin, Dir.pwd)
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:git, "-C", build_directory, :remote, "set-url", :origin, Dir.pwd)
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:git, "-C", build_dir, :fetch, :origin)
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:git, "-C", build_directory, :fetch, :origin)
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:git, "-C", build_dir, :reset, "--hard", Kamal::Git.revision)
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:git, "-C", build_directory, :reset, "--hard", Kamal::Git.revision)
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:git, "-C", build_dir, :clean, "-fdx")
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:git, "-C", build_directory, :clean, "-fdx")
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      SSHKit::Backend::Abstract.any_instance.expects(:execute)
         .with(:docker, :buildx, :build, "--push", "--platform", "linux/amd64,linux/arm64", "--builder", "kamal-app-multiarch", "-t", "dhh/app:999", "-t", "dhh/app:latest", "--label", "service=\"app\"", "--file", "Dockerfile", ".")
 
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :"rev-parse", :HEAD)
+        .returns(Kamal::Git.revision)
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :status, "--porcelain")
+        .returns("")
+
       run_command("push", "--verbose").tap do |output|
         assert_match /Cloning repo into build directory/, output
         assert_match /Resetting local clone/, output
@@ -53,7 +70,7 @@ class CliBuildTest < CliTestCase
   end
 
   test "push without clone" do
-    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    Kamal::Hooks.stubs(: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", "--verbose", fixture: :without_clone).tap do |output|
@@ -64,25 +81,66 @@ class CliBuildTest < CliTestCase
     end
   end
 
-  test "push without builder" do
+  test "push with corrupt clone" do
-    with_build_directory do
+    with_build_directory do |build_directory|
       stub_setup
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:docker, "--version", "&&", :docker, :buildx, "version")
-        .with(:docker, "--version", "&&", :docker, :buildx, "version")
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
+      SSHKit::Backend::Abstract.any_instance.expects(:execute)
-        .with(:docker, :buildx, :create, "--use", "--name", "kamal-app-multiarch")
+        .with(:git, "-C", "#{Dir.tmpdir}/kamal-clones/app-#{pwd_sha}", :clone, Dir.pwd)
-
+        .raises(SSHKit::Command::Failed.new("fatal: destination path 'kamal' already exists and is not an empty directory"))
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute)
-        .with { |*args| args[0..1] == [ :docker, :buildx ] }
-        .raises(SSHKit::Command::Failed.new("no builder"))
         .then
         .returns(true)
+        .twice
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with { |*args| args.first.start_with?("git") }
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:git, "-C", build_directory, :remote, "set-url", :origin, Dir.pwd)
+        .raises(SSHKit::Command::Failed.new("fatal: not a git repository"))
 
-      SSHKit::Backend::Abstract.any_instance.stubs(:execute).with(:mkdir, "-p", "#{Dir.tmpdir}/kamal-clones/app-#{pwd_sha}")
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :"rev-parse", :HEAD)
+        .returns(Kamal::Git.revision)
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :status, "--porcelain")
+        .returns("")
+
+      Dir.stubs(:chdir)
+
+      run_command("push", "--verbose") do |output|
+        assert_match /Cloning repo into build directory `#{build_directory}`\.\.\..*Cloning repo into build directory `#{build_directory}`\.\.\./, output
+        assert_match "Resetting local clone as `#{build_directory}` already exists...", output
+        assert_match "Error preparing clone: Failed to clone repo: fatal: not a git repository, deleting and retrying...", output
+      end
+    end
+  end
+
+  test "push without builder" do
+    with_build_directory do |build_directory|
+      stub_setup
+
+      SSHKit::Backend::Abstract.any_instance.expects(:execute)
+        .with(:docker, "--version", "&&", :docker, :buildx, "version")
+
+      SSHKit::Backend::Abstract.any_instance.expects(:execute)
+        .with(:docker, :buildx, :create, "--use", "--name", "kamal-app-multiarch")
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:docker, :buildx, :inspect, "kamal-app-multiarch", "> /dev/null")
+        .raises(SSHKit::Command::Failed.new("no builder"))
+
+      SSHKit::Backend::Abstract.any_instance.expects(:execute).with { |*args| args.first.start_with?("git") }
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :"rev-parse", :HEAD)
+        .returns(Kamal::Git.revision)
+
+      SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+        .with(:git, "-C", anything, :status, "--porcelain")
+        .returns("")
+
+      SSHKit::Backend::Abstract.any_instance.expects(:execute)
+        .with(:docker, :buildx, :build, "--push", "--platform", "linux/amd64,linux/arm64", "--builder", "kamal-app-multiarch", "-t", "dhh/app:999", "-t", "dhh/app:latest", "--label", "service=\"app\"", "--file", "Dockerfile", ".")
 
       run_command("push").tap do |output|
         assert_match /WARN Missing compatible builder, so creating a new one first/, output
@@ -111,12 +169,41 @@ class CliBuildTest < CliTestCase
 
   test "pull" do
     run_command("pull").tap do |output|
+      assert_match /docker info --format '{{index .RegistryConfig.Mirrors 0}}'/, output
       assert_match /docker image rm --force dhh\/app:999/, output
       assert_match /docker pull dhh\/app:999/, output
       assert_match "docker inspect -f '{{ .Config.Labels.service }}' dhh/app:999 | grep -x app || (echo \"Image dhh/app:999 is missing the 'service' label\" && exit 1)", output
     end
   end
 
+  test "pull with mirror" do
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :info, "--format '{{index .RegistryConfig.Mirrors 0}}'")
+      .returns("registry-mirror.example.com")
+      .at_least_once
+
+    run_command("pull").tap do |output|
+      assert_match /Pulling image on 1\.1\.1\.\d to seed the mirror\.\.\./, output
+      assert_match "Pulling image on remaining hosts...", output
+      assert_equal 4, output.scan(/docker pull dhh\/app:999/).size, output
+      assert_match "docker inspect -f '{{ .Config.Labels.service }}' dhh/app:999 | grep -x app || (echo \"Image dhh/app:999 is missing the 'service' label\" && exit 1)", output
+    end
+  end
+
+  test "pull with mirrors" do
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :info, "--format '{{index .RegistryConfig.Mirrors 0}}'")
+      .returns("registry-mirror.example.com", "registry-mirror2.example.com")
+      .at_least_once
+
+    run_command("pull").tap do |output|
+      assert_match /Pulling image on 1\.1\.1\.\d, 1\.1\.1\.\d to seed the mirrors\.\.\./, output
+      assert_match "Pulling image on remaining hosts...", output
+      assert_equal 4, output.scan(/docker pull dhh\/app:999/).size, output
+      assert_match "docker inspect -f '{{ .Config.Labels.service }}' dhh/app:999 | grep -x app || (echo \"Image dhh/app:999 is missing the 'service' label\" && exit 1)", output
+    end
+  end
+
   test "create" do
     run_command("create").tap do |output|
       assert_match /docker buildx create --use --name kamal-app-multiarch/, output
@@ -183,7 +270,7 @@ class CliBuildTest < CliTestCase
       build_directory = File.join Dir.tmpdir, "kamal-clones", "app-#{pwd_sha}", "kamal"
       FileUtils.mkdir_p build_directory
       FileUtils.touch File.join build_directory, "Dockerfile"
-      yield
+      yield build_directory + "/"
     ensure
       FileUtils.rm_rf build_directory
     end

test/cli/cli_test_case.rb

@@ -18,7 +18,7 @@ class CliTestCase < ActiveSupport::TestCase
   private
     def fail_hook(hook)
       @executions = []
-      Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+      Kamal::Hooks.stubs(:exists?).returns(true)
 
       SSHKit::Backend::Abstract.any_instance.stubs(:execute)
         .with { |*args| @executions << args; args != [ ".kamal/hooks/#{hook}" ] }
@@ -36,19 +36,25 @@ class CliTestCase < ActiveSupport::TestCase
         .with { |arg1, arg2| arg1 == :mkdir && arg2 == ".kamal/locks/app" }
       SSHKit::Backend::Abstract.any_instance.stubs(:execute)
         .with { |arg1, arg2| arg1 == :rm && arg2 == ".kamal/locks/app/details" }
+      SSHKit::Backend::Abstract.any_instance.stubs(:capture_with_info)
+        .with { |*args| args[0..2] == [ :docker, :buildx, :inspect ] }
+        .returns("")
     end
 
     def assert_hook_ran(hook, output, version:, service_version:, hosts:, command:, subcommand: nil, runtime: false)
-      performer = `whoami`.strip
+      whoami = `whoami`.chomp
+      performer = Kamal::Git.email.presence || whoami
+      service = service_version.split("@").first
 
       assert_match "Running the #{hook} hook...\n", output
 
-      expected = %r{Running\s/usr/bin/env\s\.kamal/hooks/#{hook}\sas\s#{performer}@localhost\n\s
+      expected = %r{Running\s/usr/bin/env\s\.kamal/hooks/#{hook}\sas\s#{whoami}@localhost\n\s
         DEBUG\s\[[0-9a-f]*\]\sCommand:\s\(\sexport\s
         KAMAL_RECORDED_AT=\"\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ\"\s
         KAMAL_PERFORMER=\"#{performer}\"\s
         KAMAL_VERSION=\"#{version}\"\s
         KAMAL_SERVICE_VERSION=\"#{service_version}\"\s
+        KAMAL_SERVICE=\"#{service}\"\s
         KAMAL_HOSTS=\"#{hosts}\"\s
         KAMAL_COMMAND=\"#{command}\"\s
         #{"KAMAL_SUBCOMMAND=\\\"#{subcommand}\\\"\\s" if subcommand}

test/cli/main_test.rb

@@ -1,11 +1,14 @@
 require_relative "cli_test_case"
 
 class CliMainTest < CliTestCase
+  setup { @original_env = ENV.to_h.dup }
+  teardown { ENV.clear; ENV.update @original_env }
+
   test "setup" do
     invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
 
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:server:bootstrap", [], invoke_options)
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:main:envify", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:env:push", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:accessory:boot", [ "all" ], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:deploy)
 
@@ -19,10 +22,10 @@ class CliMainTest < CliTestCase
     invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
 
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:server:bootstrap", [], invoke_options)
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:main:envify", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:env:push", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:accessory:boot", [ "all" ], invoke_options)
     # deploy
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: true))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:pull", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
@@ -46,17 +49,18 @@ class CliMainTest < CliTestCase
   test "deploy" do
     invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false, "verbose" => true }
 
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: false))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:prune:all", [], invoke_options)
 
-    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    Kamal::Hooks.stubs(: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", "--verbose").tap do |output|
+      assert_match "Running the pre-init hook...", output
       assert_hook_ran "pre-connect", output, **hook_variables
       assert_match /Log into image registry/, output
       assert_match /Build and push app image/, output
@@ -71,7 +75,7 @@ class CliMainTest < CliTestCase
   test "deploy with skip_push" do
     invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false }
 
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: true))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:pull", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
@@ -108,6 +112,23 @@ class CliMainTest < CliTestCase
     SSHKit::Backend::Abstract.any_instance.expects(:capture_with_debug)
       .with(:stat, ".kamal/locks/app", ">", "/dev/null", "&&", :cat, ".kamal/locks/app/details", "|", :base64, "-d")
 
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:git, "-C", anything, :"rev-parse", :HEAD)
+      .returns(Kamal::Git.revision)
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:git, "-C", anything, :status, "--porcelain")
+      .returns("")
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :buildx, :inspect, "kamal-app-multiarch", "> /dev/null")
+      .returns("")
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :info, "--format '{{index .RegistryConfig.Mirrors 0}}'")
+      .returns("")
+      .at_least_once
+
     assert_raises(Kamal::Cli::LockError) do
       run_command("deploy")
     end
@@ -129,16 +150,33 @@ class CliMainTest < CliTestCase
       .with { |*arg| arg[0..1] == [ :mkdir, ".kamal/locks/app" ] }
       .raises(SocketError, "getaddrinfo: nodename nor servname provided, or not known")
 
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:git, "-C", anything, :"rev-parse", :HEAD)
+      .returns(Kamal::Git.revision)
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:git, "-C", anything, :status, "--porcelain")
+      .returns("")
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :buildx, :inspect, "kamal-app-multiarch", "> /dev/null")
+      .returns("")
+
+    SSHKit::Backend::Abstract.any_instance.expects(:capture_with_info)
+      .with(:docker, :info, "--format '{{index .RegistryConfig.Mirrors 0}}'")
+      .returns("")
+      .at_least_once
+
     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 }
+    invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => false, :skip_local => false }
 
     Kamal::Cli::Main.any_instance.expects(:invoke)
-      .with("kamal:cli:registry:login", [], invoke_options)
+      .with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: false))
       .raises(RuntimeError)
 
     assert_not KAMAL.holding_lock?
@@ -151,7 +189,7 @@ class CliMainTest < CliTestCase
   test "deploy with skipped hooks" do
     invoke_options = { "config_file" => "test/fixtures/deploy_simple.yml", "version" => "999", "skip_hooks" => true }
 
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: false))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
@@ -168,7 +206,7 @@ class CliMainTest < CliTestCase
 
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:healthcheck:perform", [], invoke_options).never
 
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: false))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
@@ -181,7 +219,7 @@ class CliMainTest < CliTestCase
   test "deploy with missing secrets" do
     invoke_options = { "config_file" => "test/fixtures/deploy_with_secrets.yml", "version" => "999", "skip_hooks" => false }
 
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options)
+    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:registry:login", [], invoke_options.merge(skip_local: false))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:build:deliver", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:traefik:boot", [], invoke_options)
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
@@ -198,7 +236,7 @@ class CliMainTest < CliTestCase
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:stale_containers", [], invoke_options.merge(stop: true))
     Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:app:boot", [], invoke_options)
 
-    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    Kamal::Hooks.stubs(:exists?).returns(true)
 
     hook_variables = { version: 999, service_version: "app@999", hosts: "1.1.1.1,1.1.1.2", command: "redeploy" }
 
@@ -259,7 +297,7 @@ class CliMainTest < CliTestCase
       .with(:docker, :container, :ls, "--all", "--filter", "name=^app-web-version-to-rollback$", "--quiet", "|", :xargs, :docker, :inspect, "--format", "'{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}'")
       .returns("unhealthy").at_least_once # health check
 
-    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    Kamal::Hooks.stubs(: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", "--verbose", "123", config_file: "deploy_with_accessories").tap do |output|
@@ -356,21 +394,8 @@ class CliMainTest < CliTestCase
     end
   end
 
-  test "config with aliases" do
-    run_command("config", config_file: "deploy_with_aliases").tap do |output|
-      config = YAML.load(output)
-
-      assert_equal [ "web", "web_tokyo", "workers", "workers_tokyo" ], 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 "init" do
-    Pathname.any_instance.expects(:exist?).returns(false).times(3)
+    Pathname.any_instance.expects(:exist?).returns(false).times(4)
     Pathname.any_instance.stubs(:mkpath)
     FileUtils.stubs(:mkdir_p)
     FileUtils.stubs(:cp_r)
@@ -383,7 +408,7 @@ class CliMainTest < CliTestCase
   end
 
   test "init with existing config" do
-    Pathname.any_instance.expects(:exist?).returns(true).times(3)
+    Pathname.any_instance.expects(:exist?).returns(true).times(4)
 
     run_command("init").tap do |output|
       assert_match /Config file already exists in config\/deploy.yml \(remove first to create a new one\)/, output
@@ -391,7 +416,7 @@ class CliMainTest < CliTestCase
   end
 
   test "init with bundle option" do
-    Pathname.any_instance.expects(:exist?).returns(false).times(4)
+    Pathname.any_instance.expects(:exist?).returns(false).times(5)
     Pathname.any_instance.stubs(:mkpath)
     FileUtils.stubs(:mkdir_p)
     FileUtils.stubs(:cp_r)
@@ -408,7 +433,7 @@ class CliMainTest < CliTestCase
   end
 
   test "init with bundle option and existing binstub" do
-    Pathname.any_instance.expects(:exist?).returns(true).times(4)
+    Pathname.any_instance.expects(:exist?).returns(true).times(5)
     Pathname.any_instance.stubs(:mkpath)
     FileUtils.stubs(:mkdir_p)
     FileUtils.stubs(:cp_r)
@@ -420,46 +445,6 @@ class CliMainTest < CliTestCase
     end
   end
 
-  test "envify" do
-    Pathname.any_instance.expects(:exist?).returns(true).times(3)
-    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 blank line trimming" do
-    file = <<~EOF
-      HELLO=<%= 'world' %>
-      <% if true -%>
-      KEY=value
-      <% end  -%>
-    EOF
-
-    Pathname.any_instance.expects(:exist?).returns(true).times(3)
-    File.expects(:read).with(".env.erb").returns(file.strip)
-    File.expects(:write).with(".env", "HELLO=world\nKEY=value\n", perm: 0600)
-
-    run_command("envify")
-  end
-
-  test "envify with destination" do
-    Pathname.any_instance.expects(:exist?).returns(true).times(4)
-    File.expects(:read).with(".env.world.erb").returns("HELLO=<%= 'world' %>")
-    File.expects(:write).with(".env.world", "HELLO=world", perm: 0600)
-
-    run_command("envify", "-d", "world", config_file: "deploy_for_dest")
-  end
-
-  test "envify with skip_push" do
-    Pathname.any_instance.expects(:exist?).returns(true).times(1)
-    File.expects(:read).with(".env.erb").returns("HELLO=<%= 'world' %>")
-    File.expects(:write).with(".env", "HELLO=world", perm: 0600)
-
-    Kamal::Cli::Main.any_instance.expects(:invoke).with("kamal:cli:env:push").never
-    run_command("envify", "--skip-push")
-  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
@@ -484,6 +469,24 @@ class CliMainTest < CliTestCase
     end
   end
 
+  test "docs" do
+    run_command("docs").tap do |output|
+      assert_match "# Kamal Configuration", output
+    end
+  end
+
+  test "docs subsection" do
+    run_command("docs", "accessory").tap do |output|
+      assert_match "# Accessories", output
+    end
+  end
+
+  test "docs unknown" do
+    run_command("docs", "foo").tap do |output|
+      assert_match "No documentation found for foo", output
+    end
+  end
+
   test "version" do
     version = stdouted { Kamal::Cli::Main.new.version }
     assert_equal Kamal::VERSION, version
@@ -493,4 +496,22 @@ class CliMainTest < CliTestCase
     def run_command(*command, config_file: "deploy_simple")
       stdouted { Kamal::Cli::Main.start([ *command, "-c", "test/fixtures/#{config_file}.yml" ]) }
     end
+
+    def with_test_dotenv(**files)
+      Dir.mktmpdir do |dir|
+        fixtures_dup = File.join(dir, "test")
+        FileUtils.mkdir_p(fixtures_dup)
+        FileUtils.cp_r("test/fixtures/", fixtures_dup)
+
+        Dir.chdir(dir) do
+          FileUtils.mkdir_p(".kamal")
+          Dir.chdir(".kamal") do
+            files.each do |filename, contents|
+              File.binwrite(filename.to_s, contents)
+            end
+          end
+          yield
+        end
+      end
+    end
 end

test/cli/registry_test.rb

@@ -8,12 +8,41 @@ class CliRegistryTest < CliTestCase
     end
   end
 
+  test "login skip local" do
+    run_command("login", "-L").tap do |output|
+      assert_no_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 "login skip remote" do
+    run_command("login", "-R").tap do |output|
+      assert_match /docker login -u \[REDACTED\] -p \[REDACTED\] as .*@localhost/, output
+      assert_no_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 as .*@localhost/, output
       assert_match /docker logout on 1.1.1.\d/, output
     end
   end
 
+  test "logout skip local" do
+    run_command("logout", "-L").tap do |output|
+      assert_no_match /docker logout as .*@localhost/, output
+      assert_match /docker logout on 1.1.1.\d/, output
+    end
+  end
+
+  test "logout skip remote" do
+    run_command("logout", "-R").tap do |output|
+      assert_match /docker logout as .*@localhost/, output
+      assert_no_match /docker logout on 1.1.1.\d/, output
+    end
+  end
+
   private
     def run_command(*command)
       stdouted { Kamal::Cli::Registry.start([ *command, "-c", "test/fixtures/deploy_with_accessories.yml" ]) }

test/cli/server_test.rb

@@ -40,7 +40,8 @@ class CliServerTest < CliTestCase
     SSHKit::Backend::Abstract.any_instance.expects(:execute).with('[ "${EUID:-$(id -u)}" -eq 0 ] || command -v sudo >/dev/null || command -v su >/dev/null', raise_on_non_zero_exit: false).returns(true).at_least_once
     SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:sh, "-c", "'curl -fsSL https://get.docker.com || wget -O - https://get.docker.com || echo \"exit 1\"'", "|", :sh).at_least_once
     SSHKit::Backend::Abstract.any_instance.expects(:execute).with(:mkdir, "-p", ".kamal").returns("").at_least_once
-    Kamal::Commands::Hook.any_instance.stubs(:hook_exists?).returns(true)
+    Kamal::Hooks.stubs(:exists?).returns(true)
+    SSHKit::Backend::Abstract.any_instance.expects(:execute).with(".kamal/hooks/pre-init", anything).at_least_once
     SSHKit::Backend::Abstract.any_instance.expects(:execute).with(".kamal/hooks/pre-connect", anything).at_least_once
     SSHKit::Backend::Abstract.any_instance.expects(:execute).with(".kamal/hooks/docker-setup", anything).at_least_once
 

test/cli/traefik_test.rb

@@ -4,7 +4,7 @@ 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 --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" #{Kamal::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
+      assert_match "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" #{Kamal::Configuration::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
     end
   end
 
@@ -14,7 +14,7 @@ class CliTraefikTest < CliTestCase
     run_command("reboot", "-y").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 --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" #{Kamal::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
+      assert_match "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" #{Kamal::Configuration::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"", output
     end
   end
 
@@ -69,6 +69,20 @@ class CliTraefikTest < CliTestCase
     assert_match "docker logs traefik --timestamps --tail 10 --follow", run_command("logs", "--follow")
   end
 
+  test "logs with follow and grep" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 -p 22 'docker logs traefik --timestamps --tail 10 --follow 2>&1 | grep \"hey\"'")
+
+    assert_match "docker logs traefik --timestamps --tail 10 --follow 2>&1 | grep \"hey\"", run_command("logs", "--follow", "--grep", "hey")
+  end
+
+  test "logs with follow, grep, and grep options" do
+    SSHKit::Backend::Abstract.any_instance.stubs(:exec)
+      .with("ssh -t root@1.1.1.1 -p 22 'docker logs traefik --timestamps --tail 10 --follow 2>&1 | grep \"hey\" -C 2'")
+
+    assert_match "docker logs traefik --timestamps --tail 10 --follow 2>&1 | grep \"hey\" -C 2", run_command("logs", "--follow", "--grep", "hey", "--grep-options", "-C 2")
+  end
+
   test "remove" do
     Kamal::Cli::Traefik.any_instance.expects(:stop)
     Kamal::Cli::Traefik.any_instance.expects(:remove_container)

test/commander_test.rb

@@ -137,17 +137,17 @@ class CommanderTest < ActiveSupport::TestCase
   end
 
   test "traefik hosts should observe filtered roles" do
-    configure_with(:deploy_with_aliases)
+    configure_with(:deploy_with_multiple_traefik_roles)
 
     @kamal.specific_roles = [ "web_tokyo" ]
     assert_equal [ "1.1.1.3", "1.1.1.4" ], @kamal.traefik_hosts
   end
 
   test "traefik hosts should observe filtered hosts" do
-    configure_with(:deploy_with_aliases)
+    configure_with(:deploy_with_multiple_traefik_roles)
 
-    @kamal.specific_hosts = [ "1.1.1.4" ]
+    @kamal.specific_hosts = [ "1.1.1.2" ]
-    assert_equal [ "1.1.1.4" ], @kamal.traefik_hosts
+    assert_equal [ "1.1.1.2" ], @kamal.traefik_hosts
   end
 
   private

test/commands/accessory_test.rb

@@ -24,7 +24,7 @@ class CommandsAccessoryTest < ActiveSupport::TestCase
           "host" => "1.1.1.6",
           "port" => "6379:6379",
           "labels" => {
-            "cache" => true
+            "cache" => "true"
           },
           "env" => {
             "SOMETHING" => "else"
@@ -125,6 +125,10 @@ class CommandsAccessoryTest < ActiveSupport::TestCase
     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(" ")
+
+    assert_equal \
+      "docker logs app-mysql  --since 5m  --tail 100 --timestamps 2>&1 | grep 'thing' -C 2",
+      new_command(:mysql).logs(since: "5m", lines: 100, grep: "thing", grep_options: "-C 2").join(" ")
   end
 
   test "follow logs" do

test/commands/app_test.rb

@@ -139,23 +139,45 @@ class CommandsAppTest < ActiveSupport::TestCase
     assert_equal \
       "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs 2>&1",
       new_command.logs.join(" ")
+  end
 
+  test "logs with since" do
     assert_equal \
       "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs --since 5m 2>&1",
       new_command.logs(since: "5m").join(" ")
+  end
 
+  test "logs with lines" do
     assert_equal \
       "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs --tail 100 2>&1",
       new_command.logs(lines: "100").join(" ")
+  end
 
+  test "logs with since and lines" do
     assert_equal \
       "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs --since 5m --tail 100 2>&1",
       new_command.logs(since: "5m", lines: "100").join(" ")
+  end
 
+  test "logs with grep" do
     assert_equal \
       "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs 2>&1 | grep 'my-id'",
       new_command.logs(grep: "my-id").join(" ")
+  end
 
+  test "logs with grep and grep options" do
+    assert_equal \
+      "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs 2>&1 | grep 'my-id' -C 2",
+      new_command.logs(grep: "my-id", grep_options: "-C 2").join(" ")
+  end
+
+  test "logs with since, grep and grep options" do
+    assert_equal \
+      "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs --since 5m 2>&1 | grep 'my-id' -C 2",
+      new_command.logs(since: "5m", grep: "my-id", grep_options: "-C 2").join(" ")
+  end
+
+  test "logs with since and grep" do
     assert_equal \
       "sh -c 'docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting --filter ancestor=$(docker image ls --filter reference=dhh/app:latest --format '\\''{{.ID}}'\\'') ; docker ps --latest --quiet --filter label=service=app --filter label=role=web --filter status=running --filter status=restarting' | head -1 | xargs docker logs --since 5m 2>&1 | grep 'my-id'",
       new_command.logs(since: "5m", grep: "my-id").join(" ")

test/commands/auditor_test.rb

@@ -12,7 +12,7 @@ class CommandsAuditorTest < ActiveSupport::TestCase
     }
 
     @auditor = new_command
-    @performer = `whoami`.strip
+    @performer = Kamal::Git.email.presence || `whoami`.chomp
     @recorded_at = Time.now.utc.iso8601
   end
 

test/commands/builder_test.rb

@@ -158,6 +158,53 @@ class CommandsBuilderTest < ActiveSupport::TestCase
       builder.push.join(" ")
   end
 
+  test "multiarch context hosts" do
+    command = new_builder_command
+    assert_equal "docker buildx inspect kamal-app-multiarch > /dev/null", command.context_hosts.join(" ")
+    assert_equal "", command.config_context_hosts.join(" ")
+  end
+
+  test "native context hosts" do
+    command = new_builder_command(builder: { "multiarch" => false })
+    assert_equal :true, command.context_hosts
+    assert_equal "", command.config_context_hosts.join(" ")
+  end
+
+  test "native cached context hosts" do
+    command = new_builder_command(builder: { "multiarch" => false, "cache" => { "type" => "registry" } })
+    assert_equal "docker buildx inspect kamal-app-native-cached > /dev/null", command.context_hosts.join(" ")
+    assert_equal "", command.config_context_hosts.join(" ")
+  end
+
+  test "native remote context hosts" do
+    command = new_builder_command(builder: { "remote" => { "arch" => "amd64", "host" => "ssh://host" } })
+    assert_equal "docker context inspect kamal-app-native-remote-amd64 --format '{{.Endpoints.docker.Host}}'", command.context_hosts.join(" ")
+    assert_equal [ "ssh://host" ], command.config_context_hosts
+  end
+
+  test "multiarch remote context hosts" do
+    command = new_builder_command(builder: {
+      "remote" => { "arch" => "amd64", "host" => "ssh://host" },
+      "local" => { "arch" => "arm64" }
+    })
+    assert_equal "docker context inspect kamal-app-multiarch-remote-arm64 --format '{{.Endpoints.docker.Host}}' ; docker context inspect kamal-app-multiarch-remote-amd64 --format '{{.Endpoints.docker.Host}}'", command.context_hosts.join(" ")
+    assert_equal [ "ssh://host" ], command.config_context_hosts
+  end
+
+  test "multiarch remote context hosts with local host" do
+    command = new_builder_command(builder: {
+      "remote" => { "arch" => "amd64", "host" => "ssh://host" },
+      "local" => { "arch" => "arm64", "host" => "unix:///var/run/docker.sock" }
+    })
+    assert_equal "docker context inspect kamal-app-multiarch-remote-arm64 --format '{{.Endpoints.docker.Host}}' ; docker context inspect kamal-app-multiarch-remote-amd64 --format '{{.Endpoints.docker.Host}}'", command.context_hosts.join(" ")
+    assert_equal [ "unix:///var/run/docker.sock", "ssh://host" ], command.config_context_hosts
+  end
+
+  test "mirror count" do
+    command = new_builder_command
+    assert_equal "docker info --format '{{index .RegistryConfig.Mirrors 0}}'", command.first_mirror.join(" ")
+  end
+
   private
     def new_builder_command(additional_config = {})
       Kamal::Commands::Builder.new(Kamal::Configuration.new(@config.merge(additional_config), version: "123"))

test/commands/hook_test.rb

@@ -11,7 +11,7 @@ class CommandsHookTest < ActiveSupport::TestCase
       traefik: { "args" => { "accesslog.format" => "json", "metrics.prometheus.buckets" => "0.1,0.3,1.2,5.0" } }
     }
 
-    @performer = `whoami`.strip
+    @performer = Kamal::Git.email.presence || `whoami`.chomp
     @recorded_at = Time.now.utc.iso8601
   end
 
@@ -22,19 +22,24 @@ class CommandsHookTest < ActiveSupport::TestCase
         "KAMAL_RECORDED_AT" => @recorded_at,
         "KAMAL_PERFORMER" => @performer,
         "KAMAL_VERSION" => "123",
-        "KAMAL_SERVICE_VERSION" => "app@123" } }
+        "KAMAL_SERVICE_VERSION" => "app@123",
+        "KAMAL_SERVICE" => "app" } }
     ], new_command.run("foo")
   end
 
   test "run with custom hooks_path" do
+    ENV["KAMAL_HOOKS_PATH"] = "custom/hooks/path"
     assert_equal [
       "custom/hooks/path/foo",
       { env: {
         "KAMAL_RECORDED_AT" => @recorded_at,
         "KAMAL_PERFORMER" => @performer,
         "KAMAL_VERSION" => "123",
-        "KAMAL_SERVICE_VERSION" => "app@123" } }
+        "KAMAL_SERVICE_VERSION" => "app@123",
-    ], new_command(hooks_path: "custom/hooks/path").run("foo")
+        "KAMAL_SERVICE" => "app" } }
+    ], new_command.run("foo")
+  ensure
+    ENV.delete("KAMAL_HOOKS_PATH")
   end
 
   private

test/commands/traefik_test.rb

@@ -91,7 +91,7 @@ class CommandsTraefikTest < ActiveSupport::TestCase
     @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 --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" #{Kamal::Commands::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"",
+      "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" #{Kamal::Configuration::Traefik::DEFAULT_IMAGE} --providers.docker --log.level=\"DEBUG\"",
       new_command.run.join(" ")
   end
 
@@ -111,6 +111,11 @@ class CommandsTraefikTest < ActiveSupport::TestCase
       new_command.run.join(" ")
   end
 
+  test "run with args array" do
+    @config[:traefik]["args"] = { "entrypoints.web.forwardedheaders.trustedips" => %w[ 127.0.0.1 127.0.0.2 ] }
+    assert_equal "docker run --name traefik --detach --restart unless-stopped --publish 80:80 --volume /var/run/docker.sock:/var/run/docker.sock --env-file .kamal/env/traefik/traefik.env --log-opt max-size=\"10m\" --label traefik.http.routers.catchall.entryPoints=\"http\" --label traefik.http.routers.catchall.rule=\"PathPrefix(\\`/\\`)\" --label traefik.http.routers.catchall.service=\"unavailable\" --label traefik.http.routers.catchall.priority=\"1\" --label traefik.http.services.unavailable.loadbalancer.server.port=\"0\" traefik:test --providers.docker --log.level=\"DEBUG\" --entrypoints.web.forwardedheaders.trustedips=\"127.0.0.1\" --entrypoints.web.forwardedheaders.trustedips=\"127.0.0.2\"", new_command.run.join(" ")
+  end
+
   test "traefik start" do
     assert_equal \
       "docker container start traefik",
@@ -153,6 +158,12 @@ class CommandsTraefikTest < ActiveSupport::TestCase
       new_command.logs(grep: "hello!").join(" ")
   end
 
+  test "traefik logs with grep hello! and grep options" do
+    assert_equal \
+      "docker logs traefik --timestamps 2>&1 | grep 'hello!' -C 2",
+      new_command.logs(grep: "hello!", grep_options: "-C 2").join(" ")
+  end
+
   test "traefik remove container" do
     assert_equal \
       "docker container prune --force --filter label=org.opencontainers.image.title=Traefik",

test/configuration/accessory_test.rb

@@ -35,7 +35,7 @@ class ConfigurationAccessoryTest < ActiveSupport::TestCase
           "hosts" => [ "1.1.1.6", "1.1.1.7" ],
           "port" => "6379:6379",
           "labels" => {
-            "cache" => true
+            "cache" => "true"
           },
           "env" => {
             "SOMETHING" => "else"
@@ -44,7 +44,7 @@ class ConfigurationAccessoryTest < ActiveSupport::TestCase
             "/var/lib/redis:/data"
           ],
           "options" => {
-            "cpus" => 4,
+            "cpus" => "4",
             "memory" => "2GB"
           }
         },
@@ -54,13 +54,13 @@ class ConfigurationAccessoryTest < ActiveSupport::TestCase
           "roles" => [ "web" ],
           "port" => "4321:4321",
           "labels" => {
-            "cache" => true
+            "cache" => "true"
           },
           "env" => {
             "STATSD_PORT" => "8126"
           },
           "options" => {
-            "cpus" => 4,
+            "cpus" => "4",
             "memory" => "2GB"
           }
         }
@@ -89,22 +89,20 @@ class ConfigurationAccessoryTest < ActiveSupport::TestCase
 
   test "missing host" do
     @deploy[:accessories]["mysql"]["host"] = nil
-    @config = Kamal::Configuration.new(@deploy)
 
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
-      @config.accessory(:mysql).hosts
+      Kamal::Configuration.new(@deploy)
     end
   end
 
   test "setting host, hosts and roles" do
-    @deploy[:accessories]["mysql"]["hosts"] = true
+    @deploy[:accessories]["mysql"]["hosts"] = [ "mysql-db1" ]
-    @deploy[:accessories]["mysql"]["roles"] = true
+    @deploy[:accessories]["mysql"]["roles"] = [ "db" ]
-    @config = Kamal::Configuration.new(@deploy)
 
-    exception = assert_raises(ArgumentError) do
+    exception = assert_raises(Kamal::ConfigurationError) do
-      @config.accessory(:mysql).hosts
+      Kamal::Configuration.new(@deploy)
     end
-    assert_equal "Specify one of `host`, `hosts` or `roles` for accessory `mysql`", exception.message
+    assert_equal "accessories/mysql: specify one of `host`, `hosts` or `roles`", exception.message
   end
 
   test "all hosts" do

test/configuration/builder_test.rb

@@ -7,41 +7,37 @@ class ConfigurationBuilderTest < ActiveSupport::TestCase
       servers: [ "1.1.1.1" ]
     }
 
-    @config = Kamal::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 = Kamal::Configuration.new(@deploy_with_builder_option)
   end
 
   test "multiarch?" do
-    assert_equal true, @config.builder.multiarch?
+    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?
+    assert_equal false, config_with_builder_option.builder.multiarch?
   end
 
   test "local?" do
-    assert_equal false, @config.builder.local?
+    assert_equal false, config.builder.local?
   end
 
   test "remote?" do
-    assert_equal false, @config.builder.remote?
+    assert_equal false, config.builder.remote?
   end
 
   test "remote_arch" do
-    assert_nil @config.builder.remote_arch
+    assert_nil config.builder.remote_arch
   end
 
   test "remote_host" do
-    assert_nil @config.builder.remote_host
+    assert_nil config.builder.remote_host
   end
 
   test "setting both local and remote configs" do
@@ -50,112 +46,121 @@ class ConfigurationBuilderTest < ActiveSupport::TestCase
       "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.local?
-    assert_equal true, @config_with_builder_option.builder.remote?
+    assert_equal true, config_with_builder_option.builder.remote?
 
-    assert_equal "amd64", @config_with_builder_option.builder.remote_arch
+    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 "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 "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
+    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?
+    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
+    assert_raises(Kamal::ConfigurationError) do
-      @config_with_builder_option.builder
+      config_with_builder_option.builder
     end
   end
 
   test "cache_from" do
-    assert_nil @config.builder.cache_from
+    assert_nil config.builder.cache_from
   end
 
   test "cache_to" do
-    assert_nil @config.builder.cache_to
+    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", config_with_builder_option.builder.cache_from
-    assert_equal "type=gha,mode=max", @config_with_builder_option.builder.cache_to
+    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,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
+    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 when using a custom registry" do
-    @config_with_builder_option.registry["server"] = "registry.example.com"
+    @deploy_with_builder_option[:registry]["server"] = "registry.example.com"
     @deploy_with_builder_option[:builder] = { "cache" => { "type" => "registry", "options" => "mode=max,image-manifest=true,oci-mediatypes=true" } }
 
-    assert_equal "type=registry,ref=registry.example.com/dhh/app-build-cache", @config_with_builder_option.builder.cache_from
+    assert_equal "type=registry,ref=registry.example.com/dhh/app-build-cache", config_with_builder_option.builder.cache_from
-    assert_equal "type=registry,mode=max,image-manifest=true,oci-mediatypes=true,ref=registry.example.com/dhh/app-build-cache", @config_with_builder_option.builder.cache_to
+    assert_equal "type=registry,mode=max,image-manifest=true,oci-mediatypes=true,ref=registry.example.com/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" => "kamal", "options" => "mode=max" } }
 
-    assert_equal "type=registry,ref=kamal", @config_with_builder_option.builder.cache_from
+    assert_equal "type=registry,ref=kamal", config_with_builder_option.builder.cache_from
-    assert_equal "type=registry,mode=max,ref=kamal", @config_with_builder_option.builder.cache_to
+    assert_equal "type=registry,mode=max,ref=kamal", config_with_builder_option.builder.cache_to
   end
 
   test "args" do
-    assert_equal({}, @config.builder.args)
+    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)
+    assert_equal({ "key" => "value" }, config_with_builder_option.builder.args)
   end
 
   test "secrets" do
-    assert_equal [], @config.builder.secrets
+    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
+    assert_equal [ "GITHUB_TOKEN" ], config_with_builder_option.builder.secrets
   end
 
   test "dockerfile" do
-    assert_equal "Dockerfile", @config.builder.dockerfile
+    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
+    assert_equal "Dockerfile.dev", config_with_builder_option.builder.dockerfile
   end
 
   test "context" do
-    assert_equal ".", @config.builder.context
+    assert_equal ".", config.builder.context
   end
 
   test "setting context" do
     @deploy_with_builder_option[:builder] = { "context" => ".." }
 
-    assert_equal "..", @config_with_builder_option.builder.context
+    assert_equal "..", config_with_builder_option.builder.context
   end
 
   test "ssh" do
-    assert_nil @config.builder.ssh
+    assert_nil config.builder.ssh
   end
 
   test "setting ssh params" do
     @deploy_with_builder_option[:builder] = { "ssh" => "default=$SSH_AUTH_SOCK" }
 
-    assert_equal "default=$SSH_AUTH_SOCK", @config_with_builder_option.builder.ssh
+    assert_equal "default=$SSH_AUTH_SOCK", config_with_builder_option.builder.ssh
   end
+
+  private
+    def config
+      Kamal::Configuration.new(@deploy)
+    end
+
+    def config_with_builder_option
+      Kamal::Configuration.new(@deploy_with_builder_option)
+    end
 end

test/configuration/env_test.rb

@@ -19,7 +19,7 @@ class ConfigurationEnvTest < ActiveSupport::TestCase
 
   test "secret" do
     ENV["PASSWORD"] = "hello"
-    env = Kamal::Configuration::Env.from_config config: { "secret" => [ "PASSWORD" ] }
+    env = Kamal::Configuration::Env.new config: { "secret" => [ "PASSWORD" ] }
 
     assert_config \
       config: { "secret" => [ "PASSWORD" ] },
@@ -34,7 +34,7 @@ class ConfigurationEnvTest < ActiveSupport::TestCase
       "secret" => [ "PASSWORD" ]
     }
 
-    assert_raises(KeyError) { Kamal::Configuration::Env.from_config(config: { "secret" => [ "PASSWORD" ] }).secrets }
+    assert_raises(KeyError) { Kamal::Configuration::Env.new(config: { "secret" => [ "PASSWORD" ] }).secrets }
   end
 
   test "secret and clear" do
@@ -67,7 +67,7 @@ class ConfigurationEnvTest < ActiveSupport::TestCase
 
   private
     def assert_config(config:, clear:, secrets:)
-      env = Kamal::Configuration::Env.from_config config: config
+      env = Kamal::Configuration::Env.new config: config, secrets_file: "secrets.env"
       assert_equal clear, env.clear
       assert_equal secrets, env.secrets
     end

test/configuration/role_test.rb

@@ -18,7 +18,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
           "cmd" => "bin/jobs",
           "env" => {
             "REDIS_URL" => "redis://a/b",
-            "WEB_CONCURRENCY" => 4
+            "WEB_CONCURRENCY" => "4"
           }
         }
       }
@@ -53,7 +53,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
   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"]
+    assert_equal "70", Kamal::Configuration.new(@deploy_with_roles).role(:workers).labels["my.custom.label"]
   end
 
   test "overwriting default traefik label" do
@@ -63,7 +63,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
 
   test "default traefik label on non-web role" do
     config = Kamal::Configuration.new(@deploy_with_roles.tap { |c|
-      c[:servers]["beta"] = { "traefik" => "true", "hosts" => [ "1.1.1.5" ] }
+      c[:servers]["beta"] = { "traefik" => true, "hosts" => [ "1.1.1.5" ] }
     })
 
     assert_equal [ "--label", "service=\"app\"", "--label", "role=\"beta\"", "--label", "destination", "--label", "traefik.http.services.app-beta.loadbalancer.server.scheme=\"http\"", "--label", "traefik.http.routers.app-beta.rule=\"PathPrefix(\\`/\\`)\"", "--label", "traefik.http.routers.app-beta.priority=\"2\"", "--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
@@ -102,7 +102,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
     @deploy_with_roles[:servers]["workers"]["env"] = {
       "clear" => {
         "REDIS_URL" => "redis://a/b",
-        "WEB_CONCURRENCY" => 4
+        "WEB_CONCURRENCY" => "4"
       },
       "secret" => [
         "DB_PASSWORD"
@@ -117,7 +117,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
       DB_PASSWORD=secret&\"123
     ENV
 
-    assert_equal expected_secrets_file, @config_with_roles.role(:workers).env("1.1.1.3").secrets_io.string
+    assert_equal expected_secrets_file, Kamal::Configuration.new(@deploy_with_roles).role(:workers).env("1.1.1.3").secrets_io.string
     assert_equal [ "--env-file", ".kamal/env/roles/app-workers.env", "--env", "REDIS_URL=\"redis://a/b\"", "--env", "WEB_CONCURRENCY=\"4\"" ], @config_with_roles.role(:workers).env_args("1.1.1.3")
   ensure
     ENV["REDIS_PASSWORD"] = nil
@@ -128,7 +128,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
     @deploy_with_roles[:servers]["workers"]["env"] = {
       "clear" => {
         "REDIS_URL" => "redis://a/b",
-        "WEB_CONCURRENCY" => 4
+        "WEB_CONCURRENCY" => "4"
       },
       "secret" => [
         "DB_PASSWORD"
@@ -141,7 +141,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
       DB_PASSWORD=secret123
     ENV
 
-    assert_equal expected_secrets_file, @config_with_roles.role(:workers).env("1.1.1.3").secrets_io.string
+    assert_equal expected_secrets_file, Kamal::Configuration.new(@deploy_with_roles).role(:workers).env("1.1.1.3").secrets_io.string
     assert_equal [ "--env-file", ".kamal/env/roles/app-workers.env", "--env", "REDIS_URL=\"redis://a/b\"", "--env", "WEB_CONCURRENCY=\"4\"" ], @config_with_roles.role(:workers).env_args("1.1.1.3")
   ensure
     ENV["DB_PASSWORD"] = nil
@@ -163,7 +163,7 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
       REDIS_PASSWORD=secret456
     ENV
 
-    assert_equal expected_secrets_file, @config_with_roles.role(:workers).env("1.1.1.3").secrets_io.string
+    assert_equal expected_secrets_file, Kamal::Configuration.new(@deploy_with_roles).role(:workers).env("1.1.1.3").secrets_io.string
     assert_equal [ "--env-file", ".kamal/env/roles/app-workers.env", "--env", "REDIS_URL=\"redis://a/b\"", "--env", "WEB_CONCURRENCY=\"4\"" ], @config_with_roles.role(:workers).env_args("1.1.1.3")
   ensure
     ENV["REDIS_PASSWORD"] = nil
@@ -191,8 +191,9 @@ class ConfigurationRoleTest < ActiveSupport::TestCase
       REDIS_PASSWORD=secret456
     ENV
 
-    assert_equal expected_secrets_file, @config_with_roles.role(:workers).env("1.1.1.3").secrets_io.string
+    config = Kamal::Configuration.new(@deploy_with_roles)
-    assert_equal [ "--env-file", ".kamal/env/roles/app-workers.env", "--env", "REDIS_URL=\"redis://c/d\"" ], @config_with_roles.role(:workers).env_args("1.1.1.3")
+    assert_equal expected_secrets_file, config.role(:workers).env("1.1.1.3").secrets_io.string
+    assert_equal [ "--env-file", ".kamal/env/roles/app-workers.env", "--env", "REDIS_URL=\"redis://c/d\"" ], config.role(:workers).env_args("1.1.1.3")
   ensure
     ENV["REDIS_PASSWORD"] = nil
   end

test/configuration/validation_test.rb

@@ -0,0 +1,116 @@
+require "test_helper"
+class ConfigurationValidationTest < ActiveSupport::TestCase
+  test "unknown root key" do
+    assert_error "unknown key: unknown", unknown: "value"
+    assert_error "unknown keys: unknown, unknown2", unknown: "value", unknown2: "value"
+  end
+
+  test "wrong root types" do
+    [ :service, :image, :asset_path, :primary_role, :minimum_version, :run_directory ].each do |key|
+      assert_error "#{key}: should be a string", **{ key => [] }
+    end
+
+    [ :require_destination, :allow_empty_roles ].each do |key|
+      assert_error "#{key}: should be a boolean", **{ key => "foo" }
+    end
+
+    [ :stop_wait_time, :retain_containers, :readiness_delay ].each do |key|
+      assert_error "#{key}: should be an integer", **{ key => "foo" }
+    end
+
+    assert_error "volumes: should be an array", volumes: "foo"
+
+    assert_error "servers: should be an array or a hash", servers: "foo"
+
+    [ :labels, :registry, :accessories, :env, :ssh, :sshkit, :builder, :traefik, :boot, :healthcheck, :logging ].each do |key|
+      assert_error "#{key}: should be a hash", **{ key =>[] }
+    end
+  end
+
+  test "servers" do
+    assert_error "servers: should be an array or a hash", servers: "foo"
+    assert_error "servers/0: should be a string or a hash", servers: [ [] ]
+    assert_error "servers/0: multiple hosts found", servers: [ { "a" => "b", "c" => "d" } ]
+    assert_error "servers/0/foo: should be a string or an array", servers: [ { "foo" => {} } ]
+    assert_error "servers/0/foo/0: should be a string", servers: [ { "foo" => [ [] ] } ]
+  end
+
+  test "roles" do
+    assert_error "servers/web: should be an array or a hash", servers: { "web" => "foo" }
+    assert_error "servers/web/hosts: should be an array", servers: { "web" => { "hosts" => "" } }
+    assert_error "servers/web/hosts/0: should be a string or a hash", servers: { "web" => { "hosts" => [ [] ] } }
+    assert_error "servers/web/options: should be a hash", servers: { "web" => { "options" => "" } }
+    assert_error "servers/web/logging/options: should be a hash", servers: { "web" => { "logging" => { "options" => "" } } }
+    assert_error "servers/web/logging/driver: should be a string", servers: { "web" => { "logging" => { "driver" => [] } } }
+    assert_error "servers/web/labels: should be a hash", servers: { "web" => { "labels" => [] } }
+    assert_error "servers/web/env: should be a hash", servers: { "web" => { "env" => [] } }
+    assert_error "servers/web/env: tags are only allowed in the root env", servers: { "web" => { "hosts" => [ "1.1.1.1" ], "env" => { "tags" => {} } } }
+  end
+
+  test "registry" do
+    assert_error "registry/username: is required", registry: {}
+    assert_error "registry/password: is required", registry: { "username" => "foo" }
+    assert_error "registry/password: should be a string or an array with one string (for secret lookup)", registry: { "username" => "foo", "password" => [ "SECRET1", "SECRET2" ] }
+    assert_error "registry/server: should be a string", registry: { "username" => "foo", "password" => "bar", "server" => [] }
+  end
+
+  test "accessories" do
+    assert_error "accessories/accessory1: should be a hash", accessories: { "accessory1" => [] }
+    assert_error "accessories/accessory1: unknown key: unknown", accessories: { "accessory1" => { "unknown" => "baz" } }
+    assert_error "accessories/accessory1/options: should be a hash", accessories: { "accessory1" => { "options" => [] } }
+    assert_error "accessories/accessory1/host: should be a string", accessories: { "accessory1" => { "host" => [] } }
+    assert_error "accessories/accessory1/env: should be a hash", accessories: { "accessory1" => { "env" => [] } }
+    assert_error "accessories/accessory1/env: tags are only allowed in the root env", accessories: { "accessory1" => { "host" => "host", "env" => { "tags" => {} } } }
+  end
+
+  test "env" do
+    assert_error "env: should be a hash", env: []
+    assert_error "env/FOO: should be a string", env: { "FOO" => [] }
+    assert_error "env/clear/FOO: should be a string", env: { "clear" => { "FOO" => [] } }
+    assert_error "env/secret: should be an array", env: { "secret" => { "FOO" => [] } }
+    assert_error "env/secret/0: should be a string", env: { "secret" => [ [] ] }
+    assert_error "env/tags: should be a hash", env: { "tags" => [] }
+    assert_error "env/tags/tag1: should be a hash", env: { "tags" => { "tag1" => "foo" } }
+    assert_error "env/tags/tag1/FOO: should be a string", env: { "tags" => { "tag1" => { "FOO" => [] } } }
+    assert_error "env/tags/tag1/clear/FOO: should be a string", env: { "tags" => { "tag1" => { "clear" => { "FOO" => [] } } } }
+    assert_error "env/tags/tag1/secret: should be an array", env: { "tags" => { "tag1" => { "secret" => {} } } }
+    assert_error "env/tags/tag1/secret/0: should be a string", env: { "tags" => { "tag1" => { "secret" => [ [] ] } } }
+    assert_error "env/tags/tag1: tags are only allowed in the root env", env: { "tags" => { "tag1" => { "tags" => {} } } }
+  end
+
+  test "ssh" do
+    assert_error "ssh: unknown key: foo", ssh: { "foo" => "bar" }
+    assert_error "ssh/user: should be a string", ssh: { "user" => [] }
+  end
+
+  test "sshkit" do
+    assert_error "sshkit: unknown key: foo", sshkit: { "foo" => "bar" }
+    assert_error "sshkit/max_concurrent_starts: should be an integer", sshkit: { "max_concurrent_starts" => "foo" }
+  end
+
+  test "builder" do
+    assert_error "builder: unknown key: foo", builder: { "foo" => "bar" }
+    assert_error "builder/remote: should be a hash", builder: { "remote" => true }
+    assert_error "builder/remote: unknown key: foo", builder: { "remote" => { "foo" => "bar" } }
+    assert_error "builder/local: unknown key: foo", builder: { "local" => { "foo" => "bar" } }
+    assert_error "builder/remote/arch: should be a string", builder: { "remote" => { "arch" => [] } }
+    assert_error "builder/args: should be a hash", builder: { "args" => [ "foo" ] }
+    assert_error "builder/cache/options: should be a string", builder: { "cache" => { "options" => [] } }
+  end
+
+  private
+    def assert_error(message, **invalid_config)
+      valid_config = {
+        service: "app",
+        image: "app",
+        registry: { "username" => "user", "password" => "secret" },
+        servers: [ "1.1.1.1" ]
+      }
+
+      error = assert_raises Kamal::ConfigurationError do
+        Kamal::Configuration.new(valid_config.merge(invalid_config))
+      end
+
+      assert_equal message, error.message
+    end
+end

test/configuration_test.rb

@@ -28,7 +28,7 @@ class ConfigurationTest < ActiveSupport::TestCase
 
   %i[ service image registry ].each do |key|
     test "#{key} config required" do
-      assert_raise(ArgumentError) do
+      assert_raise(Kamal::ConfigurationError) do
         Kamal::Configuration.new @deploy.tap { _1.delete key }
       end
     end
@@ -36,19 +36,21 @@ class ConfigurationTest < ActiveSupport::TestCase
 
   %w[ username password ].each do |key|
     test "registry #{key} required" do
-      assert_raise(ArgumentError) do
+      assert_raise(Kamal::ConfigurationError) do
         Kamal::Configuration.new @deploy.tap { _1[:registry].delete key }
       end
     end
   end
 
   test "service name valid" do
-    assert Kamal::Configuration.new(@deploy.tap { _1[:service] = "hey-app1_primary" }).valid?
+    assert_nothing_raised do
-    assert Kamal::Configuration.new(@deploy.tap { _1[:service] = "MyApp" }).valid?
+      Kamal::Configuration.new(@deploy.tap { _1[:service] = "hey-app1_primary" })
+      Kamal::Configuration.new(@deploy.tap { _1[:service] = "MyApp" })
+    end
   end
 
   test "service name invalid" do
-    assert_raise(ArgumentError) do
+    assert_raise(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.tap { _1[:service] = "app.com" }
     end
   end
@@ -158,39 +160,34 @@ class ConfigurationTest < ActiveSupport::TestCase
     assert_equal "healthcheck-app", @config.healthcheck_service
   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
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: [])
     end
 
     # Empty server list
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: { "web" => [] })
     end
 
     # Missing hosts key
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: { "web" => {} })
     end
 
     # Empty hosts list
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: { "web" => { "hosts" => [] } })
     end
 
     # Nil hosts
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: { "web" => { "hosts" => nil } })
     end
 
     # One role with hosts, one without
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: { "web" => %w[ web ], "workers" => { "hosts" => %w[ ] } })
     end
   end
@@ -200,7 +197,7 @@ class ConfigurationTest < ActiveSupport::TestCase
       Kamal::Configuration.new @deploy.merge(servers: { "web" => %w[ web ], "workers" => { "hosts" => %w[ ] } }, allow_empty_roles: true)
     end
 
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new @deploy.merge(servers: { "web" => %w[], "workers" => { "hosts" => %w[] } }, allow_empty_roles: true)
     end
   end
@@ -215,17 +212,17 @@ class ConfigurationTest < ActiveSupport::TestCase
 
   test "logging args with configured options" do
     config = Kamal::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
+    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 = Kamal::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
+    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 = Kamal::Configuration.create_from config_file: Pathname.new(File.expand_path("fixtures/deploy.erb.yml", __dir__))
-    assert_equal "my-user", config.registry["username"]
+    assert_equal "my-user", config.registry.username
   end
 
   test "destination yml config merge" do
@@ -249,7 +246,7 @@ class ConfigurationTest < ActiveSupport::TestCase
   test "destination required" do
     dest_config_file = Pathname.new(File.expand_path("fixtures/deploy_for_required_dest.yml", __dir__))
 
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       config = Kamal::Configuration.create_from config_file: dest_config_file
     end
 
@@ -272,7 +269,7 @@ class ConfigurationTest < ActiveSupport::TestCase
         volume_args: [ "--volume", "/local/path:/container/path" ],
         builder: {},
         logging: [ "--log-opt", "max-size=\"10m\"" ],
-        healthcheck: { "path"=>"/up", "port"=>3000, "max_attempts" => 7, "cord" => "/tmp/kamal-cord", "log_lines" => 50 } }
+        healthcheck: { "cmd"=>"curl -f http://localhost:3000/up || exit 1", "interval" => "1s", "path"=>"/up", "port"=>3000, "max_attempts" => 7, "cord" => "/tmp/kamal-cord", "log_lines" => 50 } }
 
     assert_equal expected_config, @config.to_h
   end
@@ -288,7 +285,7 @@ class ConfigurationTest < ActiveSupport::TestCase
   end
 
   test "min version is higher" do
-    assert_raises(ArgumentError) do
+    assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new(@deploy.tap { |c| c.merge!(minimum_version: "10000.0.0") })
     end
   end
@@ -334,7 +331,7 @@ class ConfigurationTest < ActiveSupport::TestCase
   end
 
   test "primary role missing" do
-    error = assert_raises(ArgumentError) do
+    error = assert_raises(Kamal::ConfigurationError) do
       Kamal::Configuration.new(@deploy.merge(primary_role: "bar"))
     end
     assert_match /bar isn't defined/, error.message
@@ -345,6 +342,14 @@ class ConfigurationTest < ActiveSupport::TestCase
     config = Kamal::Configuration.new(@deploy_with_roles.merge(retain_containers: 2))
     assert_equal 2, config.retain_containers
 
-    assert_raises(ArgumentError) { Kamal::Configuration.new(@deploy_with_roles.merge(retain_containers: 0)) }
+    assert_raises(Kamal::ConfigurationError) { Kamal::Configuration.new(@deploy_with_roles.merge(retain_containers: 0)) }
+  end
+
+  test "extensions" do
+    dest_config_file = Pathname.new(File.expand_path("fixtures/deploy_with_extensions.yml", __dir__))
+
+    config = Kamal::Configuration.create_from config_file: dest_config_file
+    assert_equal config.role(:web_tokyo).running_traefik?, true
+    assert_equal config.role(:web_chicago).running_traefik?, true
   end
 end

test/fixtures/deploy_primary_web_role_override.yml

@@ -2,12 +2,12 @@ service: app
 image: dhh/app
 servers:
   web_chicago:
-    traefik: enabled
+    traefik: true
     hosts:
       - 1.1.1.1
       - 1.1.1.2
   web_tokyo:
-    traefik: enabled
+    traefik: true
     hosts:
       - 1.1.1.3
       - 1.1.1.4

test/fixtures/deploy_with_aliases.yml

@@ -1,36 +0,0 @@
-# helper aliases
-chicago_hosts: &chicago_hosts
-  hosts:
-    - 1.1.1.1
-    - 1.1.1.2
-tokyo_hosts: &tokyo_hosts
-  hosts:
-    - 1.1.1.3
-    - 1.1.1.4
-web_common: &web_common
-  env:
-    ROLE: "web"
-  traefik: true
-
-# actual config
-service: app
-image: dhh/app
-servers:
-  web:
-    <<: *chicago_hosts
-    <<: *web_common
-  web_tokyo:
-    <<: *tokyo_hosts
-    <<: *web_common
-  workers:
-    cmd: bin/jobs
-    <<: *chicago_hosts
-  workers_tokyo:
-    cmd: bin/jobs
-    <<: *tokyo_hosts
-env:
-  REDIS_URL: redis://x/y
-registry:
-  server: registry.digitalocean.com
-  username: user
-  password: pw

test/fixtures/deploy_with_extensions.yml

@@ -0,0 +1,24 @@
+
+x-web: &web
+  traefik: true
+
+service: app
+image: dhh/app
+servers:
+  web_chicago:
+    <<: *web
+    hosts:
+      - 1.1.1.1
+      - 1.1.1.2
+  web_tokyo:
+    <<: *web
+    hosts:
+      - 1.1.1.3
+      - 1.1.1.4
+env:
+  REDIS_URL: redis://x/y
+registry:
+  server: registry.digitalocean.com
+  username: user
+  password: pw
+primary_role: web_tokyo

test/fixtures/deploy_with_multiple_traefik_roles.yml

@@ -0,0 +1,34 @@
+# actual config
+service: app
+image: dhh/app
+servers:
+  web:
+    hosts:
+      - 1.1.1.1
+      - 1.1.1.2
+    env:
+      ROLE: "web"
+    traefik: true
+  web_tokyo:
+    hosts:
+      - 1.1.1.3
+      - 1.1.1.4
+    env:
+      ROLE: "web"
+    traefik: true
+  workers:
+    cmd: bin/jobs
+    hosts:
+      - 1.1.1.1
+      - 1.1.1.2
+  workers_tokyo:
+    cmd: bin/jobs
+    hosts:
+      - 1.1.1.3
+      - 1.1.1.4
+env:
+  REDIS_URL: redis://x/y
+registry:
+  server: registry.digitalocean.com
+  username: user
+  password: pw

test/integration/accessory_test.rb

@@ -2,8 +2,6 @@ require_relative "integration_test"
 
 class AccessoryTest < IntegrationTest
   test "boot, stop, start, restart, logs, remove" do
-    kamal :envify
-
     kamal :accessory, :boot, :busybox
     assert_accessory_running :busybox
 

test/integration/app_test.rb

@@ -2,8 +2,6 @@ require_relative "integration_test"
 
 class AppTest < IntegrationTest
   test "stop, start, boot, logs, images, containers, exec, remove" do
-    kamal :envify
-
     kamal :deploy
 
     assert_app_is_up

test/integration/broken_deploy_test.rb

@@ -4,8 +4,6 @@ class BrokenDeployTest < IntegrationTest
   test "deploying a bad image" do
     @app = "app_with_roles"
 
-    kamal :envify
-
     first_version = latest_app_version
 
     kamal :deploy
@@ -26,7 +24,7 @@ class BrokenDeployTest < IntegrationTest
   private
     def assert_failed_deploy(output)
       assert_match "Waiting for the first healthy web container before booting workers on vm3...", output
-      assert_match /First web container is unhealthy on vm[12], not booting other roles/, output
+      assert_match /First web container is unhealthy on vm[12], not booting any other roles/, output
       assert_match "First web container is unhealthy, not booting workers on vm3", output
       assert_match "nginx: [emerg] unexpected end of file, expecting \";\" or \"}\" in /etc/nginx/conf.d/default.conf:2", output
       assert_match 'ERROR {"Status":"unhealthy","FailingStreak":0,"Log":[]}', output

test/integration/docker-compose.yml

@@ -1,4 +1,3 @@
-version: "3.7"
 name: "kamal-test"
 
 volumes: