dash 3.2.0 → 4.0.0

data/lib/{kamal → dash}/cli/app.rb

@@ -1,4 +1,4 @@
-class Kamal::Cli::App < Kamal::Cli::Base
+class Dash::Cli::App < Dash::Cli::Base
   desc "boot", "Boot app on servers (or reboot app if already running)"
   def boot
     modify(lock: true) do
@@ -7,17 +7,17 @@ class Kamal::Cli::App < Kamal::Cli::Base
         say "Start container with version #{version} (or reboot if already running)...", :magenta
 
         # Assets are prepared in a separate step to ensure they are on all hosts before booting
-        on(KAMAL.app_hosts) do
-          Kamal::Cli::App::ErrorPages.new(host, self).run
+        on(DASH.app_hosts) do
+          Dash::Cli::App::ErrorPages.new(host, self).run
 
-          KAMAL.roles_on(host).each do |role|
-            Kamal::Cli::App::Assets.new(host, role, self).run
-            Kamal::Cli::App::SslCertificates.new(host, role, self).run
+          DASH.roles_on(host).each do |role|
+            Dash::Cli::App::Assets.new(host, role, self).run
+            Dash::Cli::App::SslCertificates.new(host, role, self).run
           end
         end
 
         # Primary hosts and roles are returned first, so they can open the barrier
-        barrier = Kamal::Cli::Healthcheck::Barrier.new
+        barrier = Dash::Cli::Healthcheck::Barrier.new
         cli = self
 
         boot_groups = host_boot_groups
@@ -26,8 +26,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
           host_list = Array(hosts).join(",")
           run_hook "pre-app-boot", hosts: host_list
 
-          on_roles(KAMAL.roles, hosts: hosts, parallel: KAMAL.config.parallel_roles?, rolling: true) do |host, role|
-            Kamal::Cli::App::Boot.new(host, role, self, version, barrier, cli).run
+          on_roles(DASH.roles, hosts: hosts, parallel: DASH.config.parallel_roles?, rolling: true) do |host, role|
+            Dash::Cli::App::Boot.new(host, role, self, version, barrier, cli).run
           end
 
           run_hook "post-app-boot", hosts: host_list
@@ -35,13 +35,13 @@ class Kamal::Cli::App < Kamal::Cli::Base
           # `wait` paces one group against the next, so the last group has nothing to pace
           # against. Without a `limit` there is only ever one group, and waiting at all
           # would be a fixed delay on every deploy buying no staggering.
-          sleep KAMAL.config.boot.wait if KAMAL.config.boot.wait && index < boot_groups.size - 1
+          sleep DASH.config.boot.wait if DASH.config.boot.wait && index < boot_groups.size - 1
         end
 
         # Tag once the app booted on all hosts
-        on(KAMAL.app_hosts) do |host|
-          execute *KAMAL.auditor.record("Tagging #{KAMAL.config.absolute_image} as the latest image"), verbosity: :debug
-          execute *KAMAL.app.tag_latest_image
+        on(DASH.app_hosts) do |host|
+          execute *DASH.auditor.record("Tagging #{DASH.config.absolute_image} as the latest image"), verbosity: :debug
+          execute *DASH.app.tag_latest_image
         end
       end
     end
@@ -52,15 +52,15 @@ class Kamal::Cli::App < Kamal::Cli::Base
     modify(lock: true) do
       cli = self
 
-      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts, parallel: KAMAL.config.parallel_roles?, rolling: true) do |host, role|
-        app = KAMAL.app(role: role, host: host)
-        execute *KAMAL.auditor.record("Started app version #{KAMAL.config.version}"), verbosity: :debug
+      on_roles(DASH.roles, hosts: DASH.app_hosts, parallel: DASH.config.parallel_roles?, rolling: true) do |host, role|
+        app = DASH.app(role: role, host: host)
+        execute *DASH.auditor.record("Started app version #{DASH.config.version}"), verbosity: :debug
         execute *app.start, raise_on_non_zero_exit: false
 
         if role.running_proxy?
           version = capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip
           endpoint = capture_with_info(*app.container_id_for_version(version)).strip
-          raise Kamal::Cli::BootError, "Failed to get endpoint for #{role} on #{host}, did the container boot?" if endpoint.empty?
+          raise Dash::Cli::BootError, "Failed to get endpoint for #{role} on #{host}, did the container boot?" if endpoint.empty?
 
           cli.run_hook "pre-proxy-deploy", hosts: host.to_s, role: role.name
           execute *app.deploy(target: endpoint)
@@ -73,9 +73,9 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "stop", "Stop app container on servers"
   def stop
     modify(lock: true) do
-      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts, parallel: KAMAL.config.parallel_roles?) do |host, role|
-        app = KAMAL.app(role: role, host: host)
-        execute *KAMAL.auditor.record("Stopped app", role: role), verbosity: :debug
+      on_roles(DASH.roles, hosts: DASH.app_hosts, parallel: DASH.config.parallel_roles?) do |host, role|
+        app = DASH.app(role: role, host: host)
+        execute *DASH.auditor.record("Stopped app", role: role), verbosity: :debug
 
         if role.running_proxy?
           version = capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip
@@ -94,8 +94,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "details", "Show details about app containers"
   def details
     quiet = options[:quiet]
-    on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-      puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).info), quiet: quiet
+    on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
+      puts_by_host host, capture_with_info(*DASH.app(role: role, host: host).info), quiet: quiet
     end
   end
 
@@ -123,7 +123,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
     with_raw_output(raw) do
       pre_connect_if_required
 
-      cmd = Kamal::Utils.join_commands(cmd)
+      cmd = Dash::Utils.join_commands(cmd)
       env = options[:env]
       detach = options[:detach]
       quiet = options[:quiet]
@@ -131,17 +131,17 @@ class Kamal::Cli::App < Kamal::Cli::Base
       when options[:interactive] && options[:reuse]
         say "Get current version of running container...", :magenta unless options[:version]
         using_version(options[:version] || current_running_version) do |version|
-          say "Launching interactive command with version #{version} via SSH from existing container on #{KAMAL.primary_host}...", :magenta
-          run_locally { exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_existing_container_over_ssh(cmd, env: env) }
+          say "Launching interactive command with version #{version} via SSH from existing container on #{DASH.primary_host}...", :magenta
+          run_locally { exec DASH.app(role: DASH.primary_role, host: DASH.primary_host).execute_in_existing_container_over_ssh(cmd, env: env) }
         end
 
       when options[:interactive]
         say "Get most recent version available as an image...", :magenta unless options[:version]
         using_version(version_or_latest) do |version|
-          say "Launching interactive command with version #{version} via SSH from new container on #{KAMAL.primary_host}...", :magenta
-          on(KAMAL.primary_host) { execute *KAMAL.registry.login }
+          say "Launching interactive command with version #{version} via SSH from new container on #{DASH.primary_host}...", :magenta
+          on(DASH.primary_host) { execute *DASH.registry.login }
           run_locally do
-            exec KAMAL.app(role: KAMAL.primary_role, host: KAMAL.primary_host).execute_in_new_container_over_ssh(cmd, env: env)
+            exec DASH.app(role: DASH.primary_role, host: DASH.primary_host).execute_in_new_container_over_ssh(cmd, env: env)
           end
         end
 
@@ -150,9 +150,9 @@ class Kamal::Cli::App < Kamal::Cli::Base
         using_version(options[:version] || current_running_version) do |version|
           say "Launching command with version #{version} from existing container...", :magenta
 
-          on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}", role: role), verbosity: :debug
-            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_existing_container(cmd, env: env), strip: !raw), quiet: quiet, raw: raw
+          on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
+            execute *DASH.auditor.record("Executed cmd '#{cmd}' on app version #{version}", role: role), verbosity: :debug
+            puts_by_host host, capture_with_info(*DASH.app(role: role, host: host).execute_in_existing_container(cmd, env: env), strip: !raw), quiet: quiet, raw: raw
           end
         end
 
@@ -160,11 +160,11 @@ class Kamal::Cli::App < Kamal::Cli::Base
         say "Get most recent version available as an image...", :magenta unless options[:version]
         using_version(version_or_latest) do |version|
           say "Launching command with version #{version} from new container...", :magenta
-          on(KAMAL.app_hosts) { execute *KAMAL.registry.login }
+          on(DASH.app_hosts) { execute *DASH.registry.login }
 
-          on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-            execute *KAMAL.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
-            puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).execute_in_new_container(cmd, env: env, detach: detach), strip: !raw), quiet: quiet, raw: raw
+          on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
+            execute *DASH.auditor.record("Executed cmd '#{cmd}' on app version #{version}"), verbosity: :debug
+            puts_by_host host, capture_with_info(*DASH.app(role: role, host: host).execute_in_new_container(cmd, env: env, detach: detach), strip: !raw), quiet: quiet, raw: raw
           end
         end
       end
@@ -174,7 +174,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "containers", "Show app containers on servers"
   def containers
     quiet = options[:quiet]
-    on(KAMAL.app_hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.app.list_containers), quiet: quiet }
+    on(DASH.app_hosts) { |host| puts_by_host host, capture_with_info(*DASH.app.list_containers), quiet: quiet }
   end
 
   desc "stale_containers", "Detect app stale containers"
@@ -184,8 +184,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
     stop = options[:stop]
 
     with_lock_if_stopping do
-      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-        app = KAMAL.app(role: role, host: host)
+      on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
+        app = DASH.app(role: role, host: host)
         versions = capture_with_info(*app.list_versions, raise_on_non_zero_exit: false).split("\n")
         versions -= [ capture_with_info(*app.current_running_version, raise_on_non_zero_exit: false).strip ]
 
@@ -204,7 +204,7 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "images", "Show app images on servers"
   def images
     quiet = options[:quiet]
-    on(KAMAL.app_hosts) { |host| puts_by_host host, capture_with_info(*KAMAL.app.list_images), quiet: quiet }
+    on(DASH.app_hosts) { |host| puts_by_host host, capture_with_info(*DASH.app.list_images), quiet: quiet }
   end
 
   desc "logs", "Show log lines from app on servers (use --help to show options)"
@@ -229,21 +229,21 @@ class Kamal::Cli::App < Kamal::Cli::Base
       lines = options[:lines].presence || ((since || grep) ? nil : 10) # Default to 10 lines if since or grep isn't set
 
       run_locally do
-        info "Following logs on #{KAMAL.primary_host}..."
+        info "Following logs on #{DASH.primary_host}..."
 
-        KAMAL.specific_roles ||= [ KAMAL.primary_role.name ]
-        role = KAMAL.roles_on(KAMAL.primary_host).first
+        DASH.specific_roles ||= [ DASH.primary_role.name ]
+        role = DASH.roles_on(DASH.primary_host).first
 
-        app = KAMAL.app(role: role, host: host)
-        info app.follow_logs(host: KAMAL.primary_host, container_id: container_id, timestamps: timestamps, lines: lines, grep: grep, grep_options: grep_options)
-        exec app.follow_logs(host: KAMAL.primary_host, container_id: container_id, timestamps: timestamps, lines: lines, grep: grep, grep_options: grep_options)
+        app = DASH.app(role: role, host: host)
+        info app.follow_logs(host: DASH.primary_host, container_id: container_id, timestamps: timestamps, lines: lines, grep: grep, grep_options: grep_options)
+        exec app.follow_logs(host: DASH.primary_host, container_id: container_id, timestamps: timestamps, 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
 
-      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
+      on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
         begin
-          puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).logs(container_id: container_id, timestamps: timestamps, since: since, lines: lines, grep: grep, grep_options: grep_options)), quiet: quiet
+          puts_by_host host, capture_with_info(*DASH.app(role: role, host: host).logs(container_id: container_id, timestamps: timestamps, since: since, lines: lines, grep: grep, grep_options: grep_options)), quiet: quiet
         rescue SSHKit::Command::Failed
           puts_by_host host, "Nothing found", quiet: quiet
         end
@@ -264,8 +264,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "live", "Set the app to live mode"
   def live
     modify(lock: true) do
-      on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
-        execute *KAMAL.app(role: role, host: host).live if role.running_proxy?
+      on_roles(DASH.roles, hosts: DASH.proxy_hosts) do |host, role|
+        execute *DASH.app(role: role, host: host).live if role.running_proxy?
       end
     end
   end
@@ -274,16 +274,16 @@ class Kamal::Cli::App < Kamal::Cli::Base
   option :drain_timeout, type: :numeric, desc: "How long to allow in-flight requests to complete (defaults to drain_timeout from config)"
   option :message, type: :string, desc: "Message to display to clients while stopped"
   def maintenance
-    maintenance_options = { drain_timeout: options[:drain_timeout] || KAMAL.config.drain_timeout, message: options[:message] }
+    maintenance_options = { drain_timeout: options[:drain_timeout] || DASH.config.drain_timeout, message: options[:message] }
 
     modify(lock: true) do
-      on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
-        execute *KAMAL.app(role: role, host: host).maintenance(**maintenance_options) if role.running_proxy?
+      on_roles(DASH.roles, hosts: DASH.proxy_hosts) do |host, role|
+        execute *DASH.app(role: role, host: host).maintenance(**maintenance_options) if role.running_proxy?
       end
     end
   end
 
-  desc "rollout <deploy|set|stop>", "Manage a canary rollout of a new version through kamal-proxy"
+  desc "rollout <deploy|set|stop>", "Manage a canary rollout of a new version through dash-proxy"
   option :percent, type: :numeric, desc: "Percentage of traffic to send to the rollout target"
   option :list, type: :array, desc: "Send requests whose kamal-rollout cookie matches these values to the rollout target"
   def rollout(action)
@@ -298,9 +298,9 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "remove_container [VERSION]", "Remove app container with given version from servers", hide: true
   def remove_container(version)
     modify(lock: true) do
-      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-        execute *KAMAL.auditor.record("Removed app container with version #{version}", role: role), verbosity: :debug
-        execute *KAMAL.app(role: role, host: host).remove_container(version: version)
+      on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
+        execute *DASH.auditor.record("Removed app container with version #{version}", role: role), verbosity: :debug
+        execute *DASH.app(role: role, host: host).remove_container(version: version)
       end
     end
   end
@@ -308,9 +308,9 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "remove_containers", "Remove all app containers from servers", hide: true
   def remove_containers
     modify(lock: true) do
-      on_roles(KAMAL.roles, hosts: KAMAL.app_hosts) do |host, role|
-        execute *KAMAL.auditor.record("Removed all app containers", role: role), verbosity: :debug
-        execute *KAMAL.app(role: role, host: host).remove_containers
+      on_roles(DASH.roles, hosts: DASH.app_hosts) do |host, role|
+        execute *DASH.auditor.record("Removed all app containers", role: role), verbosity: :debug
+        execute *DASH.app(role: role, host: host).remove_containers
       end
     end
   end
@@ -319,8 +319,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
   def remove_images
     modify(lock: true) do
       on(hosts_removing_all_roles) do
-        execute *KAMAL.auditor.record("Removed all app images"), verbosity: :debug
-        execute *KAMAL.app.remove_images
+        execute *DASH.auditor.record("Removed all app images"), verbosity: :debug
+        execute *DASH.app.remove_images
       end
     end
   end
@@ -329,9 +329,9 @@ class Kamal::Cli::App < Kamal::Cli::Base
   def remove_app_directories
     modify(lock: true) do
       on(hosts_removing_all_roles) do |host|
-        execute *KAMAL.server.remove_app_directory, raise_on_non_zero_exit: false
-        execute *KAMAL.auditor.record("Removed #{KAMAL.config.app_directory}"), verbosity: :debug
-        execute *KAMAL.app.remove_proxy_app_directory, raise_on_non_zero_exit: false
+        execute *DASH.server.remove_app_directory, raise_on_non_zero_exit: false
+        execute *DASH.auditor.record("Removed #{DASH.config.app_directory}"), verbosity: :debug
+        execute *DASH.app.remove_proxy_app_directory, raise_on_non_zero_exit: false
       end
     end
   end
@@ -339,9 +339,9 @@ class Kamal::Cli::App < Kamal::Cli::Base
   desc "version", "Show app version currently running on servers"
   def version
     quiet = options[:quiet]
-    on(KAMAL.app_hosts) do |host|
-      role = KAMAL.roles_on(host).first
-      puts_by_host host, capture_with_info(*KAMAL.app(role: role, host: host).current_running_version).strip, quiet: quiet
+    on(DASH.app_hosts) do |host|
+      role = DASH.roles_on(host).first
+      puts_by_host host, capture_with_info(*DASH.app(role: role, host: host).current_running_version).strip, quiet: quiet
     end
   end
 
@@ -352,14 +352,14 @@ class Kamal::Cli::App < Kamal::Cli::Base
         using_version(version_or_latest) do |version|
           say "Start rollout target with version #{version} alongside the live version...", :magenta
 
-          on(KAMAL.proxy_hosts) do
-            KAMAL.roles_on(host).each do |role|
-              Kamal::Cli::App::Assets.new(host, role, self).run if role.running_proxy?
+          on(DASH.proxy_hosts) do
+            DASH.roles_on(host).each do |role|
+              Dash::Cli::App::Assets.new(host, role, self).run if role.running_proxy?
             end
           end
 
-          on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts, parallel: KAMAL.config.parallel_roles?, rolling: true) do |host, role|
-            Kamal::Cli::App::RolloutBoot.new(host, role, self, version).run if role.running_proxy?
+          on_roles(DASH.roles, hosts: DASH.proxy_hosts, parallel: DASH.config.parallel_roles?, rolling: true) do |host, role|
+            Dash::Cli::App::RolloutBoot.new(host, role, self, version).run if role.running_proxy?
           end
         end
       end
@@ -373,49 +373,49 @@ class Kamal::Cli::App < Kamal::Cli::Base
       end
 
       modify(lock: true) do
-        on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
-          execute *KAMAL.app(role: role, host: host).rollout_set(percent: percent, list: list) if role.running_proxy?
+        on_roles(DASH.roles, hosts: DASH.proxy_hosts) do |host, role|
+          execute *DASH.app(role: role, host: host).rollout_set(percent: percent, list: list) if role.running_proxy?
         end
       end
     end
 
     def stop_rollout
       modify(lock: true) do
-        on_roles(KAMAL.roles, hosts: KAMAL.proxy_hosts) do |host, role|
-          execute *KAMAL.app(role: role, host: host).rollout_stop if role.running_proxy?
+        on_roles(DASH.roles, hosts: DASH.proxy_hosts) do |host, role|
+          execute *DASH.app(role: role, host: host).rollout_stop if role.running_proxy?
         end
       end
     end
 
     def hosts_removing_all_roles
-      KAMAL.app_hosts.select { |host| KAMAL.roles_on(host).map(&:name).sort == KAMAL.config.host_roles(host.to_s).map(&:name).sort }
+      DASH.app_hosts.select { |host| DASH.roles_on(host).map(&:name).sort == DASH.config.host_roles(host.to_s).map(&:name).sort }
     end
 
     def using_version(new_version)
       if new_version
         begin
-          old_version = KAMAL.config.version
-          KAMAL.config.version = new_version
+          old_version = DASH.config.version
+          DASH.config.version = new_version
           yield new_version
         ensure
-          KAMAL.config.version = old_version
+          DASH.config.version = old_version
         end
       else
-        yield KAMAL.config.version
+        yield DASH.config.version
       end
     end
 
-    def current_running_version(host: KAMAL.primary_host)
+    def current_running_version(host: DASH.primary_host)
       version = nil
       on(host) do
-        role = KAMAL.roles_on(host).first
-        version = capture_with_info(*KAMAL.app(role: role, host: host).current_running_version).strip
+        role = DASH.roles_on(host).first
+        version = capture_with_info(*DASH.app(role: role, host: host).current_running_version).strip
       end
       version.presence
     end
 
     def version_or_latest
-      options[:version] || KAMAL.config.latest_tag
+      options[:version] || DASH.config.latest_tag
     end
 
     def with_lock_if_stopping
@@ -427,8 +427,8 @@ class Kamal::Cli::App < Kamal::Cli::Base
     end
 
     def host_boot_groups
-      hosts = KAMAL.app_hosts
-      limit = KAMAL.config.boot.limit_for(hosts)
+      hosts = DASH.app_hosts
+      limit = DASH.config.boot.limit_for(hosts)
 
       limit ? hosts.each_slice(limit).to_a : [ hosts ]
     end