knife-cloudformation 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.0.1
+* Initial release

data/README.md

@@ -0,0 +1,3 @@
+## Knife Cloud Formation
+
+Cloud formation tooling for knife.

data/knife-cloudformation.gemspec

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'knife-cloudformation/version'
+Gem::Specification.new do |s|
+  s.name = 'knife-cloudformation'
+  s.version = KnifeCloudformation::VERSION.version
+  s.summary = 'Knife tooling for Cloud Formation'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/heavywater/knife-cloudformation'
+  s.description = 'Knife tooling for Cloud Formation'
+  s.require_path = 'lib'
+  s.add_dependency 'chef'
+  s.add_dependency 'fog', '~> 1.12.1'
+  s.add_dependency 'attribute_struct', '~> 0.1.2'
+  s.files = Dir['**/*']
+end

data/lib/chef/knife/cloudformation_base.rb

@@ -0,0 +1,177 @@
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module CloudformationDefault
+      class << self
+        def included(klass)
+          klass.instance_eval do
+            deps do
+              require 'fog'
+              Chef::Config[:knife][:cloudformation] ||= Mash.new
+              Chef::Config[:knife][:cloudformation][:credentials] ||= Mash.new
+              Chef::Config[:knife][:cloudformation][:options] ||= Mash.new
+            end
+
+            option(:key,
+              :short => '-K KEY',
+              :long => '--key KEY',
+              :description => 'AWS access key id',
+              :proc => lambda {|val|
+                Chef::Config[:knife][:cloudformation][:credentials][:key] = val
+              }
+            )
+            option(:secret,
+              :short => '-S SECRET',
+              :long => '--secret SECRET',
+              :description => 'AWS secret access key',
+              :proc => lambda {|val|
+                Chef::Config[:knife][:cloudformation][:credentials][:secret] = val
+              }
+            )
+            option(:region,
+              :short => '-r REGION',
+              :long => '--region REGION',
+              :description => 'AWS region',
+              :proc => lambda {|val|
+                Chef::Config[:knife][:cloudformation][:credentials][:region] = val
+              }
+            )
+          end
+        end
+      end
+    end
+
+    class CloudformationBase < Knife
+
+      class << self
+        def aws_con
+          @connection ||= Fog::AWS::CloudFormation.new(
+            :aws_access_key_id => _key,
+            :aws_secret_access_key => _secret,
+            :region => _region
+          )
+        end
+
+        def _key
+          Chef::Config[:knife][:cloudformation][:credentials][:key] ||
+            Chef::Config[:knife][:aws_access_key_id]
+        end
+
+        def _secret
+          Chef::Config[:knife][:cloudformation][:credentials][:secret] ||
+            Chef::Config[:knife][:aws_secret_access_key]
+        end
+
+        def _region
+          Chef::Config[:knife][:cloudformation][:credentials][:region] ||
+            Chef::Config[:knife][:region]
+        end
+
+      end
+
+      def _debug(e, *args)
+        if(ENV['DEBUG'])
+          ui.fatal "Exception information: #{e.class}: #{e}\n#{e.backtrace.join("\n")}\n"
+          args.each do |string|
+            ui.fatal string
+          end
+        end
+      end
+
+      def aws_con
+        self.class.aws_con
+      end
+      
+      def stack_status(name)
+        aws_con.describe_stacks('StackName' => name).body['Stacks'].first['StackStatus']
+      end
+
+      def get_titles(thing, format=false)
+        unless(@titles)
+          hash = thing.is_a?(Array) ? thing.first : thing
+          hash ||= {}
+          @titles = hash.keys.map do |key|
+            next unless attribute_allowed?(key)
+            key.gsub(/([a-z])([A-Z])/, '\1 \2')
+          end.compact
+        end
+        if(format)
+          @titles.map{|s| ui.color(s, :bold)}
+        else
+          @titles
+        end
+      end
+
+      def process(things)
+        @event_ids ||= []
+        things.reverse.map do |thing|
+          next if @event_ids.include?(thing['EventId'])
+          @event_ids.push(thing['EventId']).compact!
+          get_titles(thing).map do |key|
+            thing[key.gsub(' ', '')].to_s
+          end
+        end.flatten.compact
+      end
+
+      def allowed_attributes
+        Chef::Config[:knife][:cloudformation][:attributes] || default_attributes
+      end
+
+      def default_attributes
+        %w(Timestamp StackName StackId)
+      end
+
+      def attribute_allowed?(attr)
+        config[:all_attributes] || allowed_attributes.include?(attr)
+      end
+
+      def things_output(stack, things, what)
+        output = get_titles(things, :format)
+        output += process(things)
+        output.compact.flatten
+        if(output.empty?)
+          ui.warn 'No information found'
+        else
+          ui.info "#{what.to_s.capitalize} for stack: #{ui.color(stack, :bold)}" if stack
+          ui.info "#{ui.list(output, :uneven_columns_across, get_titles(things).size)}\n"
+        end
+      end
+
+      def get_things(stack=nil, message=nil)
+        begin
+          yield
+        rescue => e
+          ui.fatal "#{message || 'Failed to retrieve information'}#{" for requested stack: #{stack}" if stack}"
+          ui.fatal "Reason: #{e}"
+          _debug(e)
+          exit 1
+        end
+      end
+
+      def try_json_compat
+        begin
+          require 'chef/json_compat'
+        rescue
+        end
+        defined?(Chef::JSONCompat)
+      end
+      
+      def _to_json(thing)
+        if(try_json_compat)
+          Chef::JSONCompat.to_json(thing)
+        else
+          JSON.dump(thing)
+        end
+      end
+
+      def _from_json(thing)
+        if(try_json_compat)
+          Chef::JSONCompat.from_json(thing)
+        else
+          JSON.read(thing)
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/cloudformation_create.rb

@@ -0,0 +1,178 @@
+require 'knife-cloudformation/sparkle_formation'
+require 'chef/knife/cloudformation_base'
+
+class Chef
+  class Knife
+    class CloudformationCreate < CloudformationBase
+
+      banner 'knife cloudformation create NAME'
+
+      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'
+      )
+      
+      def run
+        unless(File.exists?(Chef::Config[:knife][:cloudformation][:file].to_s))
+          ui.fatal "Invalid formation file path provided: #{Chef::Config[:knife][:cloudformation][:file]}"
+          exit 1
+        end
+        name = name_args.first
+        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])
+        end
+        ui.info "#{ui.color('Cloud Formation: ', :bold)} #{ui.color('CREATE', :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)
+        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)}"
+      end
+
+      def build_stack(template)
+        stack = Mash.new
+        Chef::Config[:knife][:cloudformation][:options].each do |key, value|
+          format_key = key.split('_').map(&:capitalize).join
+          case value
+          when Hash
+            i = 1
+            value.each do |k, v|
+              stack["#{format_key}.member.#{i}.#{format_key[0, (format_key.length - 1)]}Key"] = k
+              stack["#{format_key}.member.#{i}.#{format_key[0, (format_key.length - 1)]}Value"] = v
+            end
+          when Array
+            value.each_with_index do |v, i|
+              stack["#{format_key}.member.#{i+1}"] = v
+            end
+          else
+            stack[format_key] = value
+          end
+        end
+        populate_parameters!(template)
+        stack['TemplateBody'] = Chef::JSONCompat.to_json(template)
+        stack
+      end
+
+      def populate_parameters!(stack)
+        unless(config[:disable_interactive_parameters])
+          if(stack['Parameters'])
+            Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
+            stack['Parameters'].each do |k,v|
+              valid = false
+              until(valid)
+                default = Chef::Config[:knife][:cloudformation][:options][:parameters][k] || v['Default']
+                answer = ui.ask_question("#{k.split(/([A-Z]+[^A-Z]*)/).find_all{|s|!s.empty?}.join(' ')} ", :default => default)
+                if(v['AllowedValues'])
+                  valid = v['AllowedValues'].include?(answer)
+                else
+                  valid = true
+                end
+                if(valid)
+                  Chef::Config[:knife][:cloudformation][:options][:parameters][k] = answer
+                else
+                  ui.error "Not an allowed value: #{v['AllowedValues'].join(', ')}"
+                end
+              end
+            end
+          end
+        end
+      end
+      
+      def create_stack(name, stack)
+        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}")
+          exit 1
+        end
+      end
+
+      def poll_stack(name)
+        knife_events = Chef::Knife::CloudformationEvents.new
+        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)}"
+          exit 1
+        end
+      end
+      
+      def create_in_progress?(name)
+        stack_status(name) == 'CREATE_IN_PROGRESS'
+      end
+
+      def create_successful?(name)
+        stack_status(name) == 'CREATE_COMPLETE'
+      end
+    end
+  end
+end

data/lib/chef/knife/cloudformation_describe.rb

@@ -0,0 +1,57 @@
+require 'chef/knife/cloudformation_base'
+
+class Chef
+  class Knife
+    class CloudformationDescribe < CloudformationBase
+      include CloudformationDefault
+
+      banner 'knife cloudformation describe NAME'
+      
+      option(:resources,
+        :short => '-r',
+        :long => '--resources',
+        :description => 'Display resources for stack(s)'
+      )
+      
+      option(:attribute,
+        :short => '-a ATTR',
+        :long => '--attribute ATTR',
+        :description => 'Attribute to print. Can be used multiple times.',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:attributes] ||= []
+          Chef::Config[:knife][:cloudformation][:attributes].push(val).uniq!
+        }
+      )
+
+      option(:all,
+        :long => '--all-attributes',
+        :description => 'Print all attributes'
+      )
+      
+      def run
+        name_args.each do |stack|
+          things_output(stack,
+            *(config[:resources] ? [get_resources(stack), :resources] : [get_description(stack), :description])
+          )
+        end
+      end
+
+      def default_attributes
+        config[:resources] ? %w(Timestamp ResourceType ResourceStatus) : %w(StackName CreationTime StackStatus DisableRollback)
+      end
+
+      def get_description(stack)
+        get_things(stack) do
+          [aws_con.describe_stacks('StackName' => stack).body['Stacks'].first]
+        end
+      end
+      
+      def get_resources(stack)
+        get_things(stack) do
+          aws_con.describe_stack_resources('StackName' => stack).body['StackResources']
+        end
+      end
+      
+    end
+  end
+end

data/lib/chef/knife/cloudformation_destroy.rb

@@ -0,0 +1,28 @@
+require 'chef/knife/cloudformation_base'
+
+class Chef
+  class Knife
+    class CloudformationDestroy < CloudformationBase
+
+      include CloudformationDefault
+      
+      banner 'knife cloudformation destroy NAME[ NAME ...]'
+
+      def run
+        name_args.each do |stack_name|
+          ui.warn "Destroying Cloud Formation: #{ui.color(stack_name, :bold)}"
+          ui.confirm 'Destroy this formation'
+          destroy_formation!(stack_name)
+          ui.info "  -> Destroyed Cloud Formation: #{ui.color(stack_name, :bold, :red)}"
+        end
+      end
+
+      def destroy_formation!(stack_name)
+        get_things(stack_name, 'Failed to perform destruction') do
+          aws_con.delete_stack(stack_name)
+        end
+      end
+      
+    end
+  end
+end

data/lib/chef/knife/cloudformation_events.rb

@@ -0,0 +1,85 @@
+require 'chef/knife/cloudformation_base'
+
+class Chef
+  class Knife
+    class CloudformationEvents < CloudformationBase
+
+      banner 'knife cloudformation events NAME'
+
+      include CloudformationDefault
+      
+      option(:poll,
+        :short => '-p',
+        :long => '--poll',
+        :description => 'Poll events while stack status is "in progress"',
+        :proc => lambda {|v| Chef::Config[:knife][:cloudformation][:poll] = true }
+      )
+
+      option(:attribute,
+        :short => '-a ATTR',
+        :long => '--attribute ATTR',
+        :description => 'Attribute to print. Can be used multiple times.',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:attributes] ||= []
+          Chef::Config[:knife][:cloudformation][:attributes].push(val).uniq!
+        }
+      )
+
+      option(:all_attributes,
+        :long => '--all-attributes',
+        :description => 'Print all attributes'
+      )
+
+      def run
+        name = name_args.first
+        ui.info "Cloud Formation Events for Stack: #{ui.color(name, :bold)}\n"
+        events = stack_events(name)
+        output = get_titles(events, :format)
+        output += process(events)
+        ui.info ui.list(output.flatten, :uneven_columns_across, allowed_attributes.size)
+        if(Chef::Config[:knife][:cloudformation][:poll])
+          poll_stack(name)
+        end
+      end
+      
+      def stack_events(name, continue_from_last=true)
+        get_things(name) do
+          @_stack_events ||= Mash.new
+          if(@_stack_events[name])
+            options = {'NextToken' => @_stack_events[name]}
+          else
+            options = {}
+          end
+          res = aws_con.describe_stack_events(name, options)
+          @_stack_events[name] = res.body['StackToken']
+          res.body['StackEvents']
+        end
+      end
+
+      def poll_stack(name)
+        while(stack_in_progress?(name))
+          events = stack_events(name)
+          output = process(events)
+          unless(output.empty?)
+            ui.info ui.list(output, :uneven_columns_across, allowed_attributes.size)
+          end
+          sleep(1)
+        end
+        # One more to see completion
+        events = stack_events(name)
+        output = process(events)
+        unless(output.empty?)
+          ui.info ui.list(output, :uneven_columns_across, allowed_attributes.size)
+        end
+      end
+
+      def stack_in_progress?(name)
+        stack_status(name).downcase.include?('in_progress')
+      end
+
+      def default_attributes
+        %w(Timestamp LogicalResourceId ResourceType ResourceStatus)
+      end
+    end
+  end
+end

data/lib/chef/knife/cloudformation_list.rb

@@ -0,0 +1,63 @@
+require 'chef/knife/cloudformation_base'
+
+class Chef
+  class Knife
+    class CloudformationList < CloudformationBase
+      include CloudformationDefault
+
+      banner 'knife cloudformation list NAME'
+      
+      option(:attribute,
+        :short => '-a ATTR',
+        :long => '--attribute ATTR',
+        :description => 'Attribute to print. Can be used multiple times.',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:attributes] ||= []
+          Chef::Config[:knife][:cloudformation][:attributes].push(val).uniq!
+        }
+      )
+
+      option(:all,
+        :long => '--all-attributes',
+        :description => 'Print all attributes'
+      )
+
+      option(:status,
+        :short => '-S STATUS',
+        :long => '--status STATUS',
+        :description => 'Match given status. Use "none" to disable. Can be used multiple times.',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:status] ||= []
+          Chef::Config[:knife][:cloudformation][:status].push(val).uniq!
+        }
+      )
+      
+      def run
+        things_output(nil, get_list, nil)
+      end
+
+      def get_list
+        get_things do
+          aws_con.list_stacks(aws_filter_hash).body['StackSummaries']
+        end
+      end
+
+      def default_attributes
+        %w(StackName CreationTime StackStatus TemplateDescription)
+      end
+
+      def status_filter
+        val = Chef::Config[:knife][:cloudformation][:status] || %w(CREATE_COMPLETE CREATE_IN_PROGRESS UPDATE_IN_PROGRESS UPDATE_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_COMPLETE)
+        val.map(&:downcase).include?('none') ? [] : val.map(&:upcase)
+      end
+
+      def aws_filter_hash
+        hash = Mash.new
+        status_filter.each_with_index do |filter, i|
+          hash["StackStatusFilter.member.#{i+1}"] = filter
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/knife-cloudformation.rb

@@ -0,0 +1 @@
+require 'knife-cloudformation/version'

data/lib/knife-cloudformation/sparkle_formation.rb

@@ -0,0 +1,70 @@
+require 'chef/mash'
+require 'attribute_struct'
+
+AttributeStruct.camel_keys = true
+
+module KnifeCloudformation
+  class SparkleFormation
+    class << self
+      def compile(path)
+        formation = self.instance_eval(IO.read(path), path, 1)
+        formation.compile._dump
+      end
+
+      def build(&block)
+        struct = AttributeStruct.new
+        struct.instance_exec(&block)
+        struct
+      end
+
+      def load_component(path)
+        self.instance_eval(IO.read(path), path, 1)
+      end
+
+    end
+    
+    attr_reader :name
+    attr_reader :sparkle_path
+    attr_reader :components
+    attr_reader :load_order
+    
+    def initialize(name, options={})
+      @name = name
+      @sparkle_path = options[:sparkle_path] || File.join(Dir.pwd, 'cloudformation/components')
+      @components = Mash.new
+      @load_order = []
+    end
+
+    def load(*args)
+      args.each do |thing|
+        if(thing.is_a?(Symbol))
+          path = File.join(sparkle_path, "#{thing}.rb")
+        else
+          path = thing
+        end
+        key = File.basename(path).sub('.rb', '')
+        components[key] = self.class.load_component(path)
+        @load_order << key
+      end
+      self
+    end
+
+    def overrides(&block)
+      @overrides = self.class.build(&block)
+      self
+    end
+    
+    # Returns compiled Mash instance
+    def compile
+      compiled = AttributeStruct.new
+      @load_order.each do |key|
+        compiled._merge!(components[key])
+      end
+      if(@overrides)
+        compiled._merge!(@overrides)
+      end
+      compiled
+    end
+
+  end
+end

data/lib/knife-cloudformation/version.rb

@@ -0,0 +1,6 @@
+module KnifeCloudformation
+  class Version < Gem::Version
+  end
+
+  VERSION = Version.new('0.0.1')
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: knife-cloudformation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.12.1
+- !ruby/object:Gem::Dependency
+  name: attribute_struct
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+description: Knife tooling for Cloud Formation
+email: chrisroberts.code@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/chef/knife/cloudformation_events.rb
+- lib/chef/knife/cloudformation_base.rb
+- lib/chef/knife/cloudformation_destroy.rb
+- lib/chef/knife/cloudformation_describe.rb
+- lib/chef/knife/cloudformation_list.rb
+- lib/chef/knife/cloudformation_create.rb
+- lib/knife-cloudformation.rb
+- lib/knife-cloudformation/version.rb
+- lib/knife-cloudformation/sparkle_formation.rb
+- README.md
+- knife-cloudformation.gemspec
+- CHANGELOG.md
+homepage: http://github.com/heavywater/knife-cloudformation
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Knife tooling for Cloud Formation
+test_files: []
+has_rdoc: