stack_master 0.0.1

data/lib/stack_master/stack_definition.rb

@@ -0,0 +1,49 @@
+module StackMaster
+  class StackDefinition
+    include Virtus.value_object(strict: true, required: false)
+
+    values do
+      attribute :region, String
+      attribute :stack_name, String
+      attribute :template, String
+      attribute :tags, Hash
+      attribute :notification_arns, Array[String]
+      attribute :base_dir, String
+      attribute :secret_file, String
+      attribute :stack_policy_file, String
+      attribute :additional_parameter_lookup_dirs, Array[String]
+    end
+
+    def template_file_path
+      File.join(base_dir, 'templates', template)
+    end
+
+    def parameter_files
+      [ default_parameter_file_path, region_parameter_file_path ] + additional_parameter_lookup_file_paths
+    end
+
+    def stack_policy_file_path
+      File.join(base_dir, 'policies', stack_policy_file) if stack_policy_file
+    end
+
+    private
+
+    def additional_parameter_lookup_file_paths
+      additional_parameter_lookup_dirs.map do |a|
+        File.join(base_dir, 'parameters', a, "#{underscored_stack_name}.yml")
+      end
+    end
+
+    def region_parameter_file_path
+      File.join(base_dir, 'parameters', "#{region}", "#{underscored_stack_name}.yml")
+    end
+
+    def default_parameter_file_path
+      File.join(base_dir, 'parameters', "#{underscored_stack_name}.yml")
+    end
+
+    def underscored_stack_name
+      stack_name.gsub('-', '_')
+    end
+  end
+end

data/lib/stack_master/stack_differ.rb

@@ -0,0 +1,80 @@
+module StackMaster
+  class StackDiffer
+    def initialize(proposed_stack, current_stack)
+      @proposed_stack = proposed_stack
+      @current_stack = current_stack
+    end
+
+    def proposed_template
+      JSON.pretty_generate(JSON.parse(@proposed_stack.template_body))
+    end
+
+    def current_template
+      JSON.pretty_generate(@current_stack.template_hash)
+    end
+
+    def current_parameters
+      YAML.dump(sort_params(@current_stack.parameters_with_defaults))
+    end
+
+    def proposed_parameters
+      YAML.dump(sort_params(@proposed_stack.parameters_with_defaults))
+    end
+
+    def body_different?
+      Diffy::Diff.new(current_template, proposed_template, {}).to_s != ''
+    end
+
+    def params_different?
+      Diffy::Diff.new(current_parameters, proposed_parameters, {}).to_s != ''
+    end
+
+    def output_diff
+      if @current_stack
+        text_diff('Stack', current_template, proposed_template, context: 7, include_diff_info: true)
+        text_diff('Parameters', current_parameters, proposed_parameters)
+      else
+        text_diff('Stack', '', proposed_template)
+        text_diff('Parameters', '', proposed_parameters)
+        StackMaster.stdout.puts "No stack found"
+      end
+    end
+
+    private
+
+    def text_diff(thing, current, proposed, diff_opts = {})
+      diff = Diffy::Diff.new(current, proposed, diff_opts).to_s
+      StackMaster.stdout.print "#{thing} diff: "
+      if diff == ''
+        StackMaster.stdout.puts "No changes"
+      else
+        StackMaster.stdout.puts
+        diff.each_line do |line|
+          if line.start_with?('+')
+            StackMaster.stdout.print colorize(line, :green)
+          elsif line.start_with?('-')
+            StackMaster.stdout.print colorize(line, :red)
+          else
+            StackMaster.stdout.print line
+          end
+        end
+      end
+    end
+
+    def sort_params(hash)
+      hash.sort.to_h
+    end
+
+    def colorize(text, color)
+      if colorize?
+        text.colorize(color)
+      else
+        text
+      end
+    end
+
+    def colorize?
+      ENV.fetch('COLORIZE') { 'true' } == 'true'
+    end
+  end
+end

data/lib/stack_master/stack_events/fetcher.rb

@@ -0,0 +1,45 @@
+module StackMaster
+  class StackEvents
+    class Fetcher
+      def self.fetch(*args)
+        new(*args).fetch
+      end
+
+      def initialize(stack_name, region, from: nil)
+        @stack_name = stack_name
+        @region = region
+        @from = from
+      end
+
+      def fetch
+        events = fetch_events
+        if @from
+          filter_old_events(events)
+        else
+          events
+        end
+      end
+
+      private
+
+      def cf
+        @cf ||= StackMaster.cloud_formation_driver
+      end
+
+      def filter_old_events(events)
+        events.select { |event| event.timestamp > @from }
+      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
+      end
+    end
+  end
+end

data/lib/stack_master/stack_events/presenter.rb

@@ -0,0 +1,27 @@
+module StackMaster
+  class StackEvents
+    class Presenter
+      def self.print_event(io, event)
+        new(io).print_event(event)
+      end
+
+      def initialize(io)
+        @io = io
+      end
+
+      def print_event(event)
+        @io.puts "#{event.timestamp.localtime} #{event.logical_resource_id} #{event.resource_type} #{event.resource_status} #{event.resource_status_reason}".colorize(event_colour(event))
+      end
+
+      def event_colour(event)
+        if StackStates.failure_state?(event.resource_status)
+          :red
+        elsif StackStates.success_state?(event.resource_status)
+          :green
+        else
+          :yellow
+        end
+      end
+    end
+  end
+end

data/lib/stack_master/stack_events/streamer.rb

@@ -0,0 +1,55 @@
+module StackMaster
+  class StackEvents
+    class Streamer
+      def self.stream(*args, &block)
+        new(*args, &block).stream
+      end
+
+      def initialize(stack_name, region, from: Time.now, break_on_finish_state: true, sleep_between_fetches: 1, io: nil, &block)
+        @stack_name = stack_name
+        @region = region
+        @block = block
+        @seen_events = Set.new
+        @from = from
+        @break_on_finish_state = break_on_finish_state
+        @sleep_between_fetches = sleep_between_fetches
+        @io = io
+      end
+
+      def stream
+        catch(:halt) do
+          loop do
+            events = Fetcher.fetch(@stack_name, @region, from: @from)
+            unseen_events(events).each do |event|
+              @block.call(event) if @block
+              Presenter.print_event(@io, event) if @io
+              if @break_on_finish_state && finish_state?(event)
+                throw :halt
+              end
+            end
+            sleep @sleep_between_fetches
+          end
+        end
+      rescue Interrupt
+      end
+
+      private
+
+      def unseen_events(events)
+        [].tap do |unseen_events|
+          events.each do |event|
+            next if @seen_events.include?(event.event_id)
+            @seen_events << event.event_id
+            unseen_events << event
+          end
+        end
+      end
+
+      def finish_state?(event)
+        StackStates.finish_state?(event.resource_status) &&
+          event.resource_type == 'AWS::CloudFormation::Stack' &&
+          event.logical_resource_id == @stack_name
+      end
+    end
+  end
+end

data/lib/stack_master/stack_states.rb

@@ -0,0 +1,34 @@
+module StackMaster
+  module StackStates
+    SUCCESS_STATES = %w[
+      CREATE_COMPLETE
+      UPDATE_COMPLETE
+      DELETE_COMPLETE
+    ].freeze
+    FAILURE_STATES = %w[
+      CREATE_FAILED
+      DELETE_FAILED
+      UPDATE_ROLLBACK_FAILED
+      ROLLBACK_FAILED
+      ROLLBACK_COMPLETE
+      ROLLBACK_FAILED
+      UPDATE_ROLLBACK_COMPLETE
+      UPDATE_ROLLBACK_FAILED
+    ].freeze
+    FINISH_STATES = (SUCCESS_STATES + FAILURE_STATES).freeze
+
+    extend self
+
+    def finish_state?(state)
+      FINISH_STATES.include?(state)
+    end
+
+    def failure_state?(state)
+      FAILURE_STATES.include?(state)
+    end
+
+    def success_state?(state)
+      SUCCESS_STATES.include?(state)
+    end
+  end
+end

data/lib/stack_master/template_compiler.rb

@@ -0,0 +1,21 @@
+module StackMaster
+  class TemplateCompiler
+
+    MAX_TEMPLATE_SIZE = 51200
+
+    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
+    end
+  end
+end

data/lib/stack_master/test_driver/cloud_formation.rb

@@ -0,0 +1,139 @@
+module StackMaster
+  module TestDriver
+    class Stack
+      include Virtus.model
+      attribute :stack_id, String
+      attribute :stack_name, String
+      attribute :description, String
+      attribute :parameters, Array[OpenStruct]
+      attribute :creation_time, String
+      attribute :last_update_time, String
+      attribute :stack_status, String
+      attribute :stack_status_reason, String
+      attribute :disable_rollback, String
+      attribute :notification_arns, Array
+      attribute :timeout_in_minutes, Integer
+      attribute :capabilities, Array
+      attribute :outputs, Array[OpenStruct]
+      attribute :tags, Array[OpenStruct]
+    end
+
+    class StackEvent
+      include Virtus.model
+      attribute :stack_id, String
+      attribute :event_id, String
+      attribute :stack_name, String
+      attribute :logical_resource_id, String
+      attribute :physical_resource_id, String
+      attribute :resource_type, String
+      attribute :timestamp, Time
+      attribute :resource_status, String
+      attribute :resource_status_reason, String
+      attribute :resource_properties, String
+    end
+
+    class StackResource
+      include Virtus.model
+      attribute :stack_name, String
+      attribute :stack_id, String
+      attribute :logical_resource_id, String
+      attribute :physical_resource_id, String
+      attribute :resource_type, String
+      attribute :timestamp, Time
+      attribute :resource_status, String
+      attribute :resource_status_reason, String
+      attribute :description, String
+    end
+
+    class CloudFormation
+      def initialize
+        reset
+      end
+
+      def set_region(region)
+        @region = region
+      end
+
+      def reset
+        @stacks = {}
+        @templates = {}
+        @stack_events = {}
+        @stack_resources = {}
+        @stack_policies = {}
+      end
+
+      def describe_stacks(options = {})
+        stack_name = options[:stack_name]
+        stacks = if stack_name
+          if @stacks[stack_name]
+            [@stacks[stack_name]]
+          else
+            raise Aws::CloudFormation::Errors::ValidationError.new('', 'Stack does not exist')
+          end
+        else
+          @stacks.values
+        end
+        OpenStruct.new(stacks: stacks, next_token: nil)
+      end
+
+      def describe_stack_resources(options = {})
+        @stacks.fetch(options.fetch(:stack_name)) { raise Aws::CloudFormation::Errors::ValidationError.new('', 'Stack does not exist') }
+        OpenStruct.new(stack_resources: @stack_resources[options.fetch(:stack_name)])
+      end
+
+      def get_template(options)
+        template_body = @templates[options[:stack_name]] || nil
+        OpenStruct.new(template_body: template_body)
+      end
+
+      def get_stack_policy(options)
+        OpenStruct.new(stack_policy_body: @stack_policies[options.fetch(:stack_name)])
+      end
+
+      def describe_stack_events(options)
+        events = @stack_events[options.fetch(:stack_name)] || []
+        OpenStruct.new(stack_events: events, next_token: nil)
+      end
+
+      def update_stack(options)
+        stack_name = options.fetch(:stack_name)
+        @stacks[stack_name].attributes = options
+        @stack_policies[stack_name] = options[:stack_policy_body]
+      end
+
+      def create_stack(options)
+        stack_name = options.fetch(:stack_name)
+        add_stack(options)
+        @stack_policies[stack_name] = options[:stack_policy_body]
+      end
+
+      def delete_stack(options)
+        stack_name = options.fetch(:stack_name)
+        @stacks.delete(stack_name)
+      end
+
+      def validate_template(options)
+        true
+      end
+
+      def add_stack(stack)
+        @stacks[stack.fetch(:stack_name)] = Stack.new(stack)
+      end
+
+      def add_stack_resource(options)
+        @stack_resources[options.fetch(:stack_name)] ||= []
+        @stack_resources[options.fetch(:stack_name)] << StackResource.new(options)
+      end
+
+      def set_template(stack_name, template)
+        @templates[stack_name] = template
+      end
+
+      def add_stack_event(event)
+        stack_name = event.fetch(:stack_name)
+        @stack_events[stack_name] ||= []
+        @stack_events[stack_name] << StackEvent.new(event)
+      end
+    end
+  end
+end