cf_deployer 1.3.9 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d5da90ce16ae1b8de132cba6d1359e3a643d4c9
-  data.tar.gz: 8d34ac5950b1ce737da92f384c86dc72a0b8128c
+  metadata.gz: 6ff8335edd7be5ca468d0a45f6cf614f401cbdce
+  data.tar.gz: ceecfb7632c801761d0b655f87a147ce181dfd1f
 SHA512:
-  metadata.gz: 05f26ca292c10038313d724d7a24e5b875179aa41f986fa0b757bd7ea16038cd65fa585950bf18282bde4db042dede93dbc7e2d5fe1b6c1f3749bdceab967f12
-  data.tar.gz: 843e008b514878929b1a1d2802ae2b42b5fe638acc9898f7ca6bdb0d11af0c52d8db541fad2c55f331988dac1ac2b57cd25ca866ccd322607ea3a284ed885635
+  metadata.gz: 330695b0672d8af04459a26eb04973cf11e3f95415d453743fb9fed6d269530633bb876d37527e366b990d3980628c3778db8715cfbf9ac40e00eae35b6fecfc
+  data.tar.gz: 7416a2d5697ef2d66fcd89b556c1adb902e299f4acfa84c36746c51694d775b8898b39d751485cd50e73666f79e08e79d09f6a37331922809468ef1e09630fb7

data/.travis.yml

@@ -8,6 +8,8 @@ rvm:
   - jruby-19mode
   - jruby-9.0.1.0
   - rbx-2
+before_install:
+  - gem install bundler
 matrix:
   allow_failures:
     - rvm: ruby-head

data/ChangeLog.md

@@ -22,10 +22,10 @@ version 1.2.10
   - Update DETAILS.md
 
 version 1.2.11
-  - Remove record set in R53 when stacks are deployed 
+  - Remove record set in R53 when stacks are deployed
 
 version 1.3.1
-  - Adding way to run hooks manually (outside of deploy)   
+  - Adding way to run hooks manually (outside of deploy)
   - Adding new command 'diff' to allow diffing between the deployed JSON
   - Split after-create and after-update hooks for create-or-update strategy
 
@@ -50,3 +50,7 @@ version 1.3.8
 version 1.3.9
   - Allow new ASGs to be added to template (See: https://github.com/manheim/cf_deployer/issues/31)
 
+version 1.4.0
+  - Merge settings from parent component when given (https://github.com/manheim/cf_deployer/pull/37)
+  - Added support for stack policies (https://github.com/manheim/cf_deployer/pull/40)
+  - Fix broken Travis builds with newer version of bundler (https://github.com/manheim/cf_deployer/pull/42)

data/DETAILS.md

@@ -82,6 +82,18 @@ Used by the gem for blue/green deployments and naming conventions
     * keep-previous-stack (True/False: for Cname-Swap and Auto Scaling Group Swap, previous stack will be kept after new stack is created by default. Set it to false to delete the previous stack)
     * raise-error-for-unused-inputs (True/False: it is false by default. If it is set to true, errors will be thrown if there are any inputs which are not used as parameters of CloudFormation json templates. If it is set to false or the setting does not exist, warnings will be printed in the console if there are un-used inputs.)
     * auto-scaling-group-name-output
+    * create-stack-policy: The name of the stack policy to be used during the
+      creation of the component stack.  The location of the policy json file is
+      assumed to be "config/{create-stack-policy}.json". The intended use of
+      this setting is to make it persistent by placing it in your
+      `cf_deployer.yml` file.
+    * override-stack-policy: The name of the override stack policy to be used
+      during an update of the component stack.  The location of the policy json
+      file is assumed to be "config/{override-stack-policy}.json".  Since the
+      override policy is only used occasionally to override the
+      `create-stack-policy`, the intended use of this setting is for it to be
+      called via the `--settings` cli flag, v.s. being persistently set in the
+      config file.
   * **For Components Using the Cname-Swap Deployment Strategy**
     * dns-fqdn (DNS record set name, for example, myApp.api.abc.com)
     * dns-zone (DNS hosted zone, for example, api.abc.com)

data/lib/cf_deployer/component.rb

@@ -35,7 +35,7 @@ module CfDeployer
     def json
       resolve_settings
       puts "#{name} json template:"
-      puts ConfigLoader.component_json(name, @context)
+      puts ConfigLoader.erb_to_json(name, @context)
     end
 
     def diff
@@ -43,7 +43,7 @@ module CfDeployer
       current_json = strategy.active_template
       if current_json
         puts "#{name} json template diff:"
-        new_json = ConfigLoader.component_json(name, @context)
+        new_json = ConfigLoader.erb_to_json(name, @context)
         Diffy::Diff.default_format = :color
         puts Diffy::Diff.new( current_json, new_json )
       else
@@ -100,8 +100,9 @@ module CfDeployer
 
     def resolve_settings
       inputs.each do |key, value|
-        if(value.is_a? Hash)
+        if(value.is_a?(Hash) && value.key?(:component))
           dependency = @dependencies.find { |d| d.name == value[:component] }
+          raise "No component '#{value[:component]}' found when attempting to derive input '#{key}'" unless dependency
           output_key = value[:'output-key']
           inputs[key] = dependency.output_value(output_key)
         end

data/lib/cf_deployer/config_loader.rb

@@ -1,10 +1,10 @@
 module CfDeployer
   class ConfigLoader
 
-    def self.component_json component, config
-      json_file = File.join(config[:config_dir], "#{component}.json")
+    def self.erb_to_json filename, config
+      json_file = File.join(config[:config_dir], "#{filename}.json")
       raise ApplicationError.new("#{json_file} is missing") unless File.exists?(json_file)
-      CfDeployer::Log.info "ERBing JSON for #{component}"
+      CfDeployer::Log.info "ERBing JSON for #{filename}"
       ERB.new(File.read(json_file)).result(binding)
     rescue RuntimeError,TypeError,NoMethodError => e
       self.new.send :error_document, File.read(json_file)
@@ -112,6 +112,8 @@ module CfDeployer
         if component[:settings][:'keep-previous-stack'] == nil
           component[:settings][:'keep-previous-stack'] = Defaults::KeepPreviousStack
         end
+        component[:settings][:'create-stack-policy'] ||= Defaults::CreateStackPolicy
+        component[:settings][:'override-stack-policy'] ||= Defaults::OverrideStackPolicy
       end
     end
 
@@ -131,7 +133,7 @@ module CfDeployer
         end
       end
 
-      json_content = self.class.component_json component.to_s, config
+      json_content = self.class.erb_to_json component.to_s, config
       CfDeployer::Log.info "Parsing JSON for #{component}"
       begin
         JSON.load json_content

data/lib/cf_deployer/config_validation.rb

@@ -21,7 +21,6 @@ module CfDeployer
 
     private
 
-
     def check_asg_name_output(component)
       component[:settings][:'auto-scaling-group-name-output'] ||= []
       outputs = component[:settings][:'auto-scaling-group-name-output'].map { |name| name.to_sym }

data/lib/cf_deployer/defaults.rb

@@ -6,5 +6,7 @@ module CfDeployer
     DNSDriver = 'CfDeployer::Driver::Route53'
     RaiseErrorForUnusedInputs = false
     KeepPreviousStack = true
+    CreateStackPolicy = nil
+    OverrideStackPolicy = nil
   end
 end

data/lib/cf_deployer/stack.rb

@@ -17,13 +17,25 @@ module CfDeployer
 
     def deploy
       config_dir = @context[:config_dir]
-      template = CfDeployer::ConfigLoader.component_json(@component, @context)
+      template = CfDeployer::ConfigLoader.erb_to_json(@component, @context)
       capabilities = @context[:capabilities] || []
       notify = @context[:notify] || []
       tags = @context[:tags] || {}
       params = to_str(@context[:inputs].select{|key, value| @context[:defined_parameters].keys.include?(key)})
       CfDeployer::Driver::DryRun.guard "Skipping deploy" do
-        exists? ? update_stack(template, params, capabilities, tags) : create_stack(template, params, capabilities, tags, notify)
+        if exists?
+          override_policy_json = nil
+          unless @context[:settings][:'override-stack-policy'].nil?
+            override_policy_json = CfDeployer::ConfigLoader.erb_to_json(@context[:settings][:'override-stack-policy'], @context)
+          end
+          update_stack(template, params, capabilities, tags, override_policy_json)
+        else
+          create_policy_json = nil
+          unless @context[:settings][:'create-stack-policy'].nil?
+            create_policy_json = CfDeployer::ConfigLoader.erb_to_json(@context[:settings][:'create-stack-policy'], @context)
+          end
+          create_stack(template, params, capabilities, tags, notify, create_policy_json)
+        end
       end
     end
 
@@ -106,22 +118,32 @@ module CfDeployer
       hash.each { |k,v| hash[k] = v.to_s }
     end
 
-    def update_stack(template, params, capabilities, tags)
+    def update_stack(template, params, capabilities, tags, override_policy_json)
       Log.info "Updating stack #{@stack_name}..."
-      @cf_driver.update_stack template,
-                              :capabilities => capabilities,
-                              :parameters => params
+      args = {
+        :capabilities => capabilities,
+        :parameters => params
+      }
+      unless override_policy_json.nil?
+        args[:stack_policy_during_update_body] = override_policy_json
+      end
+      @cf_driver.update_stack(template, args)
       wait_for_stack_op_terminate
     end
 
-    def create_stack(template, params, capabilities, tags, notify)
+    def create_stack(template, params, capabilities, tags, notify, create_policy_json)
       Log.info "Creating stack #{@stack_name}..."
-      @cf_driver.create_stack template,
-                              :disable_rollback => true,
-                              :capabilities => capabilities,
-                              :notify => notify,
-                              :tags => reformat_tags(tags),
-                              :parameters => params
+      args = {
+        :disable_rollback => true,
+        :capabilities => capabilities,
+        :notify => notify,
+        :tags => reformat_tags(tags),
+        :parameters => params
+      }
+      unless create_policy_json.nil?
+        args[:stack_policy_body] = create_policy_json
+      end
+      @cf_driver.create_stack(template, args)
       wait_for_stack_op_terminate
     end
 

data/lib/cf_deployer/version.rb

@@ -1,3 +1,3 @@
 module CfDeployer
-  VERSION = "1.3.9"
+  VERSION = "1.4.0"
 end

data/spec/unit/component_spec.rb

@@ -12,13 +12,17 @@ describe "component" do
             :'vpc-subnets' => {
               :component => 'base',
               :'output-key' => 'subnets'
+            },
+            :'nested-hash' => {
+              :foo => 'foo value',
+              :bar => 'bar value'
             }
            }
           }
     @base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
     @db = CfDeployer::Component.new('myApp', 'uat', 'db', {})
 
-    @web = CfDeployer::Component.new('myApp', 'uat', 'web', @context)
+    @web = CfDeployer::Component.new('myApp', 'uat', 'component', @context)
     @web.dependencies << @base
     @web.dependencies << @db
     @base.children << @web
@@ -30,13 +34,39 @@ describe "component" do
     it 'should revolve settings from parent components if parent components has been deployed' do
       allow(@base).to receive(:exists?){ true }
       allow(@base).to receive(:output_value).with('subnets') { 'abcd1234, edfas1234' }
-      expect(CfDeployer::ConfigLoader).to receive(:component_json).with('web', @context)
+      expect(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('component', @context)
       @web.json
 
       expect(@context[:inputs][:'vpc-subnets']).to eq('abcd1234, edfas1234')
     end
-  end
 
+    it 'should not attempt to resolve settings from referenced component unless component is specified' do
+      expected = {
+          :foo => 'foo value',
+          :bar => 'bar value'
+      }
+      allow(@base).to receive(:output_value).with('subnets') { 'abcd1234, edfas1234' }
+      expect(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('component', @context)
+      @web.json
+
+      expect(@context[:inputs][:'nested-hash']).to eq(expected)
+    end
+
+    it 'should provide a descriptive error message when referenced component does not exist' do
+      context = {
+          :inputs => {
+              :some_key => {
+                  :component => 'blah',
+                  :'output-key' => 'referenced_key'
+              }
+          }
+      }
+      expected_message = "No component 'blah' found when attempting to derive input 'some_key'"
+
+      component = CfDeployer::Component.new('myApp', 'uat', 'component', context)
+      expect {component.json}.to raise_error(expected_message)
+    end
+  end
 
   it "should destroy component" do
     expect(@strategy).to receive(:destroy)
@@ -72,7 +102,7 @@ describe "component" do
   end
 
   it "should find direct dependencies" do
-    web = CfDeployer::Component.new('myApp', 'uat', 'web', {})
+    web = CfDeployer::Component.new('myApp', 'uat', 'component', {})
     base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
     web.dependencies << base
 
@@ -80,7 +110,7 @@ describe "component" do
   end
 
   it "should find transitive dependencies" do
-    web = CfDeployer::Component.new('myApp', 'uat', 'web', {})
+    web = CfDeployer::Component.new('myApp', 'uat', 'component', {})
     haproxy = CfDeployer::Component.new('myApp', 'uat', 'haproxy', {})
     base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
 
@@ -91,7 +121,7 @@ describe "component" do
   end
 
   it "should find cyclic dependency" do
-    web = CfDeployer::Component.new('myApp', 'uat', 'web', {})
+    web = CfDeployer::Component.new('myApp', 'uat', 'component', {})
     haproxy = CfDeployer::Component.new('myApp', 'uat', 'haproxy', {})
     base = CfDeployer::Component.new('myApp', 'uat', 'base', {})
     foo = CfDeployer::Component.new('myApp', 'uat', 'foo', {})
@@ -127,7 +157,7 @@ describe "component" do
       it 'should raise an error that there is no stack for the component' do
         allow(@strategy).to receive(:exists?) { false }
         expect(@strategy).not_to receive(:switch)
-        expect { @web.switch }.to raise_error 'No stack exists for component: web'
+        expect { @web.switch }.to raise_error 'No stack exists for component: component'
       end
     end
 

data/spec/unit/config_loader_spec.rb

@@ -329,13 +329,13 @@ environments:
 
   it "should ERB the component JSON and make the parsed template available" do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file, :environment => 'DrWho')
-    CfDeployer::ConfigLoader.component_json('json-with-erb', config[:components][:'json-with-erb']).should include('DrWho')
+    CfDeployer::ConfigLoader.erb_to_json('json-with-erb', config[:components][:'json-with-erb']).should include('DrWho')
   end
 
   it 'should use error_document to show the broken document when parsing broken ERB' do
     config = { :config_dir => File.dirname(@config_file) }
     CfDeployer::ConfigLoader.any_instance.should_receive(:error_document)
-    expect { CfDeployer::ConfigLoader.component_json('broken_erb', config) }.to raise_error
+    expect { CfDeployer::ConfigLoader.erb_to_json('broken_erb', config) }.to raise_error
   end
 
   it 'should use error_document to show the broken document when parsing broken json' do

data/spec/unit/stack_spec.rb

@@ -1,23 +1,30 @@
 require 'spec_helper'
 
 describe CfDeployer::Stack do
-    before do
-      @cf_driver = double CfDeployer::Driver::CloudFormation
-      @stack = CfDeployer::Stack.new('test', 'web', {:cf_driver => @cf_driver})
-    end
+  before do
+    @cf_driver = double CfDeployer::Driver::CloudFormation
+    @stack = CfDeployer::Stack.new('test', 'web', {:cf_driver => @cf_driver})
+    @config = {
+      :inputs => { :foo => :bar, :goo => :hoo },
+      :tags => { :app => 'app1', :env => 'dev'},
+      :defined_parameters => { :foo => 'bar' },
+      :notify => ['topic1_arn', 'topic2_arn'],
+      :cf_driver => @cf_driver,
+      :settings => {
+        'create-stack-policy' => nil,
+        'override-stack-policy' => nil
+      }
+    }
+  end
 
   context '#deploy' do
-    it 'should call CfDeployer::ConfigLoader.component_json to get the JSON for the stack' do
-      config = { :inputs => { :foo => :bar, :goo => :hoo },
-                 :tags => { :app => 'app1', :env => 'dev'},
-                 :defined_parameters => { :foo => 'bar' },
-                 :notify => ['topic1_arn', 'topic2_arn'],
-                 :cf_driver => @cf_driver }
-      template = { :resourses => {}}
-      allow(CfDeployer::ConfigLoader).to receive(:component_json).with('web', config).and_return(template)
+    it 'creates a stack, when it doesnt exist' do
+      template = { :resources => {}}
+      allow(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('web', @config).and_return(template)
       allow(@cf_driver).to receive(:stack_exists?) { false }
       allow(@cf_driver).to receive(:stack_status) { :create_complete }
-      expected_opt = { :disable_rollback => true,
+      expected_opt = {
+        :disable_rollback => true,
         :capabilities => [],
         :notify => ['topic1_arn', 'topic2_arn'],
         :tags => [{'Key' => 'app', 'Value' => 'app1'},
@@ -25,9 +32,64 @@ describe CfDeployer::Stack do
         :parameters => {:foo => 'bar'}
       }
       expect(@cf_driver).to receive(:create_stack).with(template, expected_opt)
-      stack = CfDeployer::Stack.new('test','web', config)
+      stack = CfDeployer::Stack.new('test','web', @config)
+      stack.deploy
+    end
+
+    it 'creates a stack using a policy when defined' do
+      template = { :resources => {}}
+      create_policy = { :Statement => [] }
+      @config[:settings][:'create-stack-policy'] = 'create-policy'
+      allow(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('web', @config).and_return(template)
+      allow(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('create-policy', @config).and_return(create_policy)
+      allow(@cf_driver).to receive(:stack_exists?) { false }
+      allow(@cf_driver).to receive(:stack_status) { :create_complete }
+      expected_opt = {
+        :disable_rollback => true,
+        :capabilities => [],
+        :notify => ['topic1_arn', 'topic2_arn'],
+        :tags => [{'Key' => 'app', 'Value' => 'app1'},
+                  {'Key' => 'env', 'Value' => 'dev'}],
+        :parameters => {:foo => 'bar'},
+        :stack_policy_body => create_policy
+      }
+      expect(@cf_driver).to receive(:create_stack).with(template, expected_opt)
+      stack = CfDeployer::Stack.new('test','web', @config)
       stack.deploy
     end
+
+    it 'updates a stack, when it exists' do
+      template = { :resources => {}}
+      allow(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('web', @config).and_return(template)
+      allow(@cf_driver).to receive(:stack_exists?) { true }
+      allow(@cf_driver).to receive(:stack_status) { :create_complete }
+      expected_opt = {
+        :capabilities => [],
+        :parameters => {:foo => 'bar'}
+      }
+      expect(@cf_driver).to receive(:update_stack).with(template, expected_opt)
+      stack = CfDeployer::Stack.new('test','web', @config)
+      stack.deploy
+    end
+
+    it 'updates a stack using the override policy, when defined' do
+      template = { :resources => {}}
+      override_policy = { :Statement => [] }
+      @config[:settings][:'override-stack-policy'] = 'override-policy'
+      allow(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('web', @config).and_return(template)
+      allow(CfDeployer::ConfigLoader).to receive(:erb_to_json).with('override-policy', @config).and_return(override_policy)
+      allow(@cf_driver).to receive(:stack_exists?) { true }
+      allow(@cf_driver).to receive(:stack_status) { :create_complete }
+      expected_opt = {
+        :capabilities => [],
+        :parameters => {:foo => 'bar'},
+        :stack_policy_during_update_body => override_policy
+      }
+      expect(@cf_driver).to receive(:update_stack).with(template, expected_opt)
+      stack = CfDeployer::Stack.new('test','web', @config)
+      stack.deploy
+    end
+
   end
 
   context '#parameters' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cf_deployer
 version: !ruby/object:Gem::Version
-  version: 1.3.9
+  version: 1.4.0
 platform: ruby
 authors:
 - Jame Brechtel
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-09 00:00:00.000000000 Z
+date: 2016-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk