cfer 0.3.0 → 0.4.0

data/lib/cfer/cfn/client.rb

@@ -1,4 +1,6 @@
 require_relative '../core/client'
+require 'uri'
+
 module Cfer::Cfn
 
   class Client < Cfer::Core::Client
@@ -6,9 +8,11 @@ module Cfer::Cfn
     attr_reader :stack
 
     def initialize(options)
+      super
       @name = options[:stack_name]
-      options.delete :stack_name
-      @cfn = Aws::CloudFormation::Client.new(options)
+      @options = options
+      @options.delete :stack_name
+      @cfn = Aws::CloudFormation::Client.new(@options)
       flush_cache
     end
 
@@ -20,6 +24,17 @@ module Cfer::Cfn
       end
     end
 
+
+    def delete_stack(stack_name)
+      begin
+        @cfn.delete_stack({
+          stack_name: stack_name, # required
+        })
+      rescue Aws::CloudFormation::Errors
+        raise CferError, "Stack delete #{stack_name}"
+      end
+    end
+
     def responds_to?(method)
       @cfn.responds_to? method
     end
@@ -28,6 +43,29 @@ module Cfer::Cfn
       @cfn.send(method, *args, &block)
     end
 
+    def estimate(stack, options = {})
+      response = validate_template(template_body: stack.to_cfn)
+
+      estimate_params = []
+      response.parameters.each do |tmpl_param|
+        input_param = stack.input_parameters[tmpl_param.parameter_key]
+        if input_param
+          output_val = tmpl_param.no_echo ? '*****' : input_param
+          Cfer::LOGGER.debug "Parameter #{tmpl_param.parameter_key}=#{output_val}"
+          p = {
+            parameter_key: tmpl_param.parameter_key,
+            parameter_value: input_param,
+            use_previous_value: false
+          }
+
+          estimate_params << p
+        end
+      end
+
+      estimate_response = estimate_template_cost(template_body: stack.to_cfn, parameters: estimate_params)
+      estimate_response.url
+    end
+
     def converge(stack, options = {})
       Preconditions.check(@name).is_not_nil
       Preconditions.check(stack) { is_not_nil and has_type(Cfer::Core::Stack) }
@@ -37,12 +75,15 @@ module Cfer::Cfn
       create_params = []
       update_params = []
 
-      previous_parameters =
-        begin
-          fetch_parameters
-        rescue Cfer::Util::StackDoesNotExistError
-          nil
-        end
+      previous_parameters = fetch_parameters rescue nil
+
+      current_version = Cfer::SEMANTIC_VERSION
+      previous_version = fetch_cfer_version rescue nil
+
+      current_hash = stack.git_version
+      previous_hash = fetch_git_hash rescue nil
+
+      # Compare current and previous versions and hashes?
 
       response.parameters.each do |tmpl_param|
         input_param = stack.input_parameters[tmpl_param.parameter_key]
@@ -81,7 +122,6 @@ module Cfer::Cfn
 
       stack_options = {
         stack_name: name,
-        template_body: stack.to_cfn,
         capabilities: response.capabilities
       }
 
@@ -91,11 +131,19 @@ module Cfer::Cfn
       stack_options.merge! parse_stack_policy(:stack_policy, options[:stack_policy])
       stack_options.merge! parse_stack_policy(:stack_policy_during_update, options[:stack_policy_during_update])
 
+      stack_options.merge! upload_or_return_template(stack.to_cfn, options)
+
       cfn_stack =
         begin
           create_stack stack_options.merge parameters: create_params
+          :created
         rescue Cfer::Util::StackExistsError
-          update_stack stack_options.merge parameters: update_params
+          if options[:change]
+            create_change_set stack_options.merge change_set_name: options[:change], description: options[:change_description], parameters: update_params
+          else
+            update_stack stack_options.merge parameters: update_params
+          end
+          :updated
         end
 
       flush_cache
@@ -150,21 +198,59 @@ module Cfer::Cfn
       end
     end
 
+    def stack_cache(stack_name)
+      @stack_cache[stack_name] ||= {}
+    end
+
     def fetch_stack(stack_name = @name)
       raise Cfer::Util::StackDoesNotExistError, 'Stack name must be specified' if stack_name == nil
       begin
-        @stack_cache[stack_name] ||= describe_stacks(stack_name: stack_name).stacks.first.to_h
+        stack_cache(stack_name)[:stack] ||= describe_stacks(stack_name: stack_name).stacks.first.to_h
       rescue Aws::CloudFormation::Errors::ValidationError => e
         raise Cfer::Util::StackDoesNotExistError, e.message
       end
     end
 
+    def fetch_summary(stack_name = @name)
+      begin
+        stack_cache(stack_name)[:summary] ||= get_template_summary(stack_name: stack_name)
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        raise Cfer::Util::StackDoesNotExistError, e.message
+      end
+    end
+
+    def fetch_metadata(stack_name = @name)
+      md = fetch_summary(stack_name).metadata
+      stack_cache(stack_name)[:metadata] ||=
+        if md
+          JSON.parse(md)
+        else
+          {}
+        end
+    end
+
+    def remove(stack_name, options = {})
+      delete_stack(stack_name)
+    end
+
+    def fetch_cfer_version(stack_name = @name)
+      previous_version = Semantic::Version.new('0.0.0')
+      if previous_version_hash = fetch_metadata(stack_name).fetch('Cfer', {}).fetch('Version', nil)
+        previous_version_hash.each { |k, v| previous_version.send(k + '=', v) }
+        previous_version
+      end
+    end
+
+    def fetch_git_hash(stack_name = @name)
+      fetch_metadata(stack_name).fetch('Cfer', {}).fetch('Git', {}).fetch('Rev', nil)
+    end
+
     def fetch_parameters(stack_name = @name)
-      @stack_parameters[stack_name] ||= cfn_list_to_hash('parameter', fetch_stack(stack_name)[:parameters])
+      stack_cache(stack_name)[:parameters] ||= cfn_list_to_hash('parameter', fetch_stack(stack_name)[:parameters])
     end
 
     def fetch_outputs(stack_name = @name)
-      @stack_outputs[stack_name] ||= cfn_list_to_hash('output', fetch_stack(stack_name)[:outputs])
+      stack_cache(stack_name)[:outputs] ||= cfn_list_to_hash('output', fetch_stack(stack_name)[:outputs])
     end
 
     def fetch_output(stack_name, output_name)
@@ -181,22 +267,37 @@ module Cfer::Cfn
 
     private
 
+    def upload_or_return_template(cfn_hash, options = {})
+      if cfn_hash.bytesize <= 51200 && !options[:force_s3]
+        { template_body: cfn_hash }
+      else
+        raise Cfer::Util::CferError, 'Cfer needs to upload the template to S3, but no bucket was specified.' unless options[:s3_path]
+
+        uri = URI(options[:s3_path])
+        template = Aws::S3::Object.new bucket_name: uri.host, key: uri.path.reverse.chomp('/').reverse
+        template.put body: cfn_hash
+
+        template_url = template.public_url
+        template_url = template_url + '?versionId=' + template.version_id if template.version_id
+
+        { template_url: template_url }
+      end
+    end
+
     def cfn_list_to_hash(attribute, list)
+      return {} unless list
+
       key = :"#{attribute}_key"
       value = :"#{attribute}_value"
 
-      Hash[ *list.map { |kv| [ kv[key].to_s, kv[value].to_s ] }.flatten ]
+      HashWithIndifferentAccess[ *list.map { |kv| [ kv[key].to_s, kv[value].to_s ] }.flatten ]
     end
 
     def flush_cache
       Cfer::LOGGER.debug "*********** FLUSH CACHE ***************"
       Cfer::LOGGER.debug "Stack cache: #{@stack_cache}"
-      Cfer::LOGGER.debug "Stack parameters: #{@stack_parameters}"
-      Cfer::LOGGER.debug "Stack outputs: #{@stack_outputs}"
       Cfer::LOGGER.debug "***************************************"
       @stack_cache = {}
-      @stack_parameters = {}
-      @stack_outputs = {}
     end
 
     def for_each_event(stack_name)
@@ -224,6 +325,8 @@ module Cfer::Cfn
       Cfer::LOGGER.debug "Using #{name} from: #{value}"
       if value.nil?
         {}
+      elsif value.is_a?(Hash)
+        {"#{name}_body".to_sym => value.to_json}
       elsif value.match(/\A#{URI::regexp(%w[http https s3])}\z/) # looks like a URL
         {"#{name}_url".to_sym => value}
       elsif File.exist?(value)                               # looks like a file to read

data/lib/cfer/cli.rb

@@ -4,6 +4,7 @@ require 'table_print'
 
 module Cfer
   class Cli < Thor
+    map '-v' => :version, '--version' => :version
 
     namespace 'cfer'
     class_option :verbose, type: :boolean, default: false
@@ -12,11 +13,16 @@ module Cfer
     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: {}
+      method_option :parameter_file,
+        type: :string,
+        desc: 'A YAML or JSON file with CloudFormation parameters to pass to the stack'
+      method_option :parameter_environment,
+        type: :string,
+        desc: 'If parameter_file is set, will merge the subkey of this into the parameter list.'
     end
 
     def self.stack_options
@@ -59,6 +65,20 @@ module Cfer
     method_option :timeout,
       type: :numeric,
       desc: 'The timeout (in minutes) before the stack operation aborts'
+    method_option :s3_path,
+      type: :string,
+      desc: 'Specifies an S3 path in case the stack is created with a URL.'
+    method_option :force_s3,
+      type: :boolean,
+      default: false,
+      desc: 'Forces Cfer to upload the template to S3 and pass CloudFormation a URL.'
+    method_option :change,
+      type: :string,
+      desc: 'Issues updates as a Cfn change set.'
+    method_option :change_description,
+      type: :string,
+      desc: 'The description of this Cfn change'
+
     template_options
     stack_options
     def converge(stack_name)
@@ -71,6 +91,12 @@ module Cfer
       Cfer.describe! stack_name, options
     end
 
+    desc 'delete <stack>', 'Deletes a CloudFormation stack'
+    stack_options
+    def delete(stack_name)
+      Cfer.delete! stack_name, options
+    end
+
     desc 'tail <stack>', 'Follows stack events on standard output as they occur'
     method_option :follow,
       aliases: :f,
@@ -96,6 +122,14 @@ module Cfer
       Cfer.generate! tmpl, options
     end
 
+    desc 'estimate [OPTIONS] <template.rb>', 'Prints a link to the Amazon cost caculator estimating the cost of the resulting CloudFormation stack'
+    long_desc <<-LONGDESC
+    LONGDESC
+    template_options
+    def estimate(tmpl)
+      Cfer.estimate! tmpl, options
+    end
+
     def self.main(args)
       Cfer::LOGGER.debug "Cfer version #{Cfer::VERSION}"
       begin
@@ -128,6 +162,11 @@ module Cfer
       end
     end
 
+    desc 'version', 'Prints the current version of Cfer'
+    def version
+      puts Cfer::VERSION
+    end
+
     private
 
     def cfn(opts = {})

data/lib/cfer/core/client.rb

@@ -1,5 +1,16 @@
+require 'git'
+
 module Cfer::Core
   class Client
+    attr_reader :git
+
+    def initialize(options)
+      path = options[:working_directory] || '.'
+      if File.exist?("#{path}/.git")
+        @git = Git.open(path) rescue nil
+      end
+    end
+
     def converge
       raise Cfer::Util::CferError, 'converge not implemented on this client'
     end

data/lib/cfer/core/resource.rb

@@ -1,6 +1,6 @@
-module Cfer::Cfn
-  class Resource < Cfer::Block
-    NON_PROXIED_METHODS = [:parameters, :options, :lookup_output]
+module Cfer::Core
+  class Resource < Cfer::BlockHash
+    @@types = {}
 
     def initialize(name, type, **options, &block)
       @name = name
@@ -9,36 +9,34 @@ module Cfer::Cfn
       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)
+    def properties(keyvals = {})
       self[:Properties].merge!(keyvals)
     end
 
-    def respond_to?(method_sym)
-      !NON_PROXIED_METHODS.include?(method_sym)
+    def get_property(key)
+      puts self[:Properties]
+      self[:Properties].fetch key
     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
+    class << self
+      def resource_class(type)
+        @@types[type] ||= "CferExt::#{type}".split('::').inject(Object) { |o, c| o.const_get c if o && o.const_defined?(c) } || Class.new(Cfer::Core::Resource)
+      end
+
+      def extend_resource(type, &block)
+        resource_class(type).instance_eval(&block)
       end
     end
 
     private
-    def camelize_property(sym)
-      sym.to_s.camelize.to_sym
-    end
   end
 end

data/lib/cfer/core/stack.rb

@@ -13,16 +13,18 @@ module Cfer::Core
 
     attr_reader :options
 
-    def converge!
-      if @options[:client]
-        @options[:client].converge self
-      end
+    attr_reader :git_version
+
+    def client
+      @options[:client] || raise('No client set on this stack')
     end
 
-    def tail!(&block)
-      if @options[:client]
-        @options[:client].tail self, &block
-      end
+    def converge!(options = {})
+      client.converge self, options
+    end
+
+    def tail!(options = {}, &block)
+      client.tail self, options, &block
     end
 
     def initialize(options = {})
@@ -31,12 +33,25 @@ module Cfer::Core
 
       @options = options
 
+      self[:Metadata] = {
+        :Cfer => {
+          :Version => Cfer::SEMANTIC_VERSION.to_h.delete_if { |k, v| v === nil }
+        }
+      }
+
       self[:Parameters] = {}
       self[:Mappings] = {}
       self[:Conditions] = {}
       self[:Resources] = {}
       self[:Outputs] = {}
 
+      if options[:client] && git = options[:client].git && @git_version = (git.object('HEAD^').sha rescue nil)
+        self[:Metadata][:Cfer][:Git] = {
+          Rev: @git_version,
+          Clean: git.status.changed.empty?
+        }
+      end
+
       @parameters = HashWithIndifferentAccess.new
       @input_parameters = HashWithIndifferentAccess.new
 
@@ -84,6 +99,8 @@ module Cfer::Core
     def parameter(name, options = {})
       param = {}
       options.each do |key, v|
+        next if v === nil
+
         k = key.to_s.camelize.to_sym
         param[k] =
           case k
@@ -119,9 +136,7 @@ module Cfer::Core
     def resource(name, type, options = {}, &block)
       Preconditions.check_argument(/[[:alnum:]]+/ =~ name, "Resource name must be alphanumeric")
 
-      clazz = "CferExt::#{type}".split('::').inject(Object) { |o, c| o.const_get c if o && o.const_defined?(c) } || Cfer::Cfn::Resource
-      Preconditions.check_argument clazz <= Cfer::Cfn::Resource, "#{type} is not a valid resource type because CferExt::#{type} does not inherit from `Cfer::Cfn::Resource`"
-
+      clazz = Cfer::Core::Resource.resource_class(type)
       rc = clazz.new(name, type, options, &block)
 
       self[:Resources][name] = rc
@@ -150,10 +165,9 @@ module Cfer::Core
     # Includes template code from one or more files, and evals it in the context of this stack.
     # Filenames are relative to the file containing the invocation of this method.
     def include_template(*files)
-      calling_file = caller.first.split(/:\d/,2).first
-      dirname = File.dirname(calling_file)
+      include_base = options[:include_base] || File.dirname(caller.first.split(/:\d/,2).first)
       files.each do |file|
-        path = File.join(dirname, file)
+        path = File.join(include_base, file)
         instance_eval(File.read(path), path)
       end
     end
@@ -162,6 +176,63 @@ module Cfer::Core
       client = @options[:client] || raise(Cfer::Util::CferError, "Can not fetch stack outputs without a client")
       client.fetch_output(stack, out)
     end
+
+    def lookup_outputs(stack)
+      client = @options[:client] || raise(Cfer::Util::CferError, "Can not fetch stack outputs without a client")
+      client.fetch_outputs(stack)
+    end
+
+    private
+
+    def post_block
+      begin
+        validate_stack!(self)
+      rescue Cfer::Util::CferValidationError => e
+        Cfer::LOGGER.error "Cfer detected #{e.errors.size > 1 ? 'errors' : 'an error'} when generating the stack:"
+        e.errors.each do |err|
+          Cfer::LOGGER.error "* #{err[:error]} in Stack#{validation_contextualize(err[:context])}"
+        end
+        raise e
+      end
+    end
+
+    def validate_stack!(hash)
+      errors = []
+      context = []
+      _inner_validate_stack!(hash, errors, context)
+
+      raise Cfer::Util::CferValidationError, errors unless errors.empty?
+    end
+
+    def _inner_validate_stack!(hash, errors = [], context = [])
+      case hash
+      when Hash
+        hash.each do |k, v|
+          _inner_validate_stack!(v, errors, context + [k])
+        end
+      when Array
+        hash.each_index do |i|
+          _inner_validate_stack!(hash[i], errors, context + [i])
+        end
+      when nil
+        errors << {
+          error: "CloudFormation does not allow nulls in templates",
+          context: context
+        }
+      end
+    end
+
+    def validation_contextualize(err_ctx)
+      err_ctx.inject("") do |err_str, ctx|
+        err_str <<
+          case ctx
+          when String
+            ".#{ctx}"
+          when Numeric
+            "[#{ctx}]"
+          end
+      end
+    end
   end
 
 end