bora 0.9.4 → 1.0.0.beta1

data/lib/bora/cfn/stack.rb

@@ -0,0 +1,168 @@
+require 'set'
+require 'open-uri'
+require 'aws-sdk'
+require 'diffy'
+require 'bora/cfn/stack_status'
+require 'bora/cfn/event'
+require 'bora/cfn/output'
+
+class Bora
+  module Cfn
+
+    class Stack
+      NO_UPDATE_MESSAGE = "No updates are to be performed"
+
+      def initialize(stack_name)
+        @stack_name = stack_name
+        @processed_events = Set.new
+      end
+
+      def create(options, &block)
+        call_cfn_action(:create, options, &block)
+      end
+
+      def update(options, &block)
+        call_cfn_action(:update, options, &block)
+      end
+
+      def create_or_update(options, &block)
+        exists? ? update(options, &block) : create(options, &block)
+      end
+
+      def recreate(options, &block)
+        delete(&block) if exists?
+        create(options, &block) if !exists?
+      end
+
+      def delete(&block)
+        call_cfn_action(:delete, &block)
+      end
+
+      def events
+        return if !exists?
+        events = cloudformation.describe_stack_events({stack_name: underlying_stack.stack_id}).stack_events
+        events.reverse.map { |e| Event.new(e) }
+      end
+
+      def outputs
+        return if !exists?
+        underlying_stack.outputs.map { |output| Output.new(output) }
+      end
+
+      def template(pretty = true)
+        return if !exists?
+        template = cloudformation.get_template({stack_name: @stack_name}).template_body
+        template = JSON.pretty_generate(JSON.parse(template)) if pretty
+        template
+      end
+
+      def new_template(options, pretty = true)
+        options = resolve_options(options, true)
+        template = options[:template_body]
+        if template
+          template = JSON.pretty_generate(JSON.parse(template)) if pretty
+          template
+        else
+          raise "new_template not yet implemented for URL #{options[:template_url]}"
+        end
+      end
+
+      def diff(options)
+        Diffy::Diff.new(template, new_template(options))
+      end
+
+      def validate(options)
+        cloudformation.validate_template(resolve_options(options).select { |k| [:template_body, :template_url].include?(k) })
+      end
+
+      def status
+        StackStatus.new(underlying_stack)
+      end
+
+      def exists?
+        status.exists?
+      end
+
+
+      # =============================================================================================
+      private
+
+      def cloudformation
+        @cfn ||= Aws::CloudFormation::Client.new
+      end
+
+      def method_missing(sym, *args, &block)
+        underlying_stack ? underlying_stack.send(sym, *args, &block) : nil
+      end
+
+      def call_cfn_action(action, options = {}, &block)
+        underlying_stack(refresh: true)
+        return true if action == :delete && !exists?
+        @previous_event_time = last_event_time
+        begin
+          action_options = {stack_name: @stack_name}.merge(resolve_options(options))
+          cloudformation.method("#{action.to_s.downcase}_stack").call(action_options)
+          wait_for_completion(&block)
+        rescue Aws::CloudFormation::Errors::ValidationError => e
+          raise e unless e.message.include?(NO_UPDATE_MESSAGE)
+          return nil
+        end
+        (action == :delete && !underlying_stack) || status.success?
+      end
+
+      def resolve_options(options, load_all = false)
+        return options if options[:template_body] || !options[:template_url]
+        uri = URI(options[:template_url])
+        if uri.scheme != "s3" || load_all
+          resolved_options = options.clone
+          resolved_options[:template_body] = open(options[:template_url]).read
+          resolved_options.delete(:template_url)
+          resolved_options
+        else
+          options
+        end
+      end
+
+      def wait_for_completion
+        begin
+          events = unprocessed_events
+          events.each { |e| yield e } if block_given?
+          finished = events.find do |e|
+            e.resource_type == 'AWS::CloudFormation::Stack' && e.logical_resource_id == @stack_name && e.status_complete?
+          end
+          sleep 10 unless finished
+        end until finished
+        underlying_stack(refresh: true)
+      end
+
+      def underlying_stack(refresh: false)
+        if !@_stack || refresh
+          begin
+            response = cloudformation.describe_stacks({stack_name: @stack_name})
+            @_stack = response.stacks[0]
+          rescue Aws::CloudFormation::Errors::ValidationError
+            @_stack = nil
+          end
+        end
+        @_stack
+      end
+
+      def unprocessed_events
+        return [] if !underlying_stack
+        events = cloudformation.describe_stack_events({stack_name: underlying_stack.stack_id}).stack_events
+        unprocessed_events = events.select do |event|
+          !@processed_events.include?(event.event_id) && @previous_event_time < event.timestamp
+        end
+        @processed_events.merge(unprocessed_events.map(&:event_id))
+        unprocessed_events.reverse.map { |e| Event.new(e) }
+      end
+
+      def last_event_time
+        return Time.at(0) if !underlying_stack
+        events = cloudformation.describe_stack_events({stack_name: @stack_name}).stack_events
+        events.length > 0 ? events[0].timestamp : Time.at(0)
+      end
+    end
+
+  end
+end

data/lib/bora/cfn/stack_status.rb

@@ -0,0 +1,33 @@
+require 'bora/cfn/status'
+
+class Bora
+  module Cfn
+
+    class StackStatus
+      def initialize(underlying_stack)
+        @stack = underlying_stack
+        if @stack
+          @status = Status.new(@stack.stack_status)
+        end
+      end
+
+      def exists?
+        @status && !@status.deleted?
+      end
+
+      def success?
+        @status && @status.success?
+      end
+
+      def to_s
+        if @stack
+          status_reason = @stack.stack_status_reason ? " - #{@stack.stack_status_reason}" : ""
+          "#{@stack.stack_name} - #{@status}#{status_reason}"
+        else
+          "Stack does not exist"
+        end
+      end
+    end
+
+  end
+end

data/lib/bora/cfn/status.rb

@@ -0,0 +1,43 @@
+require 'colorize'
+
+class Bora
+  module Cfn
+    class Status
+      def initialize(status)
+        @status = status
+      end
+
+      def success?
+        @status.end_with?("_COMPLETE") && !@status.include?("ROLLBACK")
+      end
+
+      def failure?
+        @status.end_with?("_FAILED") || @status.include?("ROLLBACK")
+      end
+
+      def deleted?
+        @status == "DELETE_COMPLETE"
+      end
+
+      def complete?
+        success? || failure?
+      end
+
+      def to_s
+        @status.colorize(color)
+      end
+
+
+      private
+
+      def color
+        case
+          when success?; :green
+          when failure?; :red
+          else; :yellow;
+        end
+      end
+    end
+
+  end
+end

data/lib/bora/cfn_param_resolver.rb

@@ -1,6 +1,6 @@
-require 'bora/stack'
+require 'bora/cfn/stack'
 
-module Bora
+class Bora
   class CfnParamResolver
     def initialize(param)
       @param = param
@@ -12,7 +12,7 @@ module Bora
         raise "Invalid parameter substitution: #{@param}"
       end
 
-      stack = Stack.new(stack_name)
+      stack = Cfn::Stack.new(stack_name)
       if !stack.exists?
         raise "Output #{name} not found in stack #{stack_name} as the stack does not exist"
       end

data/lib/bora/cli.rb

@@ -0,0 +1,81 @@
+require "thor"
+require "bora"
+
+class Bora
+  class Cli < Thor
+    class_option :file, type: :string, aliases: :f, default: Bora::DEFAULT_CONFIG_FILE, desc: "The Bora config file to use"
+
+    desc "apply STACK_NAME", "Creates or updates the stack"
+    option :params, type: :array, aliases: :p, desc: "Parameters to be passed to the template, eg: --params 'instance_type=t2.micro'"
+    def apply(stack_name)
+      stack(options.file, stack_name).apply(params)
+    end
+
+    desc "delete STACK_NAME", "Deletes the stack"
+    def delete(stack_name)
+      stack(options.file, stack_name).delete
+    end
+
+    desc "diff STACK_NAME", "Diffs the new template with the stack's current template"
+    option :params, type: :array, aliases: :p, desc: "Parameters to be passed to the template, eg: --params 'instance_type=t2.micro'"
+    def diff(stack_name)
+      stack(options.file, stack_name).diff(params)
+    end
+
+    desc "events STACK_NAME", "Outputs the latest events from the stack"
+    def events(stack_name)
+      stack(options.file, stack_name).events
+    end
+
+    desc "outputs STACK_NAME", "Shows the outputs from the stack"
+    def outputs(stack_name)
+      stack(options.file, stack_name).outputs
+    end
+
+    desc "recreate STACK_NAME", "Recreates (deletes then creates) the stack"
+    option :params, type: :array, aliases: :p, desc: "Parameters to be passed to the template, eg: --params 'instance_type=t2.micro'"
+    def recreate(stack_name)
+      stack(options.file, stack_name).recreate(params)
+    end
+
+    desc "show STACK_NAME", "Shows the new template for stack"
+    option :params, type: :array, aliases: :p, desc: "Parameters to be passed to the template, eg: --params 'instance_type=t2.micro'"
+    def show(stack_name)
+      stack(options.file, stack_name).show(params)
+    end
+
+    desc "show_current STACK_NAME", "Shows the current template for the stack"
+    def show_current(stack_name)
+      stack(options.file, stack_name).show_current
+    end
+
+    desc "status STACK_NAME", "Displays the current status of the stack"
+    def status(stack_name)
+      stack(options.file, stack_name).status
+    end
+
+    desc "validate STACK_NAME", "Checks the stack's template for validity"
+    option :params, type: :array, aliases: :p, desc: "Parameters to be passed to the template, eg: --params 'instance_type=t2.micro'"
+    def validate(stack_name)
+      stack(options.file, stack_name).validate(params)
+    end
+
+
+    private
+
+    def stack(config_file, stack_name)
+      bora = Bora.new(config_file_or_hash: config_file)
+      stack = bora.stack(stack_name)
+      if !stack
+        STDERR.puts "Could not find stack #{stack_name}"
+        exit(1)
+      end
+      stack
+    end
+
+    def params
+      options.params ? Hash[options.params.map { |param| param.split("=", 2) }] : {}
+    end
+
+  end
+end

data/lib/bora/stack.rb

@@ -1,164 +1,171 @@
-require 'set'
-require 'open-uri'
-require 'aws-sdk'
-require 'diffy'
-require 'bora/stack_status'
-require 'bora/event'
-require 'bora/output'
-
-module Bora
+require 'tempfile'
+require 'colorize'
+require 'cfndsl'
+require 'bora/cfn/stack'
+require 'bora/cfn_param_resolver'
+require 'bora/stack_tasks'
+
+class Bora
   class Stack
-    NO_UPDATE_MESSAGE = "No updates are to be performed"
-
-    def initialize(stack_name)
+    def initialize(stack_name, template_file, stack_config)
       @stack_name = stack_name
-      @processed_events = Set.new
+      @cfn_stack_name = stack_config['stack_name'] || @stack_name
+      @template_file = template_file
+      @stack_config = stack_config
+      @cfn_options = extract_cfn_options(stack_config)
+      @cfn_stack = Cfn::Stack.new(@cfn_stack_name)
     end
 
-    def create(options, &block)
-      call_cfn_action(:create, options, &block)
-    end
+    attr_reader :stack_name
 
-    def update(options, &block)
-      call_cfn_action(:update, options, &block)
+    def rake_tasks
+      StackTasks.new(self)
     end
 
-    def create_or_update(options, &block)
-      exists? ? update(options, &block) : create(options, &block)
+    def apply(override_params = {})
+      generate(override_params)
+      success = invoke_action(@cfn_stack.exists? ? "update" : "create", @cfn_options)
+      if success
+        outputs = @cfn_stack.outputs
+        if outputs && outputs.length > 0
+          puts "Stack outputs"
+          outputs.each { |output| puts output }
+        end
+      end
     end
 
-    def recreate(options, &block)
-      delete(&block) if exists?
-      create(options, &block) if !exists?
+    def delete
+      invoke_action("delete")
     end
 
-    def delete(&block)
-      call_cfn_action(:delete, &block)
+    def diff(override_params = {})
+      generate(override_params)
+      puts @cfn_stack.diff(@cfn_options).to_s(String.disable_colorization ? :text : :color)
     end
 
     def events
-      return if !exists?
-      events = cloudformation.describe_stack_events({stack_name: underlying_stack.stack_id}).stack_events
-      events.reverse.map { |e| Event.new(e) }
-    end
-
-    def outputs
-      return if !exists?
-      underlying_stack.outputs.map { |output| Output.new(output) }
+      events = @cfn_stack.events
+      if events
+        if events.length > 0
+          puts "Events for stack '#{@cfn_stack_name}'"
+          @cfn_stack.events.each { |e| puts e }
+        else
+          puts "Stack '#{@cfn_stack_name}' has no events"
+        end
+      else
+        puts "Stack '#{@cfn_stack_name}' does not exist"
+      end
     end
 
-    def template(pretty = true)
-      return if !exists?
-      template = cloudformation.get_template({stack_name: @stack_name}).template_body
-      template = JSON.pretty_generate(JSON.parse(template)) if pretty
-      template
+    def generate(override_params = {})
+      params = process_params(override_params)
+      if File.extname(@template_file) == ".rb"
+        template_body = run_cfndsl(@template_file, params)
+        template_json = JSON.parse(template_body)
+        if template_json["Parameters"]
+          cfn_param_keys = template_json["Parameters"].keys
+          cfn_params = params.select { |k, v| cfn_param_keys.include?(k) }.map do |k, v|
+            { parameter_key: k, parameter_value: v }
+          end
+          @cfn_options[:parameters] = cfn_params if !cfn_params.empty?
+        end
+        @cfn_options[:template_body] = template_body
+      else
+        @cfn_options[:template_url] = @template_file
+        if !params.empty?
+          @cfn_options[:parameters] = params.map do |k, v|
+            { parameter_key: k, parameter_value: v }
+          end
+        end
+      end
     end
 
-    def new_template(options, pretty = true)
-      options = resolve_options(options, true)
-      template = options[:template_body]
-      if template
-        template = JSON.pretty_generate(JSON.parse(template)) if pretty
-        template
+    def outputs
+      outputs = @cfn_stack.outputs
+      if outputs
+        if outputs.length > 0
+          puts "Outputs for stack '#{@cfn_stack_name}'"
+          outputs.each { |output| puts output }
+        else
+          puts "Stack '#{@cfn_stack_name}' has no outputs"
+        end
       else
-        raise "new_template not yet implemented for URL #{options[:template_url]}"
+        puts "Stack '#{@cfn_stack_name}' does not exist"
       end
     end
 
-    def diff(options)
-      Diffy::Diff.new(template, new_template(options))
+    def recreate(override_params = {})
+      generate(override_params)
+      invoke_action("recreate", @cfn_options)
     end
 
-    def validate(options)
-      cloudformation.validate_template(resolve_options(options).select { |k| [:template_body, :template_url].include?(k) })
+    def show(override_params = {})
+      generate(override_params)
+      puts @cfn_stack.new_template(@cfn_options)
     end
 
-    def status
-      StackStatus.new(underlying_stack)
+    def show_current
+      template = @cfn_stack.template
+      puts template ? template : "Stack '#{@cfn_stack_name}' does not exist"
     end
 
-    def exists?
-      status.exists?
+    def status
+      puts @cfn_stack.status
     end
 
-
-    # =============================================================================================
-    private
-
-    def cloudformation
-      @cfn ||= Aws::CloudFormation::Client.new
+    def validate(override_params = {})
+      generate(override_params)
+      puts "Template for stack '#{@cfn_stack_name}' is valid" if @cfn_stack.validate(@cfn_options)
     end
 
-    def method_missing(sym, *args, &block)
-      underlying_stack ? underlying_stack.send(sym, *args, &block) : nil
-    end
 
-    def call_cfn_action(action, options = {}, &block)
-      underlying_stack(refresh: true)
-      return true if action == :delete && !exists?
-      @previous_event_time = last_event_time
-      begin
-        action_options = {stack_name: @stack_name}.merge(resolve_options(options))
-        cloudformation.method("#{action.to_s.downcase}_stack").call(action_options)
-        wait_for_completion(&block)
-      rescue Aws::CloudFormation::Errors::ValidationError => e
-        raise e unless e.message.include?(NO_UPDATE_MESSAGE)
-        return nil
-      end
-      (action == :delete && !underlying_stack) || status.success?
-    end
+    protected
 
-    def resolve_options(options, load_all = false)
-      return options if options[:template_body] || !options[:template_url]
-      uri = URI(options[:template_url])
-      if uri.scheme != "s3" || load_all
-        resolved_options = options.clone
-        resolved_options[:template_body] = open(options[:template_url]).read
-        resolved_options.delete(:template_url)
-        resolved_options
+    def invoke_action(action, *args)
+      puts "#{action.capitalize} stack '#{@cfn_stack_name}'"
+      success = @cfn_stack.send(action, *args) { |event| puts event }
+      if success
+        puts "#{action.capitalize} stack '#{@cfn_stack_name}' completed successfully"
       else
-        options
+        if success == nil
+          puts "#{action.capitalize} stack '#{@cfn_stack_name}' skipped as template has not changed"
+        else
+          raise("#{action.capitalize} stack '#{@cfn_stack_name}' failed")
+        end
       end
+      success
     end
 
-    def wait_for_completion
-      begin
-        events = unprocessed_events
-        events.each { |e| yield e } if block_given?
-        finished = events.find do |e|
-          e.resource_type == 'AWS::CloudFormation::Stack' && e.logical_resource_id == @stack_name && e.status_complete?
-        end
-        sleep 10 unless finished
-      end until finished
-      underlying_stack(refresh: true)
-    end
-
-    def underlying_stack(refresh: false)
-      if !@_stack || refresh
-        begin
-          response = cloudformation.describe_stacks({stack_name: @stack_name})
-          @_stack = response.stacks[0]
-        rescue Aws::CloudFormation::Errors::ValidationError
-          @_stack = nil
-        end
-      end
-      @_stack
+    def run_cfndsl(template_file, params)
+      temp_extras = Tempfile.new("bora")
+      temp_extras.write(params.to_yaml)
+      temp_extras.close
+      template_body = CfnDsl.eval_file_with_extras(template_file, [[:yaml, temp_extras.path]]).to_json
+      temp_extras.unlink
+      template_body
     end
 
-    def unprocessed_events
-      return [] if !underlying_stack
-      events = cloudformation.describe_stack_events({stack_name: underlying_stack.stack_id}).stack_events
-      unprocessed_events = events.select do |event|
-        !@processed_events.include?(event.event_id) && @previous_event_time < event.timestamp
+    def process_params(override_params)
+      params = @stack_config['params'] || {}
+      params.merge!(override_params) if override_params
+      params.map { |k, v| [k, process_param_substitutions(v)] }.to_h
+    end
+
+    def process_param_substitutions(val)
+      old_val = nil
+      while old_val != val
+        old_val = val
+        val = val.sub(/\${[^}]+}/) do |m|
+          token = m[2..-2]
+          CfnParamResolver.new(token).resolve
+        end
       end
-      @processed_events.merge(unprocessed_events.map(&:event_id))
-      unprocessed_events.reverse.map { |e| Event.new(e) }
+      val
     end
 
-    def last_event_time
-      return Time.at(0) if !underlying_stack
-      events = cloudformation.describe_stack_events({stack_name: @stack_name}).stack_events
-      events.length > 0 ? events[0].timestamp : Time.at(0)
+    def extract_cfn_options(config)
+      valid_options = ["capabilities"]
+      config.select { |k| valid_options.include?(k) }
     end
 
   end