cpl 0.1.0

data/lib/core/controlplane.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+class Controlplane
+  attr_reader :config, :api, :gvc, :org
+
+  def initialize(config)
+    @config = config
+    @api = ControlplaneApi.new
+    @gvc = config.app
+    @org = config[:cpln_org]
+  end
+
+  # 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
+    perform(cmd)
+  end
+
+  def image_query
+    cmd = "cpln image query --org #{org} -o yaml --max -1 --prop repository=#{config.app}"
+    perform_yaml(cmd)
+  end
+
+  def image_delete(image)
+    api.image_delete(org: org, image: image)
+  end
+
+  # gvc
+
+  def gvc_get(a_gvc = gvc)
+    api.gvc_get(gvc: a_gvc, org: org)
+  end
+
+  def gvc_delete(a_gvc = gvc)
+    api.gvc_delete(gvc: a_gvc, org: org)
+  end
+
+  # workload
+
+  def workload_get(workload)
+    api.workload_get(workload: workload, gvc: gvc, org: org)
+  end
+
+  def workload_get_replicas(workload, location:)
+    cmd = "cpln workload get-replicas #{workload} #{gvc_org} --location #{location} -o yaml"
+    perform_yaml(cmd)
+  end
+
+  def workload_set_image_ref(workload, container:, image:)
+    cmd = "cpln workload update #{workload} #{gvc_org}"
+    cmd += " --set spec.containers.#{container}.image=/org/#{config[:cpln_org]}/image/#{image}"
+    perform(cmd)
+  end
+
+  def workload_set_suspend(workload, value)
+    data = workload_get(workload)
+    data["spec"]["defaultOptions"]["suspend"] = value
+    apply(data)
+  end
+
+  def workload_force_redeployment(workload)
+    cmd = "cpln workload force-redeployment #{workload} #{gvc_org}"
+    perform(cmd)
+  end
+
+  def workload_delete(workload, no_raise: false)
+    cmd = "cpln workload delete #{workload} #{gvc_org}"
+    cmd += " 2> /dev/null" if no_raise
+    no_raise ? perform_no_raise(cmd) : perform(cmd)
+  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)
+  end
+
+  def workload_exec(workload, location:, container: nil, command: nil)
+    cmd = "cpln workload exec #{workload} #{gvc_org} --location #{location}"
+    cmd += " --container #{container}" if container
+    cmd += " -- #{command}"
+    perform(cmd)
+  end
+
+  # logs
+
+  def logs(workload:)
+    cmd = "cpln logs '{workload=\"#{workload}\"}' --org #{org} -t -o raw --limit 200"
+    perform(cmd)
+  end
+
+  def log_get(workload:, from:, to:)
+    api.log_get(org: org, gvc: gvc, workload: workload, from: from, to: to)
+  end
+
+  # apply
+
+  def apply(data)
+    Tempfile.create do |f|
+      f.write(data.to_yaml)
+      f.rewind
+      cmd = "cpln apply #{gvc_org} --file #{f.path} > /dev/null"
+      perform(cmd)
+    end
+  end
+
+  private
+
+  def perform(cmd)
+    system(cmd) || exit(false)
+  end
+
+  def perform_no_raise(cmd)
+    system(cmd)
+  end
+
+  def perform_yaml(cmd)
+    result = `#{cmd}`
+    $?.success? ? YAML.safe_load(result) : exit(false) # rubocop:disable Style/SpecialGlobalVars
+  end
+
+  def gvc_org
+    "--gvc #{gvc} --org #{org}"
+  end
+end

data/lib/core/controlplane_api.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class ControlplaneApi
+  def gvc_get(org:, gvc:)
+    api_json("/org/#{org}/gvc/#{gvc}", method: :get)
+  end
+
+  def gvc_delete(org:, gvc:)
+    api_json("/org/#{org}/gvc/#{gvc}", method: :delete)
+  end
+
+  def image_delete(org:, image:)
+    api_json("/org/#{org}/image/#{image}", method: :delete)
+  end
+
+  def log_get(org:, gvc:, workload: nil, from: nil, to: nil)
+    query = { gvc: gvc }
+    query[:workload] = workload if workload
+    query = query.map { |k, v| %(#{k}="#{v}") }.join(",").then { "{#{_1}}" }
+
+    params = { query: query }
+    params[:from] = "#{from}000000000" if from
+    params[:to] = "#{to}000000000" if to
+    # params << "delay_for=0"
+    # params << "limit=30"
+    # params << "direction=forward"
+    params = params.map { |k, v| %(#{k}=#{CGI.escape(v)}) }.join("&")
+
+    api_json_direct("/logs/org/#{org}/loki/api/v1/query_range?#{params}", method: :get, host: :logs)
+  end
+
+  def workload_get(org:, gvc:, workload:)
+    api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}", method: :get)
+  end
+
+  def workload_deployments(org:, gvc:, workload:)
+    api_json("/org/#{org}/gvc/#{gvc}/workload/#{workload}/deployment", method: :get)
+  end
+
+  private
+
+  # switch between cpln rest and api
+  def api_json(...)
+    ControlplaneApiDirect.new.call(...)
+  end
+
+  # only for api (where not impelemented in cpln rest)
+  def api_json_direct(...)
+    ControlplaneApiDirect.new.call(...)
+  end
+end

data/lib/core/controlplane_api_cli.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class ControlplaneApiCli
+  def call(url, method:)
+    response = `cpln rest #{method} #{url} -o json`
+    raise(response) unless $?.success? # rubocop:disable Style/SpecialGlobalVars
+
+    JSON.parse(response)
+  end
+end

data/lib/core/controlplane_api_direct.rb

@@ -0,0 +1,42 @@
+# 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_HOSTS = { api: "https://api.cpln.io", logs: "https://logs.cpln.io" }.freeze
+
+  # API_TOKEN_REGEX = Regexp.union(
+  #  /^[\w.]{155}$/, # CPLN_TOKEN format
+  #  /^[\w\-._]{1134}$/ # 'cpln profile token' format
+  # ).freeze
+
+  API_TOKEN_REGEX = /^[\w\-._]+$/.freeze
+
+  def call(url, method:, host: :api) # 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
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
+
+    case response
+    when Net::HTTPOK
+      JSON.parse(response.body)
+    when Net::HTTPAccepted
+      true
+    when Net::HTTPNotFound
+      nil
+    else
+      raise("#{response} #{response.body}")
+    end
+  end
+
+  def api_token
+    return @@api_token if defined?(@@api_token)
+
+    @@api_token = ENV.fetch("CPLN_TOKEN", `cpln profile token`.chomp) # rubocop:disable Style/ClassVars
+    return @@api_token if @@api_token.match?(API_TOKEN_REGEX)
+
+    abort("ERROR: Unknown API token format. Please re-run 'cpln profile login' or set correct CPLN_TOKEN env variable")
+  end
+end

data/lib/core/scripts.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Scripts
+  module_function
+
+  def assert_replicas(gvc:, workload:, location:)
+    <<~SHELL
+      REPLICAS_QTY=$( \
+        curl ${CPLN_ENDPOINT}/org/shakacode-staging/gvc/#{gvc}/workload/#{workload}/deployment/#{location} \
+        -H "Authorization: ${CONTROLPLANE_TOKEN}" -s | grep -o '"replicas":[0-9]*' | grep -o '[0-9]*')
+
+      if [ "$REPLICAS_QTY" -gt 0 ]; then
+        echo "-- MULTIPLE REPLICAS ATTEMPT !!!! replicas: $REPLICAS_QTY"
+        exit -1
+      fi
+    SHELL
+  end
+
+  def helpers_cleanup
+    <<~SHELL
+      unset CONTROLPLANE_RUNNER
+    SHELL
+  end
+
+  # NOTE: please escape all '/' as '//' (as it is ruby interpolation here as well)
+  def http_dummy_server_ruby
+    'require "socket";s=TCPServer.new(ENV["PORT"]);' \
+      'loop do c=s.accept;c.puts("HTTP/1.1 200 OK\\nContent-Length: 2\\n\\nOk");c.close end'
+  end
+
+  def http_ping_ruby
+    'require "net/http";uri=URI(ENV["CPLN_GLOBAL_ENDPOINT"]);loop do puts(Net::HTTP.get(uri));sleep(5);end'
+  end
+end

data/lib/cpl/version.rb

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

data/lib/cpl.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+require "cgi"
+require "json"
+require "net/http"
+require "pathname"
+require "tempfile"
+require "thor"
+require "yaml"
+
+modules = Dir["#{__dir__}/**/*.rb"].reject { |file| file == __FILE__ || file.end_with?("main.rb") }
+modules.sort.each { require(_1) }
+
+# Fix for https://github.com/erikhuda/thor/issues/398
+# Copied from https://github.com/rails/thor/issues/398#issuecomment-622988390
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        indent = (options[:indent] || 0).to_i
+        if indent.zero?
+          stdout.puts(message)
+        else
+          message.each_line do |message_line|
+            stdout.print(" " * indent)
+            stdout.puts(message_line.chomp)
+          end
+        end
+      end
+    end
+  end
+end
+
+module Cpl
+  class Error < StandardError; end
+
+  class Cli < Thor
+    package_name "cpl"
+
+    def self.start(*args)
+      fix_help_option
+
+      super(*args)
+    end
+
+    # This is so that we're able to run `cpl COMMAND --help` to print the help
+    # (it basically changes it to `cpl --help COMMAND`, which Thor recognizes)
+    # Based on https://stackoverflow.com/questions/49042591/how-to-add-help-h-flag-to-thor-command
+    def self.fix_help_option
+      help_mappings = Thor::HELP_MAPPINGS + ["help"]
+      matches = help_mappings & ARGV
+      matches.each do |match|
+        ARGV.delete(match)
+        ARGV.unshift(match)
+      end
+    end
+
+    # Needed to silence deprecation warning
+    def self.exit_on_failure?
+      true
+    end
+
+    # Needed to be able to use "run" as a command
+    def self.is_thor_reserved_word?(word, type) # rubocop:disable Naming/PredicateName
+      return false if word == "run"
+
+      super(word, type)
+    end
+
+    def self.deprecated_commands
+      {
+        build: ::Command::BuildImage,
+        promote: ::Command::PromoteImage,
+        runner: ::Command::RunDetached
+      }
+    end
+
+    def self.all_base_commands
+      ::Command::Base.all_commands.merge(deprecated_commands)
+    end
+
+    all_base_commands.each do |command_key, command_class| # rubocop:disable Metrics/BlockLength
+      deprecated = deprecated_commands[command_key]
+
+      name = command_class::NAME
+      name_for_method = deprecated ? command_key : name.tr("-", "_")
+      usage = command_class::USAGE.empty? ? name : command_class::USAGE
+      requires_args = command_class::REQUIRES_ARGS
+      default_args = command_class::DEFAULT_ARGS
+      command_options = command_class::OPTIONS
+      description = command_class::DESCRIPTION
+      long_description = command_class::LONG_DESCRIPTION
+      examples = command_class::EXAMPLES
+      hide = command_class::HIDE || deprecated
+
+      long_description += "\n#{examples}" if examples.length.positive?
+
+      # `handle_argument_error` does not exist in the context below,
+      # so we store it here to be able to use it
+      raise_args_error = ->(*args) { handle_argument_error(commands[name_for_method], ArgumentError, *args) }
+
+      desc(usage, description, hide: hide)
+      long_desc(long_description)
+
+      command_options.each do |option|
+        method_option(option[:name], **option[:params])
+      end
+
+      define_method(name_for_method) do |*provided_args| # rubocop:disable Metrics/MethodLength
+        if deprecated
+          logger = $stderr
+          logger.puts("DEPRECATED: command '#{command_key}' is deprecated, use '#{name}' instead\n")
+        end
+
+        args = if provided_args.length.positive?
+                 provided_args
+               else
+                 default_args
+               end
+
+        raise_args_error.call(args, nil) if (args.empty? && requires_args) || (!args.empty? && !requires_args)
+
+        config = Config.new(args, options)
+
+        command_class.new(config).call
+      end
+    rescue StandardError => e
+      logger = $stderr
+      logger.puts("Unable to load command: #{e.message}")
+    end
+  end
+end
+
+# nice Ctrl+C
+trap "INT" do
+  puts
+  exit(1)
+end

data/lib/main.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "cpl"
+
+Cpl::Cli.start