cpflow 4.1.0 → 4.1.1

data/lib/core/terraform_config/workload/variables.tf

@@ -0,0 +1,263 @@
+variable "containers" {
+  type = map(
+    object({
+      args = optional(list(string))
+      command = optional(string)
+      cpu = optional(string, "1000m")
+      envs = optional(map(string))
+      image = string
+      inherit_env = optional(bool)
+      liveness_probe = optional(
+        object({
+          exec = optional(
+            object({
+              command = list(string)
+            })
+          )
+          failure_threshold = optional(number)
+          grpc = optional(
+            object({
+              port = optional(number)
+            })
+          )
+          http_get = optional(
+            object({
+              http_headers = optional(map(string))
+              path = optional(string)
+              port = optional(number)
+              scheme = optional(string)
+            })
+          )
+          initial_delay_seconds = optional(number)
+          period_seconds = optional(number)
+          success_threshold = optional(number)
+          timeout_seconds = optional(number)
+          tcp_socket = optional(
+            object({
+              port = optional(number)
+            })
+          )
+        })
+      )
+      memory = optional(string, "2048Mi")
+      ports = optional(
+        list(
+          object({
+            number = number
+            protocol = string
+          })
+        ),
+        [],
+      )
+      post_start_command = optional(string)
+      pre_stop_command = optional(string)
+      readiness_probe = optional(
+        object({
+          exec = optional(
+            object({
+              command = list(string)
+            })
+          )
+          failure_threshold = optional(number)
+          grpc = optional(
+            object({
+              port = optional(number)
+            })
+          )
+          http_get = optional(
+            object({
+              http_headers = optional(map(string))
+              path = optional(string)
+              port = optional(number)
+              scheme = optional(string)
+            })
+          )
+          initial_delay_seconds = optional(number)
+          period_seconds = optional(number)
+          success_threshold = optional(number)
+          timeout_seconds = optional(number)
+          tcp_socket = optional(
+            object({
+              port = optional(number)
+            })
+          )
+        })
+      )
+      volumes = optional(
+        list(
+          object({
+            path = string
+            uri = string
+          })
+        ),
+        [],
+      )
+    })
+  )
+}
+
+variable "description" {
+  type = string
+  default = null
+}
+
+variable "firewall_spec" {
+  type = object({
+    external = optional(
+      object({
+        inbound_allow_cidr = optional(list(string))
+        outbound_allow_hostname = optional(list(string))
+        outbound_allow_cidr = optional(list(string))
+        outbound_allow_port = optional(
+          list(
+            object({
+              number = number
+              protocol = optional(string, "tcp")
+            })
+          ),
+          []
+        )
+      })
+    )
+    internal = optional(
+      object({
+        inbound_allow_type = optional(string)
+        inbound_allow_workload = optional(list(string))
+      }),
+    )
+  })
+  default = null
+}
+
+variable "gvc" {
+  type = string
+}
+
+variable "identity_link" {
+  type = string
+  default = null
+}
+
+variable "job" {
+  type = object({
+    active_deadline_seconds = optional(number)
+    concurrency_policy = optional(string, "Forbid")
+    history_limit = optional(number, 5)
+    restart_policy = optional(string, "Never")
+    schedule = string
+  })
+  default = null
+}
+
+variable "load_balancer" {
+  type = object({
+    direct = optional(
+      object({
+        enabled = bool
+        port = optional(
+          list(
+            object({
+              container_port = optional(number)
+              external_port = number
+              protocol = string
+              scheme = optional(string)
+            })
+          ),
+          []
+        )
+      })
+    )
+    geo_location = optional(
+      object({
+        enabled = optional(bool)
+        headers = optional(
+          object({
+            asn = optional(string)
+            city = optional(string)
+            country = optional(string)
+            region = optional(string)
+          })
+        )
+      })
+    )
+  })
+  default = null
+}
+
+variable "local_options" {
+  type = object({
+    autoscaling = optional(
+      object({
+        metric = optional(string)
+        metric_percentile = optional(string)
+        target = optional(number)
+        max_scale = optional(number)
+        min_scale = optional(number)
+        scale_to_zero_delay = optional(number)
+        max_concurrency = optional(number)
+      })
+    )
+    location = string
+    capacity_ai = optional(bool, true)
+    debug = optional(bool, false)
+    suspend = optional(bool, false)
+    timeout_seconds = optional(number, 5)
+  })
+  default = null
+}
+
+variable "name" {
+  type = string
+}
+
+variable "options" {
+  type = object({
+    autoscaling = optional(
+      object({
+        max_concurrency = optional(number)
+        max_scale = optional(number)
+        metric = optional(string)
+        metric_percentile = optional(string)
+        min_scale = optional(number)
+        scale_to_zero_delay = optional(number)
+        target = optional(number)
+      })
+    )
+    capacity_ai = optional(bool, true)
+    debug = optional(bool, false)
+    suspend = optional(bool, false)
+    timeout_seconds = optional(number, 5)
+  })
+  default = null
+}
+
+variable "rollout_options" {
+  type = object({
+    max_surge_replicas = optional(string)
+    max_unavailable_replicas = optional(string)
+    min_ready_seconds = optional(number)
+    scaling_policy = optional(string, "OrderedReady")
+  })
+  default = null
+}
+
+variable "security_options" {
+  type = object({
+    file_system_group_id = optional(number)
+  })
+  default = null
+}
+
+variable "support_dynamic_tags" {
+  type = bool
+  default = false
+}
+
+variable "tags" {
+  type = map(string)
+  default = {}
+}
+
+variable "type" {
+  type = string
+}

data/lib/core/terraform_config/workload.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module TerraformConfig
+  class Workload < Base # rubocop:disable Metrics/ClassLength
+    RAW_ARGS = %i[
+      containers options local_options rollout_options security_options
+      firewall_spec load_balancer job
+    ].freeze
+
+    OPTIONS_KEYS = %i[autoscaling capacity_ai suspend timeout_seconds].freeze
+    LOCAL_OPTIONS_KEYS = (OPTIONS_KEYS + %i[location]).freeze
+    ROLLOUT_OPTIONS_KEYS = %i[min_ready_seconds max_unavailable_replicas max_surge_replicas scaling_policy].freeze
+    SECURITY_OPTIONS_KEYS = %i[file_system_group_id].freeze
+    LOAD_BALANCER_KEYS = %i[direct geo_location].freeze
+    FIREWALL_SPEC_KEYS = %i[internal external].freeze
+    VOLUME_KEYS = %i[uri path].freeze
+    JOB_KEYS = %i[schedule concurrency_policy history_limit restart_policy active_deadline_seconds].freeze
+    LIVENESS_PROBE_KEYS = %i[
+      exec http_get tcp_socket grpc
+      failure_threshold initial_delay_seconds period_seconds success_threshold timeout_seconds
+    ].freeze
+
+    attr_reader :type, :name, :gvc, :containers,
+                :description, :tags, :support_dynamic_tags, :firewall_spec, :identity_link,
+                :options, :local_options, :rollout_options, :security_options, :load_balancer, :job
+
+    def initialize( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+      type:,
+      gvc:,
+      name:,
+      containers:,
+      description: nil,
+      tags: nil,
+      support_dynamic_tags: false,
+      firewall_spec: nil,
+      identity_link: nil,
+      options: nil,
+      local_options: nil,
+      rollout_options: nil,
+      security_options: nil,
+      load_balancer: nil,
+      job: nil
+    )
+      super()
+
+      @type = type
+      @gvc = gvc
+
+      @name = name
+      @description = description
+      @tags = tags
+
+      @containers = containers
+      @firewall_spec = firewall_spec
+      @identity_link = identity_link
+
+      @options = options
+      @local_options = local_options
+      @rollout_options = rollout_options
+      @security_options = security_options
+
+      @load_balancer = load_balancer
+      @support_dynamic_tags = support_dynamic_tags
+      @job = job
+    end
+
+    def importable?
+      true
+    end
+
+    def reference
+      "module.#{name}.cpln_workload.workload"
+    end
+
+    def to_tf
+      block :module, name do
+        argument :source, "../workload"
+
+        argument :type, type
+        argument :name, name
+        argument :gvc, gvc
+        argument :identity_link, identity_link, optional: true
+        argument :support_dynamic_tags, support_dynamic_tags, optional: true
+
+        RAW_ARGS.each { |arg_name| argument arg_name, send(:"#{arg_name}_arg"), raw: true, optional: true }
+      end
+    end
+
+    def locals
+      containers.reduce({}) do |result, container|
+        envs = container[:env].to_h { |env_var| [env_var[:name], env_var[:value]] }
+        next result if envs.empty?
+
+        envs_name = :"#{container.fetch(:name)}_envs"
+        result.merge("#{envs_name}.tf" => LocalVariable.new(envs_name => envs))
+      end
+    end
+
+    private
+
+    def containers_arg
+      containers.reduce({}) { |result, container| result.merge(container_args(container)) }.crush
+    end
+
+    def container_args(container) # rubocop:disable Metrics/MethodLength
+      container_name = container.fetch(:name)
+
+      args = container.slice(:args, :command, :image, :cpu, :memory).merge(
+        post_start: container.dig(:lifecycle, :post_start, :exec, :command),
+        pre_stop: container.dig(:lifecycle, :pre_stop, :exec, :command),
+        inherit_env: container.fetch(:inherit_env, nil),
+        envs: ("local.#{container_name}_envs" if container[:env]&.any?),
+        ports: container.fetch(:ports, nil),
+        readiness_probe: container.fetch(:readiness_probe, nil)&.slice(*LIVENESS_PROBE_KEYS),
+        liveness_probe: container.fetch(:liveness_probe, nil)&.slice(*LIVENESS_PROBE_KEYS),
+        volumes: container.fetch(:volumes, nil)&.map { |volume| volume.slice(*VOLUME_KEYS) }
+      )
+
+      { container_name => args }
+    end
+
+    RAW_ARGS.each do |spec|
+      next if spec == :containers
+
+      define_method("#{spec}_arg") do
+        return if send(spec).nil?
+
+        send(spec).slice(*self.class.const_get("#{spec.upcase}_KEYS"))
+      end
+    end
+  end
+end

data/lib/cpflow/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Cpflow
-  VERSION = "4.1.0"
+  VERSION = "4.1.1"
   MIN_CPLN_VERSION = "3.1.0"
 end

data/lib/cpflow.rb

@@ -17,6 +17,9 @@ require_relative "constants/exit_code"
 
 # We need to require base before all commands, since the commands inherit from it
 require_relative "command/base"
+require_relative "command/terraform/base"
+# We need to require base terraform config before all commands, since the terraform configs inherit from it
+require_relative "core/terraform_config/base"
 
 modules = Dir["#{__dir__}/**/*.rb"].reject do |file|
   file == __FILE__ || file.end_with?("base.rb")
@@ -33,9 +36,15 @@ end
 
 require_relative "patches/thor"
 
+require_relative "patches/string"
+
 module Cpflow
   class Error < StandardError; end
 
+  def self.root_path
+    Pathname.new(File.expand_path("../", __dir__))
+  end
+
   class Cli < Thor # rubocop:disable Metrics/ClassLength
     package_name "cpflow"
     default_task :no_command
@@ -95,12 +104,21 @@ module Cpflow
     def self.fix_help_option
       help_mappings = Thor::HELP_MAPPINGS + ["help"]
       matches = help_mappings & ARGV
+
+      # Help option works correctly for subcommands
+      return if matches && subcommand?
+
       matches.each do |match|
         ARGV.delete(match)
         ARGV.unshift(match)
       end
     end
 
+    def self.subcommand?
+      (subcommand_names & ARGV).any?
+    end
+    private_class_method :subcommand?
+
     # Needed to silence deprecation warning
     def self.exit_on_failure?
       true
@@ -131,6 +149,10 @@ module Cpflow
       ::Command::Base.all_commands.merge(deprecated_commands)
     end
 
+    def self.subcommand_names
+      Dir["#{__dir__}/command/*"].filter_map { |name| File.basename(name) if File.directory?(name) }
+    end
+
     def self.process_option_params(params)
       # Ensures that if no value is provided for a non-boolean option (e.g., `cpflow command --option`),
       # it defaults to an empty string instead of the option name (which is the default Thor behavior)
@@ -139,8 +161,21 @@ module Cpflow
       params
     end
 
+    def self.klass_for(subcommand_name)
+      klass_name = subcommand_name.to_s.split("-").map(&:capitalize).join
+      full_klass_name = "Cpflow::#{klass_name}"
+      return const_get(full_klass_name) if const_defined?(full_klass_name)
+
+      Cpflow.const_set(klass_name, Class.new(BaseSubCommand)).tap do |subcommand_klass|
+        desc(subcommand_name, "#{subcommand_name.capitalize} commands")
+        subcommand(subcommand_name, subcommand_klass)
+      end
+    end
+    private_class_method :klass_for
+
     @commands_with_required_options = []
     @commands_with_extra_options = []
+    cli_package_name = @package_name
 
     ::Command::Base.common_options.each do |option|
       params = process_option_params(option[:params])
@@ -151,6 +186,7 @@ module Cpflow
       deprecated = deprecated_commands[command_key]
 
       name = command_class::NAME
+      subcommand_name = command_class::SUBCOMMAND_NAME
       name_for_method = deprecated ? command_key : name.tr("-", "_")
       usage = command_class::USAGE.empty? ? name : command_class::USAGE
       requires_args = command_class::REQUIRES_ARGS
@@ -170,21 +206,26 @@ module Cpflow
       # 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|
-        params = process_option_params(option[:params])
-        method_option(option[:name], **params)
-      end
-
       # We'll handle required options manually in `Config`
       required_options = command_options.select { |option| option[:params][:required] }.map { |option| option[:name] }
       @commands_with_required_options.push(name_for_method.to_sym) if required_options.any?
 
       @commands_with_extra_options.push(name_for_method.to_sym) if accepts_extra_options
 
-      define_method(name_for_method) do |*provided_args| # rubocop:disable Metrics/BlockLength, Metrics/MethodLength
+      klass = subcommand_name ? klass_for(subcommand_name) : self
+
+      klass.class_eval do
+        package_name(cli_package_name) if subcommand_name
+        desc(usage, description, hide: hide)
+        long_desc(long_description)
+
+        command_options.each do |option|
+          params = Cpflow::Cli.process_option_params(option[:params])
+          method_option(option[:name], **params)
+        end
+      end
+
+      klass.define_method(name_for_method) do |*provided_args| # rubocop:disable Metrics/BlockLength, Metrics/MethodLength
         if deprecated
           normalized_old_name = ::Helpers.normalize_command_name(command_key)
           ::Shell.warn_deprecated("Command '#{normalized_old_name}' is deprecated, " \

data/lib/generator_templates/templates/postgres.yml

@@ -133,7 +133,7 @@ spec:
           value: cpln://secret/postgres-poc-credentials.password
         - name: POSTGRES_USER #The name of the default user
           value: cpln://secret/postgres-poc-credentials.username
-      name: stateful
+      name: postgres
       image: postgres:15
       command: /bin/bash
       args:

data/lib/patches/array.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Array
+  def crush
+    crushed = map { |el| el.respond_to?(:crush) ? el.crush : el }.compact
+    crushed unless crushed.empty?
+  end
+end

data/lib/patches/hash.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Hash
+  # Copied from Rails
+  def deep_symbolize_keys
+    deep_transform_keys { |key| key.to_sym rescue key } # rubocop:disable Style/RescueModifier
+  end
+
+  def deep_underscore_keys
+    deep_transform_keys do |key|
+      underscored = key.to_s.underscore
+      key.is_a?(Symbol) ? underscored.to_sym : underscored
+    rescue StandardError
+      key
+    end
+  end
+
+  def crush
+    crushed = each_with_object({}) do |(key, value), hash|
+      crushed_value = value.respond_to?(:crush) ? value.crush : value
+      hash[key] = crushed_value unless crushed_value.nil?
+    end
+
+    crushed unless crushed.empty?
+  end
+
+  private
+
+  # Copied from Rails
+  def deep_transform_keys(&block)
+    deep_transform_keys_in_object(self, &block)
+  end
+
+  # Copied from Rails
+  def deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object(self.class.new) do |(key, value), result|
+        result[yield(key)] = deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/patches/string.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/OptionalBooleanParameter, Lint/UnderscorePrefixedVariableName
+class String
+  # Copied from Rails
+  def indent(amount, indent_string = nil, indent_empty_lines = false)
+    dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }
+  end
+
+  # Copied from Rails
+  def indent!(amount, indent_string = nil, indent_empty_lines = false)
+    indent_string = indent_string || self[/^[ \t]/] || " "
+    re = indent_empty_lines ? /^/ : /^(?!$)/
+    gsub!(re, indent_string * amount)
+  end
+
+  def unindent
+    gsub(/^#{scan(/^[ \t]+(?=\S)/).min}/, "")
+  end
+
+  # Copied from Rails
+  def underscore
+    gsub("::", "/").gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr("-", "_").downcase
+  end
+
+  # Covers only simple cases and used for pluralizing controlplane template kinds (`gvc`, `secret`, `policy`, etc.)
+  def pluralize
+    return self if empty?
+    return "#{self[...-1]}ies" if end_with?("y")
+
+    "#{self}s"
+  end
+end
+# rubocop:enable Style/OptionalBooleanParameter, Lint/UnderscorePrefixedVariableName

data/script/update_command_docs

@@ -12,12 +12,16 @@ commands.keys.sort.each do |command_key|
   next if command_class::HIDE
 
   name = command_class::NAME
-  usage = command_class::USAGE.empty? ? name : command_class::USAGE
+  subcommand_name = command_class::SUBCOMMAND_NAME
+
+  full_command = [subcommand_name, name].compact.join(" ")
+
+  usage = command_class::USAGE.empty? ? full_command : command_class::USAGE
   options = command_class::OPTIONS
   long_description = command_class::LONG_DESCRIPTION
   examples = command_class::EXAMPLES
 
-  command_str = "### `#{name}`\n\n"
+  command_str = "### `#{full_command}`\n\n"
   command_str += "#{long_description.strip}\n\n"
 
   if examples.empty?