cfer 0.2.0 → 0.3.0

data/lib/cfer/cfn/client.rb

@@ -3,6 +3,7 @@ module Cfer::Cfn
 
   class Client < Cfer::Core::Client
     attr_reader :name
+    attr_reader :stack
 
     def initialize(options)
       @name = options[:stack_name]
@@ -27,51 +28,74 @@ module Cfer::Cfn
       @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)
+      create_params = []
+      update_params = []
 
-        output_val = tmpl_param.no_echo ? '*****' : cfn_param
-        Cfer::LOGGER.debug "Parameter #{tmpl_param.parameter_key}=#{output_val}"
+      previous_parameters =
+        begin
+          fetch_parameters
+        rescue Cfer::Util::StackDoesNotExistError
+          nil
+        end
 
-        {
-          parameter_key: tmpl_param.parameter_key,
-          parameter_value: cfn_param,
-          use_previous_value: false
-        }
+      response.parameters.each do |tmpl_param|
+        input_param = stack.input_parameters[tmpl_param.parameter_key]
+        old_param = previous_parameters[tmpl_param.parameter_key] if previous_parameters
+
+        Cfer::LOGGER.debug "== Evaluating Parameter '#{tmpl_param.parameter_key.to_s}':"
+        Cfer::LOGGER.debug "Input value:    #{input_param.to_s || 'nil'}"
+        Cfer::LOGGER.debug "Previous value: #{old_param.to_s || 'nil'}"
+
+
+        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
+          }
+
+          create_params << p
+          update_params << p
+        else
+          if old_param
+            Cfer::LOGGER.debug "Parameter #{tmpl_param.parameter_key} is unspecified (unchanged)"
+              update_params << {
+              parameter_key: tmpl_param.parameter_key,
+              use_previous_value: true
+            }
+          else
+            Cfer::LOGGER.debug "Parameter #{tmpl_param.parameter_key} is unspecified (default)"
+          end
+        end
       end
 
-      options = {
+      Cfer::LOGGER.debug "==================="
+
+      stack_options = {
         stack_name: name,
         template_body: stack.to_cfn,
-        parameters: parameters,
         capabilities: response.capabilities
       }
 
-      created = false
-      cfn_stack = begin
-          created = true
-          create_stack options
+      stack_options[:on_failure] = options[:on_failure] if options[:on_failure]
+      stack_options[:timeout_in_minutes] = options[:timeout] if options[:timeout]
+
+      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])
+
+      cfn_stack =
+        begin
+          create_stack stack_options.merge parameters: create_params
         rescue Cfer::Util::StackExistsError
-          update_stack options
+          update_stack stack_options.merge parameters: update_params
         end
 
       flush_cache
@@ -82,13 +106,13 @@ module Cfer::Cfn
     # @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)
+    def tail(options = {})
       q = []
       event_id_highwater = nil
       counter = 0
       number = options[:number] || 0
-      for_each_event name do |event|
-        q.unshift event if counter < number
+      for_each_event name do |fetched_event|
+        q.unshift fetched_event if counter < number
         counter = counter + 1
       end
 
@@ -105,13 +129,13 @@ module Cfer::Cfn
           running = running && (/.+_(COMPLETE|FAILED)$/.match(stack_status) == nil)
 
           yielding = true
-          for_each_event name do |event|
-            if event_id_highwater == event.event_id
+          for_each_event name do |fetched_event|
+            if event_id_highwater == fetched_event.event_id
               yielding = false
             end
 
             if yielding
-              q.unshift event
+              q.unshift fetched_event
             end
           end
 
@@ -127,7 +151,28 @@ module Cfer::Cfn
     end
 
     def fetch_stack(stack_name = @name)
-      @stack_cache[stack_name] ||= describe_stacks(stack_name: stack_name).stacks.first.to_h
+      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
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        raise Cfer::Util::StackDoesNotExistError, e.message
+      end
+    end
+
+    def fetch_parameters(stack_name = @name)
+      @stack_parameters[stack_name] ||= 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])
+    end
+
+    def fetch_output(stack_name, output_name)
+      fetch_outputs(stack_name)[output_name] || raise(Cfer::Util::CferError, "Stack #{stack_name} has no output named `#{output_name}`")
+    end
+
+    def fetch_parameter(stack_name, param_name)
+      fetch_parameters(stack_name)[param_name] || raise(Cfer::Util::CferError, "Stack #{stack_name} has no parameter named `#{param_name}`")
     end
 
     def to_h
@@ -136,29 +181,58 @@ module Cfer::Cfn
 
     private
 
+    def cfn_list_to_hash(attribute, list)
+      key = :"#{attribute}_key"
+      value = :"#{attribute}_value"
+
+      Hash[ *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 fetch_output(stack_name, output_name)
-      stack = fetch_stack(stack_name)
-
-      output = stack[:outputs].find do |o|
-        o[:output_key] == output_name
+    def for_each_event(stack_name)
+      describe_stack_events(stack_name: stack_name).stack_events.each do |event|
+        yield event
       end
+    end
 
-      if output
-        output[:output_value]
-      else
-        raise CferError, "Stack #{stack_name} has no output value named `#{output_name}`"
-      end
+    # Validates a string as json
+    #
+    # @param string [String]
+    def is_json?(string)
+      JSON.parse(string)
+      true
+    rescue JSON::ParserError
+      false
     end
 
-    def for_each_event(stack_name)
-      describe_stack_events(stack_name: stack_name).stack_events.each do |event|
-        yield event
+    # Parses stack-policy-* options as an S3 URL, file to read, or JSON string
+    #
+    # @param name [String] Name of option: 'stack_policy' or 'stack_policy_during_update'
+    # @param value [String] String containing URL, filename or JSON string
+    # @return [Hash] Hash suitable for merging into options for create_stack or update_stack
+    def parse_stack_policy(name, value)
+      Cfer::LOGGER.debug "Using #{name} from: #{value}"
+      if value.nil?
+        {}
+      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
+        {"#{name}_body".to_sym => File.read(value)}
+      elsif is_json?(value)                                   # looks like a JSON string
+        {"#{name}_body".to_sym => value}
+      else                                                    # none of the above
+        raise Cfer::Util::CferError, "Stack policy must be an S3 url, a filename, or a valid json string"
       end
     end
   end
 end
-

data/lib/cfer/cli.rb

@@ -26,7 +26,7 @@ module Cfer
         default: 'table'
     end
 
-    desc 'converge [OPTIONS] <stack-name>', 'Converges a cloudformation stack according to the template'
+    desc 'converge [OPTIONS] <stack-name>', 'Create or update a cloudformation stack according to the template'
     #method_option :git_lock,
     #  type: :boolean,
     #  default: true,
@@ -34,7 +34,6 @@ module Cfer
 
     method_option :on_failure,
       type: :string,
-      default: 'DELETE',
       desc: 'The action to take if the stack creation fails'
     method_option :follow,
       aliases: :f,
@@ -49,6 +48,17 @@ module Cfer
       aliases: :t,
       type: :string,
       desc: 'Override the stack filename (defaults to <stack-name>.rb)'
+    method_option :stack_policy,
+      aliases: :s,
+      type: :string,
+      desc: 'Set a new stack policy on create or update of the stack [file|url|json]'
+    method_option :stack_policy_during_update,
+      aliases: :u,
+      type: :string,
+      desc: 'Set a temporary overriding stack policy during an update [file|url|json]'
+    method_option :timeout,
+      type: :numeric,
+      desc: 'The timeout (in minutes) before the stack operation aborts'
     template_options
     stack_options
     def converge(stack_name)
@@ -112,7 +122,7 @@ module Cfer
         if Cfer::DEBUG
           Pry::rescued(e)
         else
-          Cfer::Util.bug_report(e)
+          #Cfer::Util.bug_report(e)
         end
         exit 1
       end
@@ -135,4 +145,3 @@ module Cfer
 
 
 end
-

data/lib/cfer/core/client.rb

@@ -7,9 +7,5 @@ module Cfer::Core
     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

@@ -28,8 +28,12 @@ module Cfer::Core::Fn
       {"Condition" => cond}
     end
 
-    def and(conds)
-      {"Fn::And" => [conds]}
+    def and(*conds)
+      {"Fn::And" => conds}
+    end
+
+    def or(*conds)
+      {"Fn::Or" => conds}
     end
 
     def equals(a, b)
@@ -41,11 +45,7 @@ module Cfer::Core::Fn
     end
 
     def not(cond)
-      {"Fn::Not" => cond}
-    end
-
-    def or(conds)
-      {"Fn::Or" => conds}
+      {"Fn::Not" => [cond]}
     end
 
     def get_azs(region)

data/lib/cfer/core/resource.rb

@@ -1,6 +1,6 @@
 module Cfer::Cfn
   class Resource < Cfer::Block
-    NON_PROXIED_METHODS = [:parameters, :options, :resolve]
+    NON_PROXIED_METHODS = [:parameters, :options, :lookup_output]
 
     def initialize(name, type, **options, &block)
       @name = name

data/lib/cfer/core/stack.rb

@@ -5,7 +5,12 @@ module Cfer::Core
     include Cfer::Core
     include Cfer::Cfn
 
+    # The parameters strictly as passed via command line
+    attr_reader :input_parameters
+
+    # The fully resolved parameters, including defaults and parameters fetched from an existing stack during an update
     attr_reader :parameters
+
     attr_reader :options
 
     def converge!
@@ -20,10 +25,6 @@ module Cfer::Core
       end
     end
 
-    def resolve(val)
-      @options[:client] ? @options[:client].resolve(val) : val
-    end
-
     def initialize(options = {})
       self[:AWSTemplateFormatVersion] = '2010-09-09'
       self[:Description] = ''
@@ -37,17 +38,23 @@ module Cfer::Core
       self[:Outputs] = {}
 
       @parameters = HashWithIndifferentAccess.new
+      @input_parameters = HashWithIndifferentAccess.new
+
+      if options[:client]
+        begin
+          @parameters.merge! options[:client].fetch_parameters
+        rescue Cfer::Util::StackDoesNotExistError
+          Cfer::LOGGER.debug "Can't include current stack parameters because the stack doesn't exist yet."
+        end
+      end
 
       if options[:parameters]
         options[:parameters].each do |key, val|
-          @parameters[key] = resolve(val)
+          @input_parameters[key] = @parameters[key] = val
         end
       end
     end
 
-    def pre_block
-    end
-
     # Sets the description for this CloudFormation stack
     def description(desc)
       self[:Description] = desc
@@ -80,35 +87,12 @@ module Cfer::Core
         k = key.to_s.camelize.to_sym
         param[k] =
           case k
-          when :AllowedValues
-            str_list = v.join(',')
-            verify_param(name, "Parameter #{name} must be one of: #{str_list}") { |input_val| str_list.include?(input_val) }
-            str_list
           when :AllowedPattern
             if v.class == Regexp
-              verify_param(name, "Parameter #{name} must match /#{v.source}/") { |input_val| v =~ input_val }
               v.source
-            else
-              verify_param(name, "Parameter #{name} must match /#{v}/") { |input_val| Regexp.new(v) =~ input_val }
-              v
             end
-          when :MaxLength
-            verify_param(name, "Parameter #{name} must have length <= #{v}") { |input_val| input_val.length <= v.to_i }
-            v
-          when :MinLength
-            verify_param(name, "Parameter #{name} must have length >= #{v}") { |input_val| input_val.length >= v.to_i }
-            v
-          when :MaxValue
-            verify_param(name, "Parameter #{name} must be <= #{v}") { |input_val| input_val.to_i <= v.to_i }
-            v
-          when :MinValue
-            verify_param(name, "Parameter #{name} must be >= #{v}") { |input_val| input_val.to_i >= v.to_i }
-            v
-          when :Description
-            Preconditions.check_argument(v.length <= 4000, "#{key} must be <= 4000 characters")
-            v
           when :Default
-            @parameters[name] ||= resolve(v)
+            @parameters[name] ||= v
           end
         param[k] ||= v
       end
@@ -148,7 +132,7 @@ module Cfer::Core
     # @param name [String] The Logical ID of the output parameter
     # @param value [String] Value to return
     # @param options [Hash] Extra options for this output parameter
-    # @option options [String] :Description Informationa bout the value
+    # @option options [String] :Description Information about the value
     def output(name, value, options = {})
       self[:Outputs][name] = options.merge('Value' => value)
     end
@@ -159,6 +143,10 @@ module Cfer::Core
       to_h.to_json
     end
 
+    def client
+      @options[:client] || raise(Cfer::Util::CferError, "Stack has no associated client.")
+    end
+
     # 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)
@@ -170,9 +158,9 @@ module Cfer::Core
       end
     end
 
-    private
-    def verify_param(param_name, err_msg)
-      raise Cfer::Util::CferError, err_msg if (@parameters[param_name] && !yield(@parameters[param_name].to_s))
+    def lookup_output(stack, out)
+      client = @options[:client] || raise(Cfer::Util::CferError, "Can not fetch stack outputs without a client")
+      client.fetch_output(stack, out)
     end
   end