knife-cloudformation 0.0.1 → 0.1.0

data/CHANGELOG.md

@@ -1,2 +1,5 @@
+## v0.1.0
+* Stable-ish release
+
 ## v0.0.1
 * Initial release

data/lib/chef/knife/cloudformation_base.rb

@@ -2,6 +2,18 @@ require 'chef/knife'
 
 class Chef
   class Knife
+
+    # Populate up the hashes so they are available for knife config
+    # with issues of nils
+    ['knife.cloudformation.credentials', 'knife.cloudformation.options'].each do |stack|
+      stack.split('.').inject(Chef::Config) do |memo, item|
+        memo[item.to_sym] = Mash.new unless memo[item.to_sym]
+        memo[item.to_sym]
+      end
+    end
+    
+    Chef::Config[:knife][:cloudformation] ||= Mash.new
+    
     module CloudformationDefault
       class << self
         def included(klass)
@@ -89,9 +101,13 @@ class Chef
 
       def get_titles(thing, format=false)
         unless(@titles)
-          hash = thing.is_a?(Array) ? thing.first : thing
-          hash ||= {}
-          @titles = hash.keys.map do |key|
+          attrs = allowed_attributes
+          if(attrs.empty?)
+            hash = thing.is_a?(Array) ? thing.first : thing
+            hash ||= {}
+            attrs = hash.keys
+          end
+          @titles = attrs.map do |key|
             next unless attribute_allowed?(key)
             key.gsub(/([a-z])([A-Z])/, '\1 \2')
           end.compact
@@ -172,6 +188,15 @@ class Chef
           JSON.read(thing)
         end
       end
+
+      def _format_json(thing)
+        thing = _from_json(thing) if thing.is_a?(String)
+        if(try_json_compat)
+          Chef::JSONCompat.to_json_pretty(thing)
+        else
+          JSON.pretty_generate(thing)
+        end
+      end
     end
   end
 end

data/lib/chef/knife/cloudformation_create.rb

@@ -7,73 +7,91 @@ class Chef
 
       banner 'knife cloudformation create NAME'
 
+      module Options
+        class << self
+          def included(klass)
+            klass.class_eval do
+
+              attr_accessor :action_type
+              
+              option(:parameter,
+                :short => '-p KEY:VALUE',
+                :long => '--parameter KEY:VALUE',
+                :description => 'Set parameter. Can be used multiple times.',
+                :proc => lambda {|val|
+                  key,value = val.split(':')
+                  Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
+                  Chef::Config[:knife][:cloudformation][:options][:parameters][key] = value
+                }
+              )
+              option(:timeout,
+                :short => '-t MIN',
+                :long => '--timeout MIN',
+                :description => 'Set timeout for stack creation',
+                :proc => lambda {|val|
+                  Chef::Config[:knife][:cloudformation][:options][:timeout_in_minutes] = val
+                }
+              )
+              option(:disable_rollback,
+                :short => '-R',
+                :long => '--disable-rollback',
+                :description => 'Disable rollback on stack creation failure',
+                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:options][:disable_rollback] = true }
+              )
+              option(:capability,
+                :short => '-C CAPABILITY',
+                :long => '--capability CAPABILITY',
+                :description => 'Specify allowed capabilities. Can be used multiple times.',
+                :proc => lambda {|val|
+                  Chef::Config[:knife][:cloudformation][:options][:capabilities] ||= []
+                  Chef::Config[:knife][:cloudformation][:options][:capabilities].push(val).uniq!
+                }
+              )
+              option(:enable_processing,
+                :long => '--enable-processing',
+                :description => 'Call the unicorns.',
+                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:enable_processing] = true }
+              )
+              option(:disable_polling,
+                :long => '--disable-polling',
+                :description => 'Disable stack even polling.',
+                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:disable_polling] = true }
+              )
+              option(:notifications,
+                :long => '--notification ARN',
+                :description => 'Add notification ARN. Can be used multiple times.',
+                :proc => lambda {|val|
+                  Chef::Config[:knife][:cloudformation][:options][:notification_ARNs] ||= []
+                  Chef::Config[:knife][:cloudformation][:options][:notification_ARNs].push(val).uniq!
+                }
+              )
+              option(:file,
+                :short => '-f PATH',
+                :long => '--file PATH',
+                :description => 'Path to Cloud Formation to process',
+                :proc => lambda {|val|
+                  Chef::Config[:knife][:cloudformation][:file] = val
+                }
+              )
+              option(:disable_interactive_parameters,
+                :long => '--no-parameter-prompts',
+                :description => 'Do not prompt for input on dynamic parameters'
+              )
+
+              option(:print_only,
+                :long => '--print-only',
+                :description => 'Print template and exit'
+              )
+            end
+          end
+        end
+      end
+
       include CloudformationDefault
-      
-      option(:parameter,
-        :short => '-p KEY:VALUE',
-        :long => '--parameter KEY:VALUE',
-        :description => 'Set parameter. Can be used multiple times.',
-        :proc => lambda {|val|
-          key,value = val.split(':')
-          Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
-          Chef::Config[:knife][:cloudformation][:options][:parameters][key] = value
-        }
-      )
-      option(:timeout,
-        :short => '-t MIN',
-        :long => '--timeout MIN',
-        :description => 'Set timeout for stack creation',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:options][:timeout_in_minutes] = val
-        }
-      )
-      option(:disable_rollback,
-        :short => '-R',
-        :long => '--disable-rollback',
-        :description => 'Disable rollback on stack creation failure',
-        :proc => lambda { Chef::Config[:knife][:cloudformation][:options][:disable_rollback] = true }
-      )
-      option(:capability,
-        :short => '-C CAPABILITY',
-        :long => '--capability CAPABILITY',
-        :description => 'Specify allowed capabilities. Can be used multiple times.',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:options][:capabilities] ||= []
-          Chef::Config[:knife][:cloudformation][:options][:capabilities].push(val).uniq!
-        }
-      )
-      option(:enable_processing,
-        :long => '--enable-processing',
-        :description => 'Call the unicorns.',
-        :proc => lambda { Chef::Config[:knife][:cloudformation][:options][:enable_processing] = true }
-      )
-      option(:disable_polling,
-        :long => '--disable-polling',
-        :description => 'Disable stack even polling.',
-        :proc => lambda { Chef::Config[:knife][:cloudformation][:options][:disable_polling] = true }
-      )
-      option(:notifications,
-        :long => '--notification ARN',
-        :description => 'Add notification ARN. Can be used multiple times.',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:options][:notification_ARNs] ||= []
-          Chef::Config[:knife][:cloudformation][:options][:notification_ARNs].push(val).uniq!
-        }
-      )
-      option(:file,
-        :short => '-F PATH',
-        :long => '--file PATH',
-        :description => 'Path to Cloud Formation to process',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:file] = val
-        }
-      )
-      option(:disable_interactive_parameters,
-        :long => '--no-parameter-prompts',
-        :description => 'Do not prompt for input on dynamic parameters'
-      )
+      include Options
       
       def run
+        @action_type = self.class.name.split('::').last.sub('Cloudformation', '').upcase
         unless(File.exists?(Chef::Config[:knife][:cloudformation][:file].to_s))
           ui.fatal "Invalid formation file path provided: #{Chef::Config[:knife][:cloudformation][:file]}"
           exit 1
@@ -82,26 +100,34 @@ class Chef
         if(Chef::Config[:knife][:cloudformation][:enable_processing])
           file = KnifeCloudformation::SparkleFormation.compile(Chef::Config[:knife][:cloudformation][:file])
         else
-          file = File.read(Chef::Config[:knife][:cloudformation][:file])
+          file = _from_json(File.read(Chef::Config[:knife][:cloudformation][:file]))
         end
-        ui.info "#{ui.color('Cloud Formation: ', :bold)} #{ui.color('CREATE', :green)}"
+        ui.info "#{ui.color('Cloud Formation: ', :bold)} #{ui.color(action_type, :green)}"
         ui.info "  -> #{ui.color('Name:', :bold)} #{name} #{ui.color('Path:', :bold)} #{Chef::Config[:knife][:cloudformation][:file]} #{ui.color('(not pre-processed)', :yellow) if Chef::Config[:knife][:cloudformation][:disable_processing]}"
         stack = build_stack(file)
+        if(config[:print_only])
+          ui.warn 'Print only requested'
+          ui.info _format_json(stack['TemplateBody'])
+          exit 1
+        end
         create_stack(name, stack)
         unless(Chef::Config[:knife][:cloudformation][:disable_polling])
           poll_stack(name)
         else
           ui.warn 'Stack state polling has been disabled.'
         end
-        ui.info "Stack creation complete: #{ui.color('SUCCESS', :green)}"
+        ui.info "Stack #{action_type} complete: #{ui.color('SUCCESS', :green)}"
       end
 
       def build_stack(template)
         stack = Mash.new
+        populate_parameters!(template)
         Chef::Config[:knife][:cloudformation][:options].each do |key, value|
           format_key = key.split('_').map(&:capitalize).join
+          stack[format_key] = value
+=begin          
           case value
-          when Hash
+          when Hash && key.to_sym != :parameters
             i = 1
             value.each do |k, v|
               stack["#{format_key}.member.#{i}.#{format_key[0, (format_key.length - 1)]}Key"] = k
@@ -112,14 +138,26 @@ class Chef
               stack["#{format_key}.member.#{i+1}"] = v
             end
           else
-            stack[format_key] = value
+
           end
+=end
         end
-        populate_parameters!(template)
+        enable_capabilities!(stack, template)
         stack['TemplateBody'] = Chef::JSONCompat.to_json(template)
         stack
       end
 
+      # Currently only checking for IAM resources since that's all
+      # that is supported for creation
+      def enable_capabilities!(stack, template)
+        found = Array(template['Resources']).detect do |resource_name, resource|
+          resource['Type'].start_with?('AWS::IAM')
+        end
+        if(found)
+          stack['Capabilities'] = ['CAPABILITY_IAM']
+        end
+      end
+      
       def populate_parameters!(stack)
         unless(config[:disable_interactive_parameters])
           if(stack['Parameters'])
@@ -149,8 +187,8 @@ class Chef
         begin
           res = aws_con.create_stack(name, stack)
         rescue => e
-          ui.fatal "Failed to create stack #{name}. Reason: #{e}"
-          _debug(e, "Generated template used:\n#{stack.inspect}")
+          ui.fatal "Failed to #{action_type} stack #{name}. Reason: #{e}"
+          _debug(e, "Generated template used:\n#{_format_json(stack['TemplateBody'])}")
           exit 1
         end
       end
@@ -160,17 +198,17 @@ class Chef
         knife_events.name_args.push(name)
         Chef::Config[:knife][:cloudformation][:poll] = true
         knife_events.run
-        unless(create_successful?(name))
-          ui.fatal "Creation of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
+        unless(action_successful?(name))
+          ui.fatal "#{action_type} of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
           exit 1
         end
       end
       
-      def create_in_progress?(name)
+      def action_in_progress?(name)
         stack_status(name) == 'CREATE_IN_PROGRESS'
       end
 
-      def create_successful?(name)
+      def action_successful?(name)
         stack_status(name) == 'CREATE_COMPLETE'
       end
     end

data/lib/chef/knife/cloudformation_events.rb

@@ -63,7 +63,7 @@ class Chef
           unless(output.empty?)
             ui.info ui.list(output, :uneven_columns_across, allowed_attributes.size)
           end
-          sleep(1)
+          sleep((ENV['CLOUDFORMATION_POLL'] || 15).to_i)
         end
         # One more to see completion
         events = stack_events(name)
@@ -78,7 +78,7 @@ class Chef
       end
 
       def default_attributes
-        %w(Timestamp LogicalResourceId ResourceType ResourceStatus)
+        %w(Timestamp LogicalResourceId ResourceType ResourceStatus ResourceStatusReason)
       end
     end
   end

data/lib/chef/knife/cloudformation_update.rb

@@ -0,0 +1,31 @@
+require 'chef/knife/cloudformation_create'
+
+class Chef
+  class Knife
+    class CloudformationUpdate < CloudformationCreate
+      banner 'knife cloudformation update NAME'
+
+      include CloudformationDefault
+      include CloudformationCreate::Options
+      
+      def create_stack(name, stack)
+        begin
+          res = aws_con.update_stack(name, stack)
+        rescue => e
+          ui.fatal "Failed to update stack #{name}. Reason: #{e}"
+          _debug(e, "Generated template used:\n#{_format_json(stack['TemplateBody'])}")
+          exit 1
+        end
+      end
+
+      def action_in_progress?(name)
+        stack_status(name) == 'UPDATE_IN_PROGRESS'
+      end
+
+      def action_successful?(name)
+        stack_status(name) == 'UPDATE_COMPLETE'
+      end
+
+    end
+  end
+end

data/lib/knife-cloudformation/sparkle_attribute.rb

@@ -0,0 +1,67 @@
+require 'attribute_struct'
+
+module SparkleAttribute
+
+  # TODO: look at the docs for Fn stuff. We can probably just map
+  # simple ones with a bit of string manipulations
+  
+  def _cf_join(*args)
+    options = args.detect{|i| i.is_a?(Hash) && i[:options]} || {:options => {}}
+    args.delete(options)
+    unless(args.size == 1)
+      args = [args]
+    end
+    {'Fn::Join' => [options[:options][:delimiter] || '', *args]}
+  end
+  
+  def _cf_ref(thing)
+    thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+    {'Ref' => thing}
+  end
+
+  def _cf_map(thing, key, *suffix)
+    suffix = suffix.map do |item|
+      if(item.is_a?(Symbol))
+        _process_key(item, :force)
+      else
+        item
+      end
+    end
+    thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+    key = _process_key(key, :force) if key.is_a?(Symbol)
+    {'Fn::FindInMap' => [_process_key(thing), {'Ref' => _process_key(key)}, *suffix]}
+  end
+
+  def _cf_attr(*args)
+    args = args.map do |thing|
+      if(thing.is_a?(Symbol))
+        _process_key(thing, :force)
+      else
+        thing
+      end
+
+    end
+    {'Fn::GetAtt' => args}
+  end
+
+  def _cf_base64(arg)
+    {'Fn::Base64' => arg}
+  end
+
+  def rhel?
+    !!@platform[:rhel]
+  end
+
+  def debian?
+    !!@platform[:debian]
+  end
+
+  def _platform=(plat)
+    @platform || __hashish
+    @platform.clear
+    @platform[plat.to_sym] = true
+  end
+  
+end
+
+AttributeStruct.send(:include, SparkleAttribute)

data/lib/knife-cloudformation/sparkle_formation.rb

@@ -1,11 +1,15 @@
 require 'chef/mash'
 require 'attribute_struct'
+require 'knife-cloudformation/sparkle_attribute'
 
 AttributeStruct.camel_keys = true
 
 module KnifeCloudformation
   class SparkleFormation
     class << self
+
+      attr_reader :dynamics
+      
       def compile(path)
         formation = self.instance_eval(IO.read(path), path, 1)
         formation.compile._dump
@@ -21,6 +25,31 @@ module KnifeCloudformation
         self.instance_eval(IO.read(path), path, 1)
       end
 
+      def load_dynamics!(directory)
+        @loaded_dynamics ||= []
+        Dir.glob(File.join(directory, '*.rb')).each do |dyn|
+          dyn = File.expand_path(dyn)
+          next if @loaded_dynamics.include?(dyn)
+          self.instance_eval(IO.read(dyn), dyn, 1)
+          @loaded_dynamics << dyn
+        end
+        @loaded_dynamics.uniq!
+        true
+      end
+      
+      def dynamic(name, &block)
+        @dynamics ||= Mash.new
+        @dynamics[name] = block
+      end
+
+      def insert(dynamic_name, struct, *args)
+        if(@dynamics && @dynamics[dynamic_name])
+          struct.instance_exec(*args, &@dynamics[dynamic_name])
+          struct
+        else
+          raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{@dynamics.keys.sort.join(', ')})"
+        end
+      end
     end
     
     attr_reader :name
@@ -31,6 +60,8 @@ module KnifeCloudformation
     def initialize(name, options={})
       @name = name
       @sparkle_path = options[:sparkle_path] || File.join(Dir.pwd, 'cloudformation/components')
+      @dynamics_directory = options[:dynamics_directory] || File.join(File.dirname(@sparkle_path), 'dynamics')
+      self.class.load_dynamics!(@dynamics_directory)
       @components = Mash.new
       @load_order = []
     end

data/lib/knife-cloudformation/version.rb

@@ -2,5 +2,5 @@ module KnifeCloudformation
   class Version < Gem::Version
   end
 
-  VERSION = Version.new('0.0.1')
+  VERSION = Version.new('0.1.0')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-cloudformation
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
+date: 2013-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -71,11 +71,14 @@ files:
 - lib/chef/knife/cloudformation_describe.rb
 - lib/chef/knife/cloudformation_list.rb
 - lib/chef/knife/cloudformation_create.rb
+- lib/chef/knife/cloudformation_update.rb
 - lib/knife-cloudformation.rb
+- lib/knife-cloudformation/sparkle_attribute.rb
 - lib/knife-cloudformation/version.rb
 - lib/knife-cloudformation/sparkle_formation.rb
 - README.md
 - knife-cloudformation.gemspec
+- knife-cloudformation-0.0.1.gem
 - CHANGELOG.md
 homepage: http://github.com/heavywater/knife-cloudformation
 licenses: []