sfn 0.0.1 → 0.3.0

data/lib/sfn/command.rb

@@ -0,0 +1,45 @@
+require 'sfn'
+require 'bogo-cli'
+
+module Sfn
+  class Command < Bogo::Cli::Command
+
+    autoload :Create, 'sfn/command/create'
+    autoload :Describe, 'sfn/command/describe'
+    autoload :Destroy, 'sfn/command/destroy'
+    autoload :Events, 'sfn/command/events'
+    autoload :Export, 'sfn/command/export'
+    autoload :Import, 'sfn/command/import'
+    autoload :Inspect, 'sfn/command/inspect'
+    autoload :List, 'sfn/command/list'
+    autoload :Promote, 'sfn/command/promote'
+    autoload :Update, 'sfn/command/update'
+    autoload :Validate, 'sfn/command/validate'
+
+    # Override to provide config file searching
+    def initialize(opts, args)
+      unless(opts[:config])
+        opts = opts.to_hash.to_smash(:snake)
+        discover_config(opts)
+      end
+      super
+    end
+
+    protected
+
+    # Start with current working directory and traverse to root
+    # looking for a `.sfn` configuration file
+    #
+    # @param opts [Smash]
+    # @return [Smash]
+    def discover_config(opts)
+      cwd = Dir.pwd.split(File::SEPARATOR)
+      until(cwd.empty? || File.exists?(cwd.push('.sfn').join(File::SEPARATOR)))
+        cwd.pop(2)
+      end
+      opts[:config] = cwd.join(File::SEPARATOR) unless cwd.empty?
+      opts
+    end
+
+  end
+end

data/lib/sfn/command/create.rb

@@ -0,0 +1,87 @@
+require 'sparkle_formation'
+require 'pathname'
+require 'sfn'
+
+module Sfn
+  class Command
+    # Cloudformation create command
+    class Create < Command
+
+      include Sfn::CommandModule::Base
+      include Sfn::CommandModule::Template
+      include Sfn::CommandModule::Stack
+
+      # Run the stack creation command
+      def execute!
+        name = name_args.first
+        unless(name)
+          ui.fatal "Formation name must be specified!"
+          exit 1
+        end
+        if(config[:template])
+          file = config[:template]
+        else
+          file = load_template_file
+          nested_stacks_unpack = file.delete('sfn_nested_stack')
+        end
+        ui.info "#{ui.color('Cloud Formation:', :bold)} #{ui.color('create', :green)}"
+        stack_info = "#{ui.color('Name:', :bold)} #{name}"
+        if(config[:path])
+          stack_info << " #{ui.color('Path:', :bold)} #{config[:file]}"
+        end
+
+        unless(config[:print_only])
+          ui.info "  -> #{stack_info}"
+        end
+
+        if(nested_stacks_unpack)
+          unpack_nesting(name, file, :create)
+        else
+
+          stack = provider.connection.stacks.build(
+            config[:options].dup.merge(
+              :name => name,
+              :template => file
+            )
+          )
+
+          apply_stacks!(stack)
+          stack.template = Sfn::Utils::StackParameterScrubber.scrub!(stack.template)
+
+          if(config[:print_only])
+            ui.info _format_json(translate_template(stack.template))
+            return
+          end
+
+          populate_parameters!(stack.template)
+          stack.parameters = config[:parameters]
+
+          stack.template = translate_template(stack.template)
+          stack.save
+
+        end
+
+        if(stack)
+          if(config[:poll])
+            poll_stack(stack.name)
+            stack = provider.connection.stacks.get(name)
+
+            if(stack.reload.success?)
+              ui.info "Stack create complete: #{ui.color('SUCCESS', :green)}"
+              namespace.const_get(:Describe).new({:outputs => true}, [name]).execute!
+            else
+              ui.fatal "Create of new stack #{ui.color(name, :bold)}: #{ui.color('FAILED', :red, :bold)}"
+              ui.info ""
+              namespace.const_get(:Inspect).new({:instance_failure => true}, [name]).execute!
+              raise
+            end
+          else
+            ui.warn 'Stack state polling has been disabled.'
+            ui.info "Stack creation initialized for #{ui.color(name, :green)}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/sfn/command/describe.rb

@@ -0,0 +1,87 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Cloudformation describe command
+    class Describe < Command
+
+      include Sfn::CommandModule::Base
+
+      # information available
+      unless(defined?(AVAILABLE_DISPLAYS))
+        AVAILABLE_DISPLAYS = [:resources, :outputs]
+      end
+
+      # Run the stack describe action
+      def execute!
+        stack_name = name_args.last
+        stack = provider.connection.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
+          end
+          display = AVAILABLE_DISPLAYS.dup if display.empty?
+          display.each do |display_method|
+            self.send(display_method, stack)
+          end
+        else
+          ui.fatal "Failed to find requested stack: #{ui.color(stack_name, :bold, :red)}"
+          exit -1
+        end
+      end
+
+      # 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|
+          Smash.new(resource.attributes)
+        end
+        ui.table(self) do
+          table(:border => false) do
+            row(:header => true) do
+              allowed_attributes.each do |attr|
+                column as_title(attr), :width => stack_resources.map{|r| r[attr].to_s.length}.push(as_title(attr).length).max + 2
+              end
+            end
+            stack_resources.each do |resource|
+              row do
+                allowed_attributes.each do |attr|
+                  column resource[attr]
+                end
+              end
+            end
+          end
+        end.display
+      end
+
+      # 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
+
+      # @return [Array<String>] default attributes
+      def default_attributes
+        %w(updated logical_id type status status_reason)
+      end
+
+    end
+  end
+end

data/lib/sfn/command/destroy.rb

@@ -0,0 +1,74 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    class Destroy < Command
+
+      include Sfn::CommandModule::Base
+
+      # Run the stack destruction action
+      def execute!
+        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 Stack#{plural}: #{ui.color(stacks.join(', '), :bold)}"
+        ui.confirm "Destroy listed stack#{plural}?"
+        stacks.each do |stack_name|
+          stack = provider.connection.stacks.get(stack_name)
+          if(stack)
+            nested_stack_cleanup!(stack)
+            stack.destroy
+            ui.info "Destroy request complete for stack: #{ui.color(stack_name, :red)}"
+          else
+            ui.warn "Failed to locate requested stack: #{ui.color(stack_name, :bold)}"
+          end
+        end
+        if(config[:poll])
+          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/sfn/command/events.rb

@@ -0,0 +1,98 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Events command
+    class Events < Command
+
+      include Sfn::CommandModule::Base
+
+      # @return [Miasma::Models::Orchestration::Stack]
+      attr_reader :stack
+
+      # Run the events list action
+      def execute!
+        name = name_args.first
+        ui.info "Events for Stack: #{ui.color(name, :bold)}\n"
+        @stacks = []
+        @stack = provider.connection.stacks.get(name)
+        @stacks << stack
+        discover_stacks(stack)
+        if(stack)
+          table = ui.table(self) do
+            table(:border => false) do
+              events = get_events
+              row(:header => true) do
+                allowed_attributes.each do |attr|
+                  column attr.split('_').map(&:capitalize).join(' '), :width => ((val = events.map{|e| e[attr].to_s.length}.push(attr.length).max + 2) > 70 ? 70 : val)
+                end
+              end
+              events.each do |event|
+                row do
+                  allowed_attributes.each do |attr|
+                    column event[attr]
+                  end
+                end
+              end
+            end
+          end.display
+          if(config[:poll])
+            while(stack.in_progress?)
+              to_wait = config.fetch(:poll_wait_time, 10).to_f
+              while(to_wait > 0)
+                sleep(0.1)
+                to_wait -= 0.1
+              end
+              stack.reload
+              table.display
+            end
+          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(*args)
+        discover_stacks(stack)
+        stack_events = @stacks.map do |stack|
+          stack.events.all.map do |e|
+            e.attributes.merge(:stack_name => stack.name).to_smash
+          end
+        end.flatten.compact
+        stack_events.sort do |x,y|
+          Time.parse(x[:time].to_s) <=> Time.parse(y[:time].to_s)
+        end
+      end
+
+      def discover_stacks(stack)
+        stack.resources.reload.all.each do |resource|
+          if(resource.type == 'AWS::CloudFormation::Stack')
+            nested_stack = provider.connection.stacks.get(resource.id)
+            @stacks.push(nested_stack).uniq!
+            discover_stacks(nested_stack)
+          end
+        end
+      end
+
+      # @return [Array<String>] default attributes for events
+      def default_attributes
+        %w(stack_name time resource_logical_id resource_status resource_status_reason)
+      end
+
+      # @return [Array<String>] allowed attributes for events
+      def allowed_attributes
+        result = super
+        unless(@stacks.size > 1)
+          result.delete('stack_name')
+        end
+        result
+      end
+    end
+  end
+end

data/lib/sfn/command/export.rb

@@ -0,0 +1,103 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Export command
+    class Export < Command
+
+      include Sfn::CommandModule::Base
+      include Sfn::Utils::ObjectStorage
+
+      # Run export action
+      def execute!
+        raise NotImplementedError.new 'Implementation updates required'
+        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 = Smash.new.tap do |opts|
+            [:chef_popsicle, :chef_environment_parameter, :ignore_parameters].each do |key|
+              opts[key] = config[key] unless config[key].nil?
+            end
+          end
+          exporter = Sfn::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 = config[: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(config[:path])
+          full_path = File.join(
+            config[: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 = config[: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