knife-cloudformation 0.2.24 → 0.5.0

data/lib/chef/knife/cloudformation_destroy.rb

@@ -1,84 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation destroy command
-    class CloudformationDestroy < Knife
-
-      include KnifeCloudformation::Knife::Base
-
-      banner 'knife cloudformation destroy NAME [NAME]'
-
-      option(:polling,
-        :long => '--[no-]poll',
-        :description => 'Enable stack event polling.',
-        :boolean => true,
-        :default => true,
-        :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:poll] = val }
-      )
-
-      # Run the stack destruction action
-      def _run
-        stacks = name_args.sort
-        plural = 's' if stacks.size > 1
-        globs = stacks.find_all do |s|
-          s !~ /^[a-zA-Z0-9-]+$/
-        end
-        unless(globs.empty?)
-          glob_stacks = provider.connection.stacks.all.find_all do |remote_stack|
-            globs.detect do |glob|
-              File.fnmatch(glob, remote_stack.name)
-            end
-          end
-          stacks += glob_stacks.map(&:name)
-          stacks -= globs
-          stacks.sort!
-        end
-        ui.warn "Destroying Cloud Formation#{plural}: #{ui.color(stacks.join(', '), :bold)}"
-        ui.confirm "Destroy formation#{plural}"
-        stacks.each do |stack_name|
-          stack = provider.connection.stacks.get(stack_name)
-          if(stack)
-            nested_stack_cleanup!(stack)
-            stack.destroy
-          else
-            ui.warn "Failed to locate requested stack: #{ui.color(stack_name, :bold)}"
-          end
-        end
-        if(config[:polling])
-          if(stacks.size == 1)
-            poll_stack(stacks.first)
-          else
-            ui.error "Stack polling is not available when multiple stack deletion is requested!"
-          end
-        end
-        ui.info "  -> Destroyed Cloud Formation#{plural}: #{ui.color(stacks.join(', '), :bold, :red)}"
-      end
-
-      # Cleanup persisted templates if nested stack resources are included
-      def nested_stack_cleanup!(stack)
-        nest_stacks = stack.template.fetch('Resources', {}).values.find_all do |resource|
-          resource['Type'] == 'AWS::CloudFormation::Stack'
-        end.each do |resource|
-          url = resource['Properties']['TemplateURL']
-          if(url)
-            _, bucket_name, path = URI.parse(url).path.split('/', 3)
-            bucket = provider.connection.api_for(:storage).buckets.get(bucket_name)
-            if(bucket)
-              file = bucket.files.get(path)
-              if(file)
-                file.destroy
-                ui.info "Deleted nested stack template! (Bucket: #{bucket_name} Template: #{path})"
-              else
-                ui.warn "Failed to locate template file within bucket for deletion! (#{path})"
-              end
-            else
-              ui.warn "Failed to locate bucket containing template file for deletion! (#{bucket_name})"
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/chef/knife/cloudformation_events.rb

@@ -1,117 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation list command
-    class CloudformationEvents < Knife
-
-      banner 'knife cloudformation events NAME'
-
-      include KnifeCloudformation::Knife::Base
-
-      option(:polling,
-        :short => '-p',
-        :long => '--[no-]poll',
-        :boolean => true,
-        :default => true,
-        :description => 'Poll events while stack status is "in progress"',
-        :proc => lambda {|v| Chef::Config[:knife][:cloudformation][:poll] = v }
-      )
-
-      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(:poll_delay,
-        :short => '-D secs',
-        :long => '--poll-delay secs',
-        :description => 'Number of seconds to pause between event poll',
-        :proc => lambda {|val|
-          Chef::Config[:knife][:cloudformation][:poll_delay] = val.to_i
-        }
-      )
-
-      option(:all_attributes,
-        :long => '--all-attributes',
-        :description => 'Print all attributes'
-      )
-
-      # Run the events list action
-      def _run
-        name = name_args.first
-        ui.info "Cloud Formation Events for Stack: #{ui.color(name, :bold)}\n"
-        stack = provider.connection.stacks.get(name)
-        last_id = nil
-        if(stack)
-          events = get_events(stack)
-          things_output(name, events, 'events')
-          last_id = events.last ? events.last[:id] : nil
-          if(Chef::Config[:knife][:cloudformation][:poll])
-            cycle_events = true
-            while(cycle_events)
-              cycle_events = stack.in_progress?
-              sleep(Chef::Config[:knife][:cloudformation][:poll_delay] || 10)
-              stack.events.reload
-              events = get_events(stack, last_id)
-              unless(events.empty?)
-                last_id = events.last[:id]
-                things_output(nil, events, 'events', :no_title, :ignore_empty_output)
-              end
-              nest_stacks = stack.resources.all.find_all do |resource|
-                resource.state.to_s.end_with?('in_progress') &&
-                  resource.type == 'AWS::CloudFormation::Stack'
-              end
-              if(nest_stacks)
-                nest_stacks.each do |nest_stack|
-                  begin
-                    poll_stack(nest_stack.id)
-                    ui.info "Complete event listing for nested stack (#{nest_stack.name})"
-                  rescue => e
-                    ui.warn "Error encountered on event listing for nested stack - #{e} (#{nest_stack.name})"
-                  end
-                end
-              end
-              stack.reload
-            end
-            # Extra to see completion
-            things_output(nil, get_events(stack, last_id), 'events', :no_title, :ignore_empty_output)
-          end
-        else
-          ui.fatal "Failed to locate requested stack: #{ui.color(name, :bold, :red)}"
-          raise "Failed to locate stack: #{name}!"
-        end
-      end
-
-      # Fetch events from stack
-      #
-      # @param stack [Miasma::Models::Orchestration::Stack]
-      # @param last_id [String] only return events after this ID
-      # @return [Array<Hash>]
-      def get_events(stack, last_id=nil)
-        get_things do
-          stack_events = stack.events.all
-          if(last_id)
-            start_index = stack_events.index{|event| event.id == last_id}
-            events = stack_events.slice(0, start_index.to_i)
-          else
-            events = stack_events
-          end
-          events.map do |event|
-            Mash.new(event.attributes)
-          end
-        end
-      end
-
-      # @return [Array<String>] default attributes for events
-      def default_attributes
-        %w(time resource_logical_id resource_status resource_status_reason)
-      end
-    end
-  end
-end

data/lib/chef/knife/cloudformation_export.rb

@@ -1,162 +0,0 @@
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation export command
-    class CloudformationExport < Knife
-
-      include KnifeCloudformation::Knife::Base
-      include KnifeCloudformation::Utils::ObjectStorage
-
-      banner 'knife cloudformation export STACK_NAME'
-
-      option(:export_name,
-        :long => '--export-file-name NAME',
-        :description => 'File basename to contain the export. Can be callable block if defined within configuration',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export][:name] = v}
-      )
-
-      option(:path,
-        :long => '--export-path PATH',
-        :description => 'Directory path write export JSON file',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export][:path] = v}
-      )
-
-      option(:bucket,
-        :long => '--export-bucket BUCKET_NAME',
-        :description => 'Remote file bucket to write export JSON file',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export][:bucket] = v}
-      )
-
-      option(:bucket_prefix,
-        :long => '--bucket-key-prefix PREFIX',
-        :description => 'Key prefix for file storage in bucket. Can be callable block if defined within configuration',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export][:bucket_prefix] = v}
-      )
-
-      option(:ignore_parameters,
-        :short => '-P NAME',
-        :long => '--exclude-parameter NAME',
-        :description => 'Exclude parameter from export (can be used multiple times)',
-        :proc => lambda{|v|
-          Chef::Config[:knife][:cloudformation][:export][:ignore_parameters].push(v).uniq!
-        }
-      )
-
-      option(:chef_environment_parameter,
-        :long => '--chef-environment-parameter NAME',
-        :description => 'Parameter used within stack to specify Chef environment',
-        :proc => lambda{|v|
-          Chef::Config[:knife][:cloudformation][:export][:chef_environment_parameter] = v
-        }
-      )
-
-      option(:chef_popsicle,
-        :long => '--[no-]freeze-run-list',
-        :boolean => true,
-        :default => true,
-        :description => 'Freezes first run files',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export][:chef_popsicle] = v }
-      )
-
-      unless(Chef::Config[:knife][:cloudformation].has_key?(:export))
-        Chef::Config[:knife][:cloudformation][:export] = Mash.new(
-          :credentials => Mash.new,
-          :ignore_parameters => []
-        )
-      end
-
-      # Run export action
-      def _run
-        stack_name = name_args.first
-        ui.info "#{ui.color('Stack Export:', :bold)} #{stack_name}"
-        ui.confirm 'Perform export'
-        stack = provider.stacks.get(stack_name)
-        if(stack)
-          export_options = Mash.new.tap do |opts|
-            [:chef_popsicle, :chef_environment_parameter, :ignore_parameters].each do |key|
-              unless(Chef::Config[:knife][:cloudformation][:export][key].nil?)
-                opts[key] = Chef::Config[:knife][:cloudformation][:export][key]
-              end
-            end
-          end
-          exporter = KnifeCloudformation::Utils::StackExporter.new(stack, export_options)
-          result = exporter.export
-          outputs = [
-            write_to_file(result, stack),
-            write_to_bucket(result, stack)
-          ].compact
-          if(outputs.empty?)
-            ui.warn 'No persistent output location defined. Printing export:'
-            ui.info _format_json(result)
-          end
-          ui.info "#{ui.color('Stack export', :bold)} (#{name_args.first}): #{ui.color('complete', :green)}"
-          unless(outputs.empty?)
-            outputs.each do |output|
-              ui.info ui.color("  -> #{output}", :blue)
-            end
-          end
-        else
-          ui.fatal "Failed to discover requested stack: #{ui.color(stack_name, :red, :bold)}"
-          exit -1
-        end
-      end
-
-      # Generate file name for stack export JSON contents
-      #
-      # @param stack [Miasma::Models::Orchestration::Stack]
-      # @return [String] file name
-      def export_file_name(stack)
-        name = Chef::Config[:knife][:cloudformation][:export][:file]
-        if(name)
-          if(name.respond_to?(:call))
-            name.call(stack)
-          else
-            name.to_s
-          end
-        else
-          "#{stack.stack_name}-#{Time.now.to_i}.json"
-        end
-      end
-
-      # Write stack export to local file
-      #
-      # @param payload [Hash] stack export payload
-      # @param stack [Misama::Stack::Orchestration::Stack]
-      # @return [String, NilClass] path to file
-      def write_to_file(payload, stack)
-        raise NotImplementedError
-        if(Chef::Config[:knife][:cloudformation][:export][:path])
-          full_path = File.join(
-            File.expand_path(Chef::Config[:knife][:cloudformation][:export][:path]),
-            export_file_name(stack)
-          )
-          _, bucket, path = full_path.split('/', 3)
-          directory = provider.service_for(:storage,
-            :provider => :local,
-            :local_root => '/'
-          ).directories.get(bucket)
-          file_store(payload, path, directory)
-        end
-      end
-
-      # Write stack export to remote bucket
-      #
-      # @param payload [Hash] stack export payload
-      # @param stack [Miasma::Models::Orchestration::Stack]
-      # @return [String, NilClass] remote bucket key
-      def write_to_bucket(payload, stack)
-        raise NotImplementedError
-        if(bucket = Chef::Config[:knife][:cloudformation][:export][:bucket])
-          key_path = File.join(*[
-              bucket_prefix(stack),
-              export_file_name(stack)
-            ].compact
-          )
-          file_store(payload, key_path, provider.service_for(:storage).directories.get(bucket))
-        end
-      end
-
-    end
-  end
-end

data/lib/chef/knife/cloudformation_import.rb

@@ -1,141 +0,0 @@
-require 'stringio'
-require 'knife-cloudformation'
-
-class Chef
-  class Knife
-    # Cloudformation import command
-    class CloudformationImport < Knife
-
-      include KnifeCloudformation::Knife::Base
-      include KnifeCloudformation::Utils::JSON
-      include KnifeCloudformation::Utils::ObjectStorage
-      include KnifeCloudformation::Utils::PathSelector
-
-      banner 'knife cloudformation import NEW_STACK_NAME [JSON_EXPORT_FILE]'
-
-      option(:path,
-        :long => '--import-path PATH',
-        :description => 'Directory path JSON export files are located',
-        :proc => lambda{|v|
-          Chef::Config[:knife][:cloudformation][:import][:path] = File.expand_path(v)
-        }
-      )
-
-      option(:bucket,
-        :long => '--export-bucket BUCKET_NAME',
-        :description => 'Remote file bucket JSON export files are located',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:import][:bucket] = v}
-      )
-
-      option(:bucket_prefix,
-        :long => '--bucket-key-prefix PREFIX',
-        :description => 'Key prefix for file storage in bucket. Can be callable block if defined within configuration',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:import][:bucket_prefix] = v}
-      )
-
-      unless(Chef::Config[:knife][:cloudformation].has_key?(:import))
-        Chef::Config[:knife][:cloudformation][:import] = Mash.new
-      end
-
-      # Run the import action
-      def _run
-        stack_name, json_file = name_args
-        ui.info "#{ui.color('Stack Import:', :bold)} #{stack_name}"
-        unless(json_file)
-          entries = [].tap do |_entries|
-            _entries.push('s3') if Chef::Config[:knife][:cloudformation][:import][:bucket]
-            _entries.push('fs') if Chef::Config[:knife][:cloudformation][:import][:path]
-          end
-          if(entries.size > 1)
-            valid = false
-            until(valid)
-              answer = ui.ask_question('Import via file system (fs) or remote bucket (remote)?', :default => 'remote')
-              valid = true if %w(remote fs).include?(answer)
-              entries = [answer]
-            end
-          elsif(entries.size < 1)
-            ui.fatal 'No path or bucket set. Unable to perform dynamic lookup!'
-            exit 1
-          end
-          case entries.first
-          when 'remote'
-            json_file = remote_discovery
-          else
-            json_file = local_discovery
-          end
-        end
-        if(File.exists?(json_file) || json_file.is_a?(IO))
-          content = json_file.is_a?(IO) ? json_file.read : File.read(json_file)
-          export = Mash.new(_from_json(content))
-          begin
-            creator = Chef::Knife::CloudformationCreate.new
-            creator.name_args = [stack_name]
-            Chef::Config[:knife][:cloudformation][:template] = _from_json(export[:stack][:template])
-            Chef::Config[:knife][:cloudformation][:options] = export[:stack][:options]
-            ui.info '  - Starting creation of import'
-            creator.run
-            ui.info "#{ui.color('Stack Import', :bold)} (#{json_file}): #{ui.color('complete', :green)}"
-          rescue => e
-            ui.fatal "Failed to import stack: #{e}"
-            debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-            exit -1
-          end
-        else
-          ui.fatal "Failed to locate JSON export file (#{json_file})"
-          exit 1
-        end
-      end
-
-      # Generate bucket prefix
-      #
-      # @return [String, NilClass]
-      def bucket_prefix
-        if(prefix = Chef::Config[:knife][:cloudformation][:import][:bucket_prefix])
-          if(prefix.respond_to?(:cal))
-            prefix.call
-          else
-            prefix.to_s
-          end
-        end
-      end
-
-      # Discover remote file
-      #
-      # @return [IO] stack export IO
-      def remote_discovery
-        storage = provider.service_for(:storage)
-        directory = storage.directories.get(
-          Chef::Config[:knife][:cloudformation][:import][:bucket]
-        )
-        file = prompt_for_file(
-          directory,
-          :directories_name => 'Collections',
-          :files_names => 'Exports',
-          :filter_prefix => bucket_prefix
-        )
-        if(file)
-          remote_file = storage.files.get(file)
-          StringIO.new(remote_file.body)
-        end
-      end
-
-      # Discover remote file
-      #
-      # @return [IO] stack export IO
-      def local_discovery
-        _, bucket = Chef::Config[:knife][:cloudformation][:import][:path].split('/', 2)
-        storage = provider.service_for(:storage,
-          :provider => :local,
-          :local_root => '/'
-        )
-        directory = storage.directories.get(bucket)
-        prompt_for_file(
-          directory,
-          :directories_name => 'Collections',
-          :files_names => 'Exports'
-        )
-      end
-
-    end
-  end
-end