aws2-ssm-env 0.1.1

data/lib/aws-ssm-env/loader.rb

@@ -0,0 +1,67 @@
+require 'aws-ssm-env/fetchers/factory'
+require 'aws-ssm-env/naming_strategies/factory'
+
+module AwsSsmEnv
+  # このgemのエントリポイントとなるクラス。メイン処理を行う。
+  # AWS EC2 Parameters Storeからパラメータを取得してENVに書き込む。
+  #
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class Loader
+    # メイン処理。引数の詳細は AwsSsmEnv#load を参照。
+    def self.load(**args)
+      new(args).load
+    end
+
+    def initialize(**args)
+      parse_options(args)
+      if @logger
+        @logger.debug("#{self.class.name} overwrite: #{@overwrite}")
+        @logger.debug("#{self.class.name} fetcher: #{@fetcher}")
+        @logger.debug("#{self.class.name} naming_strategy: #{@naming_strategy}")
+      end
+    end
+
+    def load
+      @fetcher.each do |parameter|
+        var_name = @naming_strategy.parse_name(parameter)
+        @logger.debug("#{self.class.name} #{parameter.name} parameter value into ENV['#{var_name}']") if @logger
+        send(@applier, var_name, parameter.value)
+      end
+    end
+
+    private
+
+    def parse_options(**options)
+      @logger = options[:logger]
+      @fetcher = AwsSsmEnv::FetcherFactory.create_fetcher(options)
+      @naming_strategy = AwsSsmEnv::NamingStrategyFactory.create_naming_strategy(options)
+      @overwrite = overwrite?(options)
+      if @overwrite
+        @applier = :apply!
+      else
+        @applier = :apply
+      end
+    end
+
+    # overwriteフラグが指定されているかどうかを返す。
+    def overwrite?(overwrite: nil, **)
+      if overwrite.nil?
+        false
+      else
+        overwrite.to_s.downcase == 'true'
+      end
+    end
+
+    def apply(name, value)
+      if ENV[name]
+        return
+      end
+      apply!(name, value)
+    end
+
+    def apply!(name, value)
+      ENV[name] = value
+    end
+  end
+end

data/lib/aws-ssm-env/naming_strategies/basename.rb

@@ -0,0 +1,19 @@
+require 'aws-ssm-env/naming_strategy'
+
+module AwsSsmEnv
+  # 環境変数名にパラメータ名の階層表現のbasenameを利用するようにするNamingStrategy実装クラス。
+  # AwsSsmEnv#load で`naming`を指定しなかった場合にはこのクラスのインスタンスが利用される。
+  # 例えば、`/path/to/ENV_NAME`というパラメータ名であればENV['ENV_NAME']にパラメータ値がインジェクションされる。
+  #
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class BasenameNamingStrategy < NamingStrategy
+    # @see AwsSsmEnv::NamingStrategy#parse_name
+    #
+    # パラメータ名の最後の階層を変数名として返す。
+    # @return [String] 環境変数名
+    def parse_name(parameter)
+      File.basename(parameter.name)
+    end
+  end
+end

data/lib/aws-ssm-env/naming_strategies/factory.rb

@@ -0,0 +1,68 @@
+require 'aws-ssm-env/naming_strategy'
+
+module AwsSsmEnv
+  # 環境変数名を導出するためのNamingStrategyクラスを取得もしくは生成するファクトリクラス。
+  #
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class NamingStrategyFactory
+    BASENAME_STRATEGY = :basename
+    SNAKE_CASE_STRATEGY = :snakecase
+
+    class << self
+      # 環境変数名を導出するためのNamingStrategyクラスを取得もしくは生成する。
+      #
+      # @param [Hash] args AwsSsmEnv#load に渡された引数がそのまま渡される。
+      # @option args [Symbol, AwsSsmEnv::NamingStrategy, Object] naming
+      #   引数の詳細は AwsSsmEnv#load の説明を参照。
+      def create_naming_strategy(**args)
+        naming_strategy = args[:naming]
+        if naming_strategy.nil?
+          return default_strategy(args)
+        end
+        case naming_strategy
+        when BASENAME_STRATEGY
+          create_basename_strategy(args)
+        when SNAKE_CASE_STRATEGY
+          create_snakecase_strategy(args)
+        else
+          unknown_naming_strategy(naming_strategy)
+        end
+      end
+
+      private
+
+      def default_strategy(**args)
+        create_basename_strategy(args)
+      end
+
+      def create_basename_strategy(**args)
+        require 'aws-ssm-env/naming_strategies/basename'
+        AwsSsmEnv::BasenameNamingStrategy.new(args)
+      end
+
+      def create_snakecase_strategy(**args)
+        require 'aws-ssm-env/naming_strategies/snakecase'
+        AwsSsmEnv::SnakeCaseNamingStrategy.new(args)
+      end
+
+      def unknown_naming_strategy(naming_strategy)
+        unless naming_strategy_instance?(naming_strategy)
+          raise ArgumentError, 'Possible values for :naming are either :basename, :snakecase, ' \
+                + '"AwsSsmEnv::NamingStrategy" implementation class, an object with "parse_name" method.'
+        end
+        naming_strategy
+      end
+
+      def naming_strategy_instance?(object)
+        if object.is_a?(AwsSsmEnv::NamingStrategy)
+          true
+        elsif object.respond_to?(:parse_name)
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/aws-ssm-env/naming_strategies/snakecase.rb

@@ -0,0 +1,58 @@
+require 'aws-ssm-env/naming_strategy'
+
+module AwsSsmEnv
+  # パラメータ名の階層表現をスネークケースに変換した値を環境変数名とする。
+  # 例えば、`removed_prefix`が`/path`で`/path/to/environment_name`というパラメータ名なら
+  # ENV['TO_ENVIRONMENT_NAME']にパラメータ値がインジェクションされる。
+  #
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class SnakeCaseNamingStrategy < NamingStrategy
+    # ここの引数は AwsSsmEnv#load の呼び出し時に渡された引数がそのまま渡される。
+    #
+    # @param [Hash] args AwsSsmEnv#load の呼び出し時に渡された引数。
+    # @option args [String] :removed_prefix
+    #   パラメータ名から除去するプレフィクス。この文字列は導出される環境変数名に含まない。
+    #   :removed_prefixが指定されておらず、:begins_with または :path が指定されていた場合はそれを利用する。 TODO: AwsSsmEnv#loadとREADMEに反映
+    # @option args [String, Regexp] :delimiter
+    #   アンダースコアに変換する区切り文字。デフォルトはスラッシュ('/')。 TODO: AwsSsmEnv#loadとREADMEに反映
+    def initialize(**args)
+      @logger = args[:logger]
+      @delimiter = detect_delimiter(args)
+      removed_prefix = detect_prefix(args).sub(%r{/\z}, '')
+      @removed_prefix = /\A#{Regexp.escape(removed_prefix)}/
+      @logger.debug("#{self.class.name} removed_prefix is #{@removed_prefix}") if @logger
+    end
+
+    # @see AwsSsmEnv::NamingStrategy#parse_name
+    #
+    # パラメータ名からプレフィクスを除去してパス区切りをアンダースコアに変換後、大文字にして返す。
+    # @return [String] 環境変数名
+    def parse_name(parameter)
+      name_without_prefix = parameter.name.gsub(@removed_prefix, '')
+      name_without_prefix.gsub(@delimiter, '_').upcase
+    end
+
+    private
+
+    def detect_delimiter(**args)
+      if args[:delimiter].nil?
+        '/'
+      else
+        args[:delimiter]
+      end
+    end
+
+    def detect_prefix(**args)
+      if args[:removed_prefix]
+        args[:removed_prefix]
+      elsif args[:begins_with]
+        args[:begins_with]
+      elsif args[:path]
+        args[:path]
+      else
+        ''
+      end
+    end
+  end
+end

data/lib/aws-ssm-env/naming_strategy.rb

@@ -0,0 +1,23 @@
+module AwsSsmEnv
+  # パラメータの値を設定する環境変数名を決定するためのStrategyクラス。
+  # 実装クラスを AwsSsmEnv#load の引数で`naming`パラメータとして渡すことにより
+  # インジェクションされる環境変数名の命名ルールを切り替えられるようにする。
+  #
+  # @abstract
+  # @author Ryohei Sonoda
+  # @since 0.1.0
+  class NamingStrategy
+    # ここの引数は AwsSsmEnv#load の呼び出し時に渡された引数がそのまま渡される。
+    # サブクラスでは必要に応じて使う引数をインスタンス変数に保持しておく。
+    #
+    # @param [Hash] ** AwsSsmEnv#load の呼び出し時に渡された引数。
+    def initialize(**); end
+
+    # パラメータから環境変数名を導出するメソッド。
+    # @abstract
+    # @return [String] 環境変数名
+    def parse_name(_parameter)
+      raise NotImplementedError, 'parse_name'
+    end
+  end
+end

data/lib/aws-ssm-env/version.rb

@@ -0,0 +1,3 @@
+module AwsSsmEnv
+  VERSION = '0.1.1'.freeze
+end

data/spec/aws-ssm-env/fetcher_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe AwsSsmEnv::Fetcher do
+  let(:fetcher) { described_class.new(args) }
+  let(:args) { {} }
+  let(:client) { fetcher.send(:client) }
+  let(:ssm_client_args) {
+    {
+      access_key_id: 'access_key_id',
+      secret_access_key: 'secret_access_key'
+    }
+  }
+
+  describe '#initialize' do
+    context 'when decryption was not set' do
+      it 'with_decryption is true' do
+        expect(fetcher.send(:with_decryption)).to be_truthy
+      end
+    end
+
+    context 'when decryption is nil' do
+      let(:args) { { decryption: nil } }
+
+      it 'with_decryption is true' do
+        expect(fetcher.send(:with_decryption)).to be_truthy
+      end
+    end
+
+    context 'when decryption is truthy string' do
+      let(:args) { { decryption: 'TrUe' } }
+
+      it 'with_decryption is true' do
+        expect(fetcher.send(:with_decryption)).to be_truthy
+      end
+    end
+
+    context 'when decryption is not truthy string' do
+      let(:args) { { decryption: 'foo' } }
+
+      it 'with_decryption is false' do
+        expect(fetcher.send(:with_decryption)).to be_falsey
+      end
+    end
+
+    context 'when client was not set' do
+      context 'when ssm_client_args was set' do
+        let(:args) { { ssm_client_args: ssm_client_args } }
+
+        it 'client is initialized by ssm_client_args' do
+          expect(client.config[:access_key_id]).to eq('access_key_id')
+          expect(client.config[:secret_access_key]).to eq('secret_access_key')
+        end
+      end
+
+      context 'when ssm_client_args was not set' do
+        it 'client is default construction' do
+          expect(client.config[:access_key_id]).to be_nil
+        end
+      end
+    end
+
+    context 'when client was set' do
+      context 'when client is instance of Aws::SSM::Client' do
+        let(:ssm_client) { Aws::SSM::Client.new }
+        let(:args) { { client: ssm_client } }
+
+        it 'client is equals to args[:client]' do
+          expect(client).to eq(ssm_client)
+        end
+      end
+
+      context 'when client is not instance of Aws::SSM::Client' do
+        let(:ssm_client) { 'foo' }
+        let(:args) { { client: ssm_client, ssm_client_args: ssm_client_args } }
+
+        it 'client is not equals to args[:client] and client is initialized by ssm_client_args' do
+          expect(client).not_to eq(ssm_client)
+          expect(client.config[:access_key_id]).to eq('access_key_id')
+          expect(client.config[:secret_access_key]).to eq('secret_access_key')
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+    let(:parameters) { [ Parameter.new('foo', 'foo'), Parameter.new('bar', 'bar') ] }
+    let(:fetcher) {
+      mock_class = Class.new(described_class) do
+        def initialize(response); @response = response; end
+        protected def fetch(_); @response; end
+      end
+      mock_class.new(dummy_response)
+    }
+
+    context 'when fetch returns empty parameters at first' do
+      let(:dummy_response) { AwsSsmEnv::FetchResult::EMPTY }
+
+      it 'consumer is not called' do
+        called = false
+        fetcher.each do |_|
+          called = true
+        end
+        expect(called).to be_falsey
+      end
+    end
+
+    context 'when fetch returns two parameters at first and empty next_token' do
+      let(:dummy_response) { AwsSsmEnv::FetchResult.new(parameters, nil) }
+
+      it 'consumer is called twice' do
+        called = 0
+        fetcher.each do |_|
+          called += 1
+        end
+        expect(called).to eq(2)
+      end
+    end
+
+    context 'when fetch returns two parameters and next_token at first, fetch returns two parameters and empty next_token at second' do
+      let(:fetcher) {
+        mock_class = Class.new(described_class) do
+          def initialize(parameters); @parameters = parameters; @count = 0; end
+          protected def fetch(_)
+            if @count == 0
+              @count = 1
+              AwsSsmEnv::FetchResult.new(@parameters, 'next_token')
+            else
+              AwsSsmEnv::FetchResult.new(@parameters, nil)
+            end
+          end
+        end
+        mock_class.new(parameters)
+      }
+
+      it 'consumer is called four times' do
+        called = 0
+        fetcher.each do |_|
+          called += 1
+        end
+        expect(called).to eq(4)
+      end
+    end
+  end
+
+  describe '#fetch' do
+    it 'raise error' do
+      expect { fetcher.send(:fetch, 'next_token') }.to raise_error(NotImplementedError)
+    end
+  end
+end
+
+describe AwsSsmEnv::FetchResult do
+  describe '#initialize' do
+    subject { described_class.new([], 'next_token') }
+
+    it { is_expected.to have_attributes(parameters: [], next_token: 'next_token') }
+  end
+end

data/spec/aws-ssm-env/fetchers/begins_with_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'aws-ssm-env/fetchers/begins_with'
+
+describe AwsSsmEnv::BeginsWithFetcher do
+  let(:fetcher) { described_class.new(args) }
+  let(:args) { { begins_with: [ '/foo', '/bar' ] } }
+  let(:base_params) { fetcher.instance_variable_get(:'@base_params') }
+  let(:parameter_filter) { base_params[:parameter_filters][0] }
+
+  describe '#initialize' do
+    context 'when :begins_with was not set' do
+      it 'raise error' do
+        expect { described_class.new(begins_with: nil) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when :begins_with is Array' do
+      it 'parameter_filter[:values] is begins_with value' do
+        expect(parameter_filter[:values]).to eq(args[:begins_with])
+      end
+    end
+
+    context 'when :begins_with is not Array' do
+      let(:args) { { begins_with: '/foo' } }
+
+      it 'parameter_filter[:values] is [ begins_with value ]' do
+        expect(parameter_filter[:values]).to eq([ args[:begins_with] ])
+      end
+    end
+
+    context 'when :fetch_size was set and less than 50' do
+      let(:args) { { begins_with: '/foo', fetch_size: 49 } }
+
+      it '@base_params[:max_results] is fetch_size value' do
+        expect(base_params[:max_results]).to eq(49)
+      end
+    end
+
+    context 'when :fetch_size was not set' do
+      let(:args) { { begins_with: '/foo', fetch_size: nil } }
+
+      it '@base_params[:max_results] is 50' do
+        expect(base_params[:max_results]).to eq(50)
+      end
+    end
+
+    context 'when :fetch_size > 50' do
+      let(:args) { { begins_with: '/foo', fetch_size: 51 } }
+
+      it '@base_params[:max_results] is 50' do
+        expect(base_params[:max_results]).to eq(50)
+      end
+    end
+  end
+
+  describe '#fetch' do
+    let(:client) { fetcher.send(:client) }
+
+    context 'when describe_parameters return empty parameters' do
+      before do
+        allow_any_instance_of(Aws::SSM::Client).to \
+          receive(:describe_parameters).and_return(AwsSsmEnv::FetchResult::EMPTY)
+      end
+
+      it 'return AwsSsmEnv::FetchResult::EMPTY' do
+        expect(fetcher.send(:fetch, nil)).to eq(AwsSsmEnv::FetchResult::EMPTY)
+      end
+
+      context 'when next_token is nil' do
+        it 'called describe_parameters without next_token' do
+          expect(fetcher.send(:fetch, nil)).to eq(AwsSsmEnv::FetchResult::EMPTY)
+          expect(client).to \
+            have_received(:describe_parameters).with(base_params).once
+        end
+      end
+
+      context 'when next_token is not nil' do
+        it 'called get_parameters_by_path with next_token' do
+          expect(fetcher.send(:fetch, 'next_token')).to eq(AwsSsmEnv::FetchResult::EMPTY)
+          expect(client).to have_received(:describe_parameters)
+            .with(base_params.merge(next_token: 'next_token')).once
+        end
+      end
+    end
+
+    context 'when describe_parameters return not empty parameters' do
+      let!(:dummy_parameters) { [ Parameter.new('foo'), Parameter.new('bar') ] }
+      let!(:dummy_response) { AwsSsmEnv::FetchResult.new(dummy_parameters, 'next_token') }
+
+      before do
+        allow_any_instance_of(Aws::SSM::Client).to \
+          receive(:describe_parameters).and_return(dummy_response)
+        allow_any_instance_of(Aws::SSM::Client).to \
+          receive(:get_parameters).and_return(dummy_response)
+      end
+
+      it 'return parameters' do
+        response = fetcher.send(:fetch, 'next_token')
+        expect(response.parameters).to eq(dummy_response.parameters)
+        expect(response.next_token).to eq(dummy_response.next_token)
+        expect(client).to have_received(:get_parameters)
+          .with(names: dummy_parameters.map(&:name), with_decryption: true).once
+      end
+    end
+  end
+end