cpflow 3.0.0

data/lib/core/controlplane.rb

@@ -0,0 +1,552 @@
+# frozen_string_literal: true
+
+class Controlplane # rubocop:disable Metrics/ClassLength
+  attr_reader :config, :api, :gvc, :org
+
+  NO_IMAGE_AVAILABLE = "NO_IMAGE_AVAILABLE"
+
+  def initialize(config)
+    @config = config
+    @api = ControlplaneApi.new
+    @gvc = config.app
+    @org = config.org
+
+    ensure_org_exists! if org
+  end
+
+  # profile
+
+  def profile_switch(profile)
+    ENV["CPLN_PROFILE"] = profile
+    ControlplaneApiDirect.reset_api_token
+  end
+
+  def profile_exists?(profile)
+    cmd = "cpln profile get #{profile} -o yaml"
+    perform_yaml!(cmd).length.positive?
+  end
+
+  def profile_create(profile, token)
+    sensitive_data_pattern = /(?<=--token )(\S+)/
+    cmd = "cpln profile create #{profile} --token #{token}"
+    perform!(cmd, sensitive_data_pattern: sensitive_data_pattern)
+  end
+
+  def profile_delete(profile)
+    cmd = "cpln profile delete #{profile}"
+    perform!(cmd)
+  end
+
+  # image
+
+  def latest_image(a_gvc = gvc, a_org = org)
+    @latest_image ||= {}
+    @latest_image[a_gvc] ||=
+      begin
+        items = query_images(a_gvc, a_org)["items"]
+        latest_image_from(items, app_name: a_gvc)
+      end
+  end
+
+  def latest_image_next(a_gvc = gvc, a_org = org, commit: nil)
+    commit ||= config.options[:commit]
+
+    @latest_image_next ||= {}
+    @latest_image_next[a_gvc] ||= begin
+      latest_image_name = latest_image(a_gvc, a_org)
+      image = latest_image_name.split(":").first
+      image += ":#{extract_image_number(latest_image_name) + 1}"
+      image += "_#{commit}" if commit
+      image
+    end
+  end
+
+  def latest_image_from(items, app_name: gvc, name_only: true)
+    matching_items = items.select { |item| item["name"].start_with?("#{app_name}:") }
+
+    # Or special string to indicate no image available
+    if matching_items.empty?
+      name_only ? "#{app_name}:#{NO_IMAGE_AVAILABLE}" : nil
+    else
+      latest_item = matching_items.max_by { |item| DateTime.parse(item["created"]) }
+      name_only ? latest_item["name"] : latest_item
+    end
+  end
+
+  def extract_image_number(image_name)
+    return 0 if image_name.end_with?(NO_IMAGE_AVAILABLE)
+
+    image_name.match(/:(\d+)/)&.captures&.first.to_i
+  end
+
+  def extract_image_commit(image_name)
+    image_name.match(/_(\h+)$/)&.captures&.first
+  end
+
+  def query_images(a_gvc = gvc, a_org = org, partial_gvc_match: nil)
+    partial_gvc_match = config.should_app_start_with?(a_gvc) if partial_gvc_match.nil?
+    gvc_op = partial_gvc_match ? "~" : "="
+
+    api.query_images(org: a_org, gvc: a_gvc, gvc_op_type: gvc_op)
+  end
+
+  def image_build(image, dockerfile:, docker_args: [], build_args: [], push: true)
+    # 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
+
+    cmd += " #{docker_args.join(' ')}" if docker_args.any?
+    build_args.each { |build_arg| cmd += " --build-arg #{build_arg}" }
+    cmd += " #{config.app_dir}"
+    perform!(cmd)
+
+    image_push(image) if push
+  end
+
+  def fetch_image_details(image)
+    api.fetch_image_details(org: org, image: image)
+  end
+
+  def image_delete(image)
+    api.image_delete(org: org, image: image)
+  end
+
+  def image_login(org_name = config.org)
+    cmd = "cpln image docker-login --org #{org_name}"
+    perform!(cmd, output_mode: :none)
+  end
+
+  def image_pull(image)
+    cmd = "docker pull #{image}"
+    perform!(cmd, output_mode: :none)
+  end
+
+  def image_tag(old_tag, new_tag)
+    cmd = "docker tag #{old_tag} #{new_tag}"
+    perform!(cmd)
+  end
+
+  def image_push(image)
+    cmd = "docker push #{image}"
+    perform!(cmd)
+  end
+
+  # gvc
+
+  def fetch_gvcs
+    api.gvc_list(org: org)
+  end
+
+  def gvc_query(app_name = config.app)
+    # When `match_if_app_name_starts_with` is `true`, we query for any gvc containing the name,
+    # otherwise we query for a gvc with the exact name.
+    op = config.should_app_start_with?(app_name) ? "~" : "="
+
+    cmd = "cpln gvc query --org #{org} -o yaml --prop name#{op}#{app_name}"
+    perform_yaml!(cmd)
+  end
+
+  def fetch_gvc(a_gvc = gvc, a_org = org)
+    api.gvc_get(gvc: a_gvc, org: a_org)
+  end
+
+  def fetch_gvc!(a_gvc = gvc)
+    gvc_data = fetch_gvc(a_gvc)
+    return gvc_data if gvc_data
+
+    raise "Can't find app '#{gvc}', please create it with 'cpflow setup-app -a #{config.app}'."
+  end
+
+  def gvc_delete(a_gvc = gvc)
+    api.gvc_delete(gvc: a_gvc, org: org)
+  end
+
+  # workload
+
+  def fetch_workloads(a_gvc = gvc)
+    api.workload_list(gvc: a_gvc, org: org)
+  end
+
+  def fetch_workloads_by_org(a_org = org)
+    api.workload_list_by_org(org: a_org)
+  end
+
+  def fetch_workload(workload)
+    api.workload_get(workload: workload, gvc: gvc, org: org)
+  end
+
+  def fetch_workload!(workload)
+    workload_data = fetch_workload(workload)
+    return workload_data if workload_data
+
+    raise "Can't find workload '#{workload}', " \
+          "please create it with 'cpflow apply-template #{workload} -a #{config.app}'."
+  end
+
+  def query_workloads(workload, a_gvc = gvc, a_org = org, partial_workload_match: false, partial_gvc_match: nil)
+    partial_gvc_match = config.should_app_start_with?(a_gvc) if partial_gvc_match.nil?
+    gvc_op = partial_gvc_match ? "~" : "="
+    workload_op = partial_workload_match ? "~" : "="
+
+    api.query_workloads(org: a_org, gvc: a_gvc, workload: workload, gvc_op_type: gvc_op, workload_op_type: workload_op)
+  end
+
+  def fetch_workload_replicas(workload, location:)
+    cmd = "cpln workload replica get #{workload} #{gvc_org} --location #{location} -o yaml"
+    perform_yaml(cmd)
+  end
+
+  def stop_workload_replica(workload, replica, location:)
+    cmd = "cpln workload replica stop #{workload} #{gvc_org} --replica-name #{replica} --location #{location}"
+    perform(cmd, output_mode: :none)
+  end
+
+  def fetch_workload_deployments(workload)
+    api.workload_deployments(workload: workload, gvc: gvc, org: org)
+  end
+
+  def workload_deployment_version_ready?(version, next_version)
+    return false unless version["workload"] == next_version
+
+    version["containers"]&.all? do |_, container|
+      container.dig("resources", "replicas") == container.dig("resources", "replicasReady")
+    end
+  end
+
+  def workload_deployments_ready?(workload, location:, expected_status:)
+    deployed_replicas = fetch_workload_replicas(workload, location: location)["items"].length
+    return deployed_replicas.zero? if expected_status == false
+
+    deployments = fetch_workload_deployments(workload)["items"]
+    deployments.all? do |deployment|
+      next_version = deployment.dig("status", "expectedDeploymentVersion")
+
+      deployment.dig("status", "versions")&.all? do |version|
+        workload_deployment_version_ready?(version, next_version)
+      end
+    end
+  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}"
+    perform!(cmd)
+  end
+
+  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
+
+    api.update_workload(org: org, gvc: gvc, workload: workload, data: data)
+  end
+
+  def workload_suspended?(workload)
+    details = fetch_workload!(workload)
+    details["spec"]["defaultOptions"]["suspend"]
+  end
+
+  def workload_force_redeployment(workload)
+    cmd = "cpln workload force-redeployment #{workload} #{gvc_org}"
+    perform!(cmd)
+  end
+
+  def delete_workload(workload, a_gvc = gvc)
+    api.delete_workload(org: org, gvc: a_gvc, workload: workload)
+  end
+
+  def workload_connect(workload, location:, container: nil, shell: nil)
+    cmd = "cpln workload connect #{workload} #{gvc_org} --location #{location}"
+    cmd += " --container #{container}" if container
+    cmd += " --shell #{shell}" if shell
+    perform!(cmd, output_mode: :all)
+  end
+
+  def workload_exec(workload, replica, location:, container: nil, command: nil)
+    cmd = "cpln workload exec #{workload} #{gvc_org} --replica #{replica} --location #{location}"
+    cmd += " --container #{container}" if container
+    cmd += " -- #{command}"
+    perform!(cmd, output_mode: :all)
+  end
+
+  def start_cron_workload(workload, job_start_yaml, location:)
+    Tempfile.create do |f|
+      f.write(job_start_yaml)
+      f.rewind
+
+      cmd = "cpln workload cron start #{workload} #{gvc_org} --file #{f.path} --location #{location} -o yaml"
+      perform_yaml(cmd)
+    end
+  end
+
+  def fetch_cron_workload(workload, location:)
+    cmd = "cpln workload cron get #{workload} #{gvc_org} --location #{location} -o yaml"
+    perform_yaml(cmd)
+  end
+
+  def cron_workload_deployed_version(workload)
+    current_deployment = fetch_workload_deployments(workload)&.dig("items")&.first
+    return nil unless current_deployment
+
+    ready = current_deployment.dig("status", "ready")
+    last_processed_version = current_deployment.dig("status", "lastProcessedVersion")
+
+    ready ? last_processed_version : nil
+  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)
+    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"].match?(%r{/org/#{org}/gvc/#{gvc}/workload/#{workload}}) }
+    end
+  end
+
+  def fetch_domain(domain)
+    domain_data = api.fetch_domain(org: org, domain: domain)
+    route = find_domain_route(domain_data)
+    return nil if route.nil?
+
+    domain_data
+  end
+
+  def domain_workload_matches?(data, workload)
+    route = find_domain_route(data)
+    route["workloadLink"].match?(%r{/org/#{org}/gvc/#{gvc}/workload/#{workload}})
+  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:, limit:, since:, replica: nil)
+    query_parts = ["gvc=\"#{gvc}\"", "workload=\"#{workload}\""]
+    query_parts.push("replica=\"#{replica}\"") if replica
+    query = "{#{query_parts.join(',')}}"
+
+    cmd = "cpln logs '#{query}' --org #{org} -t -o raw --limit #{limit} --since #{since}"
+    perform!(cmd, output_mode: :all)
+  end
+
+  def log_get(workload:, from:, to:, replica: nil)
+    api.log_get(org: org, gvc: gvc, workload: workload, replica: replica, from: from, to: to)
+  end
+
+  # secrets
+
+  def fetch_secret(secret)
+    api.fetch_secret(org: org, secret: secret)
+  end
+
+  # identities
+
+  def fetch_identity(identity, a_gvc = gvc)
+    api.fetch_identity(org: org, gvc: a_gvc, identity: identity)
+  end
+
+  # policies
+
+  def fetch_policy(policy)
+    api.fetch_policy(org: org, policy: policy)
+  end
+
+  def bind_identity_to_policy(identity_link, policy)
+    cmd = "cpln policy add-binding #{policy} --org #{org} --identity #{identity_link} --permission reveal"
+    perform!(cmd)
+  end
+
+  def unbind_identity_from_policy(identity_link, policy)
+    cmd = "cpln policy remove-binding #{policy} --org #{org} --identity #{identity_link} --permission reveal"
+    perform!(cmd)
+  end
+
+  # apply
+  def apply_template(data) # rubocop:disable Metrics/MethodLength
+    Tempfile.create do |f|
+      f.write(data)
+      f.rewind
+      cmd = "cpln apply #{gvc_org} --file #{f.path}"
+      if Shell.tmp_stderr
+        cmd += " 2> #{Shell.tmp_stderr.path}" if Shell.should_hide_output?
+
+        Shell.debug("CMD", cmd)
+
+        result = Shell.cmd(cmd)
+        parse_apply_result(result[:output]) if result[:success]
+      else
+        Shell.debug("CMD", cmd)
+
+        result = Shell.cmd(cmd)
+        if result[:success]
+          parse_apply_result(result[:output])
+        else
+          Shell.abort("Command exited with non-zero status.")
+        end
+      end
+    end
+  end
+
+  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
+        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 org_exists?
+    items = api.list_orgs["items"]
+    items.any? { |item| item["name"] == org }
+  end
+
+  def ensure_org_exists!
+    return if org_exists?
+
+    raise "Can't find org '#{org}', please create it in the Control Plane dashboard " \
+          "or ensure that the name is correct."
+  end
+
+  # `output_mode` can be :all, :errors_only or :none.
+  # If not provided, it will be determined based on the `HIDE_COMMAND_OUTPUT` env var
+  # or the return value of `Shell.should_hide_output?`.
+  def build_command(cmd, output_mode: nil) # rubocop:disable Metrics/MethodLength
+    output_mode ||= determine_command_output_mode
+
+    case output_mode
+    when :all
+      cmd
+    when :errors_only
+      "#{cmd} > /dev/null"
+    when :none
+      "#{cmd} > /dev/null 2>&1"
+    else
+      raise "Invalid command output mode '#{output_mode}'."
+    end
+  end
+
+  def determine_command_output_mode
+    if ENV.fetch("HIDE_COMMAND_OUTPUT", nil) == "true"
+      :none
+    elsif Shell.should_hide_output?
+      :errors_only
+    else
+      :all
+    end
+  end
+
+  def perform(cmd, output_mode: nil, sensitive_data_pattern: nil)
+    cmd = build_command(cmd, output_mode: output_mode)
+
+    Shell.debug("CMD", cmd, sensitive_data_pattern: sensitive_data_pattern)
+
+    kernel_system_with_pid_handling(cmd)
+  end
+
+  # NOTE: full analogue of Kernel.system which returns pids and saves it to child_pids for proper killing
+  def kernel_system_with_pid_handling(cmd)
+    pid = Process.spawn(cmd)
+    $child_pids << pid # rubocop:disable Style/GlobalVars
+
+    _, status = Process.wait2(pid)
+    $child_pids.delete(pid) # rubocop:disable Style/GlobalVars
+
+    status.exited? ? status.success? : nil
+  rescue SystemCallError
+    nil
+  end
+
+  def perform!(cmd, output_mode: nil, sensitive_data_pattern: nil)
+    success = perform(cmd, output_mode: output_mode, sensitive_data_pattern: sensitive_data_pattern)
+    success || Shell.abort("Command exited with non-zero status.")
+  end
+
+  def perform_yaml(cmd)
+    Shell.debug("CMD", cmd)
+
+    result = Shell.cmd(cmd)
+    YAML.safe_load(result[:output], permitted_classes: [Time]) if result[:success]
+  end
+
+  def perform_yaml!(cmd)
+    perform_yaml(cmd) || Shell.abort("Command exited with non-zero status.")
+  end
+
+  def gvc_org
+    "--gvc #{gvc} --org #{org}"
+  end
+end