cpl 1.1.2 → 1.3.0

data/lib/command/run.rb

@@ -10,6 +10,7 @@ module Command
       app_option(required: true),
       image_option,
       workload_option,
+      location_option,
       use_local_token_option,
       terminal_size_option
     ].freeze
@@ -17,7 +18,6 @@ module Command
     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
@@ -29,56 +29,53 @@ module Command
       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.
       cpl run -a $APP_NAME -- 'LOG_LEVEL=warn 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
+      cpl run -a $APP_NAME -- ls /
+      cpl run -a $APP_NAME -- rails db:migrate:status
 
       # Runs command and keeps shell open.
-      cpl run rails c -a $APP_NAME
+      cpl run -a $APP_NAME -- rails c
 
       # Uses a different image (which may not be promoted yet).
-      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
+      cpl run -a $APP_NAME --image appimage:123 -- rails db:migrate # Exact image name
+      cpl run -a $APP_NAME --image latest -- rails db:migrate       # Latest sequential image
 
       # Uses a different workload than `one_off_workload` from `.controlplane/controlplane.yml`.
-      cpl run bash -a $APP_NAME -w other-workload
+      cpl run -a $APP_NAME -w other-workload -- bash
 
       # Overrides remote CPLN_TOKEN env variable with local token.
       # Useful when superuser rights are needed in remote container.
-      cpl run bash -a $APP_NAME --use-local-token
+      cpl run -a $APP_NAME --use-local-token -- bash
       ```
     EX
 
-    attr_reader :location, :workload, :one_off, :container
+    attr_reader :location, :workload_to_clone, :workload_clone, :container
 
     def call # rubocop:disable Metrics/MethodLength
-      @location = config[:default_location]
-      @workload = config.options["workload"] || config[:one_off_workload]
-      @one_off = "#{workload}-run-#{rand(1000..9999)}"
+      @location = config.location
+      @workload_to_clone = config.options["workload"] || config[:one_off_workload]
+      @workload_clone = "#{workload_to_clone}-run-#{random_four_digits}"
 
-      step("Cloning workload '#{workload}' on app '#{config.options[:app]}' to '#{one_off}'") do
+      step("Cloning workload '#{workload_to_clone}' on app '#{config.options[:app]}' to '#{workload_clone}'") do
         clone_workload
       end
 
-      wait_for_workload(one_off)
-      wait_for_replica(one_off, location)
+      wait_for_workload(workload_clone)
+      wait_for_replica(workload_clone, location)
       run_in_replica
     ensure
       progress.puts
-      ensure_workload_deleted(one_off)
+      ensure_workload_deleted(workload_clone)
     end
 
     private
 
     def clone_workload # rubocop:disable Metrics/MethodLength
       # Create a base copy of workload props
-      spec = cp.fetch_workload!(workload).fetch("spec")
-      container_spec = spec["containers"].detect { _1["name"] == workload } || spec["containers"].first
+      spec = cp.fetch_workload!(workload_to_clone).fetch("spec")
+      container_spec = spec["containers"].detect { _1["name"] == workload_to_clone } || spec["containers"].first
       @container = container_spec["name"]
 
       # remove other containers if any
@@ -111,7 +108,7 @@ module Command
       end
 
       # Create workload clone
-      cp.apply_hash("kind" => "workload", "name" => one_off, "spec" => spec)
+      cp.apply_hash("kind" => "workload", "name" => workload_clone, "spec" => spec)
     end
 
     def runner_script # rubocop:disable Metrics/MethodLength
@@ -141,7 +138,7 @@ module Command
     def run_in_replica
       progress.puts("Connecting...\n\n")
       command = %(bash -c 'eval "$CONTROLPLANE_RUNNER"')
-      cp.workload_exec(one_off, location: location, container: container, command: command)
+      cp.workload_exec(workload_clone, location: location, container: container, command: command)
     end
   end
 end

data/lib/command/run_detached.rb

@@ -9,7 +9,9 @@ module Command
       app_option(required: true),
       image_option,
       workload_option,
-      use_local_token_option
+      location_option,
+      use_local_token_option,
+      clean_on_failure_option
     ].freeze
     DESCRIPTION = "Runs one-off **_non-interactive_** replicas (close analog of `heroku run:detached`)"
     LONG_DESCRIPTION = <<~DESC
@@ -18,50 +20,46 @@ module Command
       - Implemented with only async execution methods, more suitable for production tasks
       - Has alternative log fetch implementation with only JSON-polling and no WebSockets
       - Less responsive but more stable, useful for CI tasks
+      - Deletes the workload whenever finished with success
+      - Deletes the workload whenever finished with failure by default
+      - Use `--no-clean-on-failure` to disable cleanup to help with debugging failed runs
     DESC
     EXAMPLES = <<~EX
       ```sh
       cpl run:detached rails db:prepare -a $APP_NAME
 
       # 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.
       cpl run:detached -a $APP_NAME -- 'LOG_LEVEL=warn rails db:migrate'
 
       # Uses a different image (which may not be promoted yet).
-      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
+      cpl run:detached -a $APP_NAME --image appimage:123 -- rails db:migrate # Exact image name
+      cpl run:detached -a $APP_NAME --image latest -- rails db:migrate       # Latest sequential image
 
       # 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
+      cpl run:detached -a $APP_NAME -w other-workload -- rails db:migrate:status
 
       # Overrides remote CPLN_TOKEN env variable with local token.
       # Useful when superuser rights are needed in remote container.
-      cpl run:detached rails db:migrate:status -a $APP_NAME --use-local-token
+      cpl run:detached -a $APP_NAME --use-local-token -- rails db:migrate:status
       ```
     EX
 
     WORKLOAD_SLEEP_CHECK = 2
 
-    attr_reader :location, :workload, :one_off, :container
+    attr_reader :location, :workload_to_clone, :workload_clone, :container
 
-    def call # rubocop:disable Metrics/MethodLength
-      @location = config[:default_location]
-      @workload = config.options["workload"] || config[:one_off_workload]
-      @one_off = "#{workload}-runner-#{rand(1000..9999)}"
+    def call
+      @location = config.location
+      @workload_to_clone = config.options["workload"] || config[:one_off_workload]
+      @workload_clone = "#{workload_to_clone}-runner-#{random_four_digits}"
 
-      step("Cloning workload '#{workload}' on app '#{config.options[:app]}' to '#{one_off}'") do
+      step("Cloning workload '#{workload_to_clone}' on app '#{config.options[:app]}' to '#{workload_clone}'") do
         clone_workload
       end
 
-      wait_for_workload(one_off)
+      wait_for_workload(workload_clone)
       show_logs_waiting
     ensure
-      if cp.fetch_workload(one_off)
-        progress.puts
-        ensure_workload_deleted(one_off)
-      end
       exit(1) if @crashed
     end
 
@@ -69,8 +67,8 @@ module Command
 
     def clone_workload # rubocop:disable Metrics/MethodLength
       # Get base specs of workload
-      spec = cp.fetch_workload!(workload).fetch("spec")
-      container_spec = spec["containers"].detect { _1["name"] == workload } || spec["containers"].first
+      spec = cp.fetch_workload!(workload_to_clone).fetch("spec")
+      container_spec = spec["containers"].detect { _1["name"] == workload_to_clone } || spec["containers"].first
       @container = container_spec["name"]
 
       # remove other containers if any
@@ -104,7 +102,7 @@ module Command
       container_spec["env"] << { "name" => "CONTROLPLANE_RUNNER", "value" => runner_script }
 
       # Create workload clone
-      cp.apply_hash("kind" => "workload", "name" => one_off, "spec" => spec)
+      cp.apply_hash("kind" => "workload", "name" => workload_clone, "spec" => spec)
     end
 
     def runner_script # rubocop:disable Metrics/MethodLength
@@ -118,12 +116,20 @@ module Command
       end
 
       script += <<~SHELL
-        if ! eval "#{args_join(config.args)}"; then echo "----- CRASHED -----"; fi
-
-        echo "-- FINISHED RUNNER SCRIPT, DELETING WORKLOAD --"
-        sleep 10 # grace time for logs propagation
-        curl ${CPLN_ENDPOINT}${CPLN_WORKLOAD} -H "Authorization: ${CONTROLPLANE_TOKEN}" -X DELETE -s -o /dev/null
-        while true; do sleep 1; done # wait for SIGTERM
+        crashed=0
+        if ! eval "#{args_join(config.args)}"; then
+          crashed=1
+          echo "----- CRASHED -----"
+        fi
+        clean_on_failure=#{config.options[:clean_on_failure] ? 1 : 0}
+        if [ $crashed -eq 0 ] || [ $clean_on_failure -eq 1 ]; then
+          echo "-- FINISHED RUNNER SCRIPT, DELETING WORKLOAD --"
+          sleep 30 # grace time for logs propagation
+          curl ${CPLN_ENDPOINT}${CPLN_WORKLOAD} -H "Authorization: ${CONTROLPLANE_TOKEN}" -X DELETE -s -o /dev/null
+          while true; do sleep 1; done # wait for SIGTERM
+        else
+          echo "-- FINISHED RUNNER SCRIPT --"
+        fi
       SHELL
 
       script
@@ -132,7 +138,8 @@ module Command
     def show_logs_waiting # rubocop:disable Metrics/MethodLength
       progress.puts("Scheduled, fetching logs (it's a cron job, so it may take up to a minute to start)...\n\n")
       begin
-        while cp.fetch_workload(one_off)
+        @finished = false
+        while cp.fetch_workload(workload_clone) && !@finished
           sleep(WORKLOAD_SLEEP_CHECK)
           print_uniq_logs
         end
@@ -150,6 +157,7 @@ module Command
 
       (entries - @printed_log_entries).sort.each do |(_ts, val)|
         @crashed = true if val.match?(/^----- CRASHED -----$/)
+        @finished = true if val.match?(/^-- FINISHED RUNNER SCRIPT(, DELETING WORKLOAD)? --$/)
         puts val
       end
 
@@ -157,7 +165,7 @@ module Command
     end
 
     def normalized_log_entries(from:, to:)
-      log = cp.log_get(workload: one_off, from: from, to: to)
+      log = cp.log_get(workload: workload_clone, from: from, to: to)
 
       log["data"]["result"]
         .each_with_object([]) { |obj, result| result.concat(obj["values"]) }

data/lib/command/setup_app.rb

@@ -9,12 +9,12 @@ module Command
     DESCRIPTION = "Creates an app and all its workloads"
     LONG_DESCRIPTION = <<~DESC
       - Creates an app and all its workloads
-      - Specify the templates for the app and workloads through `setup` in the `.controlplane/controlplane.yml` file
-      - This should should only be used for temporary apps like review apps, never for persistent apps like production (to update workloads for those, use 'cpl apply-template' instead)
+      - Specify the templates for the app and workloads through `setup_app_templates` in the `.controlplane/controlplane.yml` file
+      - This should only be used for temporary apps like review apps, never for persistent apps like production (to update workloads for those, use 'cpl apply-template' instead)
     DESC
 
     def call
-      templates = config[:setup]
+      templates = config[:setup_app_templates]
 
       app = cp.fetch_gvc
       if app

data/lib/command/version.rb

@@ -8,6 +8,7 @@ module Command
       - Displays the current version of the CLI
       - Can also be done with `cpl --version` or `cpl -v`
     DESC
+    WITH_INFO_HEADER = false
 
     def call
       puts Cpl::VERSION

data/lib/core/config.rb

@@ -1,24 +1,45 @@
 # frozen_string_literal: true
 
+require_relative "helpers"
+
 class Config # rubocop:disable Metrics/ClassLength
-  attr_reader :config, :current,
-              :org, :org_comes_from_env, :app, :apps, :app_dir,
+  attr_reader :org_comes_from_env, :app_comes_from_env,
               # command line options
-              :args, :options
+              :args, :options, :required_options
+
+  include Helpers
 
-  CONFIG_FILE_LOCATIION = ".controlplane/controlplane.yml"
+  CONFIG_FILE_LOCATION = ".controlplane/controlplane.yml"
 
-  def initialize(args, options)
+  def initialize(args, options, required_options)
     @args = args
     @options = options
-    @org = options[:org]
-    @org_comes_from_env = false
-    @app = options[:app]
+    @required_options = required_options
 
-    load_app_config
-    load_apps
+    ensure_required_options!
 
     Shell.verbose_mode(options[:verbose])
+    trace_mode = options[:trace]
+    return unless trace_mode
+
+    ControlplaneApiDirect.trace = trace_mode
+    Shell.warn("Trace mode is enabled, this will print sensitive information to the console.")
+  end
+
+  def org
+    @org ||= load_org_from_options || load_org_from_env || load_org_from_file
+  end
+
+  def app
+    @app ||= load_app_from_options || load_app_from_env
+  end
+
+  def location
+    @location ||= load_location_from_options || load_location_from_env || load_location_from_file
+  end
+
+  def domain
+    @domain ||= load_domain_from_options || load_domain_from_file
   end
 
   def [](key)
@@ -41,91 +62,122 @@ class Config # rubocop:disable Metrics/ClassLength
     apps[app_name.to_sym]&.dig(:match_if_app_name_starts_with) || false
   end
 
-  private
+  def app_dir
+    Pathname.new(config_file_path).parent.parent.to_s
+  end
 
-  def ensure_current_config!
-    raise "Can't find current config, please specify an app." unless current
+  def config
+    @config ||= begin
+      global_config = YAML.safe_load_file(config_file_path, symbolize_names: true, aliases: true)
+      ensure_config!(global_config)
+      ensure_config_apps!(global_config)
+
+      global_config
+    end
   end
 
-  def ensure_current_config_app!(app_name)
-    raise "Can't find app '#{app_name}' in 'controlplane.yml'." unless current
+  def apps
+    @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
+
+      [app_name, app_options_with_new_keys]
+    end
   end
 
-  def ensure_current_config_org!(app_name)
-    return if @org
+  def current
+    return unless app
 
-    raise "Can't find option 'cpln_org' for app '#{app_name}' in 'controlplane.yml', " \
-          "and CPLN_ORG env var is not set."
+    @current ||= begin
+      app_config = find_app_config(app)
+      ensure_config_app!(app, app_config)
+
+      warn_deprecated_options(app_config)
+
+      app_config
+    end
   end
 
-  def ensure_config!
-    raise "'controlplane.yml' is empty." unless config
+  def app_matches?(app_name1, app_name2, app_options)
+    app_name1 && app_name2 &&
+      (app_name1.to_s == app_name2.to_s ||
+        (app_options[:match_if_app_name_starts_with] && app_name1.to_s.start_with?(app_name2.to_s))
+      )
   end
 
-  def ensure_config_apps!
-    raise "Can't find key 'apps' in 'controlplane.yml'." unless config[:apps]
+  def find_app_config(app_name1)
+    @app_configs ||= {}
+    @app_configs[app_name1] ||= apps.find do |app_name2, app_config|
+                                  app_matches?(app_name1, app_name2, app_config)
+                                end&.last
   end
 
-  def ensure_config_app!(app_name, app_options)
-    raise "App '#{app_name}' is empty in 'controlplane.yml'." unless app_options
+  private
+
+  def ensure_current_config!
+    raise "Can't find current config, please specify an app." unless current
   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)))
+  def ensure_config!(global_config)
+    raise "'controlplane.yml' is empty." unless global_config
   end
 
-  def pick_current_config(app_name, app_options)
-    @current = app_options
-    ensure_current_config_app!(app_name)
+  def ensure_config_apps!(global_config)
+    raise "Can't find key 'apps' in 'controlplane.yml'." unless global_config[:apps]
+  end
 
-    if current.key?(:cpln_org)
-      @org = current.fetch(:cpln_org)
-    else
-      @org = ENV.fetch("CPLN_ORG", nil)
-      @org_comes_from_env = true
-    end
-    ensure_current_config_org!(app_name)
+  def ensure_config_app!(app_name, app_options)
+    raise "Can't find config for app '#{app_name}' in 'controlplane.yml'." unless app_options
   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)
+  def ensure_app!
+    return if app
 
-      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
+    raise "No app provided. " \
+          "The app can be provided either through the CPLN_APP env var " \
+          "('allow_app_override_by_env' must be set to true in 'controlplane.yml'), " \
+          "or the --app command option."
+  end
 
-      [app_name, app_options_with_new_keys]
-    end
+  def ensure_org!
+    return if org
 
-    ensure_current_config_app!(app) if app
+    raise "No org provided. " \
+          "The org can be provided either through the CPLN_ORG env var " \
+          "('allow_org_override_by_env' must be set to true in 'controlplane.yml'), " \
+          "the --org command option, " \
+          "or the 'cpln_org' key in 'controlplane.yml'."
   end
 
-  def load_app_config
-    config_file = find_app_config_file
-    @config = YAML.safe_load_file(config_file, symbolize_names: true, aliases: true)
-    @app_dir = Pathname.new(config_file).parent.parent.to_s
-    ensure_config!
-    ensure_config_apps!
+  def ensure_required_options! # rubocop:disable Metrics/CyclomaticComplexity
+    ensure_app! if required_options.include?(:app)
+    ensure_org! if required_options.include?(:org) || app
+
+    missing_str = required_options
+                  .reject { |option_name| %i[org app].include?(option_name) || options.key?(option_name) }
+                  .map { |option_name| "--#{option_name}" }
+                  .join(", ")
+
+    raise "Required options missing: #{missing_str}" unless missing_str.empty?
   end
 
-  def find_app_config_file
-    path = Pathname.new(".").expand_path
+  def config_file_path # rubocop:disable Metrics/MethodLength
+    @config_file_path ||= begin
+      path = Pathname.new(".").expand_path
 
-    loop do
-      config_file = path + CONFIG_FILE_LOCATIION
-      break config_file if File.file?(config_file)
+      loop do
+        config_file = path + CONFIG_FILE_LOCATION
+        break config_file if File.file?(config_file)
 
-      path = path.parent
+        path = path.parent
 
-      if path.root?
-        raise "Can't find project config file at 'project_folder/#{CONFIG_FILE_LOCATIION}', please create it."
+        if path.root?
+          raise "Can't find project config file at 'project_folder/#{CONFIG_FILE_LOCATION}', please create it."
+        end
       end
     end
   end
@@ -135,10 +187,86 @@ class Config # rubocop:disable Metrics/ClassLength
       org: :cpln_org,
       location: :default_location,
       prefix: :match_if_app_name_starts_with,
+      setup: :setup_app_templates,
       old_image_retention_days: :image_retention_days
     }
   end
 
+  def load_app_from_env
+    app_from_env = strip_str_and_validate(ENV.fetch("CPLN_APP", nil))
+    return unless app_from_env
+
+    app_config = find_app_config(app_from_env)
+    ensure_config_app!(app_from_env, app_config)
+
+    key_exists = app_config.key?(:allow_app_override_by_env)
+    allowed_locally = key_exists && app_config[:allow_app_override_by_env]
+    allowed_globally = !key_exists && config[:allow_app_override_by_env]
+    return unless allowed_locally || allowed_globally
+
+    @app_comes_from_env = true
+
+    app_from_env
+  end
+
+  def load_app_from_options
+    app_from_options = strip_str_and_validate(options[:app])
+    return unless app_from_options
+
+    app_config = find_app_config(app_from_options)
+    ensure_config_app!(app_from_options, app_config)
+
+    app_from_options
+  end
+
+  def load_org_from_env
+    org_from_env = strip_str_and_validate(ENV.fetch("CPLN_ORG", nil))
+    return unless org_from_env
+
+    key_exists = current&.key?(:allow_org_override_by_env)
+    allowed_locally = key_exists && current[:allow_org_override_by_env]
+    allowed_globally = !key_exists && config[:allow_org_override_by_env]
+    return unless allowed_locally || allowed_globally
+
+    @org_comes_from_env = true
+
+    org_from_env
+  end
+
+  def load_org_from_options
+    strip_str_and_validate(options[:org])
+  end
+
+  def load_org_from_file
+    return unless current&.key?(:cpln_org)
+
+    strip_str_and_validate(current[:cpln_org])
+  end
+
+  def load_location_from_options
+    strip_str_and_validate(options[:location])
+  end
+
+  def load_location_from_env
+    strip_str_and_validate(ENV.fetch("CPLN_LOCATION", nil))
+  end
+
+  def load_location_from_file
+    return unless current&.key?(:default_location)
+
+    strip_str_and_validate(current.fetch(:default_location))
+  end
+
+  def load_domain_from_options
+    strip_str_and_validate(options[:domain])
+  end
+
+  def load_domain_from_file
+    return unless current&.key?(:default_domain)
+
+    strip_str_and_validate(current.fetch(:default_domain))
+  end
+
   def warn_deprecated_options(app_options)
     deprecated_option_keys = new_option_keys.select { |old_key| app_options.key?(old_key) }
     return if deprecated_option_keys.empty?