cpl 0.5.1 → 0.7.0

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

@@ -7,7 +7,8 @@ module Command
     REQUIRES_ARGS = true
     OPTIONS = [
       app_option(required: true),
-      image_option
+      image_option,
+      workload_option
     ].freeze
     DESCRIPTION = "Runs one-off **_non-interactive_** replicas (close analog of `heroku run:detached`)"
     LONG_DESCRIPTION = <<~DESC
@@ -21,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
 
@@ -33,16 +37,19 @@ module Command
       # 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
+
+      # 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
 
     WORKLOAD_SLEEP_CHECK = 2
 
-    attr_reader :location, :workload, :one_off
+    attr_reader :location, :workload, :one_off, :container
 
     def call
       @location = config[:default_location]
-      @workload = config[:one_off_workload]
+      @workload = config.options["workload"] || config[:one_off_workload]
       @one_off = "#{workload}-runner-#{rand(1000..9999)}"
 
       clone_workload
@@ -60,37 +67,38 @@ module Command
 
       # Get base specs of workload
       spec = cp.fetch_workload!(workload).fetch("spec")
-      container = spec["containers"].detect { _1["name"] == workload } || spec["containers"].first
+      container_spec = spec["containers"].detect { _1["name"] == workload } || spec["containers"].first
+      @container = container_spec["name"]
 
       # remove other containers if any
-      spec["containers"] = [container]
+      spec["containers"] = [container_spec]
 
       # Set runner
-      container["command"] = "bash"
-      container["args"] = ["-c", 'eval "$CONTROLPLANE_RUNNER"']
+      container_spec["command"] = "bash"
+      container_spec["args"] = ["-c", 'eval "$CONTROLPLANE_RUNNER"']
 
       # Ensure one-off workload will be running
       spec["defaultOptions"]["suspend"] = false
 
       # 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
       image = config.options[:image]
       image = "/org/#{config.org}/image/#{latest_image}" if image == "latest"
-      container["image"] = image if image
+      container_spec["image"] = image if image
 
       # Set cron job props
       spec["type"] = "cron"
       spec["job"] = { "schedule" => "* * * * *", "restartPolicy" => "Never" }
       spec["defaultOptions"]["autoscaling"] = {}
-      container.delete("ports")
+      container_spec.delete("ports")
 
-      container["env"] ||= []
-      container["env"] << { "name" => "CONTROLPLANE_TOKEN", "value" => ControlplaneApiDirect.new.api_token }
-      container["env"] << { "name" => "CONTROLPLANE_RUNNER", "value" => runner_script }
+      container_spec["env"] ||= []
+      container_spec["env"] << { "name" => "CONTROLPLANE_TOKEN", "value" => ControlplaneApiDirect.new.api_token }
+      container_spec["env"] << { "name" => "CONTROLPLANE_RUNNER", "value" => runner_script }
 
       # Create workload clone
       cp.apply("kind" => "workload", "name" => one_off, "spec" => spec)

data/lib/command/setup_app.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Command
+  class SetupApp < Base
+    NAME = "setup-app"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    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)
+    DESC
+
+    def call
+      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.join(' ')} -a #{config.app}'."
+      end
+
+      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

data/lib/core/controlplane.rb

@@ -35,10 +35,13 @@ class Controlplane # rubocop:disable Metrics/ClassLength
 
   # image
 
-  def image_build(image, dockerfile:, push: true)
-    cmd = "cpln image build --org #{org} --name #{image} --dir #{config.app_dir} --dockerfile #{dockerfile}"
-    cmd += " --push" if push
+  def image_build(image, dockerfile:, build_args: [], push: true)
+    cmd = "docker build -t #{image} -f #{dockerfile}"
+    build_args.each { |build_arg| cmd += " --build-arg #{build_arg}" }
+    cmd += " #{config.app_dir}"
     perform!(cmd)
+
+    image_push(image) if push
   end
 
   def image_query(app_name = config.app, org_name = config.org)
@@ -97,7 +100,7 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     gvc_data = fetch_gvc(a_gvc)
     return gvc_data if gvc_data
 
-    raise "Can't find GVC '#{gvc}', please create it with 'cpl setup gvc -a #{config.app}'."
+    raise "Can't find app '#{gvc}', please create it with 'cpl setup-app -a #{config.app}'."
   end
 
   def gvc_delete(a_gvc = gvc)
@@ -122,7 +125,13 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     workload_data = fetch_workload(workload)
     return workload_data if workload_data
 
-    raise "Can't find workload '#{workload}', please create it with 'cpl setup #{workload} -a #{config.app}'."
+    raise "Can't find workload '#{workload}', please create it with 'cpl apply-template #{workload} -a #{config.app}'."
+  end
+
+  def query_workloads(workload, partial_match: false)
+    op = partial_match ? "~" : "="
+
+    api.query_workloads(org: org, gvc: gvc, workload: workload, op_type: op)
   end
 
   def workload_get_replicas(workload, location:)
@@ -130,6 +139,16 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     perform_yaml(cmd)
   end
 
+  def workload_get_replicas_safely(workload, location:)
+    cmd = "cpln workload get-replicas #{workload} #{gvc_org} --location #{location} -o yaml 2> /dev/null"
+    result = `#{cmd}`
+    $CHILD_STATUS.success? ? YAML.safe_load(result) : nil
+  end
+
+  def fetch_workload_deployments(workload)
+    api.workload_deployments(workload: workload, gvc: gvc, org: org)
+  end
+
   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}"
@@ -137,10 +156,26 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     perform!(cmd)
   end
 
-  def workload_set_suspend(workload, value)
+  def set_workload_env_var(workload, container:, name:, value:)
+    data = fetch_workload!(workload)
+    data["spec"]["containers"].each do |container_data|
+      next unless container_data["name"] == container
+
+      container_data["env"].each do |env_data|
+        next unless env_data["name"] == name
+
+        env_data["value"] = value
+      end
+    end
+
+    api.update_workload(org: org, gvc: gvc, workload: workload, data: data)
+  end
+
+  def set_workload_suspend(workload, value)
     data = fetch_workload!(workload)
     data["spec"]["defaultOptions"]["suspend"] = value
-    apply(data)
+
+    api.update_workload(org: org, gvc: gvc, workload: workload, data: data)
   end
 
   def workload_force_redeployment(workload)
@@ -149,15 +184,8 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     perform!(cmd)
   end
 
-  def workload_delete(workload)
-    cmd = "cpln workload delete #{workload} #{gvc_org}"
-    cmd += " 2> /dev/null"
-    perform(cmd)
-  end
-
-  def workload_delete!(workload)
-    cmd = "cpln workload delete #{workload} #{gvc_org}"
-    perform!(cmd)
+  def delete_workload(workload)
+    api.delete_workload(org: org, gvc: gvc, workload: workload)
   end
 
   def workload_connect(workload, location:, container: nil, shell: nil)
@@ -174,6 +202,40 @@ class Controlplane # rubocop:disable Metrics/ClassLength
     perform!(cmd)
   end
 
+  # domain
+
+  def find_domain_route(data)
+    port = data["spec"]["ports"].find { |current_port| current_port["number"] == 80 || current_port["number"] == 443 }
+    return nil if port.nil? || port["routes"].nil?
+
+    route = port["routes"].find { |current_route| current_route["prefix"] == "/" }
+    return nil if route.nil?
+
+    route
+  end
+
+  def find_domain_for(workloads)
+    domains = api.list_domains(org: org)["items"]
+    domains.find do |domain_data|
+      route = find_domain_route(domain_data)
+      next false if route.nil?
+
+      workloads.any? { |workload| route["workloadLink"].split("/").last == workload }
+    end
+  end
+
+  def get_domain_workload(data)
+    route = find_domain_route(data)
+    route["workloadLink"].split("/").last
+  end
+
+  def set_domain_workload(data, workload)
+    route = find_domain_route(data)
+    route["workloadLink"] = "/org/#{org}/gvc/#{gvc}/workload/#{workload}"
+
+    api.update_domain(org: org, domain: data["name"], data: data)
+  end
+
   # logs
 
   def logs(workload:)

data/lib/core/controlplane_api.rb

@@ -33,6 +33,29 @@ class ControlplaneApi
     api_json_direct("/logs/org/#{org}/loki/api/v1/query_range?#{params}", method: :get, host: :logs)
   end
 
+  def query_workloads(org:, gvc:, workload:, op_type:) # rubocop:disable Metrics/MethodLength
+    body = {
+      kind: "string",
+      spec: {
+        match: "all",
+        terms: [
+          {
+            rel: "gvc",
+            op: "=",
+            value: gvc
+          },
+          {
+            property: "name",
+            op: op_type,
+            value: workload
+          }
+        ]
+      }
+    }
+
+    api_json("/org/#{org}/workload/-query", method: :post, body: body)
+  end
+
   def workload_list(org:, gvc:)
     api_json("/org/#{org}/gvc/#{gvc}/workload", method: :get)
   end
@@ -45,10 +68,26 @@ class ControlplaneApi
     api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}", method: :get)
   end
 
+  def update_workload(org:, gvc:, workload:, data:)
+    api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}", method: :patch, body: data)
+  end
+
   def workload_deployments(org:, gvc:, workload:)
     api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}/deployment", method: :get)
   end
 
+  def delete_workload(org:, gvc:, workload:)
+    api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}", method: :delete)
+  end
+
+  def list_domains(org:)
+    api_json("/org/#{org}/domain", method: :get)
+  end
+
+  def update_domain(org:, domain:, data:)
+    api_json("/org/#{org}/domain/#{domain}", method: :patch, body: data)
+  end
+
   private
 
   # switch between cpln rest and api

data/lib/core/controlplane_api_direct.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
 class ControlplaneApiDirect
-  API_METHODS = { get: Net::HTTP::Get, post: Net::HTTP::Post, put: Net::HTTP::Put, delete: Net::HTTP::Delete }.freeze
+  API_METHODS = {
+    get: Net::HTTP::Get,
+    patch: Net::HTTP::Patch,
+    post: Net::HTTP::Post,
+    put: Net::HTTP::Put,
+    delete: Net::HTTP::Delete
+  }.freeze
   API_HOSTS = { api: "https://api.cpln.io", logs: "https://logs.cpln.io" }.freeze
 
   # API_TOKEN_REGEX = Regexp.union(
@@ -11,11 +17,12 @@ class ControlplaneApiDirect
 
   API_TOKEN_REGEX = /^[\w\-._]+$/.freeze
 
-  def call(url, method:, host: :api) # rubocop:disable Metrics/MethodLength
+  def call(url, method:, host: :api, body: nil) # rubocop:disable Metrics/MethodLength
     uri = URI("#{API_HOSTS[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: true) { |http| http.request(request) }
 
@@ -31,13 +38,16 @@ class ControlplaneApiDirect
     end
   end
 
+  # rubocop:disable Style/ClassVars
   def api_token
     return @@api_token if defined?(@@api_token)
 
-    @@api_token = ENV.fetch("CPLN_TOKEN", `cpln profile token`.chomp) # rubocop:disable Style/ClassVars
+    @@api_token = ENV.fetch("CPLN_TOKEN", nil)
+    @@api_token = `cpln profile token`.chomp if @@api_token.nil?
     return @@api_token if @@api_token.match?(API_TOKEN_REGEX)
 
     raise "Unknown API token format. " \
           "Please re-run 'cpln profile login' or set the correct CPLN_TOKEN env variable."
   end
+  # rubocop:enable Style/ClassVars
 end

data/lib/cpl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cpl
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

data/lib/cpl.rb

@@ -9,7 +9,12 @@ require "tempfile"
 require "thor"
 require "yaml"
 
-modules = Dir["#{__dir__}/**/*.rb"].reject { |file| file == __FILE__ || file.end_with?("main.rb") }
+# We need to require base before all commands, since the commands inherit from it
+require_relative "command/base"
+
+modules = Dir["#{__dir__}/**/*.rb"].reject do |file|
+  file == __FILE__ || file.end_with?("main.rb") || file.end_with?("base.rb")
+end
 modules.sort.each { require(_1) }
 
 # Fix for https://github.com/erikhuda/thor/issues/398

data/lib/deprecated_commands.json

@@ -2,5 +2,6 @@
   "build": "build-image",
   "promote": "deploy-image",
   "promote_image": "deploy-image",
-  "runner": "run:detached"
+  "runner": "run:detached",
+  "setup": "apply-template"
 }

data/templates/daily-task.yml

@@ -0,0 +1,30 @@
+kind: workload
+name: daily-task
+spec:
+  # https://docs.controlplane.com/reference/workload#cron-configuration
+  type: cron
+  job:
+    # Run daily job at 2am, see cron docs
+    schedule: 0  2  *  *  *
+    # Never or OnFailure
+    restartPolicy: Never
+  containers:
+    - name: daily-task
+      args:
+        - bundle
+        - exec
+        - rails
+        - db:prepare
+      cpu: 50m
+      inheritEnv: true
+      image: '/org/APP_ORG/image/APP_IMAGE'
+      memory: 256Mi
+  defaultOptions:
+    autoscaling:
+      maxScale: 1
+    capacityAI: false
+  firewallConfig:
+    external:
+      outboundAllowCIDR:
+        - 0.0.0.0/0
+  identityLink: /org/APP_ORG/gvc/APP_GVC/identity/APP_GVC-identity

data/templates/maintenance.yml

@@ -0,0 +1,24 @@
+kind: workload
+name: maintenance
+spec:
+  type: standard
+  containers:
+    - name: maintenance
+      env:
+        - name: PORT
+          value: '3000'
+        - name: PAGE_URL
+          value: ''
+      image: 'shakacode/maintenance-mode'
+      ports:
+        - number: 3000
+          protocol: http
+  defaultOptions:
+    autoscaling:
+      maxScale: 1
+    capacityAI: false
+    timeoutSeconds: 60
+  firewallConfig:
+    external:
+      inboundAllowCIDR:
+        - 0.0.0.0/0