stackup 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd4fb7b89612636d7c12bf5de9df53b33d426706
-  data.tar.gz: 0efb356c797b510c3c73be0feb46f64b883ca5d7
+  metadata.gz: 018537d107f8cc0049863b56dd604f8c881217c9
+  data.tar.gz: b62b34f99958d38df0d44d4a46af577832eb4174
 SHA512:
-  metadata.gz: 6820c01014c27659f323943935b8914c17f2d77be132d5e407c696216a90dce0cc188ed8d6f1e20aaebc4fcf1142b2ced902be47de5c091677c7f1f074e24131
-  data.tar.gz: 386304c7efb13945816d072f1348ce13fc01da0d3c42a551c637c57ecadcc43baa0a3e90b83b8ad0234c71762cd550edf08a5c6dc73b2a3fb9be3344b89370f3
+  metadata.gz: fe03ddbff07fbb42c2781268e131b16dfc08942bdb5b2079d6905f58b720b091d8b7c461b6413c8b1cc42e7c080d7d560a8d2d369b0a9536b033fd9ba609304d
+  data.tar.gz: 49a82e6317772a3e32322d65bc438bdcc550b0d6f61cfdf2cc06fcfa0b258135be7247fbe6f31665a6d7b6a33b5608a54a64bcc7d7f49a479a489adf75348ad6

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    stackup (0.0.9)
+    stackup (0.1.0)
       aws-sdk (~> 2.0)
       clamp (~> 1.0)
+      console_logger
+      multi_json
 
 GEM
   remote: https://rubygems.org/
@@ -11,17 +13,17 @@ GEM
     ast (2.0.0)
     astrolabe (1.3.0)
       parser (>= 2.2.0.pre.3, < 3.0)
-    aws-sdk (2.1.21)
-      aws-sdk-resources (= 2.1.21)
-    aws-sdk-core (2.1.21)
+    aws-sdk (2.1.26)
+      aws-sdk-resources (= 2.1.26)
+    aws-sdk-core (2.1.26)
       jmespath (~> 1.0)
-    aws-sdk-resources (2.1.21)
-      aws-sdk-core (= 2.1.21)
+    aws-sdk-resources (2.1.26)
+      aws-sdk-core (= 2.1.26)
     byebug (6.0.2)
     clamp (1.0.0)
+    console_logger (1.0.0)
     diff-lcs (1.2.5)
-    jmespath (1.0.2)
-      multi_json (~> 1.0)
+    jmespath (1.1.3)
     multi_json (1.11.2)
     parser (2.2.2.5)
       ast (>= 1.1, < 3.0)

data/bin/stackup

@@ -2,6 +2,95 @@
 
 $LOAD_PATH << File.expand_path("../../lib", __FILE__)
 
-require "stackup/cli"
+require "clamp"
+require "console_logger"
+require "stackup/stack"
+require "multi_json"
+require "yaml"
 
-Stackup::CLI.run
+Clamp do
+
+  option "--debug", :flag, "enable debugging"
+
+  option ["-f", "--format"], "FORMAT", "output format", :default => "yaml"
+
+  protected
+
+  def logger
+    @logger ||= ConsoleLogger.new($stdout, debug?)
+  end
+
+  def format_data(data)
+    case format.downcase
+    when "json"
+      MultiJson.dump(data, :pretty => true)
+    when "yaml"
+      YAML.dump(data)
+    end
+  end
+
+  def display_data(data)
+    puts format_data(data)
+  end
+
+  subcommand "stack", "Manage a stack." do
+
+    parameter "NAME", "Name of stack", :attribute_name => :stack_name
+
+    def run(*args)
+      super(*args)
+    rescue Stackup::NoSuchStack => e
+      signal_error "stack '#{stack_name}' does not exist"
+    rescue Stackup::StackUpdateError => e
+      signal_error e.message
+    end
+
+    private
+
+    def stack
+      Stackup::Stack.new(stack_name, :logger => logger, :log_level => :debug)
+    end
+
+    def report_change
+      change = yield
+      puts "Stack #{change}" unless change.nil?
+    end
+
+    subcommand "status", "Print stack status." do
+
+      def execute
+        puts stack.status
+      end
+
+    end
+
+    subcommand "up", "Create/update the stack" do
+
+      parameter "TEMPLATE", "CloudFormation template (.json)", :attribute_name => :template_file
+
+      def execute
+        template = File.read(template_file)
+        report_change { stack.create_or_update(template) }
+      end
+
+    end
+
+    subcommand ["down", "delete"], "Remove the stack." do
+
+      def execute
+        report_change { stack.delete }
+      end
+
+    end
+
+    subcommand "outputs", "Stack outputs." do
+
+      def execute
+        display_data(stack.outputs)
+      end
+
+    end
+
+  end
+
+end

data/lib/stackup/errors.rb

@@ -0,0 +1,15 @@
+module Stackup
+
+  # Base Stackup Exception class
+  class ServiceError < StandardError
+  end
+
+  # Raised when the specified stack does not exist
+  class NoSuchStack < ServiceError
+  end
+
+  # Raised to indicate a problem updating a stack
+  class StackUpdateError < ServiceError
+  end
+
+end

data/lib/stackup/stack.rb

@@ -1,126 +1,192 @@
 require "aws-sdk-resources"
-require "stackup/monitor"
+require "logger"
+require "stackup/errors"
+require "stackup/stack_watcher"
 
 module Stackup
-  class Stack
 
-    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
+  # An abstraction of a CloudFormation stack.
+  #
+  class Stack
 
-    def initialize(name, client_options = {})
-      @cf = Aws::CloudFormation::Client.new
-      @stack = Aws::CloudFormation::Stack.new(:name => name, :client => cf)
-      @monitor = Stackup::Monitor.new(@stack)
-      @monitor.new_events # drain previous events
+    def initialize(name, client = {}, options = {})
+      client = Aws::CloudFormation::Client.new(client) if client.is_a?(Hash)
       @name = name
+      @cf_client = client
+      @watcher = Stackup::StackWatcher.new(cf_stack)
+      options.each do |key, value|
+        public_send("#{key}=", value)
+      end
     end
 
-    attr_reader :stack, :name, :cf, :monitor
+    attr_reader :name, :cf_client, :watcher
 
-    def status
-      stack.stack_status
-    rescue Aws::CloudFormation::Errors::ValidationError
-      nil
+    # Register a handler for reporting of stack events
+    # @param [Proc] event_handler
+    #
+    def on_event(event_handler = nil, &block)
+      event_handler ||= block
+      fail ArgumentError, "no event_handler provided" if event_handler.nil?
+      @event_handler = event_handler
     end
 
-    def exists?
-      !!status
+    # @return [String] the current stack status
+    # @raise [Stackup::NoSuchStack] if the stack doesn't exist
+    #
+    def status
+      cf_stack.stack_status
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      handle_validation_error(e)
     end
 
-    def create(template, parameters)
-      cf.create_stack(:stack_name => name,
-                      :template_body => template,
-                      :disable_rollback => true,
-                      :capabilities => ["CAPABILITY_IAM"],
-                      :parameters => parameters)
-      status = wait_for_events
-
-      fail CreateError, "stack creation failed" unless status == "CREATE_COMPLETE"
+    # @return [boolean] true iff the stack exists
+    #
+    def exists?
+      status
       true
-
-    rescue ::Aws::CloudFormation::Errors::ValidationError
-      return false
+    rescue NoSuchStack
+      false
     end
 
-    class CreateError < StandardError
+    # Create or update the stack.
+    #
+    # @param [String] template template JSON
+    # @param [Array<Hash>] parameters template parameters
+    # @return [Symbol] `:created` or `:updated` if successful
+    # @raise [Stackup::StackUpdateError] if operation fails
+    #
+    def create_or_update(template, parameters = [])
+      delete if ALMOST_DEAD_STATUSES.include?(status)
+      update(template, parameters)
+    rescue NoSuchStack
+      create(template, parameters)
     end
 
-    def update(template, parameters)
-      return false unless exists?
-      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
-      cf.update_stack(:stack_name => name, :template_body => template, :parameters => parameters, :capabilities => ["CAPABILITY_IAM"])
+    alias_method :up, :create_or_update
 
-      status = wait_for_events
-      fail UpdateError, "stack update failed" unless status == "UPDATE_COMPLETE"
-      true
+    ALMOST_DEAD_STATUSES = %w(CREATE_FAILED ROLLBACK_COMPLETE)
 
-    rescue ::Aws::CloudFormation::Errors::ValidationError => e
-      if e.message == "No updates are to be performed."
-        puts e.message
-        return false
+    # Delete the stack.
+    #
+    # @param [String] template template JSON
+    # @param [Array<Hash>] parameters template parameters
+    # @return [Symbol] `:deleted` if successful
+    # @raise [Stackup::StackUpdateError] if operation fails
+    #
+    def delete
+      return nil unless exists?
+      status = modify_stack do
+        cf_client.delete_stack(:stack_name => name)
       end
-      raise e
+      fail StackUpdateError, "stack delete failed" unless status.nil?
+    rescue NoSuchStack
+      :deleted
     end
 
-    class UpdateError < StandardError
+    alias_method :down, :delete
+
+    # Get stack outputs.
+    #
+    # @return [Hash<String, String>]
+    #   mapping of logical resource-name to physical resource-name
+    # @raise [Stackup::NoSuchStack] if the stack doesn't exist
+    #
+    def outputs
+      {}.tap do |h|
+        cf_stack.outputs.each do |output|
+          h[output.output_key] = output.output_value
+        end
+      end
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      handle_validation_error(e)
     end
 
-    def delete
-      return false unless exists?
-      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."
+    private
+
+    def create(template, parameters)
+      status = modify_stack do
+        cf_client.create_stack(
+          :stack_name => name,
+          :template_body => template,
+          :capabilities => ["CAPABILITY_IAM"],
+          :parameters => parameters
+        )
+      end
+      fail StackUpdateError, "stack creation failed" unless status == "CREATE_COMPLETE"
+      :created
     end
 
-    def deploy(template, parameters = [])
-      if exists?
-        update(template, parameters)
-      else
-        create(template, parameters)
+    def update(template, parameters)
+      status = modify_stack do
+        cf_client.update_stack(:stack_name => name, :template_body => template, :parameters => parameters, :capabilities => ["CAPABILITY_IAM"])
       end
-    rescue Aws::CloudFormation::Errors::ValidationError => e
-      puts e.message
+      fail StackUpdateError, "stack update failed" unless status == "UPDATE_COMPLETE"
+      :updated
+    rescue NoUpdateRequired
+      nil
     end
 
-    def outputs
-      puts stack.outputs.flat_map { |output| "#{output.output_key} - #{output.output_value}" }
+    def logger
+      @logger ||= (cf_client.config[:logger] || Logger.new($stdout))
     end
 
-    def valid?(template)
-      response = cf.validate_template(template)
-      response[:code].nil?
+    def cf_stack
+      Aws::CloudFormation::Stack.new(:name => name, :client => cf_client)
     end
 
-    private
+    def event_handler
+      @event_handler ||= lambda do |e|
+        fields = [e.logical_resource_id, e.resource_status, e.resource_status_reason]
+        logger.info(fields.compact.join(" - "))
+      end
+    end
+
+    # Execute a block, reporting stack events, until the stack is stable.
+    #
+    # @return the final stack status
+    #
+    def modify_stack
+      watcher.zero
+      yield
+      wait_until_stable
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      handle_validation_error(e)
+    end
 
     # Wait (displaying stack events) until the stack reaches a stable state.
     #
-    def wait_for_events
+    # @return the final stack status
+    #
+    def wait_until_stable
       loop do
-        display_new_events
-        stack.reload
+        report_new_events
+        cf_stack.reload
         return status if status.nil? || status =~ /_(COMPLETE|FAILED)$/
-        sleep(2)
+        sleep(5)
       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(' - ')}")
+    def report_new_events
+      watcher.new_events.each do |e|
+        event_handler.call(e)
+      end
+    end
+
+    def handle_validation_error(e)
+      case e.message
+      when "No updates are to be performed."
+        fail NoUpdateRequired, "no updates are required"
+      when / does not exist$/
+        fail NoSuchStack, "no such stack: #{name}"
+      else
+        raise e
       end
     end
+
+    # Raised when a stack is already up-to-date
+    class NoUpdateRequired < StandardError
+    end
+
   end
+
 end

data/lib/stackup/stack_watcher.rb

@@ -0,0 +1,41 @@
+require "aws-sdk-core"
+
+module Stackup
+
+  class StackWatcher
+
+    def initialize(stack)
+      @stack = stack
+      @processed_event_ids = Set.new
+    end
+
+    attr_accessor :stack
+
+    # Yield all events since the last call
+    #
+    def new_events
+      [].tap do |events|
+        stack.events.each do |event|
+          break if @processed_event_ids.include?(event.event_id)
+          events.unshift(event)
+          @processed_event_ids.add(event.event_id)
+        end
+      end
+    rescue ::Aws::CloudFormation::Errors::ValidationError
+      []
+    end
+
+    # Consume all new events
+    #
+    def zero
+      new_events
+      nil
+    end
+
+    private
+
+    attr_accessor :processed_event_ids
+
+  end
+
+end

data/spec/stackup/stack_spec.rb

@@ -2,234 +2,298 @@ require "spec_helper"
 
 describe Stackup::Stack do
 
-  let(:stack) { described_class.new("stack_name") }
-
-  let(:cf_stack) { instance_double("Aws::CloudFormation::Stack",
-                                  :stack_status => stack_status) }
-  let(:cf_client) { instance_double("Aws::CloudFormation::Client") }
+  let(:cf_client) do
+    client_options = { :stub_responses => true }
+    if ENV.key?("AWS_DEBUG")
+      client_options[:logger] = Logger.new(STDOUT)
+      client_options[:log_level] = :debug
+    end
+    Aws::CloudFormation::Client.new(client_options)
+  end
 
-  let(:template) { double(String) }
-  let(:parameters) { [] }
-  let(:stack_status) { nil }
+  let(:stack_name) { "stack_name" }
+  let(:unique_stack_id) { "ID:#{stack_name}" }
 
-  let(:response) { Seahorse::Client::Http::Response.new }
+  subject(:stack) { described_class.new(stack_name, cf_client) }
 
   before do
-    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf_client)
-    allow(Aws::CloudFormation::Stack).to receive(:new).and_return(cf_stack)
-    allow(cf_stack).to receive(:events).and_return([])
+    cf_client.stub_responses(:describe_stacks, *describe_stacks_responses)
+    allow(stack).to receive(:sleep).at_most(5).times
+    # partial stubbing, to support spying
+    allow(cf_client).to receive(:create_stack).and_call_original
+    allow(cf_client).to receive(:delete_stack).and_call_original
+    allow(cf_client).to receive(:update_stack).and_call_original
   end
 
-  describe "#create" do
+  def service_error(code, message)
+    {
+      :status_code => 400,
+      :headers => {},
+      :body => "<ErrorResponse><Error><Code>#{code}</Code><Message>#{message}</Message></Error></ErrorResponse>"
+    }
+  end
 
-    subject(:created) { stack.create(template, parameters) }
+  def stack_does_not_exist
+    service_error("ValidationError", "Stack with id #{stack_name} does not exist")
+  end
 
-    before do
-      allow(cf_client).to receive(:create_stack).and_return(response)
+  def no_update_required
+    service_error("ValidationError", "No updates are to be performed.")
+  end
+
+  def stack_description(stack_status)
+    {
+      :stacks => [
+        {
+          :creation_time => Time.now - 100,
+          :stack_id => unique_stack_id,
+          :stack_name => stack_name,
+          :stack_status => stack_status
+        }
+      ]
+    }
+  end
+
+  context "before stack exists" do
+
+    let(:describe_stacks_responses) do
+      [
+        stack_does_not_exist
+      ]
     end
 
-    context "when stack gets successfully created" do
-      before do
-        allow(stack).to receive(:wait_for_events).and_return("CREATE_COMPLETE")
+    describe "#exists?" do
+      it "is false" do
+        expect(stack.exists?).to be false
       end
-      it { expect(created).to be true }
     end
 
-    context "when stack creation fails" do
-      before do
-        allow(stack).to receive(:wait_for_events).and_return("CREATE_FAILED")
+    describe "#status" do
+      it "raises a NoSuchStack error" do
+        expect { stack.status }.to raise_error(Stackup::NoSuchStack)
       end
-      it { expect{ created }.to raise_error Stackup::Stack::CreateError }
     end
 
-  end
-
-  describe "#update" do
-    subject(:updated) { stack.update(template, parameters) }
-
-    context "when there is no existing stack" do
-      before do
-        allow(stack).to receive(:exists?).and_return(false)
+    describe "#delete" do
+      it "returns nil" do
+        expect(stack.delete).to be_nil
       end
-      it { expect(updated).to be false }
     end
 
-    context "when there is an existing stack" do
-      before do
-        allow(stack).to receive(:exists?).and_return(true)
-        allow(cf_client).to receive(:update_stack).and_return(response)
-        allow(stack).to receive(:wait_for_events).and_return("UPDATE_COMPLETE")
+    describe "#create_or_update" do
+
+      let(:template) { "stack template" }
+
+      def create_or_update
+        stack.create_or_update(template)
       end
 
-      context "in a successfully deployed state" do
-        before do
-          allow(cf_stack).to receive(:stack_status).and_return("CREATE_COMPLETE")
+      context "successful" do
+
+        let(:describe_stacks_responses) do
+          super() + [
+            stack_description("CREATE_IN_PROGRESS"),
+            stack_description("CREATE_COMPLETE")
+          ]
         end
 
-        context "when stack gets successfully updated" do
-          it { expect(updated).to be true }
+        it "calls :create_stack" do
+          expected_args = {
+            :stack_name => stack_name,
+            :template_body => template
+          }
+          create_or_update
+          expect(cf_client).to have_received(:create_stack)
+            .with(hash_including(expected_args))
         end
 
-        context "when stack update fails" do
-          before do
-            allow(stack).to receive(:wait_for_events).and_return("UPDATE_FAILED")
-          end
-          it { expect{ updated }.to raise_error Stackup::Stack::UpdateError }
+        it "returns :created" do
+          expect(create_or_update).to eq(:created)
         end
+
       end
 
-      context "in a ROLLBACK_COMPLETE state" do
-        before do
-          allow(cf_stack).to receive(:stack_status).and_return("ROLLBACK_COMPLETE")
+      context "unsuccessful" do
+
+        let(:describe_stacks_responses) do
+          super() + [
+            stack_description("CREATE_IN_PROGRESS"),
+            stack_description("CREATE_FAILED")
+          ]
+        end
+
+        it "raises a StackUpdateError" do
+          expect { create_or_update }
+            .to raise_error(Stackup::StackUpdateError)
         end
 
-        context "when deleting existing stack succeeds" do
+      end
 
-          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
+    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
+  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 "with existing stack" do
 
-        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
+    let(:stack_status) { "CREATE_COMPLETE" }
+
+    let(:describe_stacks_responses) do
+      [
+        stack_description(stack_status)
+      ]
+    end
+
+    describe "#exists?" do
+      it "is true" do
+        expect(stack.exists?).to be true
+      end
+    end
+
+    describe "#status" do
+      it "returns the stack status" do
+        expect(stack.status).to eq(stack_status)
       end
+    end
+
+    describe "#delete" do
 
-      context "in a CREATE_FAILED state" do
-        before do
-          allow(cf_stack).to receive(:stack_status).and_return("CREATE_FAILED")
+      context "if successful" do
+
+        let(:describe_stacks_responses) do
+          super() + [
+            stack_description("DELETE_IN_PROGRESS"),
+            stack_does_not_exist
+          ]
         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)
+        it "calls delete_stack" do
+          stack.delete
+          expect(cf_client).to have_received(:delete_stack)
+            .with(hash_including(:stack_name => stack_name))
         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
+        it "returns :deleted" do
+          expect(stack.delete).to eq(:deleted)
         end
+
       end
-    end
-  end
 
-  describe "#deploy" do
+      context "if unsuccessful" do
 
-    subject(:deploy) { stack.deploy(template, parameters) }
+        let(:describe_stacks_responses) do
+          super() + [
+            stack_description("DELETE_IN_PROGRESS"),
+            stack_description("DELETE_FAILED")
+          ]
+        end
 
-    context "when stack already exists" do
+        it "raises a StackUpdateError" do
+          expect { stack.delete }.to raise_error(Stackup::StackUpdateError)
+        end
 
-      before do
-        allow(stack).to receive(:exists?).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
+    describe "#create_or_update" do
 
-      before do
-        allow(stack).to receive(:exists?).and_return(false)
-        allow(cf_client).to receive(:create_stack).and_return({ stack_id: "stack-name" })
-      end
+      let(:template) { "stack template" }
 
-      it "creates a new stack" do
-        expect(stack).to receive(:create)
-        deploy
+      def create_or_update
+        stack.create_or_update(template)
       end
-    end
-  end
 
+      context "successful" do
 
-  describe "#delete" do
+        let(:describe_stacks_responses) do
+          super() + [
+            stack_description("UPDATE_IN_PROGRESS"),
+            stack_description("UPDATE_COMPLETE")
+          ]
+        end
 
-    subject(:deleted) { stack.delete }
+        it "calls :update_stack" do
+          expected_args = {
+            :stack_name => stack_name,
+            :template_body => template
+          }
+          create_or_update
+          expect(cf_client).to have_received(:update_stack)
+            .with(hash_including(expected_args))
+        end
 
-    context "there is no existing stack" do
-      before do
-        allow(stack).to receive(:exists?).and_return false
-      end
+        it "returns :updated" do
+          expect(create_or_update).to eq(:updated)
+        end
 
-      it { expect(deleted).to be false }
+        context "if no updates are required" do
 
-      it "does not try to delete the stack" do
-        expect(cf_client).not_to receive(:delete_stack)
-      end
-    end
+          before do
+            cf_client.stub_responses(:update_stack, no_update_required)
+          end
 
-    context "there is an existing stack" do
-      before do
-        allow(stack).to receive(:exists?).and_return true
-        allow(cf_client).to receive(:delete_stack)
-      end
+          it "returns nil" do
+            expect(create_or_update).to be_nil
+          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")
+      context "unsuccessful" do
+
+        let(:describe_stacks_responses) do
+          super() + [
+            stack_description("UPDATE_IN_PROGRESS"),
+            stack_description("UPDATE_ROLLBACK_COMPLETE")
+          ]
+        end
+
+        it "raises a StackUpdateError" do
+          expect { create_or_update }.to raise_error(Stackup::StackUpdateError)
         end
-        it { expect{ deleted }.to raise_error(Stackup::Stack::UpdateError) }
+
       end
+
     end
-  end
 
+    %w(CREATE_FAILED ROLLBACK_COMPLETE).each do |initial_status|
+      context "when status is #{initial_status}" do
 
-  context "validate" do
-    it "should be valid if cf validate say so" do
-      allow(cf_client).to receive(:validate_template).and_return({})
-      expect(stack.valid?(template)).to be true
-    end
+        let(:stack_status) { initial_status }
 
-    it "should be invalid if cf validate say so" do
-      allow(cf_client).to receive(:validate_template).and_return(:code => "404")
-      expect(stack.valid?(template)).to be false
-    end
+        describe "#create_or_update" do
 
-  end
+          let(:template) { "stack template" }
 
-  context "deployed" do
-    it "should be true if it is already deployed" do
-      allow(cf_stack).to receive(:stack_status).and_return("CREATE_COMPLETE")
-      expect(stack.exists?).to be true
-    end
+          def create_or_update
+            stack.create_or_update(template)
+          end
+
+          let(:describe_stacks_responses) do
+            super() + [
+              stack_description("DELETE_IN_PROGRESS"),
+              stack_does_not_exist,
+              stack_description("CREATE_IN_PROGRESS"),
+              stack_description("CREATE_COMPLETE")
+            ]
+          end
 
-    it "should be false if it is not deployed" do
-      allow(cf_stack).to receive(:stack_status).and_raise(Aws::CloudFormation::Errors::ValidationError.new("1", "2"))
-      expect(stack.exists?).to be false
+          before do
+            cf_client.stub_responses(:update_stack, stack_does_not_exist)
+          end
+
+          it "calls :delete_stack, then :create_stack first" do
+            create_or_update
+            expect(cf_client).to have_received(:delete_stack)
+            expect(cf_client).to have_received(:create_stack)
+          end
+
+        end
+
+      end
     end
+
   end
+
 end

data/spec/stackup/stack_watcher_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+require "stackup/stack_watcher"
+
+describe Stackup::StackWatcher do
+
+  let(:stack) { instance_double(Aws::CloudFormation::Stack, :events => events) }
+  let(:events) { [] }
+
+  subject(:monitor) { described_class.new(stack) }
+
+  def add_event(description)
+    @event_id ||= 0
+    event = instance_double(
+      Aws::CloudFormation::Event,
+      :event_id => @event_id, :resource_status_reason => description
+    )
+    events.unshift(event)
+    @event_id += 1
+  end
+
+  context "with a empty set of events" do
+
+    describe "#new_events" do
+
+      it "is empty" do
+        expect(subject.new_events).to be_empty
+      end
+
+    end
+
+  end
+
+  context "when the stack does not exist" do
+
+    before do
+      allow(stack).to receive(:events) do
+        fail Aws::CloudFormation::Errors::ValidationError.new("test", "no such stack")
+      end
+    end
+
+    describe "#new_events" do
+
+      it "is empty" do
+        expect(subject.new_events).to be_empty
+      end
+
+    end
+
+  end
+
+  def new_event_reasons
+    subject.new_events.map(&:resource_status_reason)
+  end
+
+  context "when the stack has existing events" do
+
+    before do
+      add_event("earlier")
+      add_event("later")
+    end
+
+    describe "#new_events" do
+
+      it "returns the events in the order they occurred" do
+        expect(new_event_reasons).to eq(["earlier", "later"])
+      end
+
+    end
+
+    context "and more events occur" do
+
+      before do
+        subject.new_events
+        add_event("even")
+        add_event("more")
+      end
+
+      describe "#new_events" do
+
+        it "returns only the new events" do
+          expect(new_event_reasons).to eq(["even", "more"])
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/stackup.gemspec

@@ -4,10 +4,10 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 Gem::Specification.new do |spec|
 
   spec.name          = "stackup"
-  spec.version       = "0.0.9"
+  spec.version       = "0.1.0"
   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"
+  spec.summary       = "Manage CloudFormation stacks"
   spec.homepage      = "https://github.com/realestate-com-au/stackup"
   spec.license       = "MIT"
 
@@ -17,5 +17,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "aws-sdk", "~> 2.0"
   spec.add_dependency "clamp", "~> 1.0"
+  spec.add_dependency "console_logger"
+  spec.add_dependency "multi_json"
 
 end

data/woollyams/sample-template.json

@@ -34,6 +34,46 @@
           }
         ]
       }
+    },
+    "role2": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "AssumeRolePolicyDocument": {
+          "Version" : "2012-10-17",
+          "Statement": [
+            {
+              "Effect": "Allow",
+              "Principal": {
+                "Service": [ "ec2.amazonaws.com" ]
+              },
+              "Action": [ "sts:AssumeRole" ]
+            }
+          ]
+        },
+        "Path": "/blah/",
+        "Policies": [
+          {
+            "PolicyName": "rooty",
+            "PolicyDocument": {
+              "Version" : "2012-10-17",
+              "Statement": [
+                {
+                  "Effect": "Allow",
+                  "Action": "*",
+                  "Resource": "*"
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  },
+  "Outputs": {
+    "role": {
+      "Value": {
+        "Ref": "role"
+      }
     }
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stackup
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Arvind Kunday
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-06 00:00:00.000000000 Z
+date: 2015-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -39,6 +39,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: console_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - arvind.kunday@rea-group.com
@@ -54,14 +82,15 @@ files:
 - Rakefile
 - bin/stackup
 - lib/stackup.rb
-- lib/stackup/cli.rb
-- lib/stackup/monitor.rb
+- lib/stackup/errors.rb
 - lib/stackup/stack.rb
+- lib/stackup/stack_watcher.rb
 - pkg/stackup-0.0.1.gem
 - pkg/stackup-0.0.8.gem
+- pkg/stackup-0.0.9.gem
 - spec/spec_helper.rb
-- spec/stackup/monitor_spec.rb
 - spec/stackup/stack_spec.rb
+- spec/stackup/stack_watcher_spec.rb
 - stackup.gemspec
 - woollyams/sample-template.json
 homepage: https://github.com/realestate-com-au/stackup
@@ -87,5 +116,5 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: Tools for deployment to AWS
+summary: Manage CloudFormation stacks
 test_files: []

data/lib/stackup/cli.rb

@@ -1,54 +0,0 @@
-require "clamp"
-require "json"
-require "stackup/stack"
-
-module Stackup
-
-  class CLI < Clamp::Command
-
-    subcommand "stack", "Manage a stack." do
-
-      parameter "NAME", "Name of stack", :attribute_name => :stack_name
-
-      private
-
-      def stack
-        Stackup::Stack.new(stack_name)
-      end
-
-      subcommand "status", "Print stack status." do
-
-        def execute
-          puts stack.status
-        end
-
-      end
-
-      subcommand "deploy", "Create/update the stack" do
-
-        parameter "TEMPLATE", "CloudFormation template (.json)", :attribute_name => :template_file
-
-        def execute
-          template = File.read(template_file)
-          stack.deploy(template)
-        end
-
-      end
-
-      subcommand "delete", "Remove the stack." do
-        def execute
-          stack.delete
-        end
-      end
-
-      subcommand "outputs", "Stack outputs." do
-        def execute
-          stack.outputs
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/stackup/monitor.rb

@@ -1,33 +0,0 @@
-require "aws-sdk-core"
-
-module Stackup
-  class Monitor
-
-    attr_accessor :stack, :events
-    def initialize(stack)
-      @stack = stack
-      @events = Set.new
-    end
-
-    def new_events
-      stack.events.take_while do |event|
-        !seen?(event)
-      end.reverse
-    rescue ::Aws::CloudFormation::Errors::ValidationError => e
-      []
-    end
-
-    private
-
-    def seen?(event)
-      event_id = event.id
-      if events.include?(event_id)
-        true
-      else
-        events.add(event_id)
-        false
-      end
-    end
-
-  end
-end

data/spec/stackup/monitor_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe Stackup::Monitor do
-
-  let(:stack) { instance_double(Aws::CloudFormation::Stack, :events => events) }
-  let(:monitor) { described_class.new(stack) }
-
-  let(:event) { instance_double(Aws::CloudFormation::Event, :id => "1") }
-  let(:events) { [event] }
-
-  before do
-    allow(event).to receive(:event_id).and_return("1")
-  end
-
-  it "should add the event if it is non-existent" do
-    expect(monitor.new_events.size).to eq(1)
-  end
-
-  it "should skip the event if it has been shown" do
-    expect(monitor.new_events.size).to eq(1)
-    expect(monitor.new_events.size).to eq(0)
-  end
-
-end