cpflow 3.0.0

data/lib/command/generate.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Command
+  class Generator < Thor::Group
+    include Thor::Actions
+
+    def copy_files
+      directory("generator_templates", ".controlplane", verbose: ENV.fetch("HIDE_COMMAND_OUTPUT", nil) != "true")
+    end
+
+    def self.source_root
+      File.expand_path("../", __dir__)
+    end
+  end
+
+  class Generate < Base
+    NAME = "generate"
+    DESCRIPTION = "Creates base Control Plane config and template files"
+    LONG_DESCRIPTION = <<~DESC
+      Creates base Control Plane config and template files
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Creates .controlplane directory with Control Plane config and other templates
+      cpflow generate
+      ```
+    EX
+    WITH_INFO_HEADER = false
+
+    def call
+      if controlplane_directory_exists?
+        Shell.warn("The directory '.controlplane' already exists!")
+        return
+      end
+
+      Generator.start
+    end
+
+    private
+
+    def controlplane_directory_exists?
+      Dir.exist? ".controlplane"
+    end
+  end
+end

data/lib/command/info.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Command
+  class Info < Base # rubocop:disable Metrics/ClassLength
+    NAME = "info"
+    OPTIONS = [
+      app_option
+    ].freeze
+    DESCRIPTION = "Displays the diff between defined/available apps/workloads (apps equal GVCs)"
+    LONG_DESCRIPTION = <<~DESC
+      - Displays the diff between defined/available apps/workloads (apps equal GVCs)
+      - Apps that are defined but not available are displayed in red
+      - Apps that are available but not defined are displayed in green
+      - Apps that are both defined and available are displayed in white
+      - The diff is based on what's defined in the `.controlplane/controlplane.yml` file
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Shows diff for all apps in all orgs (based on `.controlplane/controlplane.yml`).
+      cpflow info
+
+      # Shows diff for all apps in a specific org.
+      cpflow info -o $ORG_NAME
+
+      # Shows diff for a specific app.
+      cpflow info -a $APP_NAME
+      ```
+    EX
+    WITH_INFO_HEADER = false
+
+    def call
+      @missing_apps_workloads = {}
+      @missing_apps_starting_with = {}
+
+      if config.app && !config.should_app_start_with?(config.app)
+        single_app_info
+      else
+        multiple_apps_info
+      end
+    end
+
+    private
+
+    def find_workloads(app)
+      app_options = config.find_app_config(app)
+
+      (app_options[:app_workloads] + app_options[:additional_workloads] + [app_options[:one_off_workload]]).uniq
+    end
+
+    def fetch_workloads(app)
+      cp.fetch_workloads(app)["items"].map { |workload| workload["name"] }
+    end
+
+    def fetch_app_workloads(org) # rubocop:disable Metrics/MethodLength
+      result = {}
+
+      workloads = cp.fetch_workloads_by_org(org)["items"]
+      workloads.each do |workload|
+        app = workload["links"].find { |link| link["rel"] == "gvc" }["href"].split("/").last
+
+        result[app] ||= []
+        result[app].push(workload["name"])
+      end
+
+      if config.app
+        result.select { |app, _| config.app_matches?(app, config.app, config.current) }
+      else
+        result.reject { |app, _| config.find_app_config(app).nil? }
+      end
+    end
+
+    def orgs
+      result = []
+
+      if config.org
+        result.push(config.org)
+      else
+        config.apps.each do |_, app_options|
+          org = app_org(app_options)
+          result.push(org) if org && !result.include?(org)
+        end
+      end
+
+      result.sort
+    end
+
+    def apps(org)
+      result = []
+
+      config.apps.each do |app_name, app_options|
+        next if config.app && !config.app_matches?(config.app, app_name, app_options)
+
+        current_app_org = app_org(app_options)
+        result.push(app_name.to_s) if current_app_org == org
+      end
+
+      result += @app_workloads.keys.map(&:to_s)
+      result.uniq.sort
+    end
+
+    def app_org(app_options)
+      app_options[:cpln_org]
+    end
+
+    def any_app_starts_with?(app)
+      @app_workloads.keys.find { |app_name| config.app_matches?(app_name, app, config.apps[app.to_sym]) }
+    end
+
+    def check_any_app_starts_with(app)
+      if any_app_starts_with?(app)
+        false
+      else
+        @missing_apps_starting_with[app] ||= ["gvc"]
+
+        puts "  - #{Shell.color("Any app starting with '#{app}'", :red)}"
+        true
+      end
+    end
+
+    def add_to_missing_workloads(app, workload)
+      if config.should_app_start_with?(app)
+        @missing_apps_starting_with[app] ||= []
+        @missing_apps_starting_with[app].push(workload)
+      else
+        @missing_apps_workloads[app] ||= []
+        @missing_apps_workloads[app].push(workload)
+      end
+    end
+
+    def print_app(app, org)
+      if config.should_app_start_with?(app)
+        check_any_app_starts_with(app)
+      elsif cp.fetch_gvc(app, org).nil?
+        @missing_apps_workloads[app] = ["gvc"]
+
+        puts "  - #{Shell.color(app, :red)}"
+        true
+      else
+        puts "  - #{app}"
+        true
+      end
+    end
+
+    def print_workload(app, workload)
+      if @defined_workloads.include?(workload) && !@available_workloads.include?(workload)
+        add_to_missing_workloads(app, workload)
+
+        puts "    - #{Shell.color(workload, :red)}"
+      elsif !@defined_workloads.include?(workload) && @available_workloads.include?(workload)
+        puts "    - #{Shell.color(workload, :green)}"
+      else
+        puts "    - #{workload}"
+      end
+    end
+
+    def print_missing_apps_workloads
+      return if @missing_apps_workloads.empty?
+
+      puts "\nSome apps/workloads are missing. Please create them with:"
+
+      @missing_apps_workloads.each do |app, workloads|
+        if workloads.include?("gvc")
+          puts "  - `cpflow setup-app -a #{app}`"
+        else
+          puts "  - `cpflow apply-template #{workloads.join(' ')} -a #{app}`"
+        end
+      end
+    end
+
+    def print_missing_apps_starting_with
+      return if @missing_apps_starting_with.empty?
+
+      puts "\nThere are no apps starting with some names. If you wish to create any, do so with " \
+           "(replace 'whatever' with whatever suffix you want):"
+
+      @missing_apps_starting_with.each do |app, _workloads|
+        puts "  - `cpflow setup-app -a #{app}-whatever`"
+      end
+    end
+
+    def single_app_info
+      puts "#{Shell.color(config.org, :blue)}:"
+
+      print_app(config.app, config.org)
+
+      @defined_workloads = find_workloads(config.app)
+      @available_workloads = fetch_workloads(config.app)
+
+      workloads = (@defined_workloads + @available_workloads).uniq
+      workloads.each do |workload|
+        print_workload(config.app, workload)
+      end
+
+      print_missing_apps_workloads
+    end
+
+    def multiple_apps_info # rubocop:disable Metrics/MethodLength
+      orgs.each do |org|
+        puts "#{Shell.color(org, :blue)}:"
+
+        @app_workloads = fetch_app_workloads(org)
+
+        apps(org).each do |app|
+          next unless print_app(app, org)
+
+          @defined_workloads = find_workloads(app)
+          @available_workloads = @app_workloads[app] || []
+
+          workloads = (@defined_workloads + @available_workloads).uniq
+          workloads.each do |workload|
+            print_workload(app, workload)
+          end
+        end
+
+        puts
+      end
+
+      print_missing_apps_workloads
+      print_missing_apps_starting_with
+    end
+  end
+end

data/lib/command/latest_image.rb

@@ -0,0 +1,19 @@
+# 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 = <<~DESC
+      - Displays the latest image name
+    DESC
+    WITH_INFO_HEADER = false
+
+    def call
+      puts cp.latest_image
+    end
+  end
+end

data/lib/command/logs.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Command
+  class Logs < Base
+    NAME = "logs"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option,
+      replica_option,
+      logs_limit_option,
+      logs_since_option
+    ].freeze
+    DESCRIPTION = "Light wrapper to display tailed raw logs for app/workload syntax"
+    LONG_DESCRIPTION = <<~DESC
+      - Light wrapper to display tailed raw logs for app/workload syntax
+      - Defaults to showing the last 200 entries from the past 1 hour before tailing
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Displays logs for the default workload (`one_off_workload`).
+      cpflow logs -a $APP_NAME
+
+      # Displays logs for a specific workload.
+      cpflow logs -a $APP_NAME -w $WORKLOAD_NAME
+
+      # Displays logs for a specific replica of a workload.
+      cpflow logs -a $APP_NAME -w $WORKLOAD_NAME -r $REPLICA_NAME
+
+      # Uses a different limit on number of entries.
+      cpflow logs -a $APP_NAME --limit 100
+
+      # Uses a different loopback window.
+      cpflow logs -a $APP_NAME --since 30min
+      ```
+    EX
+
+    def call
+      workload = config.options[:workload] || config[:one_off_workload]
+      replica = config.options[:replica]
+      limit = config.options[:limit]
+      since = config.options[:since]
+
+      message = replica ? "replica '#{replica}'" : "workload '#{workload}'"
+      progress.puts("Fetching logs for #{message}...\n\n")
+
+      cp.logs(workload: workload, replica: replica, limit: limit, since: since)
+    end
+  end
+end

data/lib/command/maintenance.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Command
+  class Maintenance < Base
+    NAME = "maintenance"
+    OPTIONS = [
+      app_option(required: true),
+      domain_option
+    ].freeze
+    DESCRIPTION = "Checks if maintenance mode is on or off for an app"
+    LONG_DESCRIPTION = <<~DESC
+      - Checks if maintenance mode is on or off for an app
+      - Outputs 'on' or 'off'
+      - Specify the one-off workload through `one_off_workload` in the `.controlplane/controlplane.yml` file
+      - 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]
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      domain_data = if config.domain
+                      cp.fetch_domain(config.domain)
+                    else
+                      cp.find_domain_for([one_off_workload, maintenance_workload])
+                    end
+      unless domain_data
+        raise "Can't find domain. " \
+              "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."
+      end
+
+      if cp.domain_workload_matches?(domain_data, maintenance_workload)
+        puts "on"
+      else
+        puts "off"
+      end
+    end
+  end
+end

data/lib/command/maintenance_off.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Command
+  class MaintenanceOff < Base
+    NAME = "maintenance:off"
+    OPTIONS = [
+      app_option(required: true),
+      domain_option
+    ].freeze
+    DESCRIPTION = "Disables maintenance mode for an app"
+    LONG_DESCRIPTION = <<~DESC
+      - Disables maintenance mode for an app
+      - Specify the one-off workload through `one_off_workload` in the `.controlplane/controlplane.yml` file
+      - 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
+
+    def call # rubocop:disable Metrics/MethodLength
+      one_off_workload = config[:one_off_workload]
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      domain_data = if config.domain
+                      cp.fetch_domain(config.domain)
+                    else
+                      cp.find_domain_for([one_off_workload, maintenance_workload])
+                    end
+      unless domain_data
+        raise "Can't find domain. " \
+              "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."
+      end
+
+      domain = domain_data["name"]
+      if cp.domain_workload_matches?(domain_data, one_off_workload)
+        progress.puts("Maintenance mode is already disabled for app '#{config.app}'.")
+        return
+      end
+
+      cp.fetch_workload!(maintenance_workload)
+
+      # Start all other workloads
+      Cpflow::Cli.start(["ps:start", "-a", config.app, "--wait"])
+
+      progress.puts
+
+      # Switch domain workload
+      step("Switching workload for domain '#{domain}' to '#{one_off_workload}'") do
+        cp.set_domain_workload(domain_data, one_off_workload)
+
+        # Give it a bit of time for the domain to update
+        Kernel.sleep(30)
+      end
+
+      progress.puts
+
+      # Stop maintenance workload
+      Cpflow::Cli.start(["ps:stop", "-a", config.app, "-w", maintenance_workload, "--wait"])
+
+      progress.puts("\nMaintenance mode disabled for app '#{config.app}'.")
+    end
+  end
+end

data/lib/command/maintenance_on.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Command
+  class MaintenanceOn < Base
+    NAME = "maintenance:on"
+    OPTIONS = [
+      app_option(required: true),
+      domain_option
+    ].freeze
+    DESCRIPTION = "Enables maintenance mode for an app"
+    LONG_DESCRIPTION = <<~DESC
+      - Enables maintenance mode for an app
+      - Specify the one-off workload through `one_off_workload` in the `.controlplane/controlplane.yml` file
+      - 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
+
+    def call # rubocop:disable Metrics/MethodLength
+      one_off_workload = config[:one_off_workload]
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      domain_data = if config.domain
+                      cp.fetch_domain(config.domain)
+                    else
+                      cp.find_domain_for([one_off_workload, maintenance_workload])
+                    end
+      unless domain_data
+        raise "Can't find domain. " \
+              "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."
+      end
+
+      domain = domain_data["name"]
+      if cp.domain_workload_matches?(domain_data, maintenance_workload)
+        progress.puts("Maintenance mode is already enabled for app '#{config.app}'.")
+        return
+      end
+
+      cp.fetch_workload!(maintenance_workload)
+
+      # Start maintenance workload
+      Cpflow::Cli.start(["ps:start", "-a", config.app, "-w", maintenance_workload, "--wait"])
+
+      progress.puts
+
+      # Switch domain workload
+      step("Switching workload for domain '#{domain}' to '#{maintenance_workload}'") do
+        cp.set_domain_workload(domain_data, maintenance_workload)
+
+        # Give it a bit of time for the domain to update
+        Kernel.sleep(30)
+      end
+
+      progress.puts
+
+      # Stop all other workloads
+      Cpflow::Cli.start(["ps:stop", "-a", config.app, "--wait"])
+
+      progress.puts("\nMaintenance mode enabled for app '#{config.app}'.")
+    end
+  end
+end

data/lib/command/maintenance_set_page.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Command
+  class MaintenanceSetPage < Base
+    NAME = "maintenance:set-page"
+    USAGE = "maintenance:set-page PAGE_URL"
+    REQUIRES_ARGS = true
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Sets the page for maintenance mode"
+    LONG_DESCRIPTION = <<~DESC
+      - Sets the page for maintenance mode
+      - Only works if the maintenance workload uses the `shakacode/maintenance-mode` image
+      - Will set the URL as an env var `PAGE_URL` on the maintenance workload
+      - Optionally specify the maintenance workload through `maintenance_workload` in the `.controlplane/controlplane.yml` file (defaults to 'maintenance')
+    DESC
+
+    def call
+      maintenance_workload = config.current[:maintenance_workload] || "maintenance"
+
+      maintenance_workload_data = cp.fetch_workload!(maintenance_workload)
+      maintenance_workload_data.dig("spec", "containers").each do |container|
+        next unless container["image"].match?(%r{^shakacode/maintenance-mode})
+
+        container_name = container["name"]
+        page_url = config.args.first
+        step("Setting '#{page_url}' as the page for maintenance mode") do
+          cp.set_workload_env_var(maintenance_workload, container: container_name, name: "PAGE_URL", value: page_url)
+        end
+      end
+    end
+  end
+end

data/lib/command/no_command.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Command
+  class NoCommand < Base
+    NAME = "no-command"
+    OPTIONS = [version_option].freeze
+    DESCRIPTION = "Called when no command was specified"
+    LONG_DESCRIPTION = <<~DESC
+      - Called when no command was specified
+    DESC
+    HIDE = true
+    WITH_INFO_HEADER = false
+    VALIDATIONS = [].freeze
+
+    def call
+      if config.options[:version]
+        Cpflow::Cli.start(["version"])
+      else
+        Cpflow::Cli.start(["help"])
+      end
+    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 = <<~DESC
+      - Opens the app endpoint URL in the default browser
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Opens the endpoint of the default workload (`one_off_workload`).
+      cpflow open -a $APP_NAME
+
+      # Opens the endpoint of a specific workload.
+      cpflow open -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    EX
+
+    def call
+      workload = config.options[:workload] || config[:one_off_workload]
+      data = cp.fetch_workload!(workload)
+      url = data["status"]["endpoint"]
+      opener = Shell.cmd("which", "xdg-open", "open")[:output].split("\n").grep_v("not found").first
+
+      Kernel.exec(opener, url)
+    end
+  end
+end

data/lib/command/open_console.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Command
+  class OpenConsole < Base
+    NAME = "open-console"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option
+    ].freeze
+    DESCRIPTION = "Opens the app console on Control Plane in the default browser"
+    LONG_DESCRIPTION = <<~DESC
+      - Opens the app console on Control Plane in the default browser
+      - Can also go directly to a workload page if `--workload` is provided
+    DESC
+
+    def call
+      workload = config.options[:workload]
+      url = "https://console.cpln.io/console/org/#{config.org}/gvc/#{config.app}"
+      url += "/workload/#{workload}" if workload
+      url += "/-info"
+      opener = Shell.cmd("which", "xdg-open", "open")[:output].split("\n").grep_v("not found").first
+
+      Kernel.exec(opener, url)
+    end
+  end
+end

data/lib/command/promote_app_from_upstream.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Command
+  class PromoteAppFromUpstream < Base
+    NAME = "promote-app-from-upstream"
+    OPTIONS = [
+      app_option(required: true),
+      upstream_token_option(required: true)
+    ].freeze
+    DESCRIPTION = "Copies the latest image from upstream, runs a release script (optional), and deploys the image"
+    LONG_DESCRIPTION = <<~DESC
+      - Copies the latest image from upstream, runs a release script (optional), and deploys the image
+      - It performs the following steps:
+        - Runs `cpflow copy-image-from-upstream` to copy the latest image from upstream
+        - Runs `cpflow deploy-image` to deploy the image
+        - If `.controlplane/controlplane.yml` includes the `release_script`, `cpflow deploy-image` will use the `--run-release-phase` option
+        - If the release script exits with a non-zero code, the command will stop executing and also exit with a non-zero code
+    DESC
+
+    def call
+      copy_image_from_upstream
+      deploy_image
+    end
+
+    private
+
+    def copy_image_from_upstream
+      Cpflow::Cli.start(["copy-image-from-upstream", "-a", config.app, "-t", config.options[:upstream_token]])
+      progress.puts
+    end
+
+    def deploy_image
+      args = []
+      args.push("--run-release-phase") if config.current[:release_script]
+      Cpflow::Cli.start(["deploy-image", "-a", config.app, *args])
+    end
+  end
+end