cloud-config 0.1.0

data/lib/cloud-config/cache/in_memory.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  module Cache
+    # A simple class for storing key-value configuration in-memory. Keys can be individuallly set to
+    # expire.
+    #
+    # @example
+    #   cache = CloudConfig::Cache::InMemory.new
+    #   cache.set(:key_to_expire, :key_value, expire_in: 5)
+    #
+    #   cache.get(:key_to_expire) #=> :key_value
+    #
+    #   sleep 5
+    #
+    #   cache.get(:key_to_expire) #=> nil
+    class InMemory
+      # Default time to expire keys (seconds)
+      DEFAULT_EXPIRE = 60 * 60
+
+      # @!attribute [r] settings
+      #   @return [Hash]
+      attr_reader :settings
+
+      def initialize
+        @settings = {}
+      end
+
+      # Check whether the key exists in the cache. Expired keys will return false.
+      #
+      # @param key [String,Symbol] Key to check
+      #
+      # @return [Boolean] Whether key exists
+      def key?(key)
+        expire(key)
+
+        settings.key?(key)
+      end
+
+      # Fetch the key from the cache
+      #
+      # @param key [String,Symbol] Key to check
+      #
+      # @return [Object] Value of key
+      def get(key)
+        expire(key)
+
+        settings.dig(key, :value)
+      end
+
+      # Set the value of the key in the cache. Optionally set an expiry of the key, otherwise
+      # a default expiry of {DEFAULT_EXPIRE} will be set.
+      #
+      # @param key [String,Symbol] Key to set
+      # @param value [Object] Value of the key
+      # @option options [Hash] :expire_in Time in seconds until key expires
+      def set(key, value, options = {})
+        expire_in = options.fetch(:expire_in) { DEFAULT_EXPIRE }
+
+        expire_at = Time.now + expire_in
+
+        settings[key] = {
+          value:,
+          expire_at:
+        }
+      end
+
+      # Delete the key from the cache
+      #
+      # @param key [String,Symbol] Key to delete
+      def delete(key)
+        settings.delete(key)
+      end
+
+      # Expire the key from the cache, if the expiry time has passed
+      #
+      # @param key [String,Symbol] Key to expire
+      def expire(key)
+        expire_at = settings.dig(key, :expire_at)
+
+        delete(key) if expire_at && expire_at <= Time.now
+      end
+    end
+  end
+end

data/lib/cloud-config/cache/redis.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  module Cache
+    # A simple class for storing key-value data in Redis.
+    #
+    # @example
+    #   cache = CloudConfig::Cache::Redis.new(url:)
+    #   cache.set(:key_to_expire, :key_value, expire_in: 5)
+    #
+    #   cache.get(:key_to_expire) #=> :key_value
+    #
+    #   sleep 5
+    #
+    #   cache.get(:key_to_expire) #=> nil
+    class Redis
+      # Default time to expire keys (seconds)
+      DEFAULT_EXPIRE = 60 * 60
+
+      # @!attribute [r] Redis client
+      #   @return [Redis]
+      attr_reader :client
+
+      def initialize(params = {})
+        @client = ::Redis.new(params)
+      end
+
+      # Check whether the key exists in the cache. Expired keys will return false.
+      #
+      # @param key [String,Symbol] Key to check
+      #
+      # @return [Boolean] Whether key exists
+      def key?(key)
+        client.exists(key) == 1
+      end
+
+      # Fetch the key from the cache
+      #
+      # @param key [String,Symbol] Key to check
+      #
+      # @return [Object] Value of key
+      def get(key)
+        client.get(key)
+      end
+
+      # Set the value of the key in the cache. Optionally set an expiry of the key, otherwise
+      # a default expiry of {DEFAULT_EXPIRE} will be set.
+      #
+      # @param key [String,Symbol] Key to set
+      # @param value [Object] Value of the key
+      # @option options [Hash] :expire_in Time in seconds until key expires
+      def set(key, value, options = {})
+        client.set(key, value, ex: options[:expire_in] || DEFAULT_EXPIRE)
+      end
+
+      # Delete the key from the cache
+      #
+      # @param key [String,Symbol] Key to delete
+      def delete(key)
+        client.del(key)
+      end
+    end
+  end
+end

data/lib/cloud-config/cache.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  # A module for handling the caching of keys.
+  module Cache
+    # Extend {Cache::ClassMethods} when included
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods for {Cache}
+    module ClassMethods
+      # @!attribute [r] Cache client instance
+      #   @return [Object]
+      attr_reader :cache
+
+      # Configure the cache client
+      #
+      # @param client [Object] Cache client instance
+      def cache_client(client)
+        @cache = client
+      end
+
+      # Fetch the value of the key from the cache, if the key exists in the cache
+      #
+      # @param key [String,Symbol] Key to fetch from the cache
+      # @option options [Hash<Symbol,Object>] Cache options
+      #
+      # @yield Fetch the value of the key if the key does not exist in the cache
+      #
+      # @return [Object] Value of the key
+      def with_cache(key, options = {})
+        return cache.get(key) if cache&.key?(key)
+
+        value = yield
+
+        cache&.set(key, value, options)
+
+        value
+      end
+    end
+  end
+end

data/lib/cloud-config/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  # Base error class for {CloudConfig}
+  class Error < StandardError; end
+
+  # Raise MissingKey error when the key is not configured.
+  class MissingKey < Error; end
+end

data/lib/cloud-config/provider_config.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'provider_options'
+
+module CloudConfig
+  # A class for storing provider configuration. Use this class to create a new provider and set the provider
+  # parameters.
+  class ProviderConfig
+    attr_reader :settings, :provider_name, :provider_options
+
+    # Create a new instance of {ProviderConfig}.
+    #
+    # @param provider_name [String,Symbol] Name of the provider
+    # @param provider_options [Hash<Symbol,Object>] List of provider options
+    def initialize(provider_name, provider_options)
+      @provider_name = provider_name
+      @provider_options = ProviderOptions.new(provider_options)
+      @settings = {}
+    end
+
+    # Store the name of a key with this provider. Provider additional options such as caching.
+    #
+    # @param setting_name [String,Symbol] Setting key
+    # @option setting_options [Hash<Symbol,Object>] List of options for the key
+    def setting(setting_name, setting_options = {})
+      setting_options = merge_options(setting_options)
+      @settings[setting_name] = setting_options
+    end
+
+    # Return an instance of the configured provider.
+    #
+    # @return [Object] Instance of the provider
+    def provider
+      @provider ||= provider_class.new(provider_options.to_h)
+    end
+
+    # Return the class of the configured provider.
+    #
+    # @return [Object] Class of the provider
+    def provider_class
+      @provider_class ||= if provider_options.klass
+                            generate_class(provider_options.klass)
+                          else
+                            provider_class_from_name(provider_name)
+                          end
+    end
+
+    private
+
+    def generate_class(klass)
+      return klass unless klass.is_a?(String)
+
+      Object.const_get(klass)
+    end
+
+    def provider_class_from_name(class_name)
+      capitalised_class_name = class_name.to_s.split('_').map(&:capitalize).join
+
+      CloudConfig::Providers.const_get(capitalised_class_name)
+    end
+
+    def merge_options(options)
+      options ||= {}
+
+      provider_options.to_h.each do |key, value|
+        if options.key?(key)
+          options[key] = value.merge(options[key]) if options[key].is_a?(Hash) && value.is_a?(Hash)
+        else
+          options[key] = value
+        end
+      end
+
+      options
+    end
+  end
+end

data/lib/cloud-config/provider_options.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  # A helper class for storing provider options.
+  class ProviderOptions
+    attr_reader :preload, :klass
+
+    # Create a new instance of {ProviderOptions}.
+    #
+    # @option param [Hash] :preload Enable preloading for the provider
+    # @option param [Hash] :class The class of the provider
+    def initialize(params = {})
+      @preload = params[:preload]
+      @klass = params[:class]
+    end
+
+    # Returns whether asynchronous preloading is enabled for the provider.
+    #
+    # @return [Boolean] Whether asynchronous preloading is enabled
+    def async_preload?
+      return false unless preload.is_a?(Hash)
+
+      preload[:async]
+    end
+
+    # Returns the class in the form of a hash
+    #
+    # @return [Hash<Symbol,Object>] Class parameters
+    def to_h
+      { preload:, class: klass }
+    end
+  end
+end

data/lib/cloud-config/providers/aws_parameter_store.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  module Providers
+    # A class for fetching configuration from the AWS Parameter Store
+    #
+    # @example
+    #   provider = AwsParameterStore.new # Assuming AWS credentials are already configured
+    #   provider.set(:example_key, :example_value)
+    #   provider.get(:example_key) #=> 'example_value'
+    class AwsParameterStore
+      # @!attribute [r] An instance of the AWS Parameter Store client
+      #   @return [Aws::SSM::Client]
+      attr_reader :client
+
+      # Create a new instance of {AwsParameterStore}.
+      def initialize(_params = {})
+        @client = Aws::SSM::Client.new
+      end
+
+      # Fetch the value of the key
+      #
+      # @param key [String,Symbol] Key to fetch
+      #
+      # @return [String] Value of the key
+      def get(key)
+        client.get_parameter(name: key).parameter.value
+      end
+
+      # Set the value of the key
+      #
+      # @param key [String,Symbol] Key to set
+      # @param value [Object] Value of the key
+      def set(key, value)
+        client.put_parameter(name: key, value:)
+      end
+
+      # def client
+      #   @client ||= Aws::SSM::Client.new
+      # end
+    end
+  end
+end

data/lib/cloud-config/providers/in_memory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  module Providers
+    # A class that acts as a provider for storing configuration in-memory
+    #
+    # @example
+    #   provider = InMemory.new # Assuming AWS credentials are already configured
+    #   provider.set(:example_key, :example_value)
+    #   provider.get(:example_key) #=> 'example_value'
+    class InMemory
+      # @!attribute [r] settings
+      #   @return [Hash]
+      attr_reader :settings
+
+      # Create an instance of {InMemory}
+      def initialize(_params = {})
+        @settings = {}
+      end
+
+      # Fetch the value of the key
+      #
+      # @param key [String,Symbol] Key to fetch
+      #
+      # @return [Object] Value of the key
+      def get(key)
+        settings[key]
+      end
+
+      # Set the value of the key
+      #
+      # @param key [String,Symbol] Key to set
+      # @param value [Object] Value of the key
+      def set(key, value)
+        @settings[key] = value
+      end
+    end
+  end
+end

data/lib/cloud-config/providers/yaml_file.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  module Providers
+    # A class for fetching configuration from the AWS Parameter Store
+    #
+    # @example
+    #   provider = YamlFile.new # Assuming AWS credentials are already configured
+    #   provider.set(:example_key, :example_value)
+    #   provider.get(:example_key) #=> 'example_value'
+    class YamlFile
+      # @!attribute [r] Contents of the Yaml file
+      #   @return [Hash]
+      attr_reader :contents
+
+      # Create an instance of {YamlFile}
+      #
+      # @option params [Hash] :filename Name of the YAML file
+      def initialize(params = {})
+        @contents = YAML.load_file(params[:filename]) || {}
+      end
+
+      # Fetch the value of the key
+      #
+      # @param key [String,Symbol] Key to fetch
+      #
+      # @return [Object] Value of the key
+      def get(key)
+        contents[key]
+      end
+
+      # Set the value of the key
+      #
+      # @param key [String,Symbol] Key to set
+      # @param value [Object] Value of the key
+      def set(key, value)
+        @contents[key] = value
+      end
+    end
+  end
+end

data/lib/cloud-config/providers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  # A module for configuring providers
+  module Providers
+    # Extend {Providers::ClassMethods} when included
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods for {Providers}
+    module ClassMethods
+      # @!attribute [r] Provider configurations
+      #   @return [Hash<Symbol,ProviderConfig>]
+      attr_reader :providers
+
+      # Add a provider to the list of provider configurations.
+      #
+      # @param provider_name [Symbol] Name of the provider
+      # @param provider_options [Hash<Symbol,Object>] Options for configuring the provider
+      #
+      # @yield A block to be evaluated on an instance of {ProviderConfig}
+      def provider(provider_name, provider_options = {}, &blk)
+        provider_config = ProviderConfig.new(provider_name, provider_options)
+        provider_config.instance_eval(&blk) if blk
+        @providers ||= {}
+        @providers[provider_name] = provider_config
+      end
+    end
+  end
+end

data/lib/cloud-config/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module CloudConfig
+  # Version of CloudConfig
+  VERSION = '0.1.0'
+end

data/lib/cloud-config.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'parallel'
+
+require_relative 'cloud-config/error'
+require_relative 'cloud-config/version'
+require_relative 'cloud-config/providers'
+require_relative 'cloud-config/cache'
+require_relative 'cloud-config/provider_config'
+
+# CloudConfig handles fetching key-value configuration settings from multiple providers.
+# Configure CloudConfig to handle providers and the configuration keys.
+#
+# @example
+#   CloudConfig.configure do
+#     provider :aws_parameter_store, preload: { async: true } do
+#       setting :db_url, cache: 60
+#       setting :api_url
+#     end
+#   end
+#
+module CloudConfig
+  include Providers
+  include Cache
+
+  module_function
+
+  # Configure {CloudConfig} with providers and their configuration keys
+  #
+  # @yield Evaluate itself.
+  def configure(&)
+    instance_eval(&)
+  end
+
+  # Fetch the value of a key using the appropriate provider.
+  #
+  # @param key [String,Symbol] Key to lookup
+  #
+  # @return [Object] Value of the key
+  def get(key)
+    provider_config = providers.values.find { |provider| provider.settings.key?(key) }
+
+    raise MissingKey, 'Key not found' if provider_config.nil?
+
+    load_key(provider_config, key)
+  end
+
+  # Set the value of a key with the configured provider.
+  #
+  # @param key [String,Symobl] Key to update
+  # @param value [Object] Value of key
+  def set(key, value)
+    provider_config = providers.values.find { |provider| provider.settings.key?(key) }
+
+    raise MissingKey, 'Key not found' if provider_config.nil?
+
+    provider_config.provider.set(key, value)
+
+    cache&.set(key, value, expire_in: provider_config.settings[key][:cache])
+  end
+
+  # Fetch all keys that are configured for preloading. This will automatically
+  # cache the corresponding keys.
+  def preload
+    return if cache.nil?
+
+    providers.each_value do |provider_config|
+      next unless provider_config.provider_options.preload
+
+      if provider_config.provider_options.async_preload?
+        Parallel.each(provider_config.settings.keys) do |key|
+          load_key(provider_config, key)
+        end
+      else
+        provider_config.settings.each_key do |key|
+          load_key(provider_config, key)
+        end
+      end
+    end
+  end
+
+  # Fetch a key with the provider configuration. If caching is configured, the key
+  # will be fetched from the cache.
+  #
+  # @param provider_config [CloudConfig::ProviderConfig] provider configuration
+  # @param key [String,Symbol] Key to fetch
+  #
+  # @return [Object] Value of the key
+  def load_key(provider_config, key)
+    with_cache(key, expire_in: provider_config.settings[key][:cache]) do
+      provider_config.provider.get(key)
+    end
+  end
+
+  # Reset the {CloudConfig} configuration
+  def reset!
+    @cache = nil
+    @provider = nil
+  end
+end

data/sig/cloud-config.rbs

@@ -0,0 +1,4 @@
+module CloudConfig
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end