cpl 1.1.2 → 1.2.0

data/lib/command/info.rb

@@ -4,7 +4,6 @@ module Command
   class Info < Base # rubocop:disable Metrics/ClassLength
     NAME = "info"
     OPTIONS = [
-      org_option,
       app_option
     ].freeze
     DESCRIPTION = "Displays the diff between defined/available apps/workloads (apps equal GVCs)"
@@ -17,7 +16,7 @@ module Command
     DESC
     EXAMPLES = <<~EX
       ```sh
-      # Shows diff for all apps in all orgs.
+      # Shows diff for all apps in all orgs (based on `.controlplane/controlplane.yml`).
       cpl info
 
       # Shows diff for all apps in a specific org.
@@ -27,6 +26,7 @@ module Command
       cpl info -a $APP_NAME
       ```
     EX
+    WITH_INFO_HEADER = false
 
     def call
       @missing_apps_workloads = {}
@@ -81,15 +81,12 @@ module Command
       end
     end
 
-    def orgs # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def orgs # rubocop:disable Metrics/MethodLength
       result = []
 
-      if config.options[:org]
-        result.push(config.options[:org])
+      if config.org
+        result.push(config.org)
       else
-        org_from_env = ENV.fetch("CPLN_ORG", nil)
-        result.push(org_from_env) if org_from_env
-
         config.apps.each do |app_name, app_options|
           next if config.app && !app_matches?(config.app, app_name, app_options)
 

data/lib/command/latest_image.rb

@@ -10,6 +10,7 @@ module Command
     LONG_DESCRIPTION = <<~DESC
       - Displays the latest image name
     DESC
+    WITH_INFO_HEADER = false
 
     def call
       puts latest_image

data/lib/command/maintenance.rb

@@ -14,6 +14,7 @@ module Command
       - 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
+    WITH_INFO_HEADER = false
 
     def call # rubocop:disable Metrics/MethodLength
       one_off_workload = config[:one_off_workload]

data/lib/command/no_command.rb

@@ -9,6 +9,7 @@ module Command
       - Called when no command was specified
     DESC
     HIDE = true
+    WITH_INFO_HEADER = false
 
     def call
       if config.options[:version]

data/lib/command/ps.rb

@@ -5,6 +5,7 @@ module Command
     NAME = "ps"
     OPTIONS = [
       app_option(required: true),
+      location_option,
       workload_option
     ].freeze
     DESCRIPTION = "Shows running replicas in app"
@@ -20,16 +21,19 @@ module Command
       cpl ps -a $APP_NAME -w $WORKLOAD_NAME
       ```
     EX
+    WITH_INFO_HEADER = false
 
     def call
       cp.fetch_gvc!
 
+      location = config.location
+
       workloads = [config.options[:workload]] if config.options[:workload]
       workloads ||= config[:app_workloads] + config[:additional_workloads]
       workloads.each do |workload|
         cp.fetch_workload!(workload)
 
-        result = cp.workload_get_replicas(workload, location: config[:default_location])
+        result = cp.workload_get_replicas(workload, location: location)
         result["items"].each { |replica| puts replica }
       end
     end

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
@@ -57,7 +57,7 @@ module Command
     attr_reader :location, :workload, :one_off, :container
 
     def call # rubocop:disable Metrics/MethodLength
-      @location = config[:default_location]
+      @location = config.location
       @workload = config.options["workload"] || config[:one_off_workload]
       @one_off = "#{workload}-run-#{rand(1000..9999)}"
 

data/lib/command/run_detached.rb

@@ -9,6 +9,7 @@ module Command
       app_option(required: true),
       image_option,
       workload_option,
+      location_option,
       use_local_token_option
     ].freeze
     DESCRIPTION = "Runs one-off **_non-interactive_** replicas (close analog of `heroku run:detached`)"
@@ -47,7 +48,7 @@ module Command
     attr_reader :location, :workload, :one_off, :container
 
     def call # rubocop:disable Metrics/MethodLength
-      @location = config[:default_location]
+      @location = config.location
       @workload = config.options["workload"] || config[:one_off_workload]
       @one_off = "#{workload}-runner-#{rand(1000..9999)}"
 

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,41 @@
 # 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 [](key)
@@ -41,91 +58,122 @@ class Config # rubocop:disable Metrics/ClassLength
     apps[app_name.to_sym]&.dig(:match_if_app_name_starts_with) || false
   end
 
-  private
-
-  def ensure_current_config!
-    raise "Can't find current config, please specify an app." unless current
+  def app_dir
+    Pathname.new(config_file_path).parent.parent.to_s
   end
 
-  def ensure_current_config_app!(app_name)
-    raise "Can't find app '#{app_name}' in 'controlplane.yml'." 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_org!(app_name)
-    return if @org
+  def apps
+    @apps ||= config[:apps].to_h do |app_name, app_options|
+      ensure_config_app!(app_name, app_options)
 
-    raise "Can't find option 'cpln_org' for app '#{app_name}' in 'controlplane.yml', " \
-          "and CPLN_ORG env var is not set."
+      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_config!
-    raise "'controlplane.yml' is empty." unless config
+  def current
+    return unless app
+
+    @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_apps!
-    raise "Can't find key 'apps' in 'controlplane.yml'." unless config[:apps]
+  private
+
+  def ensure_current_config!
+    raise "Can't find current config, please specify an app." unless current
   end
 
-  def ensure_config_app!(app_name, app_options)
-    raise "App '#{app_name}' is empty in 'controlplane.yml'." unless app_options
+  def ensure_config!(global_config)
+    raise "'controlplane.yml' is empty." unless global_config
   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_apps!(global_config)
+    raise "Can't find key 'apps' in 'controlplane.yml'." unless global_config[:apps]
   end
 
-  def pick_current_config(app_name, app_options)
-    @current = app_options
-    ensure_current_config_app!(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
 
-    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 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 load_apps # rubocop:disable Metrics/MethodLength
-    @apps = config[:apps].to_h do |app_name, app_options|
-      ensure_config_app!(app_name, app_options)
+  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
 
-      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
+  def ensure_app!
+    return if app
 
-      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 +183,76 @@ 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 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?

data/lib/core/controlplane.rb

@@ -23,9 +23,10 @@ class Controlplane # rubocop:disable Metrics/ClassLength
   end
 
   def profile_create(profile, token)
+    sensitive_data_pattern = /(?<=--token )(\S+)/
     cmd = "cpln profile create #{profile} --token #{token}"
     cmd += " > /dev/null" if Shell.should_hide_output?
-    perform!(cmd)
+    perform!(cmd, sensitive_data_pattern: sensitive_data_pattern)
   end
 
   def profile_delete(profile)
@@ -47,6 +48,7 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     # https://docs.controlplane.com/guides/push-image#step-2
     # Might need to use `docker buildx build` if compatiblitity issues arise
     cmd = "docker build --platform=linux/amd64 -t #{image} -f #{dockerfile}"
+    cmd += " --progress=plain" if ControlplaneApiDirect.trace
 
     build_args.each { |build_arg| cmd += " --build-arg #{build_arg}" }
     cmd += " #{config.app_dir}"
@@ -234,6 +236,16 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     perform!(cmd)
   end
 
+  # volumeset
+
+  def fetch_volumesets(a_gvc = gvc)
+    api.list_volumesets(org: org, gvc: a_gvc)
+  end
+
+  def delete_volumeset(volumeset, a_gvc = gvc)
+    api.delete_volumeset(org: org, gvc: a_gvc, volumeset: volumeset)
+  end
+
   # domain
 
   def find_domain_route(data)
@@ -346,8 +358,8 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     system(cmd)
   end
 
-  def perform!(cmd)
-    Shell.debug("CMD", cmd)
+  def perform!(cmd, sensitive_data_pattern: nil)
+    Shell.debug("CMD", cmd, sensitive_data_pattern: sensitive_data_pattern)
 
     system(cmd) || exit(false)
   end

data/lib/core/controlplane_api.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class ControlplaneApi
+class ControlplaneApi # rubocop:disable Metrics/ClassLength
   def gvc_list(org:)
     api_json("/org/#{org}/gvc", method: :get)
   end
@@ -86,6 +86,14 @@ class ControlplaneApi
     api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}", method: :delete)
   end
 
+  def list_volumesets(org:, gvc:)
+    api_json("/org/#{org}/gvc/#{gvc}/volumeset", method: :get)
+  end
+
+  def delete_volumeset(org:, gvc:, volumeset:)
+    api_json("/org/#{org}/gvc/#{gvc}/volumeset/#{volumeset}", method: :delete)
+  end
+
   def list_domains(org:)
     api_json("/org/#{org}/domain", method: :get)
   end

data/lib/core/controlplane_api_direct.rb

@@ -17,7 +17,12 @@ class ControlplaneApiDirect
 
   API_TOKEN_REGEX = /^[\w\-._]+$/.freeze
 
-  def call(url, method:, host: :api, body: nil) # rubocop:disable Metrics/MethodLength
+  class << self
+    attr_accessor :trace
+  end
+
+  def call(url, method:, host: :api, body: nil) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    trace = ControlplaneApiDirect.trace
     uri = URI("#{api_host(host)}#{url}")
     request = API_METHODS[method].new(uri)
     request["Content-Type"] = "application/json"
@@ -26,7 +31,11 @@ class ControlplaneApiDirect
 
     Shell.debug(method.upcase, "#{uri} #{body&.to_json}")
 
-    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+    http = Net::HTTP.new(uri.hostname, uri.port)
+    http.use_ssl = uri.scheme == "https"
+    http.set_debug_output($stdout) if trace
+
+    response = http.start { |ht| ht.request(request) }
 
     case response
     when Net::HTTPOK
@@ -35,6 +44,9 @@ class ControlplaneApiDirect
       true
     when Net::HTTPNotFound
       nil
+    when Net::HTTPForbidden
+      org = self.class.parse_org(url)
+      raise("Double check your org #{org}. #{response} #{response.body}")
     else
       raise("#{response} #{response.body}")
     end
@@ -65,4 +77,8 @@ class ControlplaneApiDirect
     remove_class_variable(:@@api_token) if defined?(@@api_token)
   end
   # rubocop:enable Style/ClassVars
+
+  def self.parse_org(url)
+    url.match(%r{^/org/([^/]+)})[1]
+  end
 end

data/lib/core/helpers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Helpers
+  def strip_str_and_validate(str)
+    return str if str.nil?
+
+    str = str.strip
+    str.empty? ? nil : str
+  end
+end

data/lib/core/shell.rb

@@ -36,7 +36,7 @@ class Shell
   end
 
   def self.confirm(message)
-    shell.yes?("#{message} (y/n)")
+    shell.yes?("#{message} (y/N)")
   end
 
   def self.warn(message)
@@ -55,11 +55,33 @@ class Shell
     @verbose = verbose
   end
 
-  def self.debug(prefix, message)
-    stderr.puts("\n[#{color(prefix, :red)}] #{message}") if verbose
+  def self.debug(prefix, message, sensitive_data_pattern: nil)
+    return unless verbose
+
+    filtered_message = hide_sensitive_data(message, sensitive_data_pattern)
+    stderr.puts("\n[#{color(prefix, :red)}] #{filtered_message}")
   end
 
   def self.should_hide_output?
     tmp_stderr && !verbose
   end
+
+  #
+  # Hide sensitive data based on the passed pattern
+  #
+  # @param [String] message
+  #   The message to get processed.
+  # @param [Regexp, nil] pattern
+  #   The regular expression to be used. If not provided, no filter gets applied.
+  #
+  # @return [String]
+  #   Filtered message.
+  #
+  # @example
+  #   hide_sensitive_data("--token abcd", /(?<=--token )(\S+)/)
+  def self.hide_sensitive_data(message, pattern = nil)
+    return message unless pattern.is_a?(Regexp)
+
+    message.gsub(pattern, "XXXXXXX")
+  end
 end

data/lib/cpl/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Cpl
-  VERSION = "1.1.2"
+  VERSION = "1.2.0"
   MIN_CPLN_VERSION = "0.0.71"
 end