sfn 0.0.1 → 0.3.0

data/lib/sfn/command/import.rb

@@ -0,0 +1,117 @@
+require 'stringio'
+require 'sfn'
+
+module Sfn
+  class Command
+    # Import command
+    class Import < Command
+
+      include Sfn::CommandModule::Base
+      include Sfn::Utils::JSON
+      include Sfn::Utils::ObjectStorage
+      include Sfn::Utils::PathSelector
+
+      # Run the import action
+      def execute!
+        raise NotImplementedError.new 'Implementation updates required'
+        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 config[:bucket]
+            _entries.push('fs') if config[: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 = namespace.const_val(:Create).new(
+              Smash.new(
+                :template => _from_json(export[:stack][:template]),
+                :options => _from_json(export[:stack][:options])
+              ),
+              [stack_name]
+            )
+            ui.info '  - Starting creation of import'
+            creator.execute!
+            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")}"
+            raise
+          end
+        else
+          ui.fatal "Failed to locate JSON export file (#{json_file})"
+          raise
+        end
+      end
+
+      # Generate bucket prefix
+      #
+      # @return [String, NilClass]
+      def bucket_prefix
+        if(prefix = config[:bucket_prefix])
+          if(prefix.respond_to?(:call))
+            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(config[: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 = config[: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

data/lib/sfn/command/inspect.rb

@@ -0,0 +1,160 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Inspect command
+    class Inspect < Command
+
+      include Sfn::CommandModule::Base
+      include Sfn::Utils::Ssher
+
+      # Run the stack inspection action
+      def execute!
+        stack_name = name_args.last
+        stack = provider.connection.stacks.get(stack_name)
+        ui.info "Stack inspection #{ui.color(stack_name, :bold)}:"
+        outputs = [:attribute, :nodes, :instance_failure].map do |key|
+          if(config.has_key?(key))
+            send("display_#{key}", stack)
+            key
+          end
+        end.compact
+        if(outputs.empty?)
+          ui.info '  Stack dump:'
+          ui.puts MultiJson.dump(
+            MultiJson.load(
+              stack.reload.to_json
+            ),
+            :pretty => true
+          )
+        end
+      end
+
+      def display_instance_failure(stack)
+        instances = stack.resources.all.find_all do |resource|
+          resource.state.to_s.end_with?('failed')
+        end.map do |resource|
+          # If compute instance, simply expand
+          if(resource.within?(:compute, :servers))
+            resource.instance
+          # If a waitcondition, check for instance ID
+          elsif(resource.type.to_s.downcase.end_with?('waitcondition'))
+            if(resource.status_reason.to_s.include?('uniqueId'))
+              srv_id = resource.status_reason.split(' ').last.strip
+              provider.connection.api_for(:compute).servers.get(srv_id)
+            end
+          end
+        end.compact
+        if(instances.empty?)
+          ui.error 'Failed to locate any failed instances'
+        else
+          log_path = config[:failure_log_path]
+          if(log_path.to_s.empty?)
+            log_path = '/var/log/chef/client.log'
+          end
+          opts = ssh_key ? {:keys => [ssh_key]} : {}
+          instances.each do |instance|
+            ui.info "  -> Log inspect for #{instance.id}:"
+            address = instance.addresses_public.map do |address|
+              if(address.version == 4)
+                address.address
+              end
+            end
+            if(address)
+              ssh_attempt_users.each do |user|
+                begin
+                  ui.info remote_file_contents(address.first, user, log_path, opts)
+                  break
+                rescue Net::SSH::AuthenticationFailed
+                  ui.warn "Authentication failed for user #{user} on instance #{address}"
+                rescue => e
+                  ui.error "Failed to retrieve log: #{e}"
+                  _debug e
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Users to attempt SSH connection
+      #
+      # @return [Array<String>] usernames for ssh connect attempt
+      def ssh_attempt_users
+        [config[:ssh_user], config[:ssh_attempt_users], ENV['USER']].flatten.compact.uniq
+      end
+
+      def ssh_key
+        config[:identity_file]
+      end
+
+      def display_attribute(stack)
+        attr = config[:attribute].split('.').inject(stack) do |memo, key|
+          args = key.scan(/\(([^)]*)\)/).flatten.first.to_s
+          if(args)
+            args = args.split(',').map{|a| a.to_i.to_s == a ? a.to_i : a}
+            key = key.split('(').first
+          end
+          if(memo.public_methods.include?(key.to_sym))
+            if(args.size == 1 && args.first.to_s.start_with?('&'))
+              memo.send(key, &args.first.slice(2, args.first.size).to_sym)
+            else
+              memo.send(*[key, args].flatten.compact)
+            end
+          else
+            raise NoMethodError.new "Invalid attribute requested! (#{memo.class}##{key})"
+          end
+        end
+        ui.info "  Attribute Lookup -> #{config[:attribute]}:"
+        ui.puts MultiJson.dump(
+          MultiJson.load(
+            MultiJson.dump(attr)
+          ),
+          :pretty => true
+        )
+      end
+
+      def display_nodes(stack)
+        asg_nodes = Smash[
+          stack.resources.all.find_all do |resource|
+            resource.within?(:auto_scale, :groups)
+          end.map do |group_resource|
+            asg = group_resource.expand
+            [
+              asg.name,
+              Smash[
+                asg.servers.map(&:expand).map{|s|
+                  [s.id, Smash.new(
+                      :name => s.name,
+                      :addresses => s.addresses.map(&:address)
+                  )]
+                }
+              ]
+            ]
+          end
+        ]
+        compute_nodes = Smash[
+          stack.resources.all.find_all do |resource|
+            resource.within?(:compute, :servers)
+          end.map do |srv|
+            srv = srv.instance
+            [srv.id, Smash.new(
+                :name => srv.name,
+                :addresses => srv.addresses.map(&:address)
+            )]
+          end
+        ]
+        unless(asg_nodes.empty?)
+          ui.info '  AutoScale Group Instances:'
+          ui.puts MultiJson.dump(asg_nodes, :pretty => true)
+        end
+        unless(compute_nodes.empty?)
+          ui.info '  Compute Instances:'
+          ui.puts MultiJson.dump(compute_nodes, :pretty => true)
+        end
+      end
+
+    end
+  end
+end

data/lib/sfn/command/list.rb

@@ -0,0 +1,59 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # List command
+    class List < Command
+
+      include Sfn::CommandModule::Base
+
+      # Run the list command
+      def execute!
+        ui.table(self) do
+          table(:border => false) do
+            stacks = get_stacks
+            row(:header => true) do
+              allowed_attributes.each do |attr|
+                column attr.split('_').map(&:capitalize).join(' '), :width => stacks.map{|s| s[attr].to_s.length}.max + 2
+              end
+            end
+            get_stacks.each do |stack|
+              row do
+                allowed_attributes.each do |attr|
+                  column stack[attr]
+                end
+              end
+            end
+          end
+        end.display
+      end
+
+      # Get the list of stacks to display
+      #
+      # @return [Array<Hash>]
+      def get_stacks
+        provider.stacks.all.map do |stack|
+          Smash.new(stack.attributes)
+        end.sort do |x, y|
+          if(y[:created].to_s.empty?)
+            -1
+          elsif(x[:created].to_s.empty?)
+            1
+          else
+            Time.parse(x[:created].to_s) <=> Time.parse(y[:created].to_s)
+          end
+        end
+      end
+
+      # @return [Array<String>] default attributes to display
+      def default_attributes
+        if(provider.connection.provider == :aws)
+          %w(name created status template_description)
+        else
+          %w(name created status description)
+        end
+      end
+
+    end
+  end
+end

data/lib/sfn/command/promote.rb

@@ -0,0 +1,17 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Promote command
+    class Promote < Command
+
+      include Sfn::CommandModule::Base
+
+      def execute!
+        raise NotImplementedError.new 'Implementation updates required'
+        stack_name, destination = name_args
+      end
+
+    end
+  end
+end

data/lib/sfn/command/update.rb

@@ -0,0 +1,95 @@
+require 'sfn'
+
+module Sfn
+  class Command
+    # Update command
+    class Update < 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
+
+        stack_info = "#{ui.color('Name:', :bold)} #{name}"
+
+        if(config[:file])
+          file = load_template_file
+          stack_info << " #{ui.color('Path:', :bold)} #{config[:file]}"
+          nested_stacks = file.delete('sfn_nested_stack')
+        end
+
+        if(nested_stacks)
+
+          unpack_nesting(name, file, :update)
+
+        else
+          stack = provider.connection.stacks.get(name)
+
+          if(stack)
+            ui.info "#{ui.color('Cloud Formation:', :bold)} #{ui.color('update', :green)}"
+
+            unless(file)
+              if(config[:template])
+                file = config[:template]
+                stack_info << " #{ui.color('(template provided)', :green)}"
+              else
+                stack_info << " #{ui.color('(no template update)', :yellow)}"
+              end
+            end
+            ui.info "  -> #{stack_info}"
+
+            apply_stacks!(stack)
+
+            if(file)
+              populate_parameters!(file, stack.parameters)
+              stack.template = translate_template(file)
+              stack.parameters = config[:parameters]
+              stack.template = Sfn::Utils::StackParameterScrubber.scrub!(stack.template)
+            else
+              populate_parameters!(stack.template, stack.parameters)
+              stack.parameters = config[:parameters]
+            end
+
+            begin
+              stack.save
+            rescue Miasma::Error::ApiError::RequestError => e
+              if(e.message.downcase.include?('no updates')) # :'(
+                ui.warn "No updates detected for stack (#{stack.name})"
+              else
+                raise
+              end
+            end
+
+            if(config[:poll])
+              poll_stack(stack.name)
+              if(stack.success?)
+                ui.info "Stack update complete: #{ui.color('SUCCESS', :green)}"
+                namespace.const_get(:Describe).new({:outputs => true}, [name]).execute!
+              else
+                ui.fatal "Update of 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 update initialized for #{ui.color(name, :green)}"
+            end
+          else
+            ui.fatal "Failed to locate requested stack: #{ui.color(name, :red, :bold)}"
+            raise
+          end
+
+        end
+      end
+
+    end
+  end
+end