knife-cloudformation 0.1.22 → 0.2.0

data/lib/chef/knife/cloudformation_describe.rb

@@ -1,10 +1,11 @@
-require 'knife-cloudformation/cloudformation_base'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation describe command
     class CloudformationDescribe < Knife
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
 
       banner 'knife cloudformation describe NAME'
 
@@ -13,13 +14,11 @@ class Chef
         :long => '--resources',
         :description => 'Display resources for stack'
       )
-
       option(:outputs,
         :short => '-o',
         :long => '--outputs',
         :description => 'Display output for stack'
       )
-
       option(:attribute,
         :short => '-a ATTR',
         :long => '--attribute ATTR',
@@ -29,45 +28,70 @@ class Chef
           Chef::Config[:knife][:cloudformation][:attributes].push(val).uniq!
         }
       )
-
       option(:all,
         :long => '--all-attributes',
         :description => 'Print all attributes'
       )
 
-      def run
+      # information available
+      unless(defined?(AVAILABLE_DISPLAYS))
+        AVAILABLE_DISPLAYS = [:resources, :outputs]
+      end
+
+      # Run the stack describe action
+      def _run
         stack_name = name_args.last
-        if(config[:outputs])
-          ui.info "Outputs for stack: #{ui.color(stack_name, :bold)}:"
-          unless(stack(stack_name).outputs.empty?)
-            stack(stack_name).outputs.each do |key, value|
-              key = snake(key).to_s.split('_').map(&:capitalize).join(' ')
-              ui.info ['  ', ui.color("#{key}:", :bold), value].join(' ')
+        stack = provider.stacks.get(stack_name)
+        if(stack)
+          display = [].tap do |to_display|
+            AVAILABLE_DISPLAYS.each do |display_option|
+              if(config[display_option])
+                to_display << display_option
+              end
             end
-          else
-            ui.info "  #{ui.color('No outputs found')}"
+          end
+          display = AVAILABLE_DISPLAYS.dup if display.empty?
+          display.each do |display_method|
+            self.send(display_method, stack)
+            ui.info ''
           end
         else
-          things_output(stack_name,
-            *(config[:resources] ? [get_resources(stack_name), :resources] : [get_description(stack_name), :description])
-          )
+          ui.fatal "Failed to find requested stack: #{ui.color(stack_name, :bold, :red)}"
+          exit -1
         end
       end
 
-      def default_attributes
-        config[:resources] ? %w(Timestamp ResourceType ResourceStatus) : %w(StackName CreationTime StackStatus DisableRollback)
+      # Display resources
+      #
+      # @param stack [Miasma::Models::Orchestration::Stack]
+      def resources(stack)
+        stack_resources = stack.resources.all.sort do |x, y|
+          y.updated <=> x.updated
+        end.map do |resource|
+          Mash.new(resource.attributes)
+        end
+        things_output(stack.name, stack_resources, :resources)
       end
 
-      def get_description(name)
-        get_things(name) do
-          [stack(name).raw_stack]
+      # Display outputs
+      #
+      # @param stack [Miasma::Models::Orchestration::Stack]
+      def outputs(stack)
+        ui.info "Outputs for stack: #{ui.color(stack.name, :bold)}"
+        unless(stack.outputs.empty?)
+          stack.outputs.each do |output|
+            key, value = output.key, output.value
+            key = snake(key).to_s.split('_').map(&:capitalize).join(' ')
+            ui.info ['  ', ui.color("#{key}:", :bold), value].join(' ')
+          end
+        else
+          ui.info "  #{ui.color('No outputs found')}"
         end
       end
 
-      def get_resources(name)
-        get_things(name) do
-          stack(name).resources
-        end
+      # @return [Array<String>] default attributes
+      def default_attributes
+        %w(updated logical_id type status status_reason)
       end
 
     end

data/lib/chef/knife/cloudformation_destroy.rb

@@ -1,10 +1,11 @@
-require 'knife-cloudformation/cloudformation_base'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation destroy command
     class CloudformationDestroy < Knife
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
 
       banner 'knife cloudformation destroy NAME [NAME]'
 
@@ -16,31 +17,29 @@ class Chef
         :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:poll] = val }
       )
 
-      def run
+      # Run the stack destruction action
+      def _run
         stacks = name_args.sort
         plural = 's' if stacks.size > 1
         ui.warn "Destroying Cloud Formation#{plural}: #{ui.color(stacks.join(', '), :bold)}"
         ui.confirm "Destroy formation#{plural}"
         stacks.each do |stack_name|
-          destroy_formation!(stack_name)
-          ui.info "Destroy request sent for stack: #{ui.color(stack_name, :bold)}"
+          stack = provider.stacks.get(stack_name)
+          if(stack)
+            stack.destroy
+          else
+            ui.warn "Failed to locate requested stack: #{ui.color(stack_name, :bold)}"
+          end
         end
         if(config[:polling])
-          begin
-            stacks.each do |stack_name|
-              poll_stack(stack_name)
-            end
-          rescue SystemExit, Fog::AWS::CloudFormation::NotFound
-            # ignore this error since this is the end result we want!
+          if(stacks.size == 1)
+            provider.fetch_stacks
+            poll_stack(stacks.first)
+          else
+            ui.error "Stack polling is not available when multiple stack deletion is requested!"
           end
-          ui.info "  -> Destroyed Cloud Formation#{plural}: #{ui.color(stacks.join(', '), :bold, :red)}"
-        end
-      end
-
-      def destroy_formation!(stack_name)
-        get_things(stack_name, 'Failed to perform destruction') do
-          stack(stack_name).destroy
         end
+        ui.info "  -> Destroyed Cloud Formation#{plural}: #{ui.color(stacks.join(', '), :bold, :red)}"
       end
 
     end

data/lib/chef/knife/cloudformation_events.rb

@@ -1,18 +1,19 @@
-require 'knife-cloudformation/cloudformation_base'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation list command
     class CloudformationEvents < Knife
 
       banner 'knife cloudformation events NAME'
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
 
       option(:polling,
         :short => '-p',
         :long => '--[no-]poll',
         :boolean => true,
-        :default => false,
+        :default => true,
         :description => 'Poll events while stack status is "in progress"',
         :proc => lambda {|v| Chef::Config[:knife][:cloudformation][:poll] = v }
       )
@@ -41,28 +42,61 @@ class Chef
         :description => 'Print all attributes'
       )
 
-      def run
+      # Run the events list action
+      def _run
         name = name_args.first
         ui.info "Cloud Formation Events for Stack: #{ui.color(name, :bold)}\n"
-        things_output(name, get_events(name), 'events')
-        if(Chef::Config[:knife][:cloudformation][:poll])
-          while(stack(name).in_progress?)
-            sleep(Chef::Config[:knife][:cloudformation][:poll_delay] || 15)
-            things_output(nil, get_events(name), 'events', :no_title, :ignore_empty_output)
+        stack = provider.stacks.get(name)
+        last_id = nil
+        if(stack)
+          events = get_events(stack)
+          things_output(name, events, 'events')
+          last_id = events.last[:id]
+          if(Chef::Config[:knife][:cloudformation][:poll])
+            cycle_events = true
+            while(cycle_events)
+              cycle_events = stack.in_progress?
+              sleep(Chef::Config[:knife][:cloudformation][:poll_delay] || 15)
+              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
+              stack.reload
+            end
+            # Extra to see completion
+            things_output(nil, get_events(stack, last_id), 'events', :no_title, :ignore_empty_output)
           end
-          # Extra to see completion
-          things_output(nil, get_events(name), 'events', :no_title, :ignore_empty_output)
+        else
+          ui.fatal "Failed to locate requested stack: #{ui.color(name, :bold, :red)}"
+          exit -1
         end
       end
 
-      def get_events(name)
+      # 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(name).events
+          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(Timestamp LogicalResourceId ResourceType ResourceStatus ResourceStatusReason)
+        %w(time resource_logical_id resource_status resource_status_reason)
       end
     end
   end

data/lib/chef/knife/cloudformation_export.rb

@@ -1,20 +1,37 @@
-require 'knife-cloudformation/cloudformation_base'
-require 'knife-cloudformation/export'
+require 'knife-cloudformation'
 
 class Chef
   class Knife
+    # Cloudformation export command
     class CloudformationExport < Knife
 
-      include KnifeCloudformation::KnifeBase
+      include KnifeCloudformation::Knife::Base
+      include KnifeCloudformation::Utils::ObjectStorage
 
-      banner 'knife cloudformation export NAME'
+      banner 'knife cloudformation export STACK_NAME'
 
-      # TODO: Add option for s3 exports
+      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 => 'Path to write export JSON file',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export_path] = v }
+        :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,
@@ -22,8 +39,7 @@ class Chef
         :long => '--exclude-parameter NAME',
         :description => 'Exclude parameter from export (can be used multiple times)',
         :proc => lambda{|v|
-          Chef::Config[:knife][:cloudformation][:ignore_parameters] ||= []
-          Chef::Config[:knife][:cloudformation][:ignore_parameters].push(v).uniq!
+          Chef::Config[:knife][:cloudformation][:export][:ignore_parameters].push(v).uniq!
         }
       )
 
@@ -31,7 +47,7 @@ class Chef
         :long => '--chef-environment-parameter NAME',
         :description => 'Parameter used within stack to specify Chef environment',
         :proc => lambda{|v|
-          Chef::Config[:knife][:cloudformation][:chef_environment_parameter] = v
+          Chef::Config[:knife][:cloudformation][:export][:chef_environment_parameter] = v
         }
       )
 
@@ -40,38 +56,105 @@ class Chef
         :boolean => true,
         :default => true,
         :description => 'Freezes first run files',
-        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:chef_popsicle] = v }
+        :proc => lambda{|v| Chef::Config[:knife][:cloudformation][:export][:chef_popsicle] = v }
       )
 
-      def run
-        if(Chef::Config[:knife][:cloudformation][:export_path])
-          file_path = File.join(
-            Chef::Config[:knife][:cloudformation][:export_path], "#{name_args.first}-#{Time.now.to_i}.json"
-          )
-        end
-        ui.info "#{ui.color('Stack Export:', :bold)} #{name_args.first}"
-        if(file_path)
-          ui.info "  - Writing to: #{file_path}"
-        else
-          ui.info "  - Printing to console"
-        end
+      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'
-        ex_opts = {}
-        [:chef_popsicle, :chef_environment_parameter, :ignore_parameters].each do |key|
-          unless(Chef::Config[:knife][:cloudformation][key].nil?)
-            ex_opts[key] = Chef::Config[:knife][:cloudformation][key]
+        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
-        exporter = KnifeCloudformation::Export.new(name_args.first, ex_opts.merge(:aws_commons => aws))
-        result = exporter.export
-        if(file_path)
-          File.open(file_path, 'w') do |file|
-            file.puts _format_json(result)
+      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
-          ui.info _format_json(result)
+          "#{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
-        ui.info "#{ui.color('Stack export', :bold)} (#{name_args.first}): #{ui.color('complete', :green)}"
       end
 
     end