stack_master 1.6.0-x64-mingw32

data/lib/stack_master/stack_events/fetcher.rb

@@ -0,0 +1,38 @@
+module StackMaster
+  module 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
+        PagedResponseAccumulator.call(cf, :describe_stack_events, { stack_name: @stack_name }, :stack_events).stack_events
+      end
+    end
+  end
+end

data/lib/stack_master/stack_events/presenter.rb

@@ -0,0 +1,27 @@
+module StackMaster
+  module 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,68 @@
+module StackMaster
+  module StackEvents
+    class Streamer
+      StackFailed = Class.new(StandardError)
+
+      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)
+                exit_with_error(event) if failure_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
+
+      def failure_state?(event)
+        StackStates.failure_state?(event.resource_status) &&
+          event.resource_type == 'AWS::CloudFormation::Stack' &&
+          event.logical_resource_id == @stack_name
+      end
+
+      def exit_with_error(event)
+        raise StackFailed, "#{event.logical_resource_id} did not succeed (last state was #{event.resource_status})"
+      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/stack_status.rb

@@ -0,0 +1,61 @@
+module StackMaster
+  class StackStatus
+    def initialize(config, stack_definition)
+      @config = config
+      @stack_definition = stack_definition
+    end
+
+    def changed_message
+      if changed?
+        'Yes'
+      elsif no_echo_params?
+        'No *'
+      else
+        'No'
+      end
+    end
+
+    def changed?
+      stack.nil? || body_changed? || parameters_changed?
+    end
+
+    def status
+      stack ? stack.stack_status : nil
+    end
+
+    def body_changed?
+      stack.nil? || differ.body_different?
+    end
+
+    def parameters_changed?
+      stack.nil? || differ.params_different?
+    end
+
+    def no_echo_params?
+      !differ.noecho_keys.empty?
+    end
+
+    private
+
+    def stack
+      return @stack if defined?(@stack)
+      StackMaster.cloud_formation_driver.set_region(stack_definition.region)
+      @stack = find_stack
+    end
+
+    def find_stack
+      Stack.find(stack_definition.region, stack_definition.stack_name)
+    rescue Aws::CloudFormation::Errors::ValidationError
+    end
+
+    def differ
+      @differ ||= StackMaster::StackDiffer.new(proposed_stack, stack)
+    end
+
+    def proposed_stack
+      @proposed_stack ||= Stack.generate(stack_definition, @config)
+    end
+
+    attr_reader :stack_definition
+  end
+end

data/lib/stack_master/template_compiler.rb

@@ -0,0 +1,30 @@
+module StackMaster
+  class TemplateCompiler
+    TemplateCompilationFailed = Class.new(RuntimeError)
+
+    def self.compile(config, template_file_path, compile_time_parameters, compiler_options = {})
+      compiler = template_compiler_for_file(template_file_path, config)
+      compiler.require_dependencies
+      compiler.compile(template_file_path, compile_time_parameters, compiler_options)
+    rescue
+      raise TemplateCompilationFailed.new("Failed to 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.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/cfndsl.rb

@@ -0,0 +1,13 @@
+module StackMaster::TemplateCompilers
+  class Cfndsl
+    def self.require_dependencies
+      require 'cfndsl'
+    end
+
+    def self.compile(template_file_path, _compile_time_parameters, _compiler_options = {})
+      ::CfnDsl.eval_file_with_extras(template_file_path).to_json
+    end
+
+    StackMaster::TemplateCompiler.register(:cfndsl, self)
+  end
+end

data/lib/stack_master/template_compilers/json.rb

@@ -0,0 +1,22 @@
+module StackMaster::TemplateCompilers
+  class Json
+    MAX_TEMPLATE_SIZE = 51200
+    private_constant :MAX_TEMPLATE_SIZE
+
+    def self.require_dependencies
+      require 'json'
+    end
+
+    def self.compile(template_file_path, _compile_time_parameters, _compiler_options = {})
+      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,71 @@
+require 'stack_master/sparkle_formation/compile_time/parameters_validator'
+require 'stack_master/sparkle_formation/compile_time/definitions_validator'
+require 'stack_master/sparkle_formation/compile_time/state_builder'
+
+module StackMaster::TemplateCompilers
+  class SparkleFormation
+
+    CompileTime = StackMaster::SparkleFormation::CompileTime
+
+    def self.require_dependencies
+      require 'sparkle_formation'
+      require 'stack_master/sparkle_formation/template_file'
+    end
+
+    def self.compile(template_file_path, compile_time_parameters, compiler_options = {})
+      sparkle_template = compile_sparkle_template(template_file_path, compiler_options)
+      definitions = sparkle_template.parameters
+      validate_definitions(definitions)
+      validate_parameters(definitions, compile_time_parameters)
+
+      sparkle_template.compile_time_parameter_setter do
+        sparkle_template.compile_state = create_state(definitions, compile_time_parameters)
+      end
+
+      JSON.pretty_generate(sparkle_template)
+    end
+
+    private
+
+    def self.compile_sparkle_template(template_file_path, compiler_options)
+      sparkle_path = compiler_options['sparkle_path'] ?
+                        File.expand_path(compiler_options['sparkle_path']) : File.dirname(template_file_path)
+
+      collection = ::SparkleFormation::SparkleCollection.new
+      root_pack = ::SparkleFormation::Sparkle.new(
+        :root => sparkle_path,
+      )
+      collection.set_root(root_pack)
+      if compiler_options['sparkle_packs']
+        compiler_options['sparkle_packs'].each do |pack_name|
+          require pack_name
+          pack = ::SparkleFormation::SparklePack.new(:name => pack_name)
+          collection.add_sparkle(pack)
+        end
+      end
+
+      sparkle_template = compile_template_with_sparkle_path(template_file_path, sparkle_path)
+      sparkle_template.sparkle.apply(collection)
+      sparkle_template
+    end
+
+    def self.compile_template_with_sparkle_path(template_path, sparkle_path)
+      ::SparkleFormation.sparkle_path = sparkle_path
+      ::SparkleFormation.compile(template_path, :sparkle)
+    end
+
+    def self.validate_definitions(definitions)
+      CompileTime::DefinitionsValidator.new(definitions).validate
+    end
+
+    def self.validate_parameters(definitions, compile_time_parameters)
+      CompileTime::ParametersValidator.new(definitions, compile_time_parameters).validate
+    end
+
+    def self.create_state(definitions, compile_time_parameters)
+      CompileTime::StateBuilder.new(definitions, compile_time_parameters).build
+    end
+
+    StackMaster::TemplateCompiler.register(:sparkle_formation, self)
+  end
+end

data/lib/stack_master/template_compilers/yaml.rb

@@ -0,0 +1,14 @@
+module StackMaster::TemplateCompilers
+  class Yaml
+    def self.require_dependencies
+      require 'yaml'
+      require 'json'
+    end
+
+    def self.compile(template_file_path, _compile_time_parameters, _compiler_options = {})
+      File.read(template_file_path)
+    end
+
+    StackMaster::TemplateCompiler.register(:yaml, self)
+  end
+end

data/lib/stack_master/template_utils.rb

@@ -0,0 +1,31 @@
+module StackMaster
+  module TemplateUtils
+    MAX_TEMPLATE_SIZE = 51200
+    MAX_S3_TEMPLATE_SIZE = 460800
+
+    extend self
+
+    def identify_template_format(template_body)
+      return :json if template_body =~ /^{/x # ignore leading whitespaces
+      :yaml
+    end
+
+    def template_hash(template_body=nil)
+      return unless template_body
+      template_format = identify_template_format(template_body)
+      case template_format
+      when :json
+        JSON.parse(template_body)
+      when :yaml
+        YAML.load(template_body)
+      end
+    end
+
+    def maybe_compressed_template_body(template_body)
+      # Do not compress the template if it's not JSON because parsing YAML as a hash ignores
+      # CloudFormation-specific tags such as !Ref
+      return template_body if template_body.size <= MAX_TEMPLATE_SIZE || identify_template_format(template_body) != :json
+      JSON.dump(template_hash(template_body))
+    end
+  end
+end

data/lib/stack_master/test_driver/cloud_formation.rb

@@ -0,0 +1,193 @@
+require 'securerandom'
+
+module StackMaster
+  module TestDriver
+    class Stack
+      attr_reader :stack_id,
+                  :stack_name,
+                  :description,
+                  :parameters,
+                  :creation_time,
+                  :last_update_time,
+                  :stack_status,
+                  :stack_status_reason,
+                  :disable_rollback,
+                  :role_arn,
+                  :notification_arns,
+                  :timeout_in_minutes,
+                  :capabilities,
+                  :outputs,
+                  :tags
+
+      include Utils::Initializable
+
+      def parameters
+        @parameters.map do |hash|
+          OpenStruct.new(parameter_key: hash[:parameter_key],
+                         parameter_value: hash[:parameter_value])
+        end
+      end
+    end
+
+    class StackEvent
+      attr_reader :stack_id,
+                  :event_id,
+                  :stack_name,
+                  :logical_resource_id,
+                  :physical_resource_id,
+                  :resource_type,
+                  :timestamp,
+                  :resource_status,
+                  :resource_status_reason,
+                  :resource_properties
+
+      include Utils::Initializable
+
+      def timestamp
+        Time.parse(@timestamp) if @timestamp
+      end
+    end
+
+    class StackResource
+      attr_reader :stack_name,
+                  :stack_id,
+                  :logical_resource_id,
+                  :physical_resource_id,
+                  :resource_type,
+                  :timestamp,
+                  :resource_status,
+                  :resource_status_reason,
+                  :description
+
+      include Utils::Initializable
+    end
+
+    class CloudFormation
+      def initialize
+        reset
+      end
+
+      def region
+        @region ||= ENV['AWS_REGION'] || Aws.config[:region] || Aws.shared_config.region
+      end
+
+      def set_region(region)
+        @region = region
+      end
+
+      def reset
+        @stacks = {}
+        @templates = {}
+        @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
+        stack_name = options.fetch(:stack_name)
+        add_stack(stack_name: stack_name, stack_status: 'REVIEW_IN_PROGRESS') unless @stacks[stack_name]
+        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)
+        @stacks[change_set.fetch(:stack_name)].attributes = 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 = {})
+        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 set_stack_policy(options)
+        @stack_policies[options.fetch(:stack_name)] = options[:stack_policy_body]
+      end
+
+      def describe_stack_events(options)
+        events = @stack_events[options.fetch(:stack_name)] || []
+        OpenStruct.new(stack_events: events, next_token: nil)
+      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