stack_master 0.2.0 → 0.3.0

data/lib/stack_master/commands/validate.rb

@@ -10,7 +10,7 @@ module StackMaster
       end
 
       def perform
-        failed unless Validator.valid?(@stack_definition)
+        failed unless Validator.valid?(@stack_definition, @config)
       end
     end
   end

data/lib/stack_master/config.rb

@@ -14,7 +14,8 @@ module StackMaster
                   :base_dir,
                   :stack_defaults,
                   :region_defaults,
-                  :region_aliases
+                  :region_aliases,
+                  :template_compilers,
 
     def self.search_up_and_chdir(config_file)
       return config_file unless File.dirname(config_file) == "."
@@ -41,6 +42,7 @@ module StackMaster
       end
       @region_defaults = normalise_region_defaults(config.fetch('region_defaults', {}))
       @stacks = []
+      @template_compilers = default_template_compilers
       load_config
     end
 
@@ -61,6 +63,13 @@ module StackMaster
 
     private
 
+    def default_template_compilers
+      {
+        rb: :sparkle_formation,
+        json: :json,
+      }
+    end
+
     def load_config
       unaliased_stacks = resolve_region_aliases(@config.fetch('stacks'))
       load_stacks(unaliased_stacks)

data/lib/stack_master/paged_response_accumulator.rb

@@ -0,0 +1,29 @@
+module StackMaster
+  class PagedResponseAccumulator
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(cf, method, arguments, accumulator_method)
+      @cf = cf
+      @method = method
+      @arguments = arguments
+      @accumulator_method = accumulator_method
+    end
+
+    def call
+      book = []
+      next_token = nil
+      first_response = nil
+      begin
+        response = @cf.public_send(@method, @arguments.merge(next_token: next_token))
+        first_response = response if first_response.nil?
+        next_token = response.next_token
+        book += response.public_send(@accumulator_method)
+      end while !next_token.nil?
+      first_response.send("#{@accumulator_method}=", book.reverse)
+      first_response.send(:next_token=, book.reverse)
+      first_response
+    end
+  end
+end

data/lib/stack_master/parameter_loader.rb

@@ -1,10 +1,13 @@
 module StackMaster
   class ParameterLoader
     def self.load(parameter_files)
+      StackMaster.debug "Searching for parameter files..."
       parameter_files.reduce({}) do |hash, file_name|
         parameters = if File.exists?(file_name)
+         StackMaster.debug "  #{file_name} found"
           YAML.load(File.read(file_name)) || {}
         else
+         StackMaster.debug "  #{file_name} not found"
           {}
         end
         parameters.each do |key, value|

data/lib/stack_master/stack.rb

@@ -40,6 +40,12 @@ module StackMaster
       template_default_parameters.merge(parameters)
     end
 
+    def missing_parameters?
+      parameters_with_defaults.any? do |key, value|
+        value == nil
+      end
+    end
+
     def self.find(region, stack_name)
       cf = StackMaster.cloud_formation_driver
       cf_stack = cf.describe_stacks(stack_name: stack_name).stacks.first
@@ -67,7 +73,7 @@ module StackMaster
 
     def self.generate(stack_definition, config)
       parameter_hash = ParameterLoader.load(stack_definition.parameter_files)
-      template_body = TemplateCompiler.compile(stack_definition.template_file_path)
+      template_body = TemplateCompiler.compile(config, stack_definition.template_file_path)
       parameters = ParameterResolver.resolve(config, stack_definition, parameter_hash)
       stack_policy_body = if stack_definition.stack_policy_file_path
                             File.read(stack_definition.stack_policy_file_path)

data/lib/stack_master/stack_events/fetcher.rb

@@ -31,14 +31,7 @@ module StackMaster
       end
 
       def fetch_events
-        events = []
-        next_token = nil
-        begin
-          response = cf.describe_stack_events(stack_name: @stack_name, next_token: next_token)
-          next_token = response.next_token
-          events += response.stack_events
-        end while !next_token.nil?
-        events.reverse
+        PagedResponseAccumulator.call(cf, :describe_stack_events, { stack_name: @stack_name }, :stack_events).stack_events
       end
     end
   end

data/lib/stack_master/template_compiler.rb

@@ -1,21 +1,25 @@
 module StackMaster
   class TemplateCompiler
 
-    MAX_TEMPLATE_SIZE = 51200
+    def self.compile(config, template_file_path)
+      template_compiler_for_file(template_file_path, config).compile(template_file_path)
+    end
+
+    def self.register(name, klass)
+      @compilers ||= {}
+      @compilers[name] = klass
+    end
+
+    # private
+    def self.template_compiler_for_file(template_file_path, config)
+      compiler_name = config.template_compilers.fetch(file_ext(template_file_path))
+      @compilers.fetch(compiler_name)
+    end
+    private_class_method :template_compiler_for_file
 
-    def self.compile(template_file_path)
-      if template_file_path.ends_with?('.rb')
-        SparkleFormation.sparkle_path = File.dirname(template_file_path)
-        JSON.pretty_generate(SparkleFormation.compile(template_file_path))
-      else
-        template_body = File.read(template_file_path)
-        if template_body.size > MAX_TEMPLATE_SIZE
-          # Parse the json and rewrite compressed
-          JSON.dump(JSON.parse(template_body))
-        else
-          template_body
-        end
-      end
+    def self.file_ext(template_file_path)
+      File.extname(template_file_path).gsub('.', '').to_sym
     end
+    private_class_method :file_ext
   end
 end

data/lib/stack_master/template_compilers/json.rb

@@ -0,0 +1,18 @@
+module StackMaster::TemplateCompilers
+  class Json
+    MAX_TEMPLATE_SIZE = 51200
+    private_constant :MAX_TEMPLATE_SIZE
+
+    def self.compile(template_file_path)
+      template_body = File.read(template_file_path)
+      if template_body.size > MAX_TEMPLATE_SIZE
+        # Parse the json and rewrite compressed
+        JSON.dump(JSON.parse(template_body))
+      else
+        template_body
+      end
+    end
+
+    StackMaster::TemplateCompiler.register(:json, self)
+  end
+end

data/lib/stack_master/template_compilers/sparkle_formation.rb

@@ -0,0 +1,10 @@
+module StackMaster::TemplateCompilers
+  class SparkleFormation
+    def self.compile(template_file_path)
+      ::SparkleFormation.sparkle_path = File.dirname(template_file_path)
+      JSON.pretty_generate(::SparkleFormation.compile(template_file_path))
+    end
+
+    StackMaster::TemplateCompiler.register(:sparkle_formation, self)
+  end
+end

data/lib/stack_master/test_driver/cloud_formation.rb

@@ -60,6 +60,39 @@ module StackMaster
         @stack_events = {}
         @stack_resources = {}
         @stack_policies = {}
+        @change_sets = {}
+      end
+
+      def create_change_set(options)
+        id = SecureRandom.uuid
+        options.merge!(change_set_id: id)
+        @change_sets[id] = options
+        @change_sets[options.fetch(:change_set_name)] = options
+        OpenStruct.new(id: id)
+      end
+
+      def describe_change_set(options)
+        change_set_id = options.fetch(:change_set_name)
+        change_set = @change_sets.fetch(change_set_id)
+        change_details = [
+          OpenStruct.new(evaluation: 'Static', change_source: 'ResourceReference', target: OpenStruct.new(attribute: 'Properties', requires_recreation: 'Always', name: 'blah'))
+        ]
+        change = OpenStruct.new(action: 'Modify', replacement: 'True', scope: ['Properties'], details: change_details)
+        changes = [
+          OpenStruct.new(type: 'AWS::Resource', resource_change: change)
+        ]
+        OpenStruct.new(change_set.merge(changes: changes, status: 'CREATE_COMPLETE'))
+      end
+
+      def execute_change_set(options)
+        change_set_id = options.fetch(:change_set_name)
+        change_set = @change_sets.fetch(change_set_id)
+        update_stack(change_set)
+      end
+
+      def delete_change_set(options)
+        change_set_id = options.fetch(:change_set_name)
+        @change_sets.delete(change_set_id)
       end
 
       def describe_stacks(options = {})

data/lib/stack_master/validator.rb

@@ -1,16 +1,17 @@
 module StackMaster
   class Validator
-    def self.valid?(stack_definition)
-      new(stack_definition).perform
+    def self.valid?(stack_definition, config)
+      new(stack_definition, config).perform
     end
 
-    def initialize(stack_definition)
+    def initialize(stack_definition, config)
       @stack_definition = stack_definition
+      @config = config
     end
 
     def perform
       StackMaster.stdout.print "#{@stack_definition.stack_name}: "
-      template_body = TemplateCompiler.compile(@stack_definition.template_file_path)
+      template_body = TemplateCompiler.compile(@config, @stack_definition.template_file_path)
       cf.validate_template(template_body: template_body)
       StackMaster.stdout.puts "valid"
       true

data/lib/stack_master/version.rb

@@ -1,3 +1,3 @@
 module StackMaster
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/stack_master/change_set_spec.rb

@@ -0,0 +1,62 @@
+RSpec.describe StackMaster::ChangeSet do
+  let(:cf) { instance_double(Aws::CloudFormation::Client) }
+  let(:region) { 'us-east-1' }
+  let(:stack_name) { 'myapp-vpc' }
+  let(:change_set_name) { 'changeset-123' }
+
+  describe '.create' do
+    before do
+      allow(StackMaster::ChangeSet).to receive(:generate_change_set_name).and_return(change_set_name)
+      allow(StackMaster).to receive(:cloud_formation_driver).and_return(cf)
+      allow(cf).to receive(:create_change_set).and_return(double(id: 'id-1'))
+    end
+
+    context 'successful response' do
+      before do
+        allow(cf).to receive(:describe_change_set).with(change_set_name: 'id-1', next_token: nil).and_return(double(next_token: nil, changes: [], :changes= => nil, :next_token= => nil, status: 'CREATE_COMPLETE'))
+      end
+
+      it 'calls the create change set API with the addition of a name' do
+        change_set = StackMaster::ChangeSet.create(stack_name: '123')
+        expect(cf).to have_received(:create_change_set).with(
+          stack_name: '123',
+          change_set_name: change_set_name
+        )
+        expect(change_set.failed?).to eq false
+      end
+    end
+
+    context 'unsuccessful response' do
+      before do
+        allow(cf).to receive(:describe_change_set).with(change_set_name: 'id-1', next_token: nil).and_return(double(next_token: nil, changes: [], :changes= => nil, :next_token= => nil, status: 'FAILED', status_reason: 'No changes'))
+      end
+
+      it 'is marked as failed' do
+        change_set = StackMaster::ChangeSet.create(stack_name: '123')
+        expect(change_set.failed?).to eq true
+      end
+    end
+  end
+
+  describe '#display' do
+    context 'a successful response' do
+      let(:target) { OpenStruct.new(name: 'GroupDescription', attribute: 'Properties', requires_recreation: 'Always') }
+      let(:changes) { [
+        OpenStruct.new(resource_change: OpenStruct.new(replacement: 'True', action: 'Modify', resource_type: 'EC2::Instance', logical_resource_id: '123', details: [OpenStruct.new(target: target, change_source: 'DirectModification', evaluation: 'Static', causing_entity: 'blah')]))
+      ] }
+      let(:cf_response) { double(next_token: nil, changes: changes, :changes= => nil, :next_token= => nil, status: 'FAILED', status_reason: 'No changes') }
+      let(:io) { StringIO.new }
+      subject(:change_set) { StackMaster::ChangeSet.new(cf_response) }
+      let(:message) { io.string }
+      before { change_set.display(io) }
+
+      it 'outputs key data' do
+        expect(message).to include 'Replace EC2::Instance 123'
+      end
+
+      it 'outputs detail data' do
+        expect(message).to include 'Properties.GroupDescription. Always requires recreation. Triggered by: DirectModification.blah'
+      end
+    end
+  end
+end

data/spec/stack_master/command_spec.rb

@@ -3,12 +3,17 @@ RSpec.describe StackMaster::Command do
     Class.new do
       include StackMaster::Command
 
-      def initialize(callable = nil)
+      def initialize(callable = nil, halt = nil)
         @callable = callable
+        @halt = halt
       end
 
+      attr_reader :finished
+
       def perform
         instance_eval(&@callable) if @callable
+        halt! if @halt
+        @finished = true
         false
       end
     end
@@ -25,4 +30,19 @@ RSpec.describe StackMaster::Command do
       expect(command_class.perform(proc { failed }).success?).to eq false
     end
   end
+
+  describe '#halt!' do
+    it 'exits the command' do
+      expect(command_class.perform(nil, true).finished).to_not eq true
+    end
+  end
+
+  context 'when a CF error occurs' do
+    it 'outputs the message' do
+      error_proc = proc {
+        raise Aws::CloudFormation::Errors::ServiceError.new('a', 'the message')
+      }
+      expect { command_class.perform(error_proc) }.to output(/the message/).to_stderr
+    end
+  end
 end

data/spec/stack_master/commands/apply_spec.rb

@@ -6,14 +6,14 @@ RSpec.describe StackMaster::Commands::Apply do
   let(:notification_arn) { 'test_arn' }
   let(:stack_definition) { StackMaster::StackDefinition.new(base_dir: '/base_dir', region: region, stack_name: stack_name) }
   let(:template_body) { '{}' }
-  let(:proposed_stack) { StackMaster::Stack.new(template_body: template_body, tags: { 'environment' => 'production' } , parameters: { 'param_1' => 'hello' }, notification_arns: [notification_arn], stack_policy_body: stack_policy_body ) }
+  let(:parameters) { { 'param_1' => 'hello' } }
+  let(:proposed_stack) { StackMaster::Stack.new(template_body: template_body, tags: { 'environment' => 'production' } , parameters: parameters, notification_arns: [notification_arn], stack_policy_body: stack_policy_body ) }
   let(:stack_policy_body) { '{}' }
 
   before do
     allow(StackMaster::Stack).to receive(:find).with(region, stack_name).and_return(stack)
     allow(StackMaster::Stack).to receive(:generate).with(stack_definition, config).and_return(proposed_stack)
     allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
-    allow(cf).to receive(:update_stack)
     allow(cf).to receive(:create_stack)
     allow(StackMaster::StackDiffer).to receive(:new).with(proposed_stack, stack).and_return double.as_null_object
     allow(StackMaster::StackEvents::Streamer).to receive(:stream)
@@ -26,10 +26,17 @@ RSpec.describe StackMaster::Commands::Apply do
 
   context 'the stack exist' do
     let(:stack) { StackMaster::Stack.new(stack_id: '1') }
+    let(:change_set) { double(display: true, failed?: false, id: 'id-1') }
 
-    it 'calls the update stack API method' do
+    before do
+      allow(cf).to receive(:create_change_set).and_return(OpenStruct.new(id: '1'))
+      allow(StackMaster::ChangeSet).to receive(:create).and_return(change_set)
+      allow(cf).to receive(:execute_change_set).and_return(OpenStruct.new(id: '1'))
+    end
+
+    it 'creates a change set' do
       apply
-      expect(cf).to have_received(:update_stack).with(
+      expect(StackMaster::ChangeSet).to have_received(:create).with(
         stack_name: stack_name,
         template_body: proposed_stack.template_body,
         parameters: [
@@ -48,13 +55,31 @@ RSpec.describe StackMaster::Commands::Apply do
       end
     end
 
-    context 'when a CF error occurs' do
+    context 'the changeset failed to create' do
+      before do
+        allow(change_set).to receive(:failed?).and_return(true)
+        allow(change_set).to receive(:status_reason).and_return('reason')
+      end
+
+      it 'outputs the status reason' do
+        expect { apply }.to output(/reason/).to_stdout
+      end
+    end
+
+    context 'user decides to not apply the change set' do
       before do
-        allow(cf).to receive(:update_stack).with(anything).and_raise(Aws::CloudFormation::Errors::ServiceError.new('a', 'the message'))
+        allow(StackMaster).to receive(:non_interactive_answer).and_return('n')
+        allow(StackMaster::ChangeSet).to receive(:delete)
+        allow(StackMaster::ChangeSet).to receive(:execute)
+        apply
+      end
+
+      it 'deletes the change set' do
+        expect(StackMaster::ChangeSet).to have_received(:delete).with(change_set.id)
       end
 
-      it 'outputs the message' do
-        expect { apply }.to output(/the message/).to_stdout
+      it "doesn't execute the change set" do
+        expect(StackMaster::ChangeSet).to_not have_received(:execute).with(change_set.id)
       end
     end
   end
@@ -88,7 +113,7 @@ RSpec.describe StackMaster::Commands::Apply do
       end
 
       it 'exits with a message' do
-        expect { apply }.to output(/The \(space compressed\) stack is larger than the limit set by AWS/).to_stdout
+        expect { apply }.to output(/The \(space compressed\) stack is larger than the limit set by AWS/).to_stderr
       end
     end
 
@@ -99,4 +124,23 @@ RSpec.describe StackMaster::Commands::Apply do
       end
     end
   end
+
+  context 'one or more parameters are empty' do
+    let(:stack) { StackMaster::Stack.new(stack_id: '1', parameters: parameters) }
+    let(:parameters) { { 'param_1' => nil } }
+
+    it "doesn't allow apply" do
+      expect { apply }.to_not output(/Continue and apply the stack/).to_stdout
+    end
+
+    it 'outputs a description of the problem' do
+      expect { apply }.to output(/Empty\/blank parameters detected/).to_stderr
+    end
+
+    it 'outputs where param files are loaded from' do
+      stack_definition.parameter_files.each do |parameter_file|
+        expect { apply }.to output(/#{parameter_file}/).to_stderr
+      end
+    end
+  end
 end