sfn 0.0.1 → 0.3.0

data/lib/sfn/command/validate.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require 'sparkle_formation'
+require 'sfn'
+
+module Sfn
+  class Command
+    # Validate command
+    class Validate < Command
+
+      include Sfn::CommandModule::Base
+      include Sfn::CommandModule::Template
+
+      def execute!
+        file = load_template_file
+        file.delete('sfn_nested_stack')
+        ui.info "#{ui.color("Template Validation (#{provider.connection.provider}): ", :bold)} #{config[:file].sub(Dir.pwd, '').sub(%r{^/}, '')}"
+        file = Sfn::Utils::StackParameterScrubber.scrub!(file)
+        file = translate_template(file)
+        begin
+          result = provider.connection.stacks.build(
+            :name => 'validation-stack',
+            :template => file
+          ).validate
+          ui.info ui.color('  -> VALID', :bold, :green)
+        rescue => e
+          ui.info ui.color('  -> INVALID', :bold, :red)
+          ui.fatal e.message
+          failed = true
+        end
+      end
+
+    end
+  end
+end

data/lib/sfn/command_module.rb

@@ -0,0 +1,9 @@
+require 'sfn'
+
+module Sfn
+  module CommandModule
+    autoload :Base, 'sfn/command_module/base'
+    autoload :Stack, 'sfn/command_module/stack'
+    autoload :Template, 'sfn/command_module/template'
+  end
+end

data/lib/sfn/command_module/base.rb

@@ -0,0 +1,150 @@
+require 'sfn'
+
+module Sfn
+  module CommandModule
+    # Base module for CLIs
+    module Base
+
+      # Instance methods for cloudformation command classes
+      module InstanceMethods
+
+        # @return [KnifeCloudformation::Provider]
+        def provider
+          memoize(:provider, :direct) do
+            Sfn::Provider.new(
+              :miasma => config[:credentials],
+              :async => false,
+              :fetch => false
+            )
+          end
+        end
+
+        # Write exception information if debug is enabled
+        #
+        # @param e [Exception]
+        # @param args [String] extra strings to output
+        def _debug(e, *args)
+          if(config[:verbose])
+            ui.fatal "Exception information: #{e.class}: #{e.message}"
+            if(ENV['DEBUG'])
+              puts "#{e.backtrace.join("\n")}\n"
+              if(e.is_a?(Miasma::Error::ApiError))
+                ui.fatal "Response body: #{e.response.body.to_s.inspect}"
+              end
+            end
+            args.each do |string|
+              ui.fatal string
+            end
+          end
+        end
+
+        # Format snake cased key to title
+        #
+        # @param string [String, Symbol]
+        # @return [String
+        def as_title(string)
+          string.to_s.split('_').map(&:capitalize).join(' ')
+        end
+
+        # Get stack
+        #
+        # @param name [String] name of stack
+        # @return [Miasma::Models::Orchestration::Stack]
+        def stack(name)
+          provider.stacks.get(name)
+        end
+
+        # @return [Array<String>] attributes to display
+        def allowed_attributes
+          opts.fetch(:attributes, config.fetch(:attributes, default_attributes))
+        end
+
+        # @return [Array<String>] default attributes to display
+        def default_attributes
+          %w(timestamp stack_name id)
+        end
+
+        # Check if attribute is allowed for display
+        #
+        # @param attr [String]
+        # @return [TrueClass, FalseClass]
+        def attribute_allowed?(attr)
+          opts.fetch(:all_attributes, config[:all_attributes], allowed_attributes.include?(attr))
+        end
+
+        # Poll events on stack
+        #
+        # @param name [String] name of stack
+        def poll_stack(name)
+          provider.connection.stacks.reload
+          retry_attempts = 0
+          begin
+            events = Sfn::Command::Events.new({:poll => true}, [name]).execute!
+          rescue => e
+            if(retry_attempts < config.fetch(:max_poll_retries, 5).to_i)
+              retry_attempts += 1
+              warn "Unexpected error encountered (#{e.class}: #{e}) Retrying [retry count: #{retry_attempts}]"
+              sleep(1)
+              retry
+            else
+              raise
+            end
+          end
+        end
+
+        # Wrapper for information retrieval. Provides consistent error
+        # message for failures
+        #
+        # @param stack [String] stack name
+        # @param message [String] failure message
+        # @yield block to wrap error handling
+        # @return [Object] result of yield
+        def get_things(stack=nil, message=nil)
+          begin
+            yield
+          rescue => e
+            ui.fatal "#{message || 'Failed to retrieve information'}#{" for requested stack: #{stack}" if stack}"
+            ui.fatal "Reason: #{e}"
+            _debug(e)
+            exit 1
+          end
+        end
+
+        # Simple compat proxy method
+        #
+        # @return [Array<String>]
+        def name_args
+          arguments
+        end
+
+        # Fetches value from local configuration (#opts) and falls
+        # back to global configuration (#options)
+        #
+        # @return [Object]
+        def config
+          memoize(:config) do
+            options.deep_merge(opts)
+          end
+        end
+
+      end
+
+      class << self
+        def included(klass)
+          klass.instance_eval do
+
+            include Sfn::CommandModule::Base::InstanceMethods
+            include Sfn::Utils::JSON
+            include Sfn::Utils::Output
+            include Bogo::AnimalStrings
+            include Bogo::Memoization
+            include Bogo::Constants
+
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/sfn/command_module/stack.rb

@@ -0,0 +1,166 @@
+require 'sfn'
+require 'sparkle_formation'
+
+module Sfn
+  module CommandModule
+    # Stack handling helper methods
+    module Stack
+
+      module InstanceMethods
+
+        # unpacked stack name joiner/identifier
+        UNPACK_NAME_JOINER = '-sfn-'
+        # maximum number of attempts to get valid parameter value
+        MAX_PARAMETER_ATTEMPTS = 5
+
+        # Apply any defined remote stacks
+        #
+        # @param stack [Miasma::Models::Orchestration::Stack]
+        # @return [Miasma::Models::Orchestration::Stack]
+        def apply_stacks!(stack)
+          remote_stacks = config.fetch(:apply_stacks, [])
+          remote_stacks.each do |stack_name|
+            remote_stack = provider.connection.stacks.get(stack_name)
+            if(remote_stack)
+              apply_nested_stacks!(remote_stack, stack)
+              stack.apply_stack(remote_stack)
+            else
+              apply_unpacked_stack!(stack_name, stack)
+            end
+          end
+          stack
+        end
+
+        # Detect nested stacks and apply
+        #
+        # @param remote_stack [Miasma::Models::Orchestration::Stack] stack to inspect for nested stacks
+        # @param stack [Miasma::Models::Orchestration::Stack] current stack
+        # @return [Miasma::Models::Orchestration::Stack]
+        def apply_nested_stacks(remote_stack, stack)
+          remote_stack.resources.all.each do |resource|
+            if(resource.type == 'AWS::CloudFormation::Stack')
+              nested_stack = resource.expand
+              apply_nested_stacks!(nested_stack, stack)
+              stack.apply_stack(nested_stack)
+            end
+          end
+          stack
+        end
+
+        # Apply all stacks from an unpacked stack
+        #
+        # @param stack_name [String] name of parent stack
+        # @param stack [Miasma::Models::Orchestration::Stack]
+        # @return [Miasma::Models::Orchestration::Stack]
+        def apply_unpacked_stack!(stack_name, stack)
+          result = provider.connection.stacks.all.find_all do |remote_stack|
+            remote_stack.name.start_with?("#{stack_name}#{UNPACK_NAME_JOINER}")
+          end.sort_by(&:name).map do |remote_stack|
+            stack.apply_stack(remote_stack)
+          end
+          unless(result.empty?)
+            stack
+          else
+            ui.error "Failed to apply requested stack. Unable to locate. (#{stack_name})"
+            raise "Failed to locate stack: #{stack_name}"
+          end
+        end
+
+        # Unpack nested stack and run action on each stack, applying
+        # the previous stacks automatically
+        #
+        # @param name [String] container stack name
+        # @param file [Hash] stack template
+        # @param action [String] create or update
+        # @return [TrueClass]
+        def unpack_nesting(name, file, action)
+          config.apply_stacks ||= []
+          stack_count = 0
+          file['Resources'].each do |stack_resource_name, stack_resource|
+
+            nested_stack_name = "#{name}#{UNPACK_NAME_JOINER}#{Kernel.sprintf('%0.3d', stack_count)}-#{stack_resource_name}"
+            nested_stack_template = stack_resource['Properties']['Stack']
+
+            namespace.const_get(action.to_s.capitalize).new(
+              Smash.new(
+                :print_only => config[:print_only],
+                :template => nested_stack_template,
+                :parameters => config.fetch(:parameters, Smash.new).to_smash,
+                :apply_stacks => config[:apply_stacks],
+                :options => config[:options]
+              ),
+              [nested_stack_name]
+            ).execute!
+            unless(config[:print_only])
+              config[:apply_stacks].push(nested_stack_name).uniq!
+            end
+            config[:template] = nil
+            provider.connection.stacks.reload
+            stack_count += 1
+          end
+
+          true
+        end
+
+        # Prompt for parameter values and store result
+        #
+        # @param stack [Hash] stack template
+        # @return [Hash]
+        def populate_parameters!(stack, current_params={})
+          if(config[:interactive_parameters])
+            if(stack['Parameters'])
+              unless(config.get(:parameters))
+                config.set(:parameters, Smash.new)
+              end
+              stack.fetch('Parameters', {}).each do |k,v|
+                next if config[:parameters][k]
+                attempt = 0
+                valid = false
+                until(valid)
+                  attempt += 1
+                  default = config[:parameters].fetch(
+                    k, current_params.fetch(
+                      k, v['Default']
+                    )
+                  )
+                  answer = ui.ask_question("#{k.split(/([A-Z]+[^A-Z]*)/).find_all{|s|!s.empty?}.join(' ')}", :default => default)
+                  validation = Sfn::Utils::StackParameterValidator.validate(answer, v)
+                  if(validation == true)
+                    unless(answer == v['Default'])
+                      config[:parameters][k] = answer
+                    end
+                    valid = true
+                  else
+                    validation.each do |validation_error|
+                      ui.error validation_error.last
+                    end
+                  end
+                  if(attempt > MAX_PARAMETER_ATTEMPTS)
+                    ui.fatal 'Failed to receive allowed parameter!'
+                    exit 1
+                  end
+                end
+              end
+            end
+          end
+          stack
+        end
+
+      end
+
+      module ClassMethods
+      end
+
+      # Load methods into class and define options
+      #
+      # @param klass [Class]
+      def self.included(klass)
+        klass.class_eval do
+          extend Sfn::CommandModule::Stack::ClassMethods
+          include Sfn::CommandModule::Stack::InstanceMethods
+        end
+      end
+
+    end
+  end
+end

data/lib/sfn/command_module/template.rb

@@ -0,0 +1,147 @@
+require 'sfn'
+require 'sparkle_formation'
+
+module Sfn
+  module CommandModule
+    # Template handling helper methods
+    module Template
+
+      # cloudformation directories that should be ignored
+      TEMPLATE_IGNORE_DIRECTORIES = %w(components dynamics registry)
+
+      module InstanceMethods
+
+        # Load the template file
+        #
+        # @param args [Symbol] options (:allow_missing)
+        # @return [Hash] loaded template
+        def load_template_file(*args)
+          unless(config[:template])
+            set_paths_and_discover_file!
+            unless(File.exists?(config[:file].to_s))
+              unless(args.include?(:allow_missing))
+                ui.fatal "Invalid formation file path provided: #{config[:file]}"
+                raise IOError.new "Failed to locate file: #{config[:file]}"
+              end
+            end
+          end
+          if(config[:template])
+            config[:template]
+          elsif(config[:file])
+            if(config[:processing])
+              sf = SparkleFormation.compile(config[:file], :sparkle)
+              if(sf.nested? && !sf.isolated_nests?)
+                raise TypeError.new('Template does not contain isolated stack nesting! Cannot process in existing state.')
+              end
+              if(sf.nested? && config[:apply_nesting])
+                sf.apply_nesting do |stack_name, stack_definition|
+                  bucket = provider.connection.api_for(:storage).buckets.get(
+                    config[:nesting_bucket]
+                  )
+                  if(config[:print_only])
+                    "http://example.com/bucket/#{name_args.first}_#{stack_name}.json"
+                  else
+                    unless(bucket)
+                      raise "Failed to locate configured bucket for stack template storage (#{bucket})!"
+                    end
+                    file = bucket.files.build
+                    file.name = "#{name_args.first}_#{stack_name}.json"
+                    file.content_type = 'text/json'
+                    file.body = MultiJson.dump(Sfn::Utils::StackParameterScrubber.scrub!(stack_definition))
+                    file.save
+                    # TODO: what if we need extra params?
+                    url = URI.parse(file.url)
+                    "#{url.scheme}://#{url.host}#{url.path}"
+                  end
+                end
+              else
+                sf.dump.merge('sfn_nested_stack' => !!sf.nested?)
+              end
+            else
+              _from_json(File.read(config[:file]))
+            end
+          end
+        end
+
+        # Apply template translation
+        #
+        # @param template [Hash]
+        # @return [Hash]
+        def translate_template(template)
+          if(klass_name = config[:translate])
+            klass = SparkleFormation::Translation.const_get(camel(klass_name))
+            args = {
+              :parameters => config.fetch(:options, :parameters, Smash.new)
+            }
+            if(chunk_size = config[:translate_chunk_size])
+              args.merge!(
+                :options => {
+                  :serialization_chunk_size => chunk_size
+                }
+              )
+            end
+            translator = klass.new(template, args)
+            translator.translate!
+            template = translator.translated
+            ui.info "#{ui.color('Translation applied:', :bold)} #{ui.color(klass_name, :yellow)}"
+          end
+          template
+        end
+
+        # Set SparkleFormation paths and locate tempate
+        #
+        # @return [TrueClass]
+        def set_paths_and_discover_file!
+          if(config[:base_directory])
+            SparkleFormation.sparkle_path = config[:base_directory]
+          end
+          if(!config[:file] && config[:file_path_prompt])
+            root = File.expand_path(
+              config.fetch(:base_directory,
+                File.join(Dir.pwd, 'cloudformation')
+              )
+            ).split('/')
+            bucket = root.pop
+            root = root.join('/')
+            directory = File.join(root, bucket)
+            config[:file] = prompt_for_file(directory,
+              :directories_name => 'Collections',
+              :files_name => 'Templates',
+              :ignore_directories => TEMPLATE_IGNORE_DIRECTORIES
+            )
+          else
+            unless(Pathname(config[:file].to_s).absolute?)
+              base_dir = config[:base_directory].to_s
+              file = config[:file].to_s
+              pwd = Dir.pwd
+              config[:file] = [
+                File.join(base_dir, file),
+                File.join(pwd, file),
+                File.join(pwd, 'cloudformation', file)
+              ].detect do |file_path|
+                File.file?(file_path)
+              end
+            end
+          end
+          true
+        end
+
+      end
+
+      module ClassMethods
+      end
+
+      # Load methods into class and define options
+      #
+      # @param klass [Class]
+      def self.included(klass)
+        klass.class_eval do
+          extend Sfn::CommandModule::Template::ClassMethods
+          include Sfn::CommandModule::Template::InstanceMethods
+          include Sfn::Utils::PathSelector
+         end
+      end
+
+    end
+  end
+end