cpl 0.6.0 → 0.7.0

data/lib/command/maintenance_off.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Command
+  class MaintenanceOff < Base
+    NAME = "maintenance:off"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Disables maintenance mode for an app"
+    LONG_DESCRIPTION = <<~DESC
+      - Disables maintenance mode for an app
+      - Specify the one-off workload through `one_off_workload` in the `.controlplane/controlplane.yml` file
+      - Optionally specify the maintenance workload through `maintenance_workload` in the `.controlplane/controlplane.yml` file (defaults to 'maintenance')
+      - Maintenance mode is only supported for domains that use path based routing mode and have a route configured for the prefix '/' on either port 80 or 443
+    DESC
+
+    def call # rubocop:disable Metrics/MethodLength
+      one_off_workload = config[:one_off_workload]
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      domain_data = cp.find_domain_for([one_off_workload, maintenance_workload])
+      unless domain_data
+        raise "Can't find domain. " \
+              "Maintenance mode is only supported for domains that use path based routing mode " \
+              "and have a route configured for the prefix '/' on either port 80 or 443."
+      end
+
+      domain = domain_data["name"]
+      domain_workload = cp.get_domain_workload(domain_data)
+      if domain_workload == one_off_workload
+        progress.puts("Maintenance mode is already disabled for app '#{config.app}'.")
+        return
+      end
+
+      cp.fetch_workload!(maintenance_workload)
+
+      # Start all other workloads
+      Cpl::Cli.start(["ps:start", "-a", config.app, "--wait"])
+
+      progress.puts
+
+      # Switch domain workload
+      step("Switching workload for domain '#{domain}' to '#{one_off_workload}'") do
+        cp.set_domain_workload(domain_data, one_off_workload)
+
+        # Give it a bit of time for the domain to update
+        sleep 30
+      end
+
+      progress.puts
+
+      # Stop maintenance workload
+      Cpl::Cli.start(["ps:stop", "-a", config.app, "-w", maintenance_workload, "--wait"])
+
+      progress.puts("\nMaintenance mode disabled for app '#{config.app}'.")
+    end
+  end
+end

data/lib/command/maintenance_on.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Command
+  class MaintenanceOn < Base
+    NAME = "maintenance:on"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Enables maintenance mode for an app"
+    LONG_DESCRIPTION = <<~DESC
+      - Enables maintenance mode for an app
+      - Specify the one-off workload through `one_off_workload` in the `.controlplane/controlplane.yml` file
+      - Optionally specify the maintenance workload through `maintenance_workload` in the `.controlplane/controlplane.yml` file (defaults to 'maintenance')
+      - Maintenance mode is only supported for domains that use path based routing mode and have a route configured for the prefix '/' on either port 80 or 443
+    DESC
+
+    def call # rubocop:disable Metrics/MethodLength
+      one_off_workload = config[:one_off_workload]
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      domain_data = cp.find_domain_for([one_off_workload, maintenance_workload])
+      unless domain_data
+        raise "Can't find domain. " \
+              "Maintenance mode is only supported for domains that use path based routing mode " \
+              "and have a route configured for the prefix '/' on either port 80 or 443."
+      end
+
+      domain = domain_data["name"]
+      domain_workload = cp.get_domain_workload(domain_data)
+      if domain_workload == maintenance_workload
+        progress.puts("Maintenance mode is already enabled for app '#{config.app}'.")
+        return
+      end
+
+      cp.fetch_workload!(maintenance_workload)
+
+      # Start maintenance workload
+      Cpl::Cli.start(["ps:start", "-a", config.app, "-w", maintenance_workload, "--wait"])
+
+      progress.puts
+
+      # Switch domain workload
+      step("Switching workload for domain '#{domain}' to '#{maintenance_workload}'") do
+        cp.set_domain_workload(domain_data, maintenance_workload)
+
+        # Give it a bit of time for the domain to update
+        sleep 30
+      end
+
+      progress.puts
+
+      # Stop all other workloads
+      Cpl::Cli.start(["ps:stop", "-a", config.app, "--wait"])
+
+      progress.puts("\nMaintenance mode enabled for app '#{config.app}'.")
+    end
+  end
+end

data/lib/command/maintenance_set_page.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Command
+  class MaintenanceSetPage < Base
+    NAME = "maintenance:set-page"
+    USAGE = "maintenance:set-page PAGE_URL"
+    REQUIRES_ARGS = true
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Sets the page for maintenance mode"
+    LONG_DESCRIPTION = <<~DESC
+      - Sets the page for maintenance mode
+      - Only works if the maintenance workload uses the `shakacode/maintenance-mode` image
+      - Will set the URL as an env var `PAGE_URL` on the maintenance workload
+      - Optionally specify the maintenance workload through `maintenance_workload` in the `.controlplane/controlplane.yml` file (defaults to 'maintenance')
+    DESC
+
+    def call
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      maintenance_workload_data = cp.fetch_workload!(maintenance_workload)
+      maintenance_workload_data.dig("spec", "containers").each do |container|
+        next unless container["image"].match?(%r{^shakacode/maintenance-mode})
+
+        container_name = container["name"]
+        page_url = config.args.first
+        step("Setting '#{page_url}' as the page for maintenance mode") do
+          cp.set_workload_env_var(maintenance_workload, container: container_name, name: "PAGE_URL", value: page_url)
+        end
+      end
+    end
+  end
+end

data/lib/command/no_command.rb

@@ -13,7 +13,7 @@ module Command
     def call
       return unless config.options[:version]
 
-      perform("cpl version")
+      Cpl::Cli.start(["version"])
     end
   end
 end

data/lib/command/promote_app_from_upstream.rb

@@ -39,7 +39,7 @@ module Command
     end
 
     def copy_image_from_upstream
-      perform("cpl copy-image-from-upstream -a #{config.app} -t #{config.options[:upstream_token]}")
+      Cpl::Cli.start(["copy-image-from-upstream", "-a", config.app, "-t", config.options[:upstream_token]])
       progress.puts
     end
 
@@ -52,7 +52,7 @@ module Command
     end
 
     def deploy_image
-      perform("cpl deploy-image -a #{config.app}")
+      Cpl::Cli.start(["deploy-image", "-a", config.app])
     end
   end
 end

data/lib/command/ps_start.rb

@@ -5,7 +5,8 @@ module Command
     NAME = "ps:start"
     OPTIONS = [
       app_option(required: true),
-      workload_option
+      workload_option,
+      wait_option("workload to be ready")
     ].freeze
     DESCRIPTION = "Starts workloads in app"
     LONG_DESCRIPTION = <<~DESC
@@ -22,12 +23,28 @@ module Command
     EX
 
     def call
-      workloads = [config.options[:workload]] if config.options[:workload]
-      workloads ||= config[:app_workloads] + config[:additional_workloads]
+      @workloads = [config.options[:workload]] if config.options[:workload]
+      @workloads ||= config[:app_workloads] + config[:additional_workloads]
 
-      workloads.reverse_each do |workload|
+      @workloads.reverse_each do |workload|
         step("Starting workload '#{workload}'") do
-          cp.workload_set_suspend(workload, false)
+          cp.set_workload_suspend(workload, false)
+        end
+      end
+
+      wait_for_ready if config.options[:wait]
+    end
+
+    private
+
+    def wait_for_ready
+      progress.puts
+
+      @workloads.reverse_each do |workload|
+        step("Waiting for workload '#{workload}' to be ready", retry_on_failure: true) do
+          cp.fetch_workload_deployments(workload)&.dig("items")&.any? do |item|
+            item.dig("status", "ready")
+          end
         end
       end
     end

data/lib/command/ps_stop.rb

@@ -5,7 +5,8 @@ module Command
     NAME = "ps:stop"
     OPTIONS = [
       app_option(required: true),
-      workload_option
+      workload_option,
+      wait_option("workload to be not ready")
     ].freeze
     DESCRIPTION = "Stops workloads in app"
     LONG_DESCRIPTION = <<~DESC
@@ -22,12 +23,28 @@ module Command
     EX
 
     def call
-      workloads = [config.options[:workload]] if config.options[:workload]
-      workloads ||= config[:app_workloads] + config[:additional_workloads]
+      @workloads = [config.options[:workload]] if config.options[:workload]
+      @workloads ||= config[:app_workloads] + config[:additional_workloads]
 
-      workloads.each do |workload|
+      @workloads.each do |workload|
         step("Stopping workload '#{workload}'") do
-          cp.workload_set_suspend(workload, true)
+          cp.set_workload_suspend(workload, true)
+        end
+      end
+
+      wait_for_not_ready if config.options[:wait]
+    end
+
+    private
+
+    def wait_for_not_ready
+      progress.puts
+
+      @workloads.each do |workload|
+        step("Waiting for workload '#{workload}' to be not ready", retry_on_failure: true) do
+          cp.fetch_workload_deployments(workload)&.dig("items")&.all? do |item|
+            !item.dig("status", "ready")
+          end
         end
       end
     end

data/lib/command/run.rb

@@ -10,13 +10,15 @@ module Command
       app_option(required: true),
       image_option,
       workload_option,
-      use_local_token_option
+      use_local_token_option,
+      terminal_size_option
     ].freeze
     DESCRIPTION = "Runs one-off **_interactive_** replicas (analog of `heroku run`)"
     LONG_DESCRIPTION = <<~DESC
       - Runs one-off **_interactive_** replicas (analog of `heroku run`)
       - Uses `Standard` workload type and `cpln exec` as the execution method, with CLI streaming
       - May not work correctly with tasks that last over 5 minutes (there's a Control Plane scaling bug at the moment)
+      - If `fix_terminal_size` is `true` in the `.controlplane/controlplane.yml` file, the remote terminal size will be fixed to match the local terminal size (may also be overriden through `--terminal-size`)
 
       > **IMPORTANT:** Useful for development where it's needed for interaction, and where network connection drops and
       > task crashing are tolerable. For production tasks, it's better to use `cpl run:detached`.
@@ -26,6 +28,12 @@ module Command
       # Opens shell (bash by default).
       cpl run -a $APP_NAME
 
+      # Need to quote COMMAND if setting ENV value or passing args.
+      cpl run 'LOG_LEVEL=warn rails db:migrate' -a $APP_NAME
+
+      # COMMAND may also be passed at the end (in this case, no need to quote).
+      cpl run -a $APP_NAME -- rails db:migrate
+
       # Runs command, displays output, and exits shell.
       cpl run ls / -a $APP_NAME
       cpl run rails db:migrate:status -a $APP_NAME
@@ -37,11 +45,11 @@ module Command
       cpl run rails db:migrate -a $APP_NAME --image appimage:123 # Exact image name
       cpl run rails db:migrate -a $APP_NAME --image latest       # Latest sequential image
 
-      # Uses a different workload
+      # Uses a different workload than `one_off_workload` from `.controlplane/controlplane.yml`.
       cpl run bash -a $APP_NAME -w other-workload
 
       # Overrides remote CPLN_TOKEN env variable with local token.
-      # Useful when need superuser rights in remote container
+      # Useful when superuser rights are needed in remote container.
       cpl run bash -a $APP_NAME --use-local-token
       ```
     EX
@@ -84,7 +92,7 @@ module Command
 
       # Ensure no scaling
       spec["defaultOptions"]["autoscaling"]["minScale"] = 1
-      spec["defaultOptions"]["autoscaling"]["minScale"] = 1
+      spec["defaultOptions"]["autoscaling"]["maxScale"] = 1
       spec["defaultOptions"]["capacityAI"] = false
 
       # Override image if specified
@@ -104,7 +112,7 @@ module Command
       cp.apply("kind" => "workload", "name" => one_off, "spec" => spec)
     end
 
-    def runner_script
+    def runner_script # rubocop:disable Metrics/MethodLength
       script = Scripts.helpers_cleanup
 
       if config.options["use_local_token"]
@@ -114,6 +122,16 @@ module Command
         SHELL
       end
 
+      # NOTE: fixes terminal size to match local terminal
+      if config.current[:fix_terminal_size] || config.options[:terminal_size]
+        if config.options[:terminal_size]
+          rows, cols = config.options[:terminal_size].split(",")
+        else
+          rows, cols = `stty -a`.match(/(\d+)\s*rows;\s*(\d+)\s*columns/).captures
+        end
+        script += "stty rows #{rows}\nstty cols #{cols}\n" if rows && cols
+      end
+
       script += args_join(config.args)
       script
     end

data/lib/command/run_cleanup.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Command
+  class RunCleanup < Base
+    NAME = "run:cleanup"
+    OPTIONS = [
+      app_option(required: true),
+      skip_confirm_option
+    ].freeze
+    DESCRIPTION = "Deletes stale run workloads for an app"
+    LONG_DESCRIPTION = <<~DESC
+      - Deletes stale run workloads for an app
+      - Workloads are considered stale based on how many days since created
+      - `stale_run_workload_created_days` in the `.controlplane/controlplane.yml` file specifies the number of days after created that the workload is considered stale
+      - Will ask for explicit user confirmation of deletion
+    DESC
+
+    def call # rubocop:disable Metrics/MethodLength
+      return progress.puts("No stale run workloads found.") if stale_run_workloads.empty?
+
+      progress.puts("Stale run workloads:")
+      stale_run_workloads.each do |workload|
+        progress.puts("  #{workload[:name]} " \
+                      "(#{Shell.color("#{workload[:date]} - #{workload[:days]} days ago", :red)})")
+      end
+
+      return unless confirm_delete
+
+      progress.puts
+      stale_run_workloads.each do |workload|
+        delete_workload(workload)
+      end
+    end
+
+    private
+
+    def app_matches?(app, app_name, app_options)
+      app == app_name.to_s || (app_options[:match_if_app_name_starts_with] && app.start_with?(app_name.to_s))
+    end
+
+    def find_app_options(app)
+      @app_options ||= {}
+      @app_options[app] ||= config.apps.find do |app_name, app_options|
+                              app_matches?(app, app_name, app_options)
+                            end&.last
+    end
+
+    def find_workloads(app)
+      app_options = find_app_options(app)
+      return [] if app_options.nil?
+
+      (app_options[:app_workloads] + app_options[:additional_workloads] + [app_options[:one_off_workload]]).uniq
+    end
+
+    def stale_run_workloads # rubocop:disable Metrics/MethodLength
+      @stale_run_workloads ||=
+        begin
+          defined_workloads = find_workloads(config.app)
+
+          run_workloads = []
+
+          now = DateTime.now
+          stale_run_workload_created_days = config[:stale_run_workload_created_days]
+
+          workloads = cp.query_workloads("-run-", partial_match: true)["items"]
+          workloads.each do |workload|
+            workload_name = workload["name"]
+
+            original_workload_name, workload_number = workload_name.split("-run-")
+            next unless defined_workloads.include?(original_workload_name) && workload_number.match?(/^\d{4}$/)
+
+            created_date = DateTime.parse(workload["created"])
+            diff_in_days = (now - created_date).to_i
+            next unless diff_in_days >= stale_run_workload_created_days
+
+            run_workloads.push({
+                                 name: workload_name,
+                                 date: created_date,
+                                 days: diff_in_days
+                               })
+          end
+
+          run_workloads
+        end
+    end
+
+    def confirm_delete
+      return true if config.options[:yes]
+
+      Shell.confirm("\nAre you sure you want to delete these #{stale_run_workloads.length} run workloads?")
+    end
+
+    def delete_workload(workload)
+      step("Deleting run workload '#{workload[:name]}'") do
+        cp.delete_workload(workload[:name])
+      end
+    end
+  end
+end

data/lib/command/run_detached.rb

@@ -22,9 +22,12 @@ module Command
       ```sh
       cpl run:detached rails db:prepare -a $APP_NAME
 
-      # Need to quote COMMAND if setting ENV value or passing args to command to run
+      # Need to quote COMMAND if setting ENV value or passing args.
       cpl run:detached 'LOG_LEVEL=warn rails db:migrate' -a $APP_NAME
 
+      # COMMAND may also be passed at the end (in this case, no need to quote).
+      cpl run:detached -a $APP_NAME -- rails db:migrate
+
       # Uses some other image.
       cpl run:detached rails db:migrate -a $APP_NAME --image /some/full/image/path
 
@@ -35,7 +38,7 @@ module Command
       cpl run:detached rails db:migrate -a $APP_NAME --image appimage:123 # Exact image name
       cpl run:detached rails db:migrate -a $APP_NAME --image latest       # Latest sequential image
 
-      # Uses a different workload
+      # Uses a different workload than `one_off_workload` from `.controlplane/controlplane.yml`.
       cpl run:detached rails db:migrate:status -a $APP_NAME -w other-workload
       ```
     EX
@@ -79,7 +82,7 @@ module Command
 
       # Ensure no scaling
       spec["defaultOptions"]["autoscaling"]["minScale"] = 1
-      spec["defaultOptions"]["autoscaling"]["minScale"] = 1
+      spec["defaultOptions"]["autoscaling"]["maxScale"] = 1
       spec["defaultOptions"]["capacityAI"] = false
 
       # Override image if specified

data/lib/command/setup_app.rb

@@ -14,16 +14,16 @@ module Command
     DESC
 
     def call
-      templates = config[:setup].join(" ")
+      templates = config[:setup]
 
       app = cp.fetch_gvc
       if app
         raise "App '#{config.app}' already exists. If you want to update this app, " \
               "either run 'cpl delete -a #{config.app}' and then re-run this command, " \
-              "or run 'cpl apply-template #{templates} -a #{config.app}'."
+              "or run 'cpl apply-template #{templates.join(' ')} -a #{config.app}'."
       end
 
-      perform("cpl apply-template #{templates} -a #{config.app}")
+      Cpl::Cli.start(["apply-template", *templates, "-a", config.app])
     end
   end
 end

data/lib/core/config.rb

@@ -15,24 +15,15 @@ class Config
     @app = options[:app]
 
     load_app_config
-
-    @apps = config[:apps]
-
-    pick_current_config if app
-    warn_deprecated_options if current
+    load_apps
   end
 
   def [](key)
     ensure_current_config!
 
-    old_key = old_option_keys[key]
-    if current.key?(key)
-      current.fetch(key)
-    elsif old_key && current.key?(old_key)
-      current.fetch(old_key)
-    else
-      raise "Can't find option '#{key}' for app '#{app}' in 'controlplane.yml'."
-    end
+    raise "Can't find option '#{key}' for app '#{app}' in 'controlplane.yml'." unless current.key?(key)
+
+    current.fetch(key)
   end
 
   def script_path
@@ -49,8 +40,8 @@ class Config
     raise "Can't find current config, please specify an app." unless current
   end
 
-  def ensure_current_config_app!(app)
-    raise "Can't find app '#{app}' in 'controlplane.yml'." unless current
+  def ensure_current_config_app!(app_name)
+    raise "Can't find app '#{app_name}' in 'controlplane.yml'." unless current
   end
 
   def ensure_config!
@@ -61,20 +52,36 @@ class Config
     raise "Can't find key 'apps' in 'controlplane.yml'." unless config[:apps]
   end
 
-  def ensure_config_app!(app, options)
-    raise "App '#{app}' is empty in 'controlplane.yml'." unless options
+  def ensure_config_app!(app_name, app_options)
+    raise "App '#{app_name}' is empty in 'controlplane.yml'." unless app_options
+  end
+
+  def app_matches_current?(app_name, app_options)
+    app && (app_name.to_s == app || (app_options[:match_if_app_name_starts_with] && app.start_with?(app_name.to_s)))
   end
 
-  def pick_current_config
-    config[:apps].each do |c_app, c_data|
-      ensure_config_app!(c_app, c_data)
-      next unless c_app.to_s == app || (c_data[:match_if_app_name_starts_with] && app.start_with?(c_app.to_s))
+  def pick_current_config(app_name, app_options)
+    @current = app_options
+    @org = self[:cpln_org]
+    ensure_current_config_app!(app_name)
+  end
+
+  def load_apps # rubocop:disable Metrics/MethodLength
+    @apps = config[:apps].to_h do |app_name, app_options|
+      ensure_config_app!(app_name, app_options)
+
+      app_options_with_new_keys = app_options.to_h do |key, value|
+        new_key = new_option_keys[key]
+        new_key ? [new_key, value] : [key, value]
+      end
+
+      if app_matches_current?(app_name, app_options_with_new_keys)
+        pick_current_config(app_name, app_options_with_new_keys)
+        warn_deprecated_options(app_options)
+      end
 
-      @current = c_data
-      @org = self[:cpln_org]
-      break
+      [app_name, app_options_with_new_keys]
     end
-    ensure_current_config_app!(app)
   end
 
   def load_app_config
@@ -100,19 +107,19 @@ class Config
     end
   end
 
-  def old_option_keys
+  def new_option_keys
     {
-      cpln_org: :org,
-      default_location: :location,
-      match_if_app_name_starts_with: :prefix
+      org: :cpln_org,
+      location: :default_location,
+      prefix: :match_if_app_name_starts_with
     }
   end
 
-  def warn_deprecated_options
-    deprecated_option_keys = old_option_keys.filter { |_new_key, old_key| current.key?(old_key) }
+  def warn_deprecated_options(app_options)
+    deprecated_option_keys = new_option_keys.filter { |old_key| app_options.key?(old_key) }
     return if deprecated_option_keys.empty?
 
-    deprecated_option_keys.each do |new_key, old_key|
+    deprecated_option_keys.each do |old_key, new_key|
       Shell.warn_deprecated("Option '#{old_key}' is deprecated, " \
                             "please use '#{new_key}' instead (in 'controlplane.yml').")
     end