cpflow 3.0.0

data/lib/command/cleanup_images.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Command
+  class CleanupImages < Base # rubocop:disable Metrics/ClassLength
+    NAME = "cleanup-images"
+    OPTIONS = [
+      app_option(required: true),
+      skip_confirm_option
+    ].freeze
+    DESCRIPTION = <<~DESC
+      Deletes all images for an app that either exceed the max quantity or are older than the specified amount of days
+    DESC
+    LONG_DESCRIPTION = <<~DESC
+      - Deletes all images for an app that either exceed the max quantity or are older than the specified amount of days
+      - Specify the max quantity through `image_retention_max_qty` in the `.controlplane/controlplane.yml` file
+      - Specify the amount of days through `image_retention_days` in the `.controlplane/controlplane.yml` file
+      - If `image_retention_max_qty` is specified, any images that exceed it will be deleted, regardless of `image_retention_days`
+      - Will ask for explicit user confirmation
+      - Never deletes the latest image
+    DESC
+
+    def call # rubocop:disable Metrics/MethodLength
+      ensure_max_qty_or_days!
+
+      return progress.puts("No images to delete.") if images_to_delete.empty?
+
+      progress.puts("Images to delete:")
+      images_to_delete.each do |image|
+        created = Shell.color((image[:created]).to_s, :red)
+        reason = Shell.color(image[:reason], :red)
+        progress.puts("  - #{image[:name]} (#{created} - #{reason})")
+      end
+
+      return unless confirm_delete
+
+      progress.puts
+      delete_images
+    end
+
+    private
+
+    def ensure_max_qty_or_days!
+      @image_retention_max_qty = config.current[:image_retention_max_qty]
+      @image_retention_days = config.current[:image_retention_days]
+      return if @image_retention_max_qty || @image_retention_days
+
+      raise "Can't find either option 'image_retention_max_qty' or 'image_retention_days' " \
+            "for app '#{@config.app}' in 'controlplane.yml'."
+    end
+
+    def app_prefix
+      config.should_app_start_with?(config.app) ? "#{config.app}-" : "#{config.app}:"
+    end
+
+    def remove_deployed_image(app, images)
+      return images unless cp.fetch_gvc(app)
+
+      # If app exists, remove latest image, because we don't want to delete the image that is currently deployed
+      latest_image_name = cp.latest_image_from(images, app_name: app)
+      images.reject { |image| image["name"] == latest_image_name }
+    end
+
+    def parse_images_and_sort_by_created(images)
+      images = images.map do |image|
+        {
+          name: image["name"],
+          created: DateTime.parse(image["created"])
+        }
+      end
+      images.sort_by { |image| image[:created] }
+    end
+
+    def add_reason_to_images(images, reason)
+      images.map do |image|
+        {
+          **image,
+          reason: reason
+        }
+      end
+    end
+
+    def filter_images_by_max_qty(images)
+      return [], images unless @image_retention_max_qty && images.length > @image_retention_max_qty
+
+      split_index = images.length - @image_retention_max_qty
+      excess_images = images[0...split_index]
+      remaining_images = images[split_index...]
+      excess_images = add_reason_to_images(excess_images, "exceeds max quantity of #{@image_retention_max_qty}")
+
+      [excess_images, remaining_images]
+    end
+
+    def filter_images_by_days(images)
+      return [] unless @image_retention_days
+
+      now = DateTime.now
+      old_images = images.select { |image| (now - image[:created]).to_i >= @image_retention_days }
+      add_reason_to_images(old_images, "older than #{@image_retention_days} days")
+    end
+
+    def images_to_delete # rubocop:disable Metrics/MethodLength
+      @images_to_delete ||=
+        begin
+          result_images = []
+
+          images = cp.query_images["items"].select { |item| item["name"].start_with?(app_prefix)	}
+          images_by_app = images.group_by { |item| item["repository"] }
+          images_by_app.each do |app, app_images|
+            app_images = remove_deployed_image(app, app_images)
+            app_images = parse_images_and_sort_by_created(app_images)
+            excess_images, remaining_images = filter_images_by_max_qty(app_images)
+            old_images = filter_images_by_days(remaining_images)
+
+            result_images += excess_images
+            result_images += old_images
+          end
+
+          result_images
+        end
+    end
+
+    def confirm_delete
+      return true if config.options[:yes]
+
+      Shell.confirm("\nAre you sure you want to delete these #{images_to_delete.length} images?")
+    end
+
+    def delete_images
+      images_to_delete.each do |image|
+        step("Deleting image '#{image[:name]}'") do
+          cp.image_delete(image[:name])
+        end
+      end
+    end
+  end
+end

data/lib/command/cleanup_stale_apps.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Command
+  class CleanupStaleApps < Base
+    NAME = "cleanup-stale-apps"
+    OPTIONS = [
+      app_option(required: true),
+      skip_confirm_option
+    ].freeze
+    DESCRIPTION = "Deletes the whole app (GVC with all workloads, all volumesets and all images) for all stale apps"
+    LONG_DESCRIPTION = <<~DESC
+      - Deletes the whole app (GVC with all workloads, all volumesets and all images) for all stale apps
+      - Also unbinds the app from the secrets policy, as long as both the identity and the policy exist (and are bound)
+      - Stale apps are identified based on the creation date of the latest image
+      - Specify the amount of days after an app should be considered stale through `stale_app_image_deployed_days` in the `.controlplane/controlplane.yml` file
+      - If `match_if_app_name_starts_with` is `true` in the `.controlplane/controlplane.yml` file, it will delete all stale apps that start with the name
+      - Will ask for explicit user confirmation
+    DESC
+
+    def call # rubocop:disable Metrics/MethodLength
+      return progress.puts("No stale apps found.") if stale_apps.empty?
+
+      progress.puts("Stale apps:")
+      stale_apps.each do |app|
+        progress.puts("  - #{app[:name]} (#{Shell.color((app[:date]).to_s, :red)})")
+      end
+
+      return unless confirm_delete
+
+      progress.puts
+      stale_apps.each do |app|
+        delete_app(app[:name])
+        progress.puts
+      end
+    end
+
+    private
+
+    def stale_apps # rubocop:disable Metrics/MethodLength
+      @stale_apps ||=
+        begin
+          apps = []
+
+          now = DateTime.now
+          stale_app_image_deployed_days = config[:stale_app_image_deployed_days]
+
+          gvcs = cp.gvc_query(config.app)["items"]
+          gvcs.each do |gvc|
+            app_name = gvc["name"]
+
+            images = cp.query_images(app_name)["items"].select { |item| item["name"].start_with?("#{app_name}:") }
+            image = cp.latest_image_from(images, app_name: app_name, name_only: false)
+            next unless image
+
+            created_date = DateTime.parse(image["created"])
+            diff_in_days = (now - created_date).to_i
+            next unless diff_in_days >= stale_app_image_deployed_days
+
+            apps.push({
+                        name: app_name,
+                        date: created_date
+                      })
+          end
+
+          apps
+        end
+    end
+
+    def confirm_delete
+      return true if config.options[:yes]
+
+      Shell.confirm("\nAre you sure you want to delete these #{stale_apps.length} apps?")
+    end
+
+    def delete_app(app)
+      Cpflow::Cli.start(["delete", "-a", app, "--yes"])
+    end
+  end
+end

data/lib/command/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Command
+  class Config < Base
+    NAME = "config"
+    OPTIONS = [
+      app_option
+    ].freeze
+    DESCRIPTION = "Displays config for each app or a specific app"
+    LONG_DESCRIPTION = <<~DESC
+      - Displays config for each app or a specific app
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Shows the config for each app.
+      cpflow config
+
+      # Shows the config for a specific app.
+      cpflow config -a $APP_NAME
+      ```
+    EX
+
+    def call # rubocop:disable Metrics/MethodLength
+      if config.app
+        puts "#{Shell.color("Current config (app '#{config.app}')", :blue)}:"
+        puts pretty_print(config.current)
+        puts
+      else
+        config.apps.each do |app_name, app_options|
+          puts "#{Shell.color("Config for app '#{app_name}'", :blue)}:"
+          puts pretty_print(app_options)
+          puts
+        end
+      end
+    end
+
+    private
+
+    def pretty_print(hash)
+      hash.transform_keys(&:to_s)
+          .to_yaml(indentation: 2)[4..]
+          # Adds an indentation of 2 to the beginning of each line
+          .gsub(/^(\s*)/, "  \\1")
+          # Adds an indentation of 2 before the '-' in array items
+          .gsub(/^(\s*)-\s/, "\\1  - ")
+    end
+  end
+end

data/lib/command/copy_image_from_upstream.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Command
+  class CopyImageFromUpstream < Base
+    NAME = "copy-image-from-upstream"
+    OPTIONS = [
+      app_option(required: true),
+      upstream_token_option(required: true),
+      image_option
+    ].freeze
+    DESCRIPTION = "Copies an image (by default the latest) from a source org to the current org"
+    LONG_DESCRIPTION = <<~DESC
+      - Copies an image (by default the latest) from a source org to the current org
+      - The source app must be specified either through the `CPLN_UPSTREAM` env var or `upstream` in the `.controlplane/controlplane.yml` file
+      - Additionally, the token for the source org must be provided through `--upstream-token` or `-t`
+      - A `cpln` profile will be temporarily created to pull the image from the source org
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Copies the latest image from the source org to the current org.
+      cpflow copy-image-from-upstream -a $APP_NAME --upstream-token $UPSTREAM_TOKEN
+
+      # Copies a specific image from the source org to the current org.
+      cpflow copy-image-from-upstream -a $APP_NAME --upstream-token $UPSTREAM_TOKEN --image appimage:123
+      ```
+    EX
+
+    def call # rubocop:disable Metrics/MethodLength
+      ensure_docker_running!
+
+      @upstream = ENV.fetch("CPLN_UPSTREAM", nil) || config[:upstream]
+      @upstream_org = ENV.fetch("CPLN_ORG_UPSTREAM", nil) || config.find_app_config(@upstream)&.dig(:cpln_org)
+      ensure_upstream_org!
+
+      create_upstream_profile
+      fetch_upstream_image_url
+      fetch_app_image_url
+      pull_image_from_upstream
+      push_image_to_app
+    ensure
+      cp.profile_switch("default")
+      delete_upstream_profile
+    end
+
+    private
+
+    def ensure_upstream_org!
+      return if @upstream_org
+
+      raise "Can't find option 'cpln_org' for app '#{@upstream}' in 'controlplane.yml', " \
+            "and CPLN_ORG_UPSTREAM env var is not set."
+    end
+
+    def create_upstream_profile
+      step("Creating upstream profile") do
+        loop do
+          @upstream_profile = "upstream-#{random_four_digits}"
+          break unless cp.profile_exists?(@upstream_profile)
+        end
+
+        cp.profile_create(@upstream_profile, config.options[:upstream_token])
+      end
+    end
+
+    def fetch_upstream_image_url
+      step("Fetching upstream image URL") do
+        cp.profile_switch(@upstream_profile)
+        upstream_image = config.options[:image]
+        upstream_image = cp.latest_image(@upstream, @upstream_org) if !upstream_image || upstream_image == "latest"
+        @commit = cp.extract_image_commit(upstream_image)
+        @upstream_image_url = "#{@upstream_org}.registry.cpln.io/#{upstream_image}"
+      end
+    end
+
+    def fetch_app_image_url
+      step("Fetching app image URL") do
+        cp.profile_switch("default")
+        app_image = cp.latest_image_next(config.app, config.org, commit: @commit)
+        @app_image_url = "#{config.org}.registry.cpln.io/#{app_image}"
+      end
+    end
+
+    def pull_image_from_upstream
+      step("Pulling image from '#{@upstream_image_url}'") do
+        cp.profile_switch(@upstream_profile)
+        cp.image_login(@upstream_org)
+        cp.image_pull(@upstream_image_url)
+      end
+    end
+
+    def push_image_to_app
+      step("Pushing image to '#{@app_image_url}'") do
+        cp.profile_switch("default")
+        cp.image_login(config.org)
+        cp.image_tag(@upstream_image_url, @app_image_url)
+        cp.image_push(@app_image_url)
+      end
+    end
+
+    def delete_upstream_profile
+      return unless @upstream_profile
+
+      step("Deleting upstream profile") do
+        cp.profile_delete(@upstream_profile)
+      end
+    end
+  end
+end

data/lib/command/delete.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Command
+  class Delete < Base # rubocop:disable Metrics/ClassLength
+    NAME = "delete"
+    OPTIONS = [
+      app_option(required: true),
+      workload_option,
+      skip_confirm_option,
+      skip_pre_deletion_hook_option
+    ].freeze
+    DESCRIPTION = "Deletes the whole app (GVC with all workloads, all volumesets and all images) or a specific workload"
+    LONG_DESCRIPTION = <<~DESC
+      - Deletes the whole app (GVC with all workloads, all volumesets and all images) or a specific workload
+      - Also unbinds the app from the secrets policy, as long as both the identity and the policy exist (and are bound)
+      - Will ask for explicit user confirmation
+      - Runs a pre-deletion hook before the app is deleted if `hooks.pre_deletion` is specified in the `.controlplane/controlplane.yml` file
+      - If the hook exits with a non-zero code, the command will stop executing and also exit with a non-zero code
+      - Use `--skip-pre-deletion-hook` to skip the hook if specified in `controlplane.yml`
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Deletes the whole app (GVC with all workloads, all volumesets and all images).
+      cpflow delete -a $APP_NAME
+
+      # Deletes a specific workload.
+      cpflow delete -a $APP_NAME -w $WORKLOAD_NAME
+      ```
+    EX
+
+    def call
+      workload = config.options[:workload]
+      if workload
+        delete_single_workload(workload)
+      else
+        delete_whole_app
+      end
+    end
+
+    private
+
+    def delete_single_workload(workload)
+      if cp.fetch_workload(workload).nil?
+        return progress.puts("Workload '#{workload}' does not exist in app '#{config.app}'.")
+      end
+      return unless confirm_delete(workload)
+
+      delete_workload(workload)
+    end
+
+    def delete_whole_app
+      return progress.puts("App '#{config.app}' does not exist.") if cp.fetch_gvc.nil?
+
+      check_volumesets
+      check_images
+      return unless confirm_delete(config.app)
+
+      run_pre_deletion_hook unless config.options[:skip_pre_deletion_hook]
+      unbind_identity_from_policy
+      delete_volumesets
+      delete_gvc
+      delete_images
+    end
+
+    def check_volumesets
+      @volumesets = cp.fetch_volumesets["items"]
+      return progress.puts("No volumesets to delete from app '#{config.app}'.") unless @volumesets.any?
+
+      message = "The following volumesets will be deleted along with the app '#{config.app}':"
+      volumesets_list = @volumesets.map { |volumeset| "- #{volumeset['name']}" }.join("\n")
+      progress.puts("#{Shell.color(message, :red)}\n#{volumesets_list}\n\n")
+    end
+
+    def check_images
+      @images = cp.query_images["items"]
+                  .select { |image| image["name"].start_with?("#{config.app}:") }
+      return progress.puts("No images to delete from app '#{config.app}'.") unless @images.any?
+
+      message = "The following images will be deleted along with the app '#{config.app}':"
+      images_list = @images.map { |image| "- #{image['name']}" }.join("\n")
+      progress.puts("#{Shell.color(message, :red)}\n#{images_list}\n\n")
+    end
+
+    def confirm_delete(item)
+      return true if config.options[:yes]
+
+      confirmed = Shell.confirm("Are you sure you want to delete '#{item}'?")
+      return false unless confirmed
+
+      progress.puts
+      true
+    end
+
+    def delete_gvc
+      step("Deleting app '#{config.app}'") do
+        cp.gvc_delete
+      end
+    end
+
+    def delete_workload(workload)
+      step("Deleting workload '#{workload}' from app '#{config.app}'") do
+        cp.delete_workload(workload)
+      end
+    end
+
+    def delete_volumesets
+      @volumesets.each do |volumeset|
+        step("Deleting volumeset '#{volumeset['name']}' from app '#{config.app}'") do
+          # If the volumeset is attached to a workload, we need to delete the workload first
+          workload = volumeset.dig("status", "usedByWorkload")&.split("/")&.last
+          cp.delete_workload(workload) if workload
+
+          cp.delete_volumeset(volumeset["name"])
+        end
+      end
+    end
+
+    def delete_images
+      @images.each do |image|
+        step("Deleting image '#{image['name']}' from app '#{config.app}'") do
+          cp.image_delete(image["name"])
+        end
+      end
+    end
+
+    def unbind_identity_from_policy
+      return if cp.fetch_identity(config.identity).nil?
+
+      policy = cp.fetch_policy(config.secrets_policy)
+      return if policy.nil?
+
+      is_bound = policy["bindings"].any? do |binding|
+        binding["principalLinks"].any? { |link| link == config.identity_link }
+      end
+      return unless is_bound
+
+      step("Unbinding identity from policy for app '#{config.app}'") do
+        cp.unbind_identity_from_policy(config.identity_link, config.secrets_policy)
+      end
+    end
+
+    def run_pre_deletion_hook
+      pre_deletion_hook = config.current.dig(:hooks, :pre_deletion)
+      return unless pre_deletion_hook
+
+      run_command_in_latest_image(pre_deletion_hook, title: "pre-deletion hook")
+    end
+  end
+end

data/lib/command/deploy_image.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Command
+  class DeployImage < Base
+    NAME = "deploy-image"
+    OPTIONS = [
+      app_option(required: true),
+      run_release_phase_option
+    ].freeze
+    DESCRIPTION = "Deploys the latest image to app workloads, and runs a release script (optional)"
+    LONG_DESCRIPTION = <<~DESC
+      - Deploys the latest image to app workloads
+      - Runs a release script before deploying if `release_script` is specified in the `.controlplane/controlplane.yml` file and `--run-release-phase` is provided
+      - The release script is run in the context of `cpflow run` with the latest image
+      - 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 # rubocop:disable Metrics/MethodLength
+      run_release_script if config.options[:run_release_phase]
+
+      deployed_endpoints = {}
+
+      image = cp.latest_image
+      if cp.fetch_image_details(image).nil?
+        raise "Image '#{image}' does not exist in the Docker repository on Control Plane " \
+              "(see https://console.cpln.io/console/org/#{config.org}/repository/#{config.app}). " \
+              "Use `cpflow build-image` first."
+      end
+
+      config[:app_workloads].each do |workload|
+        workload_data = cp.fetch_workload!(workload)
+        workload_data.dig("spec", "containers").each do |container|
+          next unless container["image"].match?(%r{^/org/#{config.org}/image/#{config.app}:})
+
+          container_name = container["name"]
+          step("Deploying image '#{image}' for workload '#{container_name}'") do
+            cp.workload_set_image_ref(workload, container: container_name, image: image)
+            deployed_endpoints[container_name] = workload_data.dig("status", "endpoint")
+          end
+        end
+      end
+
+      progress.puts("\nDeployed endpoints:")
+      deployed_endpoints.each do |workload, endpoint|
+        progress.puts("  - #{workload}: #{endpoint}")
+      end
+    end
+
+    private
+
+    def run_release_script
+      release_script = config[:release_script]
+      run_command_in_latest_image(release_script, title: "release script")
+    end
+  end
+end

data/lib/command/doctor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Command
+  class Doctor < Base
+    NAME = "doctor"
+    OPTIONS = [
+      validations_option,
+      app_option
+    ].freeze
+    DESCRIPTION = "Runs validations"
+    LONG_DESCRIPTION = <<~DESC
+      - Runs validations
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      # Runs all validations that don't require additional options by default.
+      cpflow doctor
+
+      # Runs config validation.
+      cpflow doctor --validations config
+
+      # Runs templates validation (requires app).
+      cpflow doctor --validations templates -a $APP_NAME
+      ```
+    EX
+    VALIDATIONS = [].freeze
+
+    def call
+      validations = config.options[:validations].split(",")
+      ensure_required_options!(validations)
+
+      doctor_service = DoctorService.new(config)
+      doctor_service.run_validations(validations)
+    end
+
+    private
+
+    def ensure_required_options!(validations)
+      validations.each do |validation|
+        case validation
+        when "templates"
+          raise "App is required for templates validation." unless config.app
+        end
+      end
+    end
+  end
+end

data/lib/command/env.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Command
+  class Env < Base
+    NAME = "env"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Displays app-specific environment variables"
+    LONG_DESCRIPTION = <<~DESC
+      - Displays app-specific environment variables
+    DESC
+    WITH_INFO_HEADER = false
+
+    def call
+      cp.fetch_gvc!.dig("spec", "env").map do |prop|
+        # NOTE: atm no special chars handling, consider adding if needed
+        puts "#{prop['name']}=#{prop['value']}"
+      end
+    end
+  end
+end

data/lib/command/exists.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Command
+  class Exists < Base
+    NAME = "exists"
+    OPTIONS = [
+      app_option(required: true)
+    ].freeze
+    DESCRIPTION = "Shell-checks if an application (GVC) exists, useful in scripts"
+    LONG_DESCRIPTION = <<~DESC
+      - Shell-checks if an application (GVC) exists, useful in scripts, e.g.:
+    DESC
+    EXAMPLES = <<~EX
+      ```sh
+      if [ cpflow exists -a $APP_NAME ]; ...
+      ```
+    EX
+
+    def call
+      exit(cp.fetch_gvc.nil? ? ExitCode::ERROR_DEFAULT : ExitCode::SUCCESS)
+    end
+  end
+end