container_config 0.1.0

data/lib/container_config/coercer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "container_config"
+require "container_config/coercer/base"
+require "container_config/coercer/boolean"
+require "container_config/coercer/float"
+require "container_config/coercer/integer"
+require "container_config/coercer/string"
+require "container_config/coercer/symbol"
+require "container_config/coercer/ssl_verify_mode"
+require "container_config/coercer/ssl_certificate"
+require "container_config/coercer/ssl_key"
+
+module ContainerConfig
+  # Contains classes and methods for type coercion
+  module Coercer
+    #
+    # Coerces a given value into a requested type
+    #
+    # @param [Object] value value to coerce
+    # @param [Symbol] value_type requested type such as :boolean, :integer, :string, :symbol,
+    #                            :ssl_verify_mode, :ssl_certificate, or :ssl_key
+    # @param [Hash] options Options Hash
+    # @option options [Boolean] :coerce_nil where to coerce nil values (defaults to true)
+    #
+    # @return [Object] coerced value
+    #
+    def self.coerce_value(value, value_type = nil, options = {})
+      return value unless value_type
+
+      return value if options[:coerce_nil] == false && value.nil?
+
+      value_type = value_type.to_sym
+
+      ContainerConfig.coercers.each do |coercer|
+        return coercer.coerce(value) if coercer.type == value_type
+      end
+
+      ContainerConfig.logger.warn { "Could not find valid coercion type for #{value_type}" }
+      value
+    end
+
+    #
+    # Array of default coercers
+    #
+    # @return [Array<ContainerConfig::Coercer::Base>] default coercers
+    #
+    def self.default_coercers
+      [
+        ContainerConfig::Coercer::Boolean.new,
+        ContainerConfig::Coercer::Float.new,
+        ContainerConfig::Coercer::Integer.new,
+        ContainerConfig::Coercer::SslCertificate.new,
+        ContainerConfig::Coercer::SslKey.new,
+        ContainerConfig::Coercer::SslVerifyMode.new,
+        ContainerConfig::Coercer::String.new,
+        ContainerConfig::Coercer::Symbol.new
+      ]
+    end
+  end
+end

data/lib/container_config/coercer/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ContainerConfig
+  module Coercer
+    # Base type coercer
+    class Base
+      #
+      # Returns name of the coercer
+      #
+      # @return [String] coercer name
+      #
+      def name
+        raise ContainerConfig::MissingOverride, "Must override name method in derived class #{self.class}"
+      end
+
+      #
+      # Returns the type of the coercer
+      # This is used by the ContainerConfig::Coercer.coerce_value method to determine
+      # whether this coercer should be used for a given type
+      #
+      # @return [Symbol] coercer type
+      #
+      def type
+        raise ContainerConfig::MissingOverride, "Must override type method in derived class #{self.class}"
+      end
+
+      #
+      # Coerces the given value into the coercer type
+      #
+      # @param [Object] _value given value
+      #
+      # @return [Object] coerced value
+      #
+      def coerce(_value)
+        raise ContainerConfig::MissingOverride, "Must override coerce method in derived class #{self.class}"
+      end
+    end
+  end
+end

data/lib/container_config/coercer/boolean.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "container_config/coercer/base"
+
+module ContainerConfig
+  module Coercer
+    # Boolean type coercer
+    class Boolean < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "Boolean"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :boolean
+      end
+
+      #
+      # Coerces the given value into a boolean
+      #
+      # @param [Object] value given value
+      #
+      # @return [Boolean] coerced value
+      #
+      def coerce(value)
+        # If a digit is passed, check if it is non-zero and return true for non-zero values
+        return value.to_i != 0 if value.respond_to?(:to_i) && value.to_i.to_s == value.to_s
+
+        value.to_s.casecmp?("true")
+      end
+    end
+  end
+end

data/lib/container_config/coercer/float.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "container_config/coercer/base"
+
+module ContainerConfig
+  module Coercer
+    # Float type coercer
+    class Float < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "Float"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :float
+      end
+
+      #
+      # Coerces the given value into a float
+      #
+      # @param [Object] value given value
+      #
+      # @return [Float] coerced value
+      #
+      def coerce(value)
+        return 0.0 unless value.respond_to?(:to_f)
+
+        value.to_f
+      end
+    end
+  end
+end

data/lib/container_config/coercer/integer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "container_config/coercer/base"
+
+module ContainerConfig
+  module Coercer
+    # Integer type coercer
+    class Integer < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "Integer"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :integer
+      end
+
+      #
+      # Coerces the given value into an integer
+      #
+      # @param [Object] value given value
+      #
+      # @return [Integer] coerced value
+      #
+      def coerce(value)
+        return 0 unless value.respond_to?(:to_i)
+
+        value.to_i
+      end
+    end
+  end
+end

data/lib/container_config/coercer/ssl_certificate.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "container_config"
+require "container_config/coercer/base"
+require "openssl"
+
+module ContainerConfig
+  module Coercer
+    # SSL certificate type coercer
+    class SslCertificate < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "SSL Certificate"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :ssl_certificate
+      end
+
+      #
+      # Coerces the given value into an SSL certificate
+      #
+      # @param [Object] value SSL certificate path
+      #
+      # @return [OpenSSL::X509::Certificate] coerced value
+      #
+      def coerce(value)
+        return if value.nil?
+
+        return value if value.is_a?(OpenSSL::X509::Certificate)
+
+        cert_path = value.to_s
+
+        unless File.exist?(cert_path)
+          ContainerConfig.logger.warn { "Could not find SSL certificate at #{cert_path}" }
+          return nil
+        end
+
+        OpenSSL::X509::Certificate.new(File.read(cert_path))
+      rescue OpenSSL::X509::CertificateError => e
+        ContainerConfig.logger.warn { "Could not parse SSL certificate #{cert_path} successfully: #{e}" }
+        nil
+      end
+    end
+  end
+end

data/lib/container_config/coercer/ssl_key.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "container_config"
+require "container_config/coercer/base"
+require "openssl"
+
+module ContainerConfig
+  module Coercer
+    # SSL key type coercer
+    class SslKey < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "SSL Private Key"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :ssl_key
+      end
+
+      #
+      # Coerces the given value into an SSL key
+      #
+      # @param [Object] value SSL key path
+      #
+      # @return [OpenSSL::PKey::RSA] coerced value
+      #
+      def coerce(value)
+        return if value.nil?
+
+        key_path = value.to_s
+
+        unless File.exist?(key_path)
+          ContainerConfig.logger.warn { "Could not find SSL key at #{key_path}" }
+          return
+        end
+
+        OpenSSL::PKey::RSA.new(File.read(key_path))
+      rescue OpenSSL::PKey::RSAError => e
+        ContainerConfig.logger.warn { "Could not parse SSL key #{key_path} successfully: #{e}" }
+        nil
+      end
+    end
+  end
+end

data/lib/container_config/coercer/ssl_verify_mode.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "container_config"
+require "container_config/coercer/base"
+require "openssl"
+
+module ContainerConfig
+  module Coercer
+    # SSL verification mode type coercer
+    class SslVerifyMode < Base
+      # Array of valid SSL verification modes
+      VALID_MODES = OpenSSL::SSL.constants.select { |c| c.to_s.start_with?("VERIFY") }.map(&:to_s)
+
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "SSL Verification Mode"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :ssl_verify_mode
+      end
+
+      #
+      # Coerces the given value into an SSL verification mode
+      #
+      # @param [Object] value SSL verification mode string ("VERIFY_NONE", "VERIFY_PEER", etc.)
+      #
+      # @return [Integer] coerced value
+      #
+      def coerce(value)
+        value = value.to_s
+        return Object.const_get("OpenSSL::SSL::#{value}") if VALID_MODES.include?(value)
+
+        ContainerConfig.logger.warn do
+          "Could not convert #{value.inspect} into a valid OpenSSL verification mode.\nValid modes: #{VALID_MODES.join(", ")}"
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/container_config/coercer/string.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "container_config/coercer/base"
+
+module ContainerConfig
+  module Coercer
+    # String type coercer
+    class String < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "String"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :string
+      end
+
+      #
+      # Coerces the given value into a string
+      #
+      # @param [Object] value given value
+      #
+      # @return [String] coerced value
+      #
+      def coerce(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/container_config/coercer/symbol.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "container_config/coercer/base"
+
+module ContainerConfig
+  module Coercer
+    # Symbol type coercer
+    class Symbol < Base
+      # @see ContainerConfig::Coercer::Base#name
+      def name
+        "Symbol"
+      end
+
+      # @see ContainerConfig::Coercer::Base#type
+      def type
+        :symbol
+      end
+
+      #
+      # Coerces the given value into a symbol
+      #
+      # @param [Object] value given value
+      #
+      # @return [Symbol] coerced value
+      #
+      def coerce(value)
+        return if value.nil?
+
+        value.to_s.to_sym
+      end
+    end
+  end
+end

data/lib/container_config/logger.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module ContainerConfig
+  # ContainerConfig Logging class
+  class Logger < ::Logger
+  end
+end

data/lib/container_config/provider.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "container_config"
+require "container_config/provider/base"
+require "container_config/provider/default"
+require "container_config/provider/env"
+require "container_config/provider/rails_credential"
+require "container_config/provider/secret_volume"
+
+module ContainerConfig
+  # Contains classes and methods for config value providers
+  module Provider
+    #
+    # Loads a value from the config value providers
+    #
+    # @param [String] key Configuration key to load
+    # @param [Array] dig_keys Variable keys to use to load from providers that accept a dig structure
+    #                         defaults to the lowercase key split by underscores
+    #                         "MY_PASSWORD" => ["my", "password"]
+    # @param [Hash] options Options Hash
+    # @option options [String]  :default default value if the configuration setting cannot be found
+    # @option options [String]  :secret_mount_directory directory where secret files are mounted
+    # @option options [Symbol]  :type type to use such as :boolean, :integer, :string, :symbol,
+    #                                 :ssl_verify_mode, :ssl_certificate, or :ssl_key
+    #
+    # @return [Object] configuration setting value
+    #
+    def self.load_value(key, *dig_keys, **options)
+      value = nil
+      ContainerConfig.providers.each do |p|
+        value = p.load(key, *dig_keys, **options)
+        break unless value.nil?
+      end
+
+      value
+    end
+
+    #
+    # Array of default providers
+    #
+    # @return [Array<ContainerConfig::Provider::Base>] default providers
+    #
+    def self.default_providers
+      defaults = [
+        ContainerConfig::Provider::Env.new,
+        ContainerConfig::Provider::SecretVolume.new
+      ]
+
+      defaults |= rails_providers if ContainerConfig.rails_app?
+      defaults << ContainerConfig::Provider::Default.new
+
+      defaults
+    end
+
+    #
+    # Array of Rails providers
+    # These are only included in the default providers when this gem is included
+    # as part of a rails application
+    #
+    # @return [Array<ContainerConfig::Provider::Base>] default providers
+    #
+    def self.rails_providers
+      [ContainerConfig::Provider::RailsCredential.new]
+    end
+  end
+end