stackup 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81fb1c62bb5b074f520f74488f5e030fa6366729
-  data.tar.gz: ca1c7d4a8117887dacd2b5a12aeaa2184395301e
+  metadata.gz: a3d43bfd3b75ab37503b4b44933dcb086ad80351
+  data.tar.gz: 6d43253e47b02d61f549ccd6c9064046780ec71f
 SHA512:
-  metadata.gz: d3734548eb85b676c9092a6a9ac18e191ed50ed8d255431cffaecd80f475e0ee316c0ce3c77269db5138c4b022bc60c43fb088154129ab96d3876b22069a3b34
-  data.tar.gz: dfc2b36b8e57da36eadd0f36e4635fec67fa294286d74964141e89f9d6a8b36560a41cb4891777b1fed2f6e619be61d929254e464744c1d3ebd059dc7f847a16
+  metadata.gz: 2b6971f3281601543ed3ee5d088ccacc2b7069e5b46acbf5bd8d18c2a911a3db36a6bc532c04eac14660fcccd6538c7d3d8258349eb04e3541013ccb2e002ab8
+  data.tar.gz: ecb74e9962901afd46410cdace610dff8b6fbfc75efaec26c346f25f0da47866450cb065c5f75fb7a953cf2d45ed4054710760d7091ff8f723119a484b970693

data/lib/stackup/stack.rb

@@ -4,8 +4,8 @@ module Stackup
   class Stack
 
     attr_reader :stack, :name, :cf, :monitor
-    SUCESS_STATES = ["CREATE_COMPLETE", "UPDATE_COMPLETE"]
-    FAILURE_STATES = ["CREATE_FAILED", "DELETE_COMPLETE", "DELETE_FAILED", "UPDATE_ROLLBACK_FAILED", "ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED"]
+    SUCESS_STATES = ["CREATE_COMPLETE", "DELETE_COMPLETE", "UPDATE_COMPLETE"]
+    FAILURE_STATES = ["CREATE_FAILED", "DELETE_FAILED", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED", "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_FAILED"]
     END_STATES = SUCESS_STATES + FAILURE_STATES
 
     def initialize(name)
@@ -21,44 +21,47 @@ module Stackup
                                  :disable_rollback => true,
                                  :capabilities => ["CAPABILITY_IAM"],
                                  :parameters => parameters)
-      wait_till_end
+      wait_for_events
       !response[:stack_id].nil?
     end
 
-    def deploy(template, parameters = [])
-      if deployed?
-        update(template, parameters)
-      else
-        create(template, parameters)
-      end
-    rescue Aws::CloudFormation::Errors::ValidationError => e
-      puts e.message
-    end
-
     def update(template, parameters)
       return false unless deployed?
+      if stack.stack_status == "CREATE_FAILED"
+        puts "Stack is in CREATE_FAILED state so must be manually deleted before it can be updated"
+        return false
+      end
+      if stack.stack_status == "ROLLBACK_COMPLETE"
+        deleted = delete
+        return false if !deleted
+      end
       response = cf.update_stack(:stack_name => name, :template_body => template, :parameters => parameters, :capabilities => ["CAPABILITY_IAM"])
-      wait_till_end
+      wait_for_events
       !response[:stack_id].nil?
     end
 
     def delete
-      response = cf.delete_stack(:stack_name => name)
-      stack.wait_until(:max_attempts => 1000, :delay => 10) { |resource| display_events; END_STATES.include?(resource.stack_status) }
+      return false unless deployed?
+      cf.delete_stack(:stack_name => name)
+      status = wait_for_events
+      fail UpdateError, "stack delete failed" unless status == "DELETE_COMPLETE"
+      true
     rescue Aws::CloudFormation::Errors::ValidationError
       puts "Stack does not exist."
     end
 
-    def outputs
-      puts stack.outputs.flat_map { |output| "#{output.output_key} - #{output.output_value}" }
+    def deploy(template, parameters = [])
+      if deployed?
+        update(template, parameters)
+      else
+        create(template, parameters)
+      end
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      puts e.message
     end
 
-    def display_events
-      monitor.new_events.each do |e|
-        ts = e.timestamp.localtime.strftime("%H:%M:%S")
-        fields = [e.logical_resource_id, e.resource_status, e.resource_status_reason]
-        puts("[#{ts}] #{fields.compact.join(' - ')}")
-      end
+    def outputs
+      puts stack.outputs.flat_map { |output| "#{output.output_key} - #{output.output_value}" }
     end
 
     def deployed?
@@ -72,11 +75,28 @@ module Stackup
       response[:code].nil?
     end
 
+    class UpdateError < StandardError
+    end
+
     private
 
-    def wait_till_end
-      stack.wait_until(:max_attempts => 1000, :delay => 10) { |resource| display_events; END_STATES.include?(resource.stack_status) }
+    # Wait (displaying stack events) until the stack reaches a stable state.
+    #
+    def wait_for_events
+      loop do
+        display_new_events
+        status = stack_status
+        return status if status =~ /_(COMPLETE|FAILED)$/
+        sleep(poll_interval)
+      end
     end
 
+    def display_new_events
+      monitor.new_events.each do |e|
+        ts = e.timestamp.localtime.strftime("%H:%M:%S")
+        fields = [e.logical_resource_id, e.resource_status, e.resource_status_reason]
+        puts("[#{ts}] #{fields.compact.join(' - ')}")
+      end
+    end
   end
 end

data/spec/stackup/stack_spec.rb

@@ -1,81 +1,222 @@
 require "spec_helper"
 
 describe Stackup::Stack do
-  let(:stack) { Stackup::Stack.new("stack_name") }
+
+  let(:stack) { described_class.new("stack_name") }
+
+  let(:cf_stack) { instance_double("Aws::CloudFormation::Stack") }
+  let(:cf_client) { instance_double("Aws::CloudFormation::Client") }
+
   let(:template) { double(String) }
-  let(:cf_stack) { double(Aws::CloudFormation::Stack) }
-  let(:cf) { double(Aws::CloudFormation::Client) }
   let(:parameters) { [] }
 
+  let(:response) { Seahorse::Client::Http::Response.new }
+
   before do
-    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
+    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf_client)
     allow(Aws::CloudFormation::Stack).to receive(:new).and_return(cf_stack)
   end
 
-  context "deploy" do
+  describe "#create" do
+
+    subject(:created) { stack.create(template, parameters) }
 
-    it "should call create if stack is not deployed" do
-      allow(stack).to receive(:deployed?).and_return(false)
-      expect(stack).to receive(:create).and_return(true)
-      expect(stack.deploy(template, parameters)).to be true
+    before do
+      allow(cf_client).to receive(:create_stack).and_return(response)
+      allow(stack).to receive(:wait_for_events).and_return(true)
     end
-    it "should call update if stack is deployed" do
-      allow(stack).to receive(:deployed?).and_return(true)
-      expect(stack).to receive(:update).and_return(true)
-      expect(stack.deploy(template, parameters)).to be true
+
+    context "when stack gets successfully created" do
+      before do
+        allow(response).to receive(:[]).with(:stack_id).and_return("1")
+      end
+      it { expect(created).to be true }
+    end
+
+    context "when stack creation fails" do
+      before do
+        allow(response).to receive(:[]).with(:stack_id).and_return(nil)
+      end
+      it { expect(created).to be false }
     end
+
   end
 
-  context "update" do
-    it "should allow stack update" do
-      allow(cf_stack).to receive(:stack_status).and_return("1")
-      response = Seahorse::Client::Http::Response.new
-      allow(response).to receive(:[]).with(:stack_id).and_return("1")
-      allow(cf).to receive(:update_stack).and_return(response)
-      allow(cf_stack).to receive(:wait_until).and_return(true)
-      expect(stack.update(template, parameters)).to be true
+  describe "#update" do
+    subject(:updated) { stack.update(template, parameters) }
+
+    context "when there is no existing stack" do
+      before do
+        allow(stack).to receive(:deployed?).and_return(false)
+      end
+      it { expect(updated).to be false }
     end
 
-    it "should not update if the stack is not deployed" do
-      allow(cf_stack).to receive(:stack_status).and_raise(Aws::CloudFormation::Errors::ValidationError.new("1", "2"))
-      expect(stack.update(template, parameters)).to be false
+    context "when there is an existing stack" do
+      before do
+        allow(stack).to receive(:deployed?).and_return(true)
+        allow(cf_client).to receive(:update_stack).and_return(response)
+        allow(stack).to receive(:wait_for_events).and_return(true)
+      end
+
+      context "in a successfully deployed state" do
+        before do
+          allow(cf_stack).to receive(:stack_status).and_return("CREATE_COMPLETE")
+        end
+
+        context "when stack gets successfully updated" do
+          before do
+            allow(response).to receive(:[]).with(:stack_id).and_return("1")
+          end
+          it { expect(updated).to be true }
+        end
+
+        context "when stack update fails" do
+          before do
+            allow(response).to receive(:[]).with(:stack_id).and_return(nil)
+          end
+          it { expect(updated).to be false }
+        end
+      end
+
+      context "in a ROLLBACK_COMPLETE state" do
+        before do
+          allow(cf_stack).to receive(:stack_status).and_return("ROLLBACK_COMPLETE")
+        end
+
+        context "when deleting existing stack succeeds" do
+
+          it "deletes the existing stack" do
+            allow(response).to receive(:[]).with(:stack_id).and_return("1")
+            expect(stack).to receive(:delete).and_return(true)
+            stack.update(template, parameters)
+          end
+
+          context "when stack gets successfully updated" do
+            before do
+              allow(response).to receive(:[]).with(:stack_id).and_return("1")
+              allow(stack).to receive(:delete).and_return(true)
+            end
+            it { expect(updated).to be true }
+          end
+
+          context "when stack update fails" do
+            before do
+              allow(response).to receive(:[]).with(:stack_id).and_return("1")
+              allow(stack).to receive(:delete).and_return(false)
+            end
+            it { expect(updated).to be false }
+          end
+        end
+
+        context "when deleting existing stack fails" do
+          before do
+            allow(stack).to receive(:delete).and_return(false)
+          end
+          it { expect(updated).to be false }
+        end
+      end
+
+      context "in a CREATE_FAILED state" do
+        before do
+          allow(cf_stack).to receive(:stack_status).and_return("CREATE_FAILED")
+        end
+
+        it "does not try to delete the existing stack" do
+          allow(response).to receive(:[]).with(:stack_id).and_return("1")
+          expect(stack).not_to receive(:delete)
+          stack.update(template, parameters)
+        end
+
+        it "does not try to delete the existing stack" do
+          allow(response).to receive(:[]).with(:stack_id).and_return("1")
+          expect(cf_client).not_to receive(:delete_stack)
+          expect(updated).to be false
+        end
+      end
     end
   end
 
-  context "delete" do
-    it "should delete the stack if it exists?" do
-      response = double(Struct)
-      allow(cf).to receive(:delete_stack).and_return(response)
-      allow(cf_stack).to receive(:wait_until).and_return(response)
-      expect(stack.delete).to be response
+  describe "#deploy" do
+
+    subject(:deploy) { stack.deploy(template, parameters) }
+
+    context "when stack already exists" do
+
+      before do
+        allow(stack).to receive(:deployed?).and_return(true)
+        allow(cf_stack).to receive(:stack_status).and_return("CREATE_COMPLETE")
+        allow(cf_client).to receive(:update_stack).and_return({ stack_id: "stack-name" })
+      end
+
+      it "updates the stack" do
+        expect(stack).to receive(:update)
+        deploy
+      end
+    end
+
+    context "when stack does not exist" do
+
+      before do
+        allow(stack).to receive(:deployed?).and_return(false)
+        allow(cf_client).to receive(:create_stack).and_return({ stack_id: "stack-name" })
+      end
+
+      it "creates a new stack" do
+        expect(stack).to receive(:create)
+        deploy
+      end
     end
   end
 
-  context "create" do
-    let(:response) { Seahorse::Client::Http::Response.new }
-    it "should create stack if all is well" do
-      allow(response).to receive(:[]).with(:stack_id).and_return("1")
-      allow(cf).to receive(:create_stack).and_return(response)
-      allow(cf_stack).to receive(:wait_until).and_return(true)
-      expect(stack.create(template, parameters)).to be true
+
+  describe "#delete" do
+
+    subject(:deleted) { stack.delete }
+
+    context "there is no existing stack" do
+      before do
+        allow(stack).to receive(:deployed?).and_return false
+      end
+
+      it { expect(deleted).to be false }
+
+      it "does not try to delete the stack" do
+        expect(cf_client).not_to receive(:delete_stack)
+      end
     end
 
-    it "should return nil if stack was not created" do
-      allow(response).to receive(:[]).with(:stack_id).and_return(nil)
-      allow(cf).to receive(:create_stack).and_return(response)
-      allow(cf_stack).to receive(:wait_until).and_return(false)
-      expect(stack.create(template, parameters)).to be false
+    context "there is an existing stack" do
+      before do
+        allow(stack).to receive(:deployed?).and_return true
+        allow(cf_client).to receive(:delete_stack)
+      end
+
+      context "deleting the stack succeeds" do
+        before do
+          allow(stack).to receive(:wait_for_events).and_return("DELETE_COMPLETE")
+        end
+        it { expect(deleted).to be true }
+      end
+
+      context "deleting the stack fails" do
+        before do
+          allow(stack).to receive(:wait_for_events).and_return("DELETE_FAILED")
+        end
+        it { expect{ deleted }.to raise_error(Stackup::Stack::UpdateError) }
+      end
     end
   end
 
+
   context "validate" do
     it "should be valid if cf validate say so" do
-      allow(cf).to receive(:validate_template).and_return({})
+      allow(cf_client).to receive(:validate_template).and_return({})
       expect(stack.valid?(template)).to be true
     end
 
     it "should be invalid if cf validate say so" do
-      allow(cf).to receive(:validate_template).and_return(:code => "404")
+      allow(cf_client).to receive(:validate_template).and_return(:code => "404")
       expect(stack.valid?(template)).to be false
     end
 

data/stackup.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 Gem::Specification.new do |spec|
 
   spec.name          = "stackup"
-  spec.version       = "0.0.6"
+  spec.version       = "0.0.7"
   spec.authors       = ["Arvind Kunday", "Mike Williams"]
   spec.email         = ["arvind.kunday@rea-group.com", "mike.williams@rea-group.com"]
   spec.summary       = "Tools for deployment to AWS"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stackup
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Arvind Kunday
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-28 00:00:00.000000000 Z
+date: 2015-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -62,6 +62,7 @@ files:
 - pkg/stackup-0.0.4.gem
 - pkg/stackup-0.0.5.gem
 - pkg/stackup-0.0.6.gem
+- pkg/stackup-0.0.7.gem
 - sample.json
 - spec/spec_helper.rb
 - spec/stackup/monitor_spec.rb