knife-cloudformation 0.1.22 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5038817ca4a6fbe9658bbd9652b66281b02db80e
+  data.tar.gz: 4b4da29974e40d7077c56919fb83c7c66de27e6d
+SHA512:
+  metadata.gz: e67e6e3bcd675159997cf4627f429a8c492b49d1e9a6ef22bf6820abd51ec74850de2b2997b675cd7de130bb01a6db5ff150578a088172f9b3fe3b16e4ccc423
+  data.tar.gz: 146d85f4a0db3e29a20335a9383d7bc5cea11d42c39a5a87c92dcad2d9b9959cc16dfeccb842438c0f691981b642f74d6d5def6582d3e09d24c7bcffdb4a3417

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## v0.2.0
+* This release should be considered "breaking"
+* Underlying cloud API has been changed from fog to miasma
+* The `inspect` command has been fully reworked to support `--attribute`
+* Lots and lots of other changes. See commit log.
+
 ## v0.1.22
 * Prevent full stack list loading in knife commands
 * Default logger to INFO level and allow DEBUG level via `ENV['DEBUG']`

data/README.md

@@ -1,3 +1,57 @@
-## Knife Cloud Formation
+# Knife CloudFormation
 
-Cloud formation tooling for knife.
+A plugin for the knife command provided by Chef to
+interact with AWS CloudFormation.
+
+## Compatibility
+
+This plugin now provides support for other cloud
+orchestration APIs as well:
+
+* OpenStack
+* Rackspace
+
+## Configuration
+
+The easiest way to configure the plugin is via the
+`knife.rb` file. Credentials are the only configuration
+requirement, and the `Hash` provided is proxied to
+Miasma:
+
+```ruby
+# .chef/knife.rb
+
+knife[:cloudformation][:credentials] = {
+  :aws_access_key_id => ENV['AWS_ACCESS_KEY_ID'],
+  :aws_secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'],
+  :aws_region => ENV['AWS_REGION']
+}
+```
+
+If are using Rackspace:
+
+```ruby
+# .chef/knife.rb
+
+knife[:cloudformation][:credentials] = {
+  :rackspace_username => ENV['RACKSPACE_USERNAME'],
+  :rackspace_api_key => ENV['RACKSPACE_API_KEY'],
+  :rackspace_region => ENV['RACKSPACE_REGION']
+}
+```
+
+## Commands
+
+* `knife cloudformation list`
+* `knife cloudformation create`
+* `knife cloudformation update`
+* `knife cloudformation destroy`
+* `knife cloudformation events`
+* `knife cloudformation describe`
+* `knife cloudformation inspect`
+* `knife cloudformation validate`
+
+# Info
+
+* Repository: https://github.com/heavywater/knife-cloudformation
+* IRC: Freenode @ #heavywater

data/knife-cloudformation.gemspec

@@ -10,11 +10,8 @@ Gem::Specification.new do |s|
   s.description = 'Knife tooling for Cloud Formation'
   s.require_path = 'lib'
   s.add_dependency 'chef'
-  s.add_dependency 'fog', '~> 1.17'
-  s.add_dependency 'unf'
-  s.add_dependency 'net-sftp'
-  s.add_dependency 'sparkle_formation', '~> 0.1.2'
-  s.add_dependency 'redis-objects'
-  s.add_dependency 'attribute_struct', '~> 0.1.8'
-  s.files = Dir['**/*']
+  s.add_dependency 'miasma'
+  s.add_dependency 'net-ssh'
+  s.add_dependency 'sparkle_formation', '~> 0.2.0'
+  s.files = Dir['lib/**/*'] + %w(knife-cloudformation.gemspec README.md CHANGELOG.md)
 end

data/lib/chef/knife/cloudformation_create.rb

@@ -1,152 +1,78 @@
 require 'sparkle_formation'
 require 'pathname'
-require 'knife-cloudformation/cloudformation_base'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation create command
     class CloudformationCreate < Knife
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
+      include KnifeCloudformation::Knife::Template
+      include KnifeCloudformation::Knife::Stack
 
       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|
-                  parts = val.split(':')
-                  key = parts.first
-                  value = parts[1, parts.size].join(':')
-                  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(:rollback,
-                :short => '-R',
-                :long => '--[no]-rollback',
-                :description => 'Rollback on stack creation failure',
-                :boolean => true,
-                :default => true,
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:options][:disable_rollback] = !val }
-              )
-              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(:processing,
-                :long => '--[no-]processing',
-                :description => 'Call the unicorns and explode the glitter bombs',
-                :boolean => true,
-                :default => false,
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:processing] = val }
-              )
-              option(:polling,
-                :long => '--[no-]poll',
-                :description => 'Enable stack event polling.',
-                :boolean => true,
-                :default => true,
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:poll] = val }
-              )
-              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(:interactive_parameters,
-                :long => '--[no-]parameter-prompts',
-                :boolean => true,
-                :default => true,
-                :description => 'Do not prompt for input on dynamic parameters',
-                :default => true
-              )
-              option(:print_only,
-                :long => '--print-only',
-                :description => 'Print template and exit'
-              )
-              option(:base_directory,
-                :long => '--cloudformation-directory PATH',
-                :description => 'Path to cloudformation directory',
-                :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:base_directory] = val}
-              )
-              option(:no_base_directory,
-                :long => '--no-cloudformation-directory',
-                :description => 'Unset any value used for cloudformation path',
-                :proc => lambda {|*val| Chef::Config[:knife][:cloudformation][:base_directory] = nil}
-              )
-
-              %w(rollback polling interactive_parameters).each do |key|
-                if(Chef::Config[:knife][:cloudformation][key].nil?)
-                  Chef::Config[:knife][:cloudformation][key] = true
-                end
-              end
-            end
-          end
-        end
-      end
-
-      include Options
-
-      def run
-        @action_type = self.class.name.split('::').last.sub('Cloudformation', '').upcase
+      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(:rollback,
+        :short => '-R',
+        :long => '--[no]-rollback',
+        :description => 'Rollback on stack creation failure',
+        :boolean => true,
+        :default => true,
+        :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:options][:disable_rollback] = !val }
+      )
+      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(: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(:print_only,
+        :long => '--print-only',
+        :description => 'Print template and exit'
+      )
+      option(:apply_stacks,
+        :long => '--apply-stack NAME_OR_ID',
+        :description => 'Autofill parameters using existing stack outputs. Can be used multiple times',
+        :proc => lambda {|val|
+          Chef::Config[:knife][:cloudformation][:create] ||= Mash.new
+          Chef::Config[:knife][:cloudformation][:create][:apply_stacks] ||= []
+          Chef::Config[:knife][:cloudformation][:create][:apply_stacks].push(val).uniq!
+        }
+      )
+
+      # Run the stack creation command
+      def _run
         name = name_args.first
         unless(name)
           ui.fatal "Formation name must be specified!"
           exit 1
         end
-
-        unless(Chef::Config[:knife][:cloudformation][:template])
-          set_paths_and_discover_file!
-          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
-        end
-
         if(Chef::Config[:knife][:cloudformation][:template])
           file = Chef::Config[:knife][:cloudformation][:template]
-        elsif(Chef::Config[:knife][:cloudformation][:processing])
-          file = SparkleFormation.compile(Chef::Config[:knife][:cloudformation][:file])
         else
-          file = _from_json(File.read(Chef::Config[:knife][:cloudformation][:file]))
+          file = load_template_file
         end
-        if(config[:print_only])
-          ui.warn 'Print only requested'
-          ui.info _format_json(file)
-          exit 1
-        end
-        ui.info "#{ui.color('Cloud Formation: ', :bold)} #{ui.color(action_type, :green)}"
+        ui.info "#{ui.color('Cloud Formation:', :bold)} #{ui.color('create', :green)}"
         stack_info = "#{ui.color('Name:', :bold)} #{name}"
         if(Chef::Config[:knife][:cloudformation][:path])
           stack_info << " #{ui.color('Path:', :bold)} #{Chef::Config[:knife][:cloudformation][:file]}"
@@ -154,20 +80,46 @@ class Chef
             stack_info << " #{ui.color('(not pre-processed)', :yellow)}"
           end
         end
-        ui.info "  -> #{stack_info}"
-        populate_parameters!(file)
-        stack_def = KnifeCloudformation::AwsCommons::Stack.build_stack_definition(file, Chef::Config[:knife][:cloudformation][:options])
-        aws.create_stack(name, stack_def)
-        if(Chef::Config[:knife][:cloudformation][:polling])
-          poll_stack(name)
-          if(stack(name).success?)
-            ui.info "Stack #{action_type} complete: #{ui.color('SUCCESS', :green)}"
+
+        unless(config[:print_only])
+          ui.info "  -> #{stack_info}"
+        end
+
+        stack = provider.stacks.build(
+          Chef::Config[:knife][:cloudformation][:options].dup.merge(
+            :name => name,
+            :template => file
+          )
+        )
+
+        apply_stacks!(stack)
+        stack.template = KnifeCloudformation::Utils::StackParameterScrubber.scrub!(stack.template)
+
+        if(config[:print_only])
+          ui.info _format_json(translate_template(stack.template))
+          exit 0
+        end
+
+        populate_parameters!(stack.template)
+        stack.parameters = Chef::Config[:knife][:cloudformation][:options][:parameters]
+
+        stack.template = translate_template(stack.template)
+        stack.save
+
+        if(Chef::Config[:knife][:cloudformation][:poll])
+          provider.fetch_stacks
+          poll_stack(stack.name)
+          stack = provider.stacks.get(name)
+
+          if(stack.reload.success?)
+            ui.info "Stack create complete: #{ui.color('SUCCESS', :green)}"
+            provider.fetch_stacks
             knife_output = Chef::Knife::CloudformationDescribe.new
             knife_output.name_args.push(name)
             knife_output.config[:outputs] = true
             knife_output.run
           else
-            ui.fatal "#{action_type} of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
+            ui.fatal "Create of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
             ui.info ""
             knife_inspect = Chef::Knife::CloudformationInspect.new
             knife_inspect.name_args.push(name)
@@ -181,115 +133,23 @@ class Chef
         end
       end
 
-      def populate_parameters!(stack)
-        if(Chef::Config[:knife][:cloudformation][:interactive_parameters])
-          if(stack['Parameters'])
-            Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
-            stack['Parameters'].each do |k,v|
-              next if Chef::Config[:knife][:cloudformation][:options][:parameters][k]
-              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)
-                validation = KnifeCloudformation::AwsCommons::Stack::ParameterValidator.validate(answer, v)
-                if(validation == true)
-                  Chef::Config[:knife][:cloudformation][:options][:parameters][k] = answer
-                  valid = true
-                else
-                  validation.each do |validation_error|
-                    ui.error validation_error.last
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-
-      private
-
-      def set_paths_and_discover_file!
-        if(Chef::Config[:knife][:cloudformation][:base_directory])
-          SparkleFormation.components_path = File.join(
-            Chef::Config[:knife][:cloudformation][:base_directory], 'components'
-          )
-          SparkleFormation.dynamics_path = File.join(
-            Chef::Config[:knife][:cloudformation][:base_directory], 'dynamics'
-          )
-        end
-        unless(Chef::Config[:knife][:cloudformation][:file])
-          Chef::Config[:knife][:cloudformation][:file] = prompt_for_file(
-            Chef::Config[:knife][:cloudformation][:base_directory] || File.join(Dir.pwd, 'cloudformation')
-          )
-        else
-          unless(Pathname(Chef::Config[:knife][:cloudformation][:file]).absolute?)
-            Chef::Config[:knife][:cloudformation][:file] = File.join(
-              Chef::Config[:knife][:cloudformation][:base_directory] || File.join(Dir.pwd, 'cloudformation'),
-              Chef::Config[:knife][:cloudformation][:file]
-            )
-          end
-        end
-      end
-
-      def prompt_for_file(dir)
-        directory = Dir.new(dir)
-        directories = directory.map do |d|
-          if(!d.start_with?('.') && !%w(dynamics components).include?(d) && File.directory?(path = File.join(dir, d)))
-            path
-          end
-        end.compact.sort
-        files = directory.map do |f|
-          if(!f.start_with?('.') && File.file?(path = File.join(dir, f)))
-            path
-          end
-        end.compact.sort
-        if(directories.empty? && files.empty?)
-          ui.fatal 'No formation paths discoverable!'
-        else
-          output = ['Please select the formation to create']
-          output << '(or directory to list):' unless directories.empty?
-          ui.info output.join(' ')
-          output.clear
-          idx = 1
-          valid = {}
-          unless(directories.empty?)
-            output << ui.color('Directories:', :bold)
-            directories.each do |path|
-              valid[idx] = {:path => path, :type => :directory}
-              output << [idx, "#{File.basename(path).sub('.rb', '').split(/[-_]/).map(&:capitalize).join(' ')}"]
-              idx += 1
-            end
-          end
-          unless(files.empty?)
-            output << ui.color('Templates:', :bold)
-            files.each do |path|
-              valid[idx] = {:path => path, :type => :file}
-              output << [idx, "#{File.basename(path).sub('.rb', '').split(/[-_]/).map(&:capitalize).join(' ')}"]
-              idx += 1
-            end
-          end
-          max = idx.to_s.length
-          output.map! do |o|
-            if(o.is_a?(Array))
-              "  #{o.first}.#{' ' * (max - o.first.to_s.length)} #{o.last}"
-            else
-              o
-            end
-          end
-          ui.info "#{output.join("\n")}\n"
-          response = ask_question('Enter selection: ').to_i
-          unless(valid[response])
-            ui.fatal 'How about using a real value'
-            exit 1
+      # Apply any defined remote stacks
+      #
+      # @param stack [Miasma::Models::Orchestration::Stack]
+      # @return [Miasma::Models::Orchestration::Stack]
+      def apply_stacks!(stack)
+        remote_stacks = Chef::Config[:knife][:cloudformation].
+          fetch(:create, {}).fetch(:apply_stacks, [])
+        remote_stacks.each do |stack_name|
+          remote_stack = provider.stacks.get(stack_name)
+          if(remote_stack)
+            stack.apply_stack(remote_stack)
           else
-            entry = valid[response.to_i]
-            if(entry[:type] == :directory)
-              prompt_for_file(entry[:path])
-            else
-              Chef::Config[:knife][:cloudformation][:file] = entry[:path]
-            end
+            ui.error "Failed to apply requested stack. Unable to locate. (#{stack_name})"
+            exit 1
           end
         end
+        stack
       end
 
     end