cpl 0.1.0

data/lib/command/latest_image.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Command
+  class LatestImage < Base
+    NAME = "latest-image"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Displays the latest image name"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Displays the latest image name
+    HEREDOC
+
+    def call
+      puts latest_image
+    end
+  end
+end

data/lib/command/logs.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Command
+  class Logs < Base
+    NAME = "logs"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Light wrapper to display tailed raw logs for app/workload syntax"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Light wrapper to display tailed raw logs for app/workload syntax
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Displays logs for the default workload (`one_off_workload`).
+      cpl logs -a $APP_NAME
+
+      # Displays logs for a specific workload.
+      cpl logs -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    HEREDOC
+
+    def call
+      workload = config.options[:workload] || config[:one_off_workload]
+      cp.logs(workload: workload)
+    end
+  end
+end

data/lib/command/open.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Command
+  class Open < Base
+    NAME = "open"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Opens the app endpoint URL in the default browser"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Opens the app endpoint URL in the default browser
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Opens the endpoint of the default workload (`one_off_workload`).
+      cpl open -a $APP_NAME
+
+      # Opens the endpoint of a specific workload.
+      cpl open -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    HEREDOC
+
+    def call
+      workload = config.options[:workload] || config[:one_off_workload]
+      data = cp.workload_get(workload)
+      url = data["status"]["endpoint"]
+      opener = `which xdg-open open`.split("\n").grep_v("not found").first
+
+      exec %(#{opener} "#{url}")
+    end
+  end
+end

data/lib/command/promote_image.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Command
+  class PromoteImage < Base
+    NAME = "promote-image"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Promotes the latest image to app workloads"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Promotes the latest image to app workloads
+    HEREDOC
+
+    def call
+      image = latest_image
+
+      config[:app_workloads].each do |workload|
+        cp.workload_get(workload).dig("spec", "containers").each do |container|
+          next unless container["image"].match?(%r{^/org/#{config[:cpln_org]}/image/#{config.app}:})
+
+          cp.workload_set_image_ref(workload, container: container["name"], image: image)
+          progress.puts "updated #{container['name']}"
+        end
+      end
+    end
+  end
+end

data/lib/command/ps.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Command
+  class Ps < Base
+    NAME = "ps"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Shows running replicas in app"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Shows running replicas in app
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Shows running replicas in app, for all workloads.
+      cpl ps -a $APP_NAME
+
+      # Shows running replicas in app, for a specific workload.
+      cpl ps -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    HEREDOC
+
+    def call # rubocop:disable Metrics/MethodLength
+      workloads = [config.options[:workload]] if config.options[:workload]
+      workloads ||= config[:app_workloads] + config[:additional_workloads]
+
+      workloads.each do |workload|
+        result = cp.workload_get_replicas(workload, location: config[:default_location])
+        if result.nil?
+          puts "#{workload}: no workload"
+        elsif result["items"].nil?
+          puts "#{workload}: no replicas"
+        else
+          result["items"].each { |replica| puts replica }
+        end
+      end
+    end
+  end
+end

data/lib/command/ps_restart.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Command
+  class PsRestart < Base
+    NAME = "ps:restart"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Forces redeploy of workloads in app"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Forces redeploy of workloads in app
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Forces redeploy of all workloads in app.
+      cpl ps:restart -a $APP_NAME
+
+      # Forces redeploy of a specific workload in app.
+      cpl ps:restart -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    HEREDOC
+
+    def call
+      workloads = [config.options[:workload]] if config.options[:workload]
+      workloads ||= config[:app_workloads] + config[:additional_workloads]
+
+      workloads.each do |workload|
+        cp.workload_force_redeployment(workload)
+        progress.puts "#{workload} restarted"
+      end
+    end
+  end
+end

data/lib/command/ps_start.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Command
+  class PsStart < Base
+    NAME = "ps:start"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Starts workloads in app"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Starts workloads in app
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Starts all workloads in app.
+      cpl ps:start -a $APP_NAME
+
+      # Starts a specific workload in app.
+      cpl ps:start -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    HEREDOC
+
+    def call
+      workloads = [config.options[:workload]] if config.options[:workload]
+      workloads ||= config[:app_workloads] + config[:additional_workloads]
+
+      workloads.reverse_each do |workload|
+        cp.workload_set_suspend(workload, false)
+        progress.puts "#{workload} started"
+      end
+    end
+  end
+end

data/lib/command/ps_stop.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Command
+  class PsStop < Base
+    NAME = "ps:stop"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Stops workloads in app"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Stops workloads in app
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Stops all workloads in app.
+      cpl ps:stop -a $APP_NAME
+
+      # Stops a specific workload in app.
+      cpl ps:stop -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    HEREDOC
+
+    def call
+      workloads = [config.options[:workload]] if config.options[:workload]
+      workloads ||= config[:app_workloads] + config[:additional_workloads]
+
+      workloads.each do |workload|
+        cp.workload_set_suspend(workload, true)
+        progress.puts "#{workload} stopped"
+      end
+    end
+  end
+end

data/lib/command/run.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Command
+  class Run < Base
+    NAME = "run"
+    USAGE = "run COMMAND"
+    REQUIRES_ARGS = true
+    DEFAULT_ARGS = ["bash"].freeze
+    OPTIONS = [
+      app_option(required: true),
+      image_option
+    ].freeze
+    DESCRIPTION = "Runs one-off **_interactive_** replicas (analog of `heroku run`)"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - 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)
+
+      > **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`.
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Opens shell (bash by default).
+      cpl run -a $APP_NAME
+
+      # Runs command, displays output, and exits shell.
+      cpl run ls / -a $APP_NAME
+      cpl run rails db:migrate:status -a $APP_NAME
+
+      # Runs command and keeps shell open.
+      cpl run rails c -a $APP_NAME
+
+      # 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
+      ```
+    HEREDOC
+
+    attr_reader :location, :workload, :one_off
+
+    def call
+      @location = config[:default_location]
+      @workload = config[:one_off_workload]
+      @one_off = "#{workload}-run-#{rand(1000..9999)}"
+
+      clone_workload
+      wait_for_workload(one_off)
+      sleep 2 # sometimes replica query lags workload creation, despite ok by prev query
+      wait_for_replica(one_off, location)
+      run_in_replica
+    ensure
+      ensure_workload_deleted(one_off)
+    end
+
+    private
+
+    def clone_workload # rubocop:disable Metrics/MethodLength
+      progress.puts "- Cloning workload '#{workload}' on '#{config.options[:app]}' to '#{one_off}'"
+
+      # Create a base copy of workload props
+      spec = cp.workload_get(workload).fetch("spec")
+      container = spec["containers"].detect { _1["name"] == workload } || spec["containers"].first
+
+      # remove other containers if any
+      spec["containers"] = [container]
+
+      # Stub workload command with dummy server that just responds to port
+      # Needed to avoid execution of ENTRYPOINT and CMD of Dockerfile
+      container["command"] = "ruby"
+      container["args"] = ["-e", Scripts.http_dummy_server_ruby]
+
+      # 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"]["capacityAI"] = false
+
+      # Override image if specified
+      image = config.options[:image]
+      image = "/org/#{config[:cpln_org]}/image/#{latest_image}" if image == "latest"
+      container["image"] = image if image
+
+      # Set runner
+      container["env"] ||= []
+      container["env"] << { "name" => "CONTROLPLANE_RUNNER", "value" => runner_script }
+
+      # Create workload clone
+      cp.apply("kind" => "workload", "name" => one_off, "spec" => spec)
+    end
+
+    def runner_script
+      script = Scripts.helpers_cleanup
+      script += args_join(config.args)
+      script
+    end
+
+    def run_in_replica
+      progress.puts "- Connecting"
+      command = %(bash -c 'eval "$CONTROLPLANE_RUNNER"')
+      cp.workload_exec(one_off, location: location, container: workload, command: command)
+    end
+  end
+end

data/lib/command/run_detached.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Command
+  class RunDetached < Base # rubocop:disable Metrics/ClassLength
+    NAME = "run:detached"
+    USAGE = "run:detached COMMAND"
+    REQUIRES_ARGS = true
+    OPTIONS = [
+      app_option(required: true),
+      image_option
+    ].freeze
+    DESCRIPTION = "Runs one-off **_non-interactive_** replicas (close analog of `heroku run:detached`)"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Runs one-off **_non-interactive_** replicas (close analog of `heroku run:detached`)
+      - Uses `Cron` workload type with log async fetching
+      - 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
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      cpl run:detached rails db:prepare -a $APP_NAME
+      cpl run:detached 'LOG_LEVEL=warn rails db:migrate' -a $APP_NAME
+
+      # Uses some other image.
+      cpl run:detached rails db:migrate -a $APP_NAME --image /some/full/image/path
+
+      # Uses latest app image (which may not be promoted yet).
+      cpl run:detached rails db:migrate -a $APP_NAME --image latest
+
+      # 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
+      ```
+    HEREDOC
+
+    WORKLOAD_SLEEP_CHECK = 2
+
+    attr_reader :location, :workload, :one_off
+
+    def call
+      @location = config[:default_location]
+      @workload = config[:one_off_workload]
+      @one_off = "#{workload}-runner-#{rand(1000..9999)}"
+
+      clone_workload
+      wait_for_workload(one_off)
+      show_logs_waiting
+    ensure
+      ensure_workload_deleted(one_off)
+      exit(1) if @crashed
+    end
+
+    private
+
+    def clone_workload # rubocop:disable Metrics/MethodLength
+      progress.puts "- Cloning workload '#{workload}' on '#{config.options[:app]}' to '#{one_off}'"
+
+      # Get base specs of workload
+      spec = cp.workload_get(workload).fetch("spec")
+      container = spec["containers"].detect { _1["name"] == workload } || spec["containers"].first
+
+      # remove other containers if any
+      spec["containers"] = [container]
+
+      # Set runner
+      container["command"] = "bash"
+      container["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"]["capacityAI"] = false
+
+      # Override image if specified
+      image = config.options[:image]
+      image = "/org/#{config[:cpln_org]}/image/#{latest_image}" if image == "latest"
+      container["image"] = image if image
+
+      # Set cron job props
+      spec["type"] = "cron"
+      spec["job"] = { "schedule" => "* * * * *", "restartPolicy" => "Never" }
+      spec["defaultOptions"]["autoscaling"] = {}
+      container.delete("ports")
+
+      container["env"] ||= []
+      container["env"] << { "name" => "CONTROLPLANE_TOKEN", "value" => ControlplaneApiDirect.new.api_token }
+      container["env"] << { "name" => "CONTROLPLANE_RUNNER", "value" => runner_script }
+
+      # Create workload clone
+      cp.apply("kind" => "workload", "name" => one_off, "spec" => spec)
+    end
+
+    def runner_script
+      script = "echo '-- STARTED RUNNER SCRIPT --'\n"
+      script += Scripts.helpers_cleanup
+
+      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
+      SHELL
+
+      script
+    end
+
+    def show_logs_waiting # rubocop:disable Metrics/MethodLength
+      progress.puts "- Scheduled, fetching logs (it is cron job, so it may take up to a minute to start)"
+      begin
+        while cp.workload_get(one_off)
+          sleep(WORKLOAD_SLEEP_CHECK)
+          print_uniq_logs
+        end
+      rescue RuntimeError => e
+        progress.puts "ERROR: #{e}"
+        retry
+      end
+      progress.puts "- Finished workload and logger"
+    end
+
+    def print_uniq_logs
+      @printed_log_entries ||= []
+      ts = Time.now.to_i
+      entries = normalized_log_entries(from: ts - 60, to: ts)
+
+      (entries - @printed_log_entries).sort.each do |(_ts, val)|
+        @crashed = true if val.match?(/^----- CRASHED -----$/)
+        puts val
+      end
+
+      @printed_log_entries = entries # as well truncate old entries if any
+    end
+
+    def normalized_log_entries(from:, to:)
+      log = cp.log_get(workload: one_off, from: from, to: to)
+
+      log["data"]["result"]
+        .each_with_object([]) { |obj, result| result.concat(obj["values"]) }
+        .select { |ts, _val| ts[..-10].to_i > from }
+    end
+  end
+end

data/lib/command/setup.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Command
+  class Setup < Base
+    NAME = "setup"
+    USAGE = "setup TEMPLATE [TEMPLATE] ... [TEMPLATE]"
+    REQUIRES_ARGS = true
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Applies application-specific configs from templates"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - Applies application-specific configs from templates (e.g., for every review-app)
+      - Publishes (creates or updates) those at Control Plane infrastructure
+      - Picks templates from the `.controlplane/templates` directory
+      - Templates are ordinary Control Plane templates but with variable preprocessing
+
+      **Preprocessed template variables:**
+
+      ```
+      APP_GVC      - basically GVC or app name
+      APP_LOCATION - default location
+      APP_ORG      - organization
+      APP_IMAGE    - will use latest app image
+      ```
+    HEREDOC
+    EXAMPLES = <<~HEREDOC
+      ```sh
+      # Applies single template.
+      cpl setup redis -a $APP_NAME
+
+      # Applies several templates (practically creating full app).
+      cpl setup gvc postgres redis rails -a $APP_NAME
+      ```
+    HEREDOC
+
+    def call
+      config.args.each do |template|
+        filename = "#{config.app_cpln_dir}/templates/#{template}.yml"
+        abort("ERROR: Can't find template for '#{template}' at #{filename}") unless File.exist?(filename)
+
+        apply_template(filename)
+        progress.puts(template)
+      end
+    end
+
+    private
+
+    def apply_template(filename)
+      data = File.read(filename)
+                 .gsub("APP_GVC", config.app)
+                 .gsub("APP_LOCATION", config[:default_location])
+                 .gsub("APP_ORG", config[:cpln_org])
+                 .gsub("APP_IMAGE", latest_image)
+
+      cp.apply(YAML.safe_load(data))
+    end
+  end
+end

data/lib/command/test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Be sure to have run: gem install debug
+require "debug"
+
+# rubocop:disable Lint/Debugger
+module Command
+  class Test < Base
+    NAME = "test"
+    OPTIONS = all_options
+    DESCRIPTION = "For debugging purposes"
+    LONG_DESCRIPTION = <<~HEREDOC
+      - For debugging purposes
+    HEREDOC
+    HIDE = true
+
+    def call
+      # Change code here to test.
+      # You can use `debugger` to debug.
+      # debugger
+      # Or print values
+      pp latest_image_next
+    end
+  end
+end
+# rubocop:enable Lint/Debugger

data/lib/core/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+class Config
+  attr_reader :config, :current,
+              :app, :app_dir,
+              # command line options
+              :args, :options
+
+  CONFIG_FILE_LOCATIION = ".controlplane/controlplane.yml"
+
+  def initialize(args, options)
+    @args = args
+    @options = options
+    @app = options[:app]
+
+    load_app_config
+    pick_current_config if app
+  end
+
+  def [](key) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    abort("ERROR: should specify app") unless app
+
+    logger = $stderr
+
+    if current.key?(key)
+      current.fetch(key)
+    elsif key == :cpln_org && current.key?(:org)
+      logger.puts("DEPRECATED: option 'org' is deprecated, use 'cpln_org' instead\n")
+      current.fetch(:org)
+    elsif key == :default_location && current.key?(:location)
+      logger.puts("DEPRECATED: option 'location' is deprecated, use 'default_location' instead\n")
+      current.fetch(:location)
+    elsif key == :match_if_app_name_starts_with && current.key?(:prefix)
+      logger.puts("DEPRECATED: option 'prefix' is deprecated, use 'match_if_app_name_starts_with' instead\n")
+      current.fetch(:prefix)
+    else
+      abort("ERROR: should specify #{key} in controlplane.yml")
+    end
+  end
+
+  def script_path
+    Pathname.new(__dir__).parent.parent
+  end
+
+  def app_cpln_dir
+    "#{app_dir}/.controlplane"
+  end
+
+  private
+
+  def pick_current_config
+    config[:apps].each do |c_app, c_data|
+      if c_app.to_s == app || (c_data[:match_if_app_name_starts_with] && app.start_with?(c_app.to_s))
+        @current = c_data
+        break
+      end
+    end
+  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
+  end
+
+  def find_app_config_file
+    path = Pathname.new(".").expand_path
+
+    loop do
+      config_file = path + CONFIG_FILE_LOCATIION
+      break config_file if File.file?(config_file)
+
+      path = path.parent
+
+      if path.root?
+        puts "ERROR: Can't find project config file, should be 'project_folder/#{CONFIG_FILE_LOCATIION}'"
+        exit(-1)
+      end
+    end
+  end
+end