kumo_keisei 2.1.1 → 2.2.1

data/VERSION

@@ -1 +1 @@
-2.1.1
+2.2.1

data/lib/kumo_keisei/cloud_formation_stack.rb

@@ -147,7 +147,7 @@ module KumoKeisei
     rescue Aws::CloudFormation::Errors::ValidationError => ex
       raise ex unless ex.message == "No updates are to be performed."
       ConsoleJockey.write_line "No changes need to be applied for #{@stack_name}."
-    rescue Aws::Waiters::Errors::FailureStateError => ex
+    rescue Aws::Waiters::Errors::FailureStateError
       ConsoleJockey.write_line "Failed to apply the environment update. The stack has been rolled back. It is still safe to apply updates."
       ConsoleJockey.write_line "Find error details in the AWS CloudFormation console: #{stack_events_url}"
       raise UpdateError.new("Stack update failed for #{@stack_name}.")

data/lib/kumo_keisei/environment_config.rb

@@ -5,118 +5,121 @@ require 'yaml'
 require_relative 'file_loader'
 require_relative 'parameter_builder'
 
-class KumoKeisei::EnvironmentConfig
-  LOGGER = Logger.new(STDOUT)
-
-  attr_reader :app_name, :env_name
-
-  def initialize(options, logger = LOGGER)
-    @app_name = options[:app_name]
-    @env_name = options[:env_name]
-    @config_dir_path = options[:config_dir_path]
-    @params_template_file_path = options[:params_template_file_path]
-    @injected_config = options[:injected_config] || {}
-    @file_loader = KumoKeisei::FileLoader.new(options)
-
-    @log = logger
-  end
-
-  def get_binding
-    binding
-  end
+module KumoKeisei
+  # Environment Configuration for a cloud formation stack
+  class EnvironmentConfig
+    LOGGER = Logger.new(STDOUT)
+
+    attr_reader :app_name, :env_name
+
+    def initialize(options, logger = LOGGER)
+      @app_name = options[:app_name]
+      @env_name = options[:env_name]
+      @config_dir_path = options[:config_dir_path]
+      @params_template_file_path = options[:params_template_file_path]
+      @injected_config = options[:injected_config] || {}
+      @file_loader = KumoKeisei::FileLoader.new(options)
+
+      @log = logger
+    end
 
-  def production?
-    env_name == "production"
-  end
+    def production?
+      env_name == 'production'
+    end
 
-  def development?
-    !(%w(production staging).include?(env_name))
-  end
+    def development?
+      !%w(production staging).include? env_name
+    end
 
-  def plain_text_secrets
-    @plain_text_secrets ||= decrypt_secrets(encrypted_secrets)
-  end
+    def plain_text_secrets
+      @plain_text_secrets ||= decrypt_secrets(encrypted_secrets)
+    end
 
-  def config
-    @config ||= common_config.merge(env_config).merge(@injected_config)
-  end
+    def config
+      # a hash of all settings that apply to this environment
+      @config ||= common_config.merge(env_config).merge(@injected_config)
+    end
 
-  def cf_params
-    return [] unless params_template
-    KumoKeisei::ParameterBuilder.new(get_stack_params(params_template)).params
-  end
+    def cf_params
+      # returns a list of Cfn friendly paramater_value, paramater_key pairs for
+      # consumption by cloudformation.
+      return [] unless params
+      config
 
-  private
+      stack_params = YAML.load(params.result(binding))
+      KumoKeisei::ParameterBuilder.new(stack_params).params
+    end
 
-  def kms
-    @kms ||= KumoKi::KMS.new
-  end
+    private
 
-  def get_stack_params(params_template)
-    YAML.load(ERB.new(params_template).result(get_binding))
-  end
+    def kms
+      @kms ||= KumoKi::KMS.new
+    end
 
-  def params_template
-    return nil unless @params_template_file_path
+    def params
+      return nil unless @params_template_file_path
+      @file_loader.load_erb(@params_template_file_path)
+    end
 
-    @file_loader.load_config!(@params_template_file_path)
-  end
+    def decrypt_secrets(secrets)
+      Hash[
+        secrets.map do |name, cipher_text|
+          @log.debug "Decrypting '#{name}'"
+          decrypt_cipher name, cipher_text
+        end
+      ]
+    end
 
-  def decrypt_secrets(secrets)
-    Hash[
-      secrets.map do |name, cipher_text|
-        @log.debug "Decrypting '#{name}'"
-        if cipher_text.start_with? '[ENC,'
-          begin
-            [name, "#{kms.decrypt cipher_text[5,cipher_text.size]}"]
-          rescue
-            @log.error "Error decrypting secret '#{name}'"
-            raise
-          end
-        else
-          [name, cipher_text]
+    def decrypt_cipher(name, cipher_text)
+      if cipher_text.start_with? '[ENC,'
+        begin
+          [name, kms.decrypt(cipher_text[5, cipher_text.size]).to_s]
+        rescue
+          @log.error "Error decrypting secret '#{name}'"
+          raise
         end
+      else
+        [name, cipher_text]
       end
-    ]
-  end
+    end
 
-  def env_config_file_name
-    "#{env_name}.yml"
-  end
+    def env_config_file_name
+      "#{env_name}.yml"
+    end
 
-  def env_secrets_file_name
-    "#{env_name}_secrets.yml"
-  end
+    def env_secrets_file_name
+      "#{env_name}_secrets.yml"
+    end
 
-  def encrypted_secrets
-    encrypted_common_secrets.merge(encrypted_env_secrets)
-  end
+    def encrypted_secrets
+      encrypted_common_secrets.merge(encrypted_env_secrets)
+    end
 
-  def encrypted_common_secrets
-    @file_loader.load_config('common_secrets.yml')
-  end
+    def encrypted_common_secrets
+      @file_loader.load_hash('common_secrets.yml')
+    end
 
-  def encrypted_env_secrets
-    secrets = @file_loader.load_config(env_secrets_file_name)
+    def encrypted_env_secrets
+      secrets = @file_loader.load_hash(env_secrets_file_name)
 
-    if !secrets.empty?
-      secrets
-    else
-      @file_loader.load_config('development_secrets.yml')
+      if !secrets.empty?
+        secrets
+      else
+        @file_loader.load_hash('development_secrets.yml')
+      end
     end
-  end
 
-  def common_config
-    @file_loader.load_config('common.yml')
-  end
-
-  def env_config
-    config = @file_loader.load_config(env_config_file_name)
+    def common_config
+      @file_loader.load_hash('common.yml')
+    end
 
-    if !config.empty?
-      config
-    else
-      @file_loader.load_config('development.yml')
+    def env_config
+      config = @file_loader.load_hash(env_config_file_name)
+      if !config.empty?
+        config
+      else
+        @file_loader.load_hash('development.yml')
+      end
     end
   end
 end

data/lib/kumo_keisei/file_loader.rb

@@ -4,15 +4,27 @@ module KumoKeisei
       @config_dir_path = options[:config_dir_path]
     end
 
-    def load_config!(file_name, context = nil)
-      erb_result = ERB.new(File.read(file_path(file_name))).result(context)
-      YAML.load(erb_result)
+    def load_hash(file_name, optional = true)
+      # reads a file presuming it's a yml in form of key: value, returning it as a hash
+      path = file_path(file_name)
+
+      begin
+        YAML::load(File.read(path))
+      rescue Errno::ENOENT => ex
+        # file not found, return empty dictionary if that is ok
+        return {} if optional
+        raise ex
+      rescue StandardError => ex
+        # this is an error we weren't expecting
+        raise ex
+      end
     end
 
-    def load_config(file_name)
+    def load_erb(file_name)
+      # loads a file, constructs an ERB object from it and returns the ERB object
+      # DOES NOT RENDER A RESULT!!
       path = file_path(file_name)
-      return {} unless File.exist?(path)
-      load_config!(file_name)
+      ERB.new(File.read(path))
     end
 
     private

data/lib/kumo_keisei/parameter_builder.rb

@@ -21,11 +21,11 @@ module KumoKeisei
     end
 
     def parsed_file_params
-      return [] unless (@file_path && File.exists?(@file_path))
+      return [] unless (@file_path && File.exist?(@file_path))
 
       file_contents = JSON.parse(File.read(@file_path))
 
-      file_contents.map do |param| 
+      file_contents.map do |param|
         {
           parameter_key: param["ParameterKey"],
           parameter_value: param["ParameterValue"]

data/spec/lib/kumo_keisei/environment_config_spec.rb

@@ -11,170 +11,227 @@ describe KumoKeisei::EnvironmentConfig do
     }
   end
   let(:file_loader) { instance_double(KumoKeisei::FileLoader) }
-  let(:parameter_template) { "stack_name: <%= config['stack_name'] %>" }
+  let(:parameters) { ERB.new("") }
   let(:params_template_file_path) { '/junk.txt' }
   let(:environment_config_file_name) { "#{env_name}.yml" }
   let(:kms) { instance_double(KumoKi::KMS) }
   let(:logger) { double(:test_logger, debug: nil) }
+  let(:environment_config) { described_class.new(options, logger) }
 
   before do
     allow(KumoKeisei::FileLoader).to receive(:new).and_return(file_loader)
     allow(KumoKi::KMS).to receive(:new).and_return(kms)
-    allow(file_loader).to receive(:load_config!).with(params_template_file_path).and_return(parameter_template)
+    allow(file_loader).to receive(:load_erb).with(params_template_file_path).and_return(parameters)
   end
 
-  describe '#cf_params' do
-    subject { described_class.new(options, logger).cf_params }
+  context 'unit tests' do
+    let(:fake_environment_binding) { binding }
 
-    context 'params template file path is not provided' do
-      let(:options) do
-        {
-          env_name: env_name,
-          config_dir_path: config_dir_path
-        }
-      end
-
-      it 'creates an empty array' do
-        expect(subject).to eq([])
-      end
-    end
+    describe '#cf_params' do
+      subject { environment_config.cf_params }
 
-    context 'params file is empty' do
-      let(:parameter_template) { nil }
+      context 'params template file path is not provided' do
+        let(:options) do
+          {
+            env_name: env_name,
+            config_dir_path: config_dir_path
+          }
+        end
 
-      it 'creates an empty array' do
-        expect(subject).to eq([])
+        it 'creates an empty array' do
+          expect(subject).to eq([])
+        end
       end
-    end
 
-    context 'a hard-coded param' do
-      let(:parameter_template) { "parameter_key: <%= 'parameter_value' %>" }
+      context 'params is empty' do
+        let(:parameters) { nil }
 
-      it 'creates a array containing an aws formatted parameter hash' do
-        expect(subject).to eq([{parameter_key: "parameter_key", parameter_value: "parameter_value"}])
+        it 'creates an empty array' do
+          expect(subject).to eq([])
+        end
       end
-    end
 
-    context 'templated params' do
-      let(:environment_parameters) { { "stack_name" => "okonomiyaki" } }
+      context 'a hard-coded param' do
+        let(:parameters) { ERB.new("stack_name: \"foo-stack\"") }
+        let(:parameters) { ERB.new("parameter_key: \"parameter_value\"") }
 
-      context 'environment params' do
-        it 'creates a array containing an aws formatted parameter hash' do
-          allow(file_loader).to receive(:load_config).with('common.yml').and_return({})
-          allow(file_loader).to receive(:load_config).with(environment_config_file_name).and_return(environment_parameters)
+        before do
+          allow(file_loader).to receive(:load_hash).with('common.yml').and_return({})
+          allow(file_loader).to receive(:load_hash).with('the_jungle.yml').and_return({})
+          allow(file_loader).to receive(:load_hash).with('development.yml').and_return({})
+        end
 
-          expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "okonomiyaki"}])
+        it 'creates a array containing an aws formatted parameter hash' do
+          expect(subject).to eq([{parameter_key: "parameter_key", parameter_value: "parameter_value"}])
         end
       end
-    end
-  end
 
-  describe "#config" do
-    subject { described_class.new(options, logger).config }
+      describe "#config" do
+        subject { described_class.new(options, logger).config }
 
-    context 'injected config' do
+        context 'injected config' do
 
-      let(:options) do
-        {
-          env_name: env_name,
-          config_dir_path: config_dir_path,
-          params_template_file_path: params_template_file_path,
-          injected_config: { "injected" => "yes" }
-        }
-      end
+          let(:options) do
+            {
+              env_name: env_name,
+              config_dir_path: config_dir_path,
+              params_template_file_path: params_template_file_path,
+              injected_config: { "injected" => "yes" }
+            }
+          end
 
-      let(:common_parameters) { { "stack_name" => "okonomiyaki" } }
-      it 'adds injected config to the config hash' do
-        allow(file_loader).to receive(:load_config).with('common.yml').and_return(common_parameters)
-        allow(file_loader).to receive(:load_config).with(environment_config_file_name).and_return({})
-        allow(file_loader).to receive(:load_config).with('development.yml').and_return({})
+          let(:common_parameters) { { "stack_name" => "okonomiyaki" } }
+          it 'adds injected config to the config hash' do
+            expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_parameters)
+            expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
+            expect(file_loader).to receive(:load_hash).with("development.yml").and_return({})
 
-        expect(subject).to eq({ "stack_name" => "okonomiyaki", "injected" => "yes" })
-      end
-    end
+            expect(subject).to eq({ "stack_name" => "okonomiyaki", "injected" => "yes" })
+          end
+        end
 
-    context 'common config' do
-      let(:common_parameters) { { "stack_name" => "okonomiyaki" } }
+        context 'common config' do
+          let(:common_parameters) { { "stack_name" => "okonomiyaki" } }
 
-      it 'creates a array containing an aws formatted parameter hash' do
-        allow(file_loader).to receive(:load_config).with('common.yml').and_return(common_parameters)
-        allow(file_loader).to receive(:load_config).with(environment_config_file_name).and_return({})
-        allow(file_loader).to receive(:load_config).with('development.yml').and_return({})
+          it 'creates a array containing an aws formatted parameter hash' do
+            expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_parameters)
+            expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
+            expect(file_loader).to receive(:load_hash).with("development.yml").and_return({})
 
-        expect(subject).to eq('stack_name' => 'okonomiyaki')
+            expect(subject).to eq('stack_name' => 'okonomiyaki')
+          end
+        end
+
+        context 'merging common and environment specific configurations' do
+          let(:environment_config) { {'image' => 'ami-5678'} }
+          let(:development_config) { {'image' => 'ami-9999'} }
+
+          context 'with environmental overrides' do
+            let(:parameter_template) { "image: <%= config['image'] %>" }
+            let(:common_config) { {'image' => 'ami-1234'} }
+            let(:env_name) { 'development' }
+
+            it 'replaces the common value with the env value' do
+              expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_config)
+              expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return(environment_config)
+              expect(subject).to eq('image' => 'ami-5678')
+            end
+          end
+
+          it 'falls back to a default environment if the requested one does not exist' do
+            expect(file_loader).to receive(:load_hash).with('common.yml').and_return({})
+            expect(file_loader).to receive(:load_hash).with("#{env_name}.yml").and_return({})
+            expect(file_loader).to receive(:load_hash).with("development.yml").and_return(development_config)
+
+            expect(subject).to eq('image' => 'ami-9999')
+          end
+        end
       end
-    end
 
-    context 'merging common and environment specific configurations' do
-      let(:environment_config) { {'image' => 'ami-5678'} }
+      describe "#plain_text_secrets" do
+        subject { described_class.new(options, logger).plain_text_secrets }
 
-      context 'with environmental overrides' do
-        let(:parameter_template) { "image: <%= config['image'] %>" }
-        let(:common_config) { {'image' => 'ami-1234'} }
-        let(:env_name) { 'development' }
+        let(:crypted_password) { 'lookatmyencryptedpasswords' }
+        let(:plain_text_password) { 'plain_text_password' }
+        let(:secrets) { { 'secret_password' => "[ENC,#{crypted_password}" } }
 
-        it 'replaces the common value with the env value' do
-          allow(file_loader).to receive(:load_config).with('common.yml').and_return(common_config)
-          allow(file_loader).to receive(:load_config).with('development.yml').and_return(environment_config)
+        let(:crypted_env_password) { 'cryptedenvpassword' }
+        let(:plain_text_env_password) { 'plain_text_env_password' }
+        let(:env_secrets) { { 'secret_password' => "[ENC,#{crypted_env_password}"}}
 
-          expect(subject).to eq('image' => 'ami-5678')
+        before do
+          allow(kms).to receive(:decrypt).with(crypted_password).and_return(plain_text_password)
         end
-      end
-
-      it 'falls back to a default environment if the requested one does not exist' do
-        allow(file_loader).to receive(:load_config).with('common.yml').and_return({})
-        allow(file_loader).to receive(:load_config).with("#{env_name}.yml").and_return({})
-        expect(file_loader).to receive(:load_config).with("development.yml").and_return(environment_config)
 
-        expect(subject).to eq('image' => 'ami-5678')
-      end
-    end
-  end
+        it 'decrypts common secrets' do
+          allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return(secrets)
+          allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return({})
+          allow(file_loader).to receive(:load_hash).with("development_secrets.yml").and_return({})
 
-  describe "#plain_text_secrets" do
-    subject { described_class.new(options, logger).plain_text_secrets }
-
-    let(:crypted_password) { 'lookatmyencryptedpasswords' }
-    let(:plain_text_password) { 'plain_text_password' }
-    let(:secrets) { { 'secret_password' => "[ENC,#{crypted_password}" } }
+          expect(subject).to eq('secret_password' => plain_text_password)
+        end
 
-    let(:crypted_env_password) { 'cryptedenvpassword' }
-    let(:plain_text_env_password) { 'plain_text_env_password' }
-    let(:env_secrets) { { 'secret_password' => "[ENC,#{crypted_env_password}"}}
+        it 'decrypts environment secrets' do
+          allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return({})
+          allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return(secrets)
 
-    before do
-      allow(kms).to receive(:decrypt).with(crypted_password).and_return(plain_text_password)
-    end
+          expect(subject).to eq('secret_password' => plain_text_password)
+        end
 
-    it 'decrypts common secrets' do
-      allow(file_loader).to receive(:load_config).with('common_secrets.yml').and_return(secrets)
-      allow(file_loader).to receive(:load_config).with("#{env_name}_secrets.yml").and_return({})
-      allow(file_loader).to receive(:load_config).with("development_secrets.yml").and_return({})
+        it 'gives preference to environment secrets' do
+          allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return(secrets)
+          allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return(env_secrets)
+          allow(kms).to receive(:decrypt).with(crypted_env_password).and_return(plain_text_env_password)
 
-      expect(subject).to eq('secret_password' => plain_text_password)
-    end
+          expect(subject).to eq('secret_password' => plain_text_env_password)
+        end
 
-    it 'decrypts environment secrets' do
-      allow(file_loader).to receive(:load_config).with('common_secrets.yml').and_return({})
-      allow(file_loader).to receive(:load_config).with("#{env_name}_secrets.yml").and_return(secrets)
+        it 'falls back to a default environment if the requested one does not exist' do
+          allow(file_loader).to receive(:load_hash).with('common_secrets.yml').and_return({})
+          allow(file_loader).to receive(:load_hash).with("#{env_name}_secrets.yml").and_return({})
+          expect(file_loader).to receive(:load_hash).with("development_secrets.yml").and_return(secrets)
 
-      expect(subject).to eq('secret_password' => plain_text_password)
-    end
+          expect(subject).to eq('secret_password' => plain_text_password)
+        end
+      end
 
-    it 'gives preference to environment secrets' do
-      allow(file_loader).to receive(:load_config).with('common_secrets.yml').and_return(secrets)
-      allow(file_loader).to receive(:load_config).with("#{env_name}_secrets.yml").and_return(env_secrets)
-      allow(kms).to receive(:decrypt).with(crypted_env_password).and_return(plain_text_env_password)
+      describe '#development?' do
+        %w(production staging).each do |environment|
+          it "returns false for #{environment}" do
+            expect(
+              described_class.new({
+                env_name: environment,
+                config_dir_path: '',
+                params_template_file_path: ''}
+              ).development?).to eq false
+          end
+        end
 
-      expect(subject).to eq('secret_password' => plain_text_env_password)
+        it 'returns true for anything other than production or staging' do
+          expect(
+            described_class.new({
+              env_name: 'fred',
+              config_dir_path: '',
+              params_template_file_path: ''}
+            ).development?).to eq true
+        end
+      end
     end
 
-    it 'falls back to a default environment if the requested one does not exist' do
-      allow(file_loader).to receive(:load_config).with('common_secrets.yml').and_return({})
-      allow(file_loader).to receive(:load_config).with("#{env_name}_secrets.yml").and_return({})
-      expect(file_loader).to receive(:load_config).with("development_secrets.yml").and_return(secrets)
-
-      expect(subject).to eq('secret_password' => plain_text_password)
+    context 'integration tests' do
+
+      describe '#cf_params' do
+        subject { environment_config.cf_params }
+
+        context 'templated params' do
+          let(:parameters) { ERB.new("stack_name: \"<%= config['stack_name'] %>\"" ) }
+          let(:common_config) { { "stack_name" => "common"} }
+          let(:staging_config) { { "stack_name" => "staging" } }
+          let(:development_config) { { "stack_name" => "development" } }
+
+          context 'hiearchy of parameters' do
+            it 'will load values from the common paramater file' do
+              expect(file_loader).to receive(:load_hash).with('common.yml').and_return(common_config)
+              expect(file_loader).to receive(:load_hash).with("development.yml").and_return({})
+              expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
+              expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "common"}])
+            end
+
+            it 'will load values from the environment specific file' do
+              expect(file_loader).to receive(:load_hash).with('common.yml').and_return({})
+              expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return(staging_config)
+              expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "staging"}])
+            end
+
+            it 'will load values from the shared development file if an environment specific file has no values' do
+              expect(file_loader).to receive(:load_hash).with('common.yml').and_return({})
+              expect(file_loader).to receive(:load_hash).with(environment_config_file_name).and_return({})
+              expect(file_loader).to receive(:load_hash).with("development.yml").and_return(development_config)
+              expect(subject).to eq([{parameter_key: "stack_name", parameter_value: "development"}])
+            end
+          end
+        end
+      end
     end
   end
 end