cfer 0.1.1

data/lib/cfer/cfn/aws.rb

@@ -0,0 +1,29 @@
+module Cfer::Cfn::AWS
+  class << self
+    include Cfer::Core
+    def account_id
+      Fn::ref 'AWS::AccountId'
+    end
+
+    def notification_arns
+      Fn::ref 'AWS::NotificationARNs'
+    end
+
+    def no_value
+      Fn::ref 'AWS::NoValue'
+    end
+
+    def region
+      Fn::ref 'AWS::Region'
+    end
+
+    def stack_id
+      Fn::ref 'AWS::StackId'
+    end
+
+    def stack_name
+      Fn::ref 'AWS::StackName'
+    end
+  end
+end
+

data/lib/cfer/cfn/client.rb

@@ -0,0 +1,164 @@
+require_relative '../core/client'
+module Cfer::Cfn
+
+  class Client < Cfer::Core::Client
+    attr_reader :name
+
+    def initialize(options)
+      @name = options[:stack_name]
+      options.delete :stack_name
+      @cfn = Aws::CloudFormation::Client.new(options)
+      flush_cache
+    end
+
+    def create_stack(*args)
+      begin
+        @cfn.create_stack(*args)
+      rescue Aws::CloudFormation::Errors::AlreadyExistsException
+        raise Cfer::Util::StackExistsError
+      end
+    end
+
+    def responds_to?(method)
+      @cfn.responds_to? method
+    end
+
+    def method_missing(method, *args, &block)
+      @cfn.send(method, *args, &block)
+    end
+
+    def resolve(param)
+      # See if the value follows the form @<stack>.<output>
+      m = /^@(.+?)\.(.+)$/.match(param)
+
+      if m
+        fetch_output(m[1], m[2])
+      else
+        param
+      end
+    end
+
+
+    def converge(stack, options = {})
+      Preconditions.check(@name).is_not_nil
+      Preconditions.check(stack) { is_not_nil and has_type(Cfer::Core::Stack) }
+
+      response = validate_template(template_body: stack.to_cfn)
+
+      parameters = response.parameters.map do |tmpl_param|
+        cfn_param = stack.parameters[tmpl_param.parameter_key] || raise(Cfer::Util::CferError, "Parameter #{tmpl_param.parameter_key} was required, but not specified")
+        cfn_param = resolve(cfn_param)
+
+        output_val = tmpl_param.no_echo ? '*****' : cfn_param
+        Cfer::LOGGER.debug "Parameter #{tmpl_param.parameter_key}=#{output_val}"
+
+        {
+          parameter_key: tmpl_param.parameter_key,
+          parameter_value: cfn_param,
+          use_previous_value: false
+        }
+      end
+
+      options = {
+        stack_name: name,
+        template_body: stack.to_cfn,
+        parameters: parameters,
+        capabilities: response.capabilities
+      }
+
+      created = false
+      cfn_stack = begin
+          created = true
+          create_stack options
+        rescue Cfer::Util::StackExistsError
+          update_stack options
+        end
+
+      flush_cache
+      cfn_stack
+    end
+
+    # Yields to the given block for each CloudFormation event that qualifies, given the specified options.
+    # @param options [Hash] The options hash
+    # @option options [Fixnum] :number The maximum number of already-existing CloudFormation events to yield.
+    # @option options [Boolean] :follow Set to true to wait until the stack enters a `COMPLETE` or `FAILED` state, yielding events as they occur.
+    def tail(options = {}, &block)
+      q = []
+      event_id_highwater = nil
+      counter = 0
+      number = options[:number] || 0
+      for_each_event name do |event|
+        q.unshift event if counter < number
+        counter = counter + 1
+      end
+
+      while q.size > 0
+        event = q.shift
+        yield event
+        event_id_highwater = event.event_id
+      end
+
+      running = true
+      if options[:follow]
+        while running
+          stack_status = describe_stacks(stack_name: name).stacks.first.stack_status
+          running = running && (/.+_(COMPLETE|FAILED)$/.match(stack_status) == nil)
+
+          yielding = true
+          for_each_event name do |event|
+            if event_id_highwater == event.event_id
+              yielding = false
+            end
+
+            if yielding
+              q.unshift event
+            end
+          end
+
+          while q.size > 0
+            event = q.shift
+            yield event
+            event_id_highwater = event.event_id
+          end
+
+          sleep 1 if running unless options[:no_sleep]
+        end
+      end
+    end
+
+    def fetch_stack(stack_name = @name)
+      @stack_cache[stack_name] ||= describe_stacks(stack_name: stack_name).stacks.first.to_h
+    end
+
+    def to_h
+      @stack.to_h
+    end
+
+    private
+
+    def flush_cache
+      @stack_cache = {}
+    end
+
+    def fetch_output(stack_name, output_name)
+      stack = fetch_stack(stack_name)
+
+      output = stack[:outputs].find do |o|
+        o[:output_key] == output_name
+      end
+
+      if output
+        output[:output_value]
+      else
+        raise CferError, "Stack #{stack_name} has no output value named `#{output_name}`"
+      end
+    end
+
+    def for_each_event(stack_name)
+      describe_stack_events(stack_name: stack_name).stack_events.each do |event|
+        yield event
+      end
+    end
+  end
+end
+

data/lib/cfer/cli.rb

@@ -0,0 +1,138 @@
+require 'thor'
+require 'rainbow'
+require 'table_print'
+
+module Cfer
+  class Cli < Thor
+
+    namespace 'cfer'
+    class_option :verbose, type: :boolean, default: false
+    class_option :profile, type: :string, aliases: :p, desc: 'The AWS profile to use from your credentials file'
+    class_option :region, type: :string, aliases: :r, desc: 'The AWS region to use'
+    class_option :pretty_print, type: :boolean, default: :true, desc: 'Render JSON in a more human-friendly format'
+
+    def self.template_options
+
+      method_option :parameters,
+        type: :hash,
+        desc: 'The CloudFormation parameters to pass to the stack',
+        default: {}
+    end
+
+    def self.stack_options
+      method_option :output_format,
+        type: :string,
+        desc: 'The output format of the stack [table|json]',
+        default: 'table'
+    end
+
+    desc 'converge [OPTIONS] <stack-name>', 'Converges a cloudformation stack according to the template'
+    #method_option :git_lock,
+    #  type: :boolean,
+    #  default: true,
+    #  desc: 'When enabled, Cfer will not converge a stack in a dirty git tree'
+
+    method_option :on_failure,
+      type: :string,
+      default: 'DELETE',
+      desc: 'The action to take if the stack creation fails'
+    method_option :follow,
+      aliases: :f,
+      type: :boolean,
+      default: true,
+      desc: 'Follow stack events on standard output while the changes are made.'
+    method_option :number,
+      type: :numeric,
+      default: 1,
+      desc: 'Prints the last (n) stack events.'
+    method_option :template,
+      aliases: :t,
+      type: :string,
+      desc: 'Override the stack filename (defaults to <stack-name>.rb)'
+    template_options
+    stack_options
+    def converge(stack_name)
+      Cfer.converge! stack_name, options
+    end
+
+    desc 'describe <stack>', 'Fetches and prints information about a CloudFormation'
+    stack_options
+    def describe(stack_name)
+      Cfer.describe! stack_name, options
+    end
+
+    desc 'tail <stack>', 'Follows stack events on standard output as they occur'
+    method_option :follow,
+      aliases: :f,
+      type: :boolean,
+      default: false,
+      desc: 'Follow stack events on standard output while the changes are made.'
+    method_option :number,
+      aliases: :n,
+      type: :numeric,
+      default: 10,
+      desc: 'Prints the last (n) stack events.'
+    stack_options
+    def tail(stack_name)
+      Cfer.tail! stack_name, options
+    end
+
+    desc 'generate [OPTIONS] <template.rb>', 'Generates a CloudFormation template by evaluating a Cfer template'
+    long_desc <<-LONGDESC
+      Generates a CloudFormation template by evaluating a Cfer template.
+    LONGDESC
+    template_options
+    def generate(tmpl)
+      Cfer.generate! tmpl, options
+    end
+
+    def self.main(args)
+      Cfer::LOGGER.debug "Cfer version #{Cfer::VERSION}"
+      begin
+        Cli.start(args)
+      rescue Aws::Errors::NoSuchProfileError => e
+        Cfer::LOGGER.error "#{e.message}. Specify a valid profile with the --profile option."
+        exit 1
+      rescue Aws::Errors::MissingRegionError => e
+        Cfer::LOGGER.error "Missing region. Specify a valid AWS region with the --region option, or use the AWS_REGION environment variable."
+        exit 1
+      rescue Interrupt
+        Cfer::LOGGER.info 'Caught interrupt. Goodbye.'
+      rescue Cfer::Util::TemplateError => e
+        Cfer::LOGGER.fatal "Template error: #{e.message}"
+        Cfer::LOGGER.fatal Cfer::Cli.format_backtrace(e.template_backtrace) unless e.template_backtrace.empty?
+        exit 1
+      rescue Cfer::Util::CferError => e
+        Cfer::LOGGER.error "#{e.message}"
+        exit 1
+      rescue  StandardError => e
+        Cfer::LOGGER.fatal "#{e.class.name}: #{e.message}"
+        Cfer::LOGGER.fatal Cfer::Cli.format_backtrace(e.backtrace) unless e.backtrace.empty?
+
+        if Cfer::DEBUG
+          Pry::rescued(e)
+        else
+          Cfer::Util.bug_report(e)
+        end
+        exit 1
+      end
+    end
+
+    private
+
+    def cfn(opts = {})
+      @cfn ||= opts
+    end
+    private
+    def self.format_backtrace(bt)
+      "Backtrace: #{bt.join("\n   from ")}"
+    end
+    def self.exit_on_failure?
+      true
+    end
+
+  end
+
+
+end
+

data/lib/cfer/core/client.rb

@@ -0,0 +1,15 @@
+module Cfer::Core
+  class Client
+    def converge
+      raise Cfer::Util::CferError, 'converge not implemented on this client'
+    end
+
+    def tail(options = {}, &block)
+      raise Cfer::Util::CferError, 'tail not implemented on this client'
+    end
+
+    def resolve(param)
+      param
+    end
+  end
+end

data/lib/cfer/core/fn.rb

@@ -0,0 +1,55 @@
+module Cfer::Core::Fn
+  class << self
+    def join(sep, args)
+      {"Fn::Join" => [sep, args]}
+    end
+
+    def ref(r)
+      {"Ref" => r}
+    end
+
+    def get_att(r, att)
+      {"Fn::GetAtt" => [r, att]}
+    end
+
+    def find_in_map(map_name, key1, key2)
+      {"Fn::FindInMap" => [map_name, key1, key2]}
+    end
+
+    def select(i, o)
+      {"Fn::Select" => [i, o]}
+    end
+
+    def base64(v)
+      {"Fn::Base64" => v}
+    end
+
+    def condition(cond)
+      {"Condition" => cond}
+    end
+
+    def and(conds)
+      {"Fn::And" => [conds]}
+    end
+
+    def equals(a, b)
+      {"Fn::Equals" => [a, b]}
+    end
+
+    def if(cond, t, f)
+      {"Fn::If" => [cond, t, f]}
+    end
+
+    def not(cond)
+      {"Fn::Not" => cond}
+    end
+
+    def or(conds)
+      {"Fn::Or" => conds}
+    end
+
+    def get_azs(region)
+      {"Fn::GetAZs" => region}
+    end
+  end
+end

data/lib/cfer/core/resource.rb

@@ -0,0 +1,44 @@
+module Cfer::Cfn
+  class Resource < Cfer::Block
+    NON_PROXIED_METHODS = [:parameters, :options]
+
+    def initialize(name, type, **options, &block)
+      @name = name
+
+      self[:Type] = type
+      self.merge!(options)
+      self[:Properties] = HashWithIndifferentAccess.new
+      build_from_block(&block)
+    end
+
+    def tag(k, v, **options)
+      self[:Properties][:Tags] ||= []
+      self[:Properties][:Tags].unshift({"Key" => k, "Value" => v}.merge(options))
+    end
+
+    def properties(**keyvals)
+      self[:Properties].merge!(keyvals)
+    end
+
+    def respond_to?(method_sym)
+      !NON_PROXIED_METHODS.include?(method_sym)
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      key = camelize_property(method_sym)
+      case arguments.size
+      when 0
+        Cfer::Core::Fn::ref(method_sym)
+      when 1
+        properties key => arguments.first
+      else
+        properties key => arguments
+      end
+    end
+
+    private
+    def camelize_property(sym)
+      sym.to_s.camelize.to_sym
+    end
+  end
+end