dash 2.12.0

data/lib/kamal/configuration/validator/env.rb

@@ -0,0 +1,54 @@
+class Kamal::Configuration::Validator::Env < Kamal::Configuration::Validator
+  SPECIAL_KEYS = [ "clear", "secret", "tags" ]
+
+  def validate!
+    if known_keys.any?
+      validate_complex_env!
+    else
+      validate_simple_env!
+    end
+  end
+
+  private
+    def validate_simple_env!
+      validate_hash_of!(config, String)
+    end
+
+    def validate_complex_env!
+      unknown_keys_error unknown_keys if unknown_keys.any?
+
+      with_context("clear") { validate_hash_of!(config["clear"], String) } if config.key?("clear")
+      with_context("secret") { validate_array_of!(config["secret"], String) } if config.key?("secret")
+      validate_tags! if config.key?("tags")
+    end
+
+    def known_keys
+      @known_keys ||= config.keys & SPECIAL_KEYS
+    end
+
+    def unknown_keys
+      @unknown_keys ||= config.keys - SPECIAL_KEYS
+    end
+
+    def validate_tags!
+      if context == "env"
+        with_context("tags") do
+          validate_type! config["tags"], Hash
+
+          config["tags"].each do |tag, value|
+            with_context(tag) do
+              validate_type! value, Hash
+
+              Kamal::Configuration::Validator::Env.new(
+                value,
+                example: example["tags"].values[1],
+                context: context
+              ).validate!
+            end
+          end
+        end
+      else
+        error "tags are only allowed in the root env"
+      end
+    end
+end

data/lib/kamal/configuration/validator/proxy.rb

@@ -0,0 +1,47 @@
+class Kamal::Configuration::Validator::Proxy < Kamal::Configuration::Validator
+  def validate!
+    unless config.nil?
+      super
+
+      # Skip SSL host validation when a loadbalancer is present
+      # since SSL is disabled when using a loadbalancer
+      if config["host"].blank? && config["hosts"].blank? && config["ssl"] && config["loadbalancer"].blank?
+        error "Must set a host to enable automatic SSL"
+      end
+
+      if (config.keys & [ "host", "hosts" ]).size > 1
+        error "Specify one of 'host' or 'hosts', not both"
+      end
+
+      if config["ssl"].is_a?(Hash)
+        if config["ssl"]["certificate_pem"].present? && config["ssl"]["private_key_pem"].blank?
+          error "Missing private_key_pem setting (required when certificate_pem is present)"
+        end
+
+        if config["ssl"]["private_key_pem"].present? && config["ssl"]["certificate_pem"].blank?
+          error "Missing certificate_pem setting (required when private_key_pem is present)"
+        end
+      end
+
+      if run_config = config["run"]
+        if run_config["bind_ips"].present?
+          ensure_valid_bind_ips(config["bind_ips"])
+        end
+
+        if run_config["publish"] == false
+          if run_config["bind_ips"].present? || run_config["http_port"].present? || run_config["https_port"].present?
+            error "Cannot set http_port, https_port or bind_ips when publish is false"
+          end
+        end
+      end
+    end
+  end
+
+  private
+    def ensure_valid_bind_ips(bind_ips)
+      bind_ips.present? && bind_ips.each do |ip|
+        next if ip =~ Resolv::IPv4::Regex || ip =~ Resolv::IPv6::Regex
+        error "Invalid publish IP address: #{ip}"
+      end
+    end
+end

data/lib/kamal/configuration/validator/registry.rb

@@ -0,0 +1,27 @@
+class Kamal::Configuration::Validator::Registry < Kamal::Configuration::Validator
+  STRING_OR_ONE_ITEM_ARRAY_KEYS = [ "username", "password" ]
+
+  def validate!
+    validate_against_example! \
+      config.except(*STRING_OR_ONE_ITEM_ARRAY_KEYS),
+      example.except(*STRING_OR_ONE_ITEM_ARRAY_KEYS)
+
+    validate_string_or_one_item_array! "username"
+    validate_string_or_one_item_array! "password"
+  end
+
+  private
+    def validate_string_or_one_item_array!(key)
+      with_context(key) do
+        value = config[key]
+
+        unless config["server"]&.match?("^localhost[:$]")
+          error "is required" unless value.present?
+
+          unless value.is_a?(String) || (value.is_a?(Array) && value.size == 1 && value.first.is_a?(String))
+            error "should be a string or an array with one string (for secret lookup)"
+          end
+        end
+      end
+    end
+end

data/lib/kamal/configuration/validator/role.rb

@@ -0,0 +1,13 @@
+class Kamal::Configuration::Validator::Role < Kamal::Configuration::Validator
+  def validate!
+    validate_type! config, Array, Hash
+
+    if config.is_a?(Array)
+      validate_servers!(config)
+    else
+      super
+      validate_labels!(config["labels"])
+      validate_docker_options!(config["options"])
+    end
+  end
+end

data/lib/kamal/configuration/validator/servers.rb

@@ -0,0 +1,7 @@
+class Kamal::Configuration::Validator::Servers < Kamal::Configuration::Validator
+  def validate!
+    validate_type! config, Array, Hash, NilClass
+
+    validate_servers! config if config.is_a?(Array)
+  end
+end

data/lib/kamal/configuration/validator.rb

@@ -0,0 +1,251 @@
+class Kamal::Configuration::Validator
+  attr_reader :config, :example, :context
+
+  def initialize(config, example:, context:)
+    @config = config
+    @example = example
+    @context = context
+  end
+
+  def validate!
+    validate_against_example! config, example
+  end
+
+  private
+    def validate_against_example!(validation_config, example)
+      validate_type! validation_config, example.class
+
+      if example.class == Hash
+        check_unknown_keys! validation_config, example
+
+        validation_config.each do |key, value|
+          next if extension?(key)
+          with_context(key) do
+            example_value = example[key]
+
+            if example_value == "..."
+              unless key.to_s == "proxy" && boolean?(value.class)
+                validate_type! value, *(Array if key == :servers), Hash
+              end
+            elsif key.to_s == "ssl"
+                validate_type! value, TrueClass, FalseClass, Hash
+            elsif key.to_s == "hooks_output"
+                validate_hooks_output!(value)
+            elsif key == "hosts"
+              validate_servers! value
+            elsif example_value.is_a?(Array)
+              if key == "arch"
+                validate_array_of_or_type! value, example_value.first.class
+              elsif key.to_s == "config"
+                validate_ssh_config!(value)
+              elsif key.to_s == "files" || key.to_s == "directories"
+                validate_paths!(value)
+              else
+                validate_array_of! value, example_value.first.class
+              end
+            elsif example_value.is_a?(Hash)
+              case key.to_s
+              when "options", "args"
+                validate_type! value, Hash
+              when "labels"
+                validate_hash_of! value, example_value.first[1].class
+              else
+                validate_against_example! value, example_value
+              end
+            else
+              validate_type! value, example_value.class
+            end
+          end
+        end
+      end
+    end
+
+
+    def valid_type?(value, type)
+      value.is_a?(type) ||
+        (type == String && stringish?(value)) ||
+        (boolean?(type) && boolean?(value.class))
+    end
+
+    def type_description(type)
+      if type == Integer || type == Array
+        "an #{type.name.downcase}"
+      elsif type == TrueClass || type == FalseClass
+        "a boolean"
+      else
+        "a #{type.name.downcase}"
+      end
+    end
+
+    def boolean?(type)
+      type == TrueClass || type == FalseClass
+    end
+
+    def stringish?(value)
+      value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    end
+
+    def validate_array_of_or_type!(value, type)
+      if value.is_a?(Array)
+        validate_array_of! value, type
+      else
+        validate_type! value, type
+      end
+    rescue Kamal::ConfigurationError
+      type_error(Array, type)
+    end
+
+    def validate_array_of!(array, type)
+      validate_type! array, Array
+
+      array.each_with_index do |value, index|
+        with_context(index) do
+          validate_type! value, type
+        end
+      end
+    end
+
+    def validate_hash_of!(hash, type)
+      validate_type! hash, Hash
+
+      hash.each do |key, value|
+        with_context(key) do
+          validate_type! value, type
+        end
+      end
+    end
+
+    def validate_servers!(servers)
+      validate_type! servers, Array
+
+      servers.each_with_index do |server, index|
+        with_context(index) do
+          validate_type! server, String, Hash
+
+          if server.is_a?(Hash)
+            error "multiple hosts found" unless server.size == 1
+            host, tags = server.first
+
+            with_context(host) do
+              validate_type! tags, String, Array
+              validate_array_of! tags, String if tags.is_a?(Array)
+            end
+          end
+        end
+      end
+    end
+
+    def validate_ssh_config!(config)
+      if config.is_a?(Array)
+        validate_array_of! config, String
+      elsif boolean?(config.class) || config.is_a?(String)
+        # Booleans and Strings are allowed
+      else
+        type_error(TrueClass, FalseClass, String, Array)
+      end
+    end
+
+    def validate_paths!(paths)
+      validate_type! paths, Array
+
+      paths.each_with_index do |path, index|
+        with_context(index) do
+          validate_type! path, String, Hash
+
+          if path.is_a?(Hash)
+            %w[local remote mode owner options].each do |key|
+              with_context(key) do
+                validate_type! path[key], String if path.key?(key)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def validate_hooks_output!(value)
+      # hooks_output can be either a symbol/string (global) or a hash (per-hook)
+      if value.is_a?(Hash)
+        value.each do |hook, level|
+          with_context(hook) do
+            validate_type! level, String, Symbol
+          end
+        end
+      else
+        validate_type! value, String, Symbol
+      end
+    end
+
+    def validate_type!(value, *types)
+      type_error(*types) unless types.any? { |type| valid_type?(value, type) }
+    end
+
+    def error(message)
+      raise Kamal::ConfigurationError, "#{error_context}#{message}"
+    end
+
+    def type_error(*expected_types)
+      descriptions = expected_types.map { |type| type_description(type) }.uniq
+      error "should be #{descriptions.join(" or ")}"
+    end
+
+    def unknown_keys_error(unknown_keys)
+      error "unknown #{"key".pluralize(unknown_keys.count)}: #{unknown_keys.join(", ")}"
+    end
+
+    def error_context
+      "#{context}: " if context.present?
+    end
+
+    def with_context(context)
+      old_context = @context
+      @context = [ @context, context ].select(&:present?).join("/")
+      yield
+    ensure
+      @context = old_context
+    end
+
+    def allow_extensions?
+      false
+    end
+
+    def extension?(key)
+      key.to_s.start_with?("x-")
+    end
+
+    def check_unknown_keys!(config, example)
+      unknown_keys = config.keys - example.keys
+      unknown_keys.reject! { |key| extension?(key) } if allow_extensions?
+      unknown_keys_error unknown_keys if unknown_keys.present?
+    end
+
+    def validate_labels!(labels)
+      return true if labels.blank?
+
+      with_context("labels") do
+        labels.each do |key, _|
+          with_context(key) do
+            error "invalid label. destination, role, and service are reserved labels" if %w[destination role service].include?(key)
+          end
+        end
+      end
+    end
+
+    def validate_docker_options!(options)
+      if restart_policy = options&.find { |key, _| key.to_s == "restart" }
+        validate_restart_policy!(restart_policy.last)
+      end
+    end
+
+    def validate_restart_policy!(restart_policy)
+      with_context("options/restart") do
+        unless restart_policy.is_a?(String)
+          error %(should be a string. Use "no" to disable restarts)
+        end
+
+        unless restart_policy.match?(/\A(?:no|always|unless-stopped|on-failure(?::\d+)?)\z/)
+          error "should be no, always, unless-stopped, on-failure, or on-failure:N"
+        end
+      end
+    end
+end

data/lib/kamal/configuration/volume.rb

@@ -0,0 +1,29 @@
+class Kamal::Configuration::Volume
+  attr_reader :host_path, :container_path, :options
+  delegate :argumentize, to: Kamal::Utils
+
+  def initialize(host_path:, container_path:, options: nil)
+    @host_path = host_path
+    @container_path = container_path
+    @options = options
+  end
+
+  def docker_args
+    argumentize "--volume", docker_args_string
+  end
+
+  def docker_args_string
+    volume_string = "#{host_path_for_docker_volume}:#{container_path}"
+    volume_string += ":#{options}" if options.present?
+    volume_string
+  end
+
+  private
+    def host_path_for_docker_volume
+      if Pathname.new(host_path).absolute?
+        host_path
+      else
+        "$PWD/#{host_path}"
+      end
+    end
+end