cpl 1.1.2.rc.0 → 1.2.0

data/lib/core/config.rb

@@ -1,21 +1,41 @@
 # frozen_string_literal: true
 
-class Config
-  attr_reader :config, :current,
-              :org, :app, :apps, :app_dir,
+require_relative "helpers"
+
+class Config # rubocop:disable Metrics/ClassLength
+  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]
-    @app = options[:app]
+    @required_options = required_options
+
+    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
 
-    load_app_config
-    load_apps
+  def location
+    @location ||= load_location_from_options || load_location_from_env || load_location_from_file
   end
 
   def [](key)
@@ -38,77 +58,122 @@ class Config
     apps[app_name.to_sym]&.dig(:match_if_app_name_starts_with) || false
   end
 
+  def app_dir
+    Pathname.new(config_file_path).parent.parent.to_s
+  end
+
+  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 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 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
+
   private
 
   def ensure_current_config!
     raise "Can't find current config, please specify an app." unless current
   end
 
-  def ensure_current_config_app!(app_name)
-    raise "Can't find app '#{app_name}' in 'controlplane.yml'." unless current
+  def ensure_config!(global_config)
+    raise "'controlplane.yml' is empty." unless global_config
   end
 
-  def ensure_config!
-    raise "'controlplane.yml' is empty." unless config
-  end
-
-  def ensure_config_apps!
-    raise "Can't find key 'apps' in 'controlplane.yml'." unless config[:apps]
+  def ensure_config_apps!(global_config)
+    raise "Can't find key 'apps' in 'controlplane.yml'." unless global_config[:apps]
   end
 
   def ensure_config_app!(app_name, app_options)
-    raise "App '#{app_name}' is empty in 'controlplane.yml'." unless app_options
+    raise "Can't find config for app '#{app_name}' 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)))
+  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 pick_current_config(app_name, app_options)
-    @current = app_options
-    @org = self[:cpln_org]
-    ensure_current_config_app!(app_name)
+  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 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
+  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
@@ -118,10 +183,76 @@ class Config
       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,14 +23,15 @@ 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.tmp_stderr
-    perform!(cmd)
+    cmd += " > /dev/null" if Shell.should_hide_output?
+    perform!(cmd, sensitive_data_pattern: sensitive_data_pattern)
   end
 
   def profile_delete(profile)
     cmd = "cpln profile delete #{profile}"
-    cmd += " > /dev/null" if Shell.tmp_stderr
+    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -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}"
@@ -61,25 +63,25 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   def image_login(org_name = config.org)
     cmd = "cpln image docker-login --org #{org_name}"
-    cmd += " > /dev/null 2>&1" if Shell.tmp_stderr
+    cmd += " > /dev/null 2>&1" if Shell.should_hide_output?
     perform!(cmd)
   end
 
   def image_pull(image)
     cmd = "docker pull #{image}"
-    cmd += " > /dev/null" if Shell.tmp_stderr
+    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
   def image_tag(old_tag, new_tag)
     cmd = "docker tag #{old_tag} #{new_tag}"
-    cmd += " > /dev/null" if Shell.tmp_stderr
+    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
   def image_push(image)
     cmd = "docker push #{image}"
-    cmd += " > /dev/null" if Shell.tmp_stderr
+    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -148,7 +150,11 @@ class Controlplane # rubocop:disable Metrics/ClassLength
   end
 
   def workload_get_replicas_safely(workload, location:)
-    cmd = "cpln workload get-replicas #{workload} #{gvc_org} --location #{location} -o yaml 2> /dev/null"
+    cmd = "cpln workload get-replicas #{workload} #{gvc_org} --location #{location} -o yaml"
+    cmd += " 2> /dev/null" if Shell.should_hide_output?
+
+    Shell.debug("CMD", cmd)
+
     result = `#{cmd}`
     $CHILD_STATUS.success? ? YAML.safe_load(result) : nil
   end
@@ -180,7 +186,7 @@ class Controlplane # rubocop:disable Metrics/ClassLength
   def workload_set_image_ref(workload, container:, image:)
     cmd = "cpln workload update #{workload} #{gvc_org}"
     cmd += " --set spec.containers.#{container}.image=/org/#{config.org}/image/#{image}"
-    cmd += " > /dev/null" if Shell.tmp_stderr
+    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -208,7 +214,7 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   def workload_force_redeployment(workload)
     cmd = "cpln workload force-redeployment #{workload} #{gvc_org}"
-    cmd += " > /dev/null" if Shell.tmp_stderr
+    cmd += " > /dev/null" if Shell.should_hide_output?
     perform!(cmd)
   end
 
@@ -230,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)
@@ -280,41 +296,77 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     Tempfile.create do |f|
       f.write(data)
       f.rewind
-      cmd = "cpln apply #{gvc_org} --file #{f.path} > /dev/null"
+      cmd = "cpln apply #{gvc_org} --file #{f.path}"
       if Shell.tmp_stderr
-        cmd += " 2> #{Shell.tmp_stderr.path}"
-        perform(cmd)
+        cmd += " 2> #{Shell.tmp_stderr.path}" if Shell.should_hide_output?
+
+        Shell.debug("CMD", cmd)
+
+        result = `#{cmd}`
+        $CHILD_STATUS.success? ? parse_apply_result(result) : false
       else
-        perform!(cmd)
+        Shell.debug("CMD", cmd)
+
+        result = `#{cmd}`
+        $CHILD_STATUS.success? ? parse_apply_result(result) : exit(false)
       end
     end
   end
 
-  def apply_hash(data) # rubocop:disable Metrics/MethodLength
-    Tempfile.create do |f|
-      f.write(data.to_yaml)
-      f.rewind
-      cmd = "cpln apply #{gvc_org} --file #{f.path} > /dev/null"
-      if Shell.tmp_stderr
-        cmd += " 2> #{Shell.tmp_stderr.path}"
-        perform(cmd)
+  def apply_hash(data)
+    apply_template(data.to_yaml)
+  end
+
+  def parse_apply_result(result) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    items = []
+
+    lines = result.split("\n")
+    lines.each do |line|
+      # The line can be in one of these formats:
+      # - "Created /org/shakacode-open-source-examples/gvc/my-app-staging"
+      # - "Created /org/shakacode-open-source-examples/gvc/my-app-staging/workload/redis"
+      # - "Updated gvc 'tutorial-app-test-1'"
+      # - "Updated workload 'redis'"
+      if line.start_with?("Created")
+        matches = line.match(%r{Created\s/org/[^/]+/gvc/([^/]+)($|(/([^/]+)/([^/]+)$))})&.captures
+        next unless matches
+
+        app, _, __, kind, name = matches
+        if kind
+          items.push({ kind: kind, name: name })
+        else
+          items.push({ kind: "app", name: app })
+        end
       else
-        perform!(cmd)
+        matches = line.match(/Updated\s([^\s]+)\s'([^\s]+)'$/)&.captures
+        next unless matches
+
+        kind, name = matches
+        kind = "app" if kind == "gvc"
+        items.push({ kind: kind, name: name })
       end
     end
+
+    items
   end
 
   private
 
   def perform(cmd)
+    Shell.debug("CMD", cmd)
+
     system(cmd)
   end
 
-  def perform!(cmd)
+  def perform!(cmd, sensitive_data_pattern: nil)
+    Shell.debug("CMD", cmd, sensitive_data_pattern: sensitive_data_pattern)
+
     system(cmd) || exit(false)
   end
 
   def perform_yaml(cmd)
+    Shell.debug("CMD", cmd)
+
     result = `#{cmd}`
     $CHILD_STATUS.success? ? YAML.safe_load(result) : 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,14 +17,25 @@ 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"
     request["Authorization"] = api_token
     request.body = body.to_json if body
 
-    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+    Shell.debug(method.upcase, "#{uri} #{body&.to_json}")
+
+    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
@@ -33,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
@@ -63,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

@@ -2,7 +2,7 @@
 
 class Shell
   class << self
-    attr_reader :tmp_stderr
+    attr_reader :tmp_stderr, :verbose
   end
 
   def self.shell
@@ -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)
@@ -50,4 +50,38 @@ class Shell
   def self.abort(message)
     Kernel.abort(color("ERROR: #{message}", :red))
   end
+
+  def self.verbose_mode(verbose)
+    @verbose = verbose
+  end
+
+  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.rc.0"
+  VERSION = "1.2.0"
   MIN_CPLN_VERSION = "0.0.71"
 end