global 1.1.0 → 2.0.0

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'global'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/global.gemspec

@@ -9,10 +9,8 @@ Gem::Specification.new do |s|
   s.authors = ['Railsware LLC']
   s.email = 'contact@railsware.com'
 
-  s.rubyforge_project = 'global'
-
-  s.description = 'Simple way to load your configs from yaml'
-  s.summary = 'Simple way to load your configs from yaml'
+  s.description = 'Simple way to load your configs from yaml/aws/gcp'
+  s.summary = 'Simple way to load your configs from yaml/aws/gcp'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -22,15 +20,12 @@ Gem::Specification.new do |s|
   s.homepage = 'https://github.com/railsware/global'
   s.licenses = ['MIT']
 
+  s.add_development_dependency 'aws-sdk-ssm', '~> 1'
+  s.add_development_dependency 'google-cloud-secret_manager', '~> 0'
   s.add_development_dependency 'rake',      '~> 12.3.1'
   s.add_development_dependency 'rspec',     '>= 3.0'
-  s.add_development_dependency 'rubocop',   '~> 0.57'
+  s.add_development_dependency 'rubocop',   '~> 0.81.0'
   s.add_development_dependency 'simplecov', '~> 0.16.1'
-  if defined?(JRUBY_VERSION)
-    s.add_development_dependency 'therubyrhino', '>= 0'
-  else
-    s.add_development_dependency 'therubyracer', '>= 0'
-  end
 
   s.add_runtime_dependency 'activesupport', '>= 2.0'
 end

data/lib/global.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'date'
 require 'yaml'
 
 require 'active_support/core_ext/hash/indifferent_access'
@@ -7,7 +8,6 @@ require 'active_support/core_ext/hash/deep_merge'
 
 require 'global/configuration'
 require 'global/base'
-require 'global/engine' if defined?(Rails)
 require 'global/version'
 
 module Global

data/lib/global/backend/aws_parameter_store.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Global
+  module Backend
+    # Loads Global configuration from the AWS Systems Manager Parameter Store
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html
+    #
+    # This backend requires the `aws-sdk` or `aws-sdk-ssm` gem, so make sure to add it to your Gemfile.
+    #
+    # Available options:
+    # - `prefix` (required): the prefix in Parameter Store; all parameters within the prefix will be loaded;
+    #   make sure to add a trailing slash, if you want it
+    #   see https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-su-organize.html
+    # - `client`: pass you own Aws::SSM::Client instance, or alternatively set:
+    # - `aws_options`: credentials and other AWS configuration options that are passed to AWS::SSM::Client.new
+    #   see https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SSM/Client.html#initialize-instance_method
+    #   If AWS access is already configured through environment variables,
+    #   you don't need to pass the credentials explicitly.
+    #
+    # For Rails:
+    # - the `prefix` is optional and defaults to `/[Rails enviroment]/[Name of the app class]/`,
+    #    for example: `/production/MyApp/`
+    # - to use a different app name, pass `app_name`,
+    #    for example: `backend :aws_parameter_store, app_name: 'new_name_for_my_app'`
+    class AwsParameterStore
+
+      PATH_SEPARATOR = '/'
+
+      def initialize(options = {})
+        require_aws_gem
+        init_prefix(options)
+        init_client(options)
+      end
+
+      def load
+        build_configuration_from_parameters(load_all_parameters_from_ssm)
+      end
+
+      private
+
+      def require_aws_gem
+        require 'aws-sdk-ssm'
+      rescue LoadError
+        begin
+          require 'aws-sdk'
+        rescue LoadError
+          raise 'Either the `aws-sdk-ssm` or `aws-sdk` gem must be installed.'
+        end
+      end
+
+      def init_prefix(options)
+        @prefix = if defined?(Rails)
+                    options.fetch(:prefix) do
+                      environment = Rails.env.to_s
+                      app_name = options.fetch(:app_name) { Rails.application.class.module_parent_name }
+                      "/#{environment}/#{app_name}/"
+                    end
+                  else
+                    options.fetch(:prefix)
+                  end
+      end
+
+      def init_client(options)
+        if options.key?(:client)
+          @ssm = options[:client]
+        else
+          aws_options = options.fetch(:aws_options, {})
+          @ssm = Aws::SSM::Client.new(aws_options)
+        end
+      end
+
+      def load_all_parameters_from_ssm
+        response = load_parameters_from_ssm
+        all_parameters = response.parameters
+        loop do
+          break unless response.next_token
+
+          response = load_parameters_from_ssm(response.next_token)
+          all_parameters.concat(response.parameters)
+        end
+
+        all_parameters
+      end
+
+      def load_parameters_from_ssm(next_token = nil)
+        @ssm.get_parameters_by_path(
+          path: @prefix,
+          recursive: true,
+          with_decryption: true,
+          next_token: next_token
+        )
+      end
+
+      # builds a nested configuration hash from the array of parameters from SSM
+      def build_configuration_from_parameters(parameters)
+        configuration = {}
+        parameters.each do |parameter|
+          parameter_parts = parameter.name[@prefix.length..-1].split(PATH_SEPARATOR).map(&:to_sym)
+          param_container = parameter_parts[0..-2].reduce(configuration) do |container, part|
+            container[part] ||= {}
+          end
+          param_container[parameter_parts[-1]] = parameter.value
+        end
+
+        configuration
+      end
+
+    end
+  end
+end

data/lib/global/backend/filesystem.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Global
+  module Backend
+    # Loads Global configuration from the filesystem
+    #
+    # Available options:
+    # - `directory` (required): the directory with config files
+    # - `environment` (required): the environment to load
+    # - `yaml_whitelist_classes`: the set of classes that are permitted to unmarshal from the configuration files
+    #
+    # For Rails:
+    # - the `directory` is optional and defaults to `config/global`
+    # - the `environment` is optional and defaults to the current Rails environment
+    class Filesystem
+
+      FILE_ENV_SPLIT = '.'
+      YAML_EXT = '.yml'
+
+      def initialize(options = {})
+        if defined?(Rails)
+          @path = options.fetch(:path) { Rails.root.join('config', 'global').to_s }
+          @environment = options.fetch(:environment) { Rails.env.to_s }
+        else
+          @path = options.fetch(:path)
+          @environment = options.fetch(:environment)
+        end
+        @yaml_whitelist_classes = options.fetch(:yaml_whitelist_classes, [])
+      end
+
+      def load
+        load_from_path(@path)
+      end
+
+      private
+
+      def load_from_path(path)
+        load_from_file(path).deep_merge(load_from_directory(path))
+      end
+
+      def load_from_file(path)
+        config = {}
+
+        if File.exist?(file = "#{path}#{YAML_EXT}")
+          configurations = load_yml_file(file)
+          config = get_config_by_key(configurations, 'default')
+          config.deep_merge!(get_config_by_key(configurations, @environment))
+          if File.exist?(env_file = "#{path}#{FILE_ENV_SPLIT}#{@environment}#{YAML_EXT}")
+            config.deep_merge!(load_yml_file(env_file) || {})
+          end
+        end
+
+        config
+      end
+
+      def get_config_by_key(config, key)
+        return {} if config.empty?
+
+        config[key.to_sym] || config[key.to_s] || {}
+      end
+
+      def load_yml_file(file)
+        YAML.safe_load(
+          ERB.new(IO.read(file)).result,
+          [Date, Time, DateTime, Symbol].concat(@yaml_whitelist_classes),
+          [], true
+        )
+      end
+
+      def load_from_directory(path)
+        config = {}
+
+        if File.directory?(path)
+          Dir["#{path}/*"].each do |entry|
+            namespace = File.basename(entry, YAML_EXT)
+            next if namespace.include? FILE_ENV_SPLIT # skip files with dot(s) in name
+
+            file_with_path = File.join(File.dirname(entry), File.basename(entry, YAML_EXT))
+            config.deep_merge!(namespace => load_from_path(file_with_path))
+          end
+        end
+
+        config
+      end
+
+    end
+  end
+end

data/lib/global/backend/gcp_secret_manager.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Global
+  module Backend
+    # Loads Global configuration from the Google Cloud Secret Manager
+    # https://cloud.google.com/secret-manager/docs
+    #
+    # This backend requires the `google-cloud-secret_manager` gem, so make sure to add it to your Gemfile.
+    #
+    # Available options:
+    # - `project_id` (required): Google Cloud project name
+    # - `prefix` (required): the prefix in Secret Manager; all parameters within the prefix will be loaded;
+    #   make sure to add a undescore, if you want it
+    #   see https://cloud.google.com/secret-manager/docs/overview
+    # - `client`: pass you own Google::Cloud::SecretManager instance, or alternatively set:
+    # - `gcp_options`: credentials and other Google cloud configuration options
+    #   that are passed to Google::Cloud::SecretManager.configure
+    #   see https://googleapis.dev/ruby/google-cloud-secret_manager/latest/index.html
+    #   If Google Cloud access is already configured through environment variables,
+    #   you don't need to pass the credentials explicitly.
+    #
+    # For Rails:
+    # - the `prefix` is optional and defaults to `[Rails enviroment]-[Name of the app class]-`,
+    #    for example: `production-myapp-`
+    # - to use a different app name, pass `app_name`,
+    #    for example: `backend :gcp_secret_manager, app_name: 'new_name_for_my_app'`
+    class GcpSecretManager
+
+      GCP_SEPARATOR = '/'
+      PATH_SEPARATOR = '-'
+
+      def initialize(options = {})
+        @project_id = options.fetch(:project_id)
+        require_gcp_gem
+        init_prefix(options)
+        init_client(options)
+      end
+
+      def load
+        pages = load_all_parameters_from_gcsm
+
+        configuration = {}
+        pages.each do |page|
+          configuration.deep_merge!(build_configuration_from_page(page))
+        end
+
+        configuration
+      end
+
+      private
+
+      def require_gcp_gem
+        require 'google/cloud/secret_manager'
+      rescue LoadError
+        raise 'The `google-cloud-secret_manager` gem must be installed.'
+      end
+
+      def init_prefix(options)
+        @prefix = if defined?(Rails)
+                    options.fetch(:prefix) do
+                      environment = Rails.env.to_s
+                      app_name = options.fetch(:app_name) { Rails.application.class.module_parent_name }
+                      "#{environment}-#{app_name}-"
+                    end
+                  else
+                    options.fetch(:prefix)
+                  end
+      end
+
+      def init_client(options)
+        if options.key?(:client)
+          @gcsm = options[:client]
+        else
+          gcp_options = options.fetch(:gcp_options, {})
+          @gcsm = Google::Cloud::SecretManager.secret_manager_service do |config|
+            config.credentials = gcp_options[:credentials] if gcp_options[:credentials]
+            config.timeout = gcp_options[:timeout] if gcp_options[:timeout]
+          end
+        end
+      end
+
+      def load_all_parameters_from_gcsm
+        response = load_parameters_from_gcsm
+        all_pages = [response]
+        loop do
+          break if response.next_page_token.empty?
+
+          response = load_parameters_from_gcsm(response.next_page_token)
+          all_pages << response
+        end
+
+        all_pages
+      end
+
+      def load_parameters_from_gcsm(next_token = nil)
+        @gcsm.list_secrets(
+          parent: @gcsm.project_path(project: @project_id),
+          page_size: 25_000,
+          page_token: next_token
+        )
+      end
+
+      # builds a nested configuration hash from the array of parameters from Secret Manager
+      def build_configuration_from_page(page)
+        configuration = {}
+
+        page.each do |parameter|
+          key_name = get_gcp_key_name(parameter)
+          next unless key_name.start_with?(@prefix)
+
+          parameter_parts = key_name[@prefix.length..-1].split(PATH_SEPARATOR).map(&:to_sym)
+          param_container = parameter_parts[0..-2].reduce(configuration) do |container, part|
+            container[part] ||= {}
+          end
+          param_container[parameter_parts[-1]] = get_latest_key_value(key_name)
+        end
+
+        configuration
+      end
+
+      def get_gcp_key_name(parameter)
+        parameter.name.split(GCP_SEPARATOR).last
+      end
+
+      def get_latest_key_value(key_name)
+        name = @gcsm.secret_version_path(
+          project:        @project_id,
+          secret:         key_name,
+          secret_version: 'latest'
+        )
+        version = @gcsm.access_secret_version(name: name)
+        version.payload.data
+      end
+
+    end
+  end
+end

data/lib/global/base.rb

@@ -6,19 +6,21 @@ require 'json'
 module Global
   module Base
 
-    FILE_ENV_SPLIT = '.'
-    YAML_EXT = '.yml'
-
     extend self
 
-    attr_writer :environment, :config_directory, :namespace, :except, :only, :yaml_whitelist_classes
-
     def configure
       yield self
     end
 
     def configuration
-      @configuration ||= load_configuration(config_directory, environment)
+      raise 'Backend must be defined' unless @backends
+
+      @configuration ||= begin
+        configuration_hash = @backends.reduce({}) do |configuration, backend|
+          configuration.deep_merge(backend.load.with_indifferent_access)
+        end
+        Configuration.new(configuration_hash)
+      end
     end
 
     def reload!
@@ -26,93 +28,45 @@ module Global
       configuration
     end
 
-    def environment
-      @environment || raise('environment should be defined')
-    end
-
-    def config_directory
-      @config_directory || raise('config_directory should be defined')
-    end
-
-    def namespace
-      @namespace ||= 'Global'
-    end
-
-    def except
-      @except ||= :all
-    end
-
-    def only
-      @only ||= []
-    end
-
-    def yaml_whitelist_classes
-      @yaml_whitelist_classes ||= []
-    end
-
-    def generate_js(options = {})
-      current_namespace = options[:namespace] || namespace
-
-      js_options = { except: except, only: only }.merge(options)
-      "window.#{current_namespace} = #{configuration.filter(js_options).to_json}"
-    end
-
-    protected
-
-    def load_configuration(dir, env)
-      config = load_from_file(dir, env)
-      config.deep_merge!(load_from_directory(dir, env))
-      Configuration.new(config)
-    end
-
-    def load_from_file(dir, env)
-      config = {}
-
-      if File.exist?(file = "#{dir}#{YAML_EXT}")
-        configurations = load_yml_file(file)
-        config = get_config_by_key(configurations, 'default')
-        config.deep_merge!(get_config_by_key(configurations, env))
-        if File.exist?(env_file = "#{dir}#{FILE_ENV_SPLIT}#{env}#{YAML_EXT}")
-          config.deep_merge!(load_yml_file(env_file) || {})
-        end
+    # Add a backend to load configuration from.
+    #
+    # You can define several backends; they will all be loaded
+    # and the configuration hashes will be merged.
+    #
+    # Configure with either:
+    #   Global.backend :filesystem, directory: 'config', environment: Rails.env
+    # or:
+    #   Global.backend YourConfigurationBackend.new
+    #
+    # backend configuration classes MUST have a `load` method that returns a configuration Hash
+    def backend(backend, options = {})
+      @backends ||= []
+      if backend.is_a?(Symbol)
+        require "global/backend/#{backend}"
+        backend_class = Global::Backend.const_get(camel_case(backend.to_s))
+        @backends.push backend_class.new(options)
+      elsif backend.respond_to?(:load)
+        @backends.push backend
+      else
+        raise 'Backend must be either a Global::Backend class or a symbol'
       end
-
-      config
-    end
-
-    def get_config_by_key(config, key)
-      config[key.to_sym] || config[key.to_s] || {}
-    end
-
-    def load_yml_file(file)
-      YAML.safe_load(
-        ERB.new(IO.read(file)).result,
-        [Date, Time, DateTime, Symbol].concat(yaml_whitelist_classes),
-        [], true
-      )
     end
 
-    def load_from_directory(dir, env)
-      config = {}
-
-      if File.directory?(dir)
-        Dir["#{dir}/*"].each do |entry|
-          namespace = File.basename(entry, YAML_EXT)
-          next if namespace.include? FILE_ENV_SPLIT # skip files with dot(s) in name
-          file_with_path = File.join(File.dirname(entry), File.basename(entry, YAML_EXT))
-          config.deep_merge!(namespace => load_configuration(file_with_path, env))
-        end
-      end
-
-      config
-    end
+    protected
 
     def respond_to_missing?(method, include_private = false)
       configuration.key?(method) || super
     end
 
     def method_missing(method, *args, &block)
-      configuration.key?(method) ? configuration[method] : super
+      configuration.key?(method) ? configuration.get_configuration_value(method) : super
+    end
+
+    # from Bundler::Thor::Util.camel_case
+    def camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+
+      str.split('_').map(&:capitalize).join
     end
 
   end