knife-cloudformation 0.1.22 → 0.2.0

data/lib/knife-cloudformation/knife.rb

@@ -0,0 +1,9 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Knife
+    autoload :Base, 'knife-cloudformation/knife/base'
+    autoload :Stack, 'knife-cloudformation/knife/stack'
+    autoload :Template, 'knife-cloudformation/knife/template'
+  end
+end

data/lib/knife-cloudformation/knife/base.rb

@@ -0,0 +1,179 @@
+require 'chef/knife'
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Knife
+    # Base to build cloudformation related knife commands
+    module Base
+
+      # Instance methods for cloudformation command classes
+      module InstanceMethods
+
+        # @return [KnifeCloudformation::Provider]
+        def provider
+          self.class.provider
+        end
+
+        # Write exception information if debug is enabled
+        #
+        # @param e [Exception]
+        # @param args [String] extra strings to output
+        def _debug(e, *args)
+          if(ENV['DEBUG'])
+            ui.fatal "Exception information: #{e.class}: #{e}\n#{e.backtrace.join("\n")}\n"
+            args.each do |string|
+              ui.fatal string
+            end
+          end
+        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
+          Chef::Config[:knife][:cloudformation][: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)
+          config[:all_attributes] || allowed_attributes.include?(attr)
+        end
+
+        # Poll events on stack
+        #
+        # @param name [String] name of stack
+        def poll_stack(name)
+          knife_events = Chef::Knife::CloudformationEvents.new
+          knife_events.name_args.push(name)
+          Chef::Config[:knife][:cloudformation][:poll] = true
+          knife_events.run
+        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
+
+        # Disable chef configuration. Let the dep loader do that for us
+        # so it doesn't squash config values set via options
+        def configure_chef
+          true
+        end
+
+        # Wrapper to allow consistent exception handling
+        def run
+          begin
+            _run
+          rescue => e
+            ui.fatal "Unexpected Error: #{e}"
+            _debug(e)
+            exit 1
+          end
+        end
+
+      end
+
+      module ClassMethods
+
+        # @return [KnifeCloudformation::Provider]
+        def provider
+          Thread.current[:_provider] ||= KnifeCloudformation::Provider.new(
+            :miasma => Chef::Config[:knife][:cloudformation][:credentials],
+            :async => false,
+            :fetch => false
+          )
+        end
+
+        # @return [FalseClass]
+        def use_separate_defaults?
+          false
+        end
+
+      end
+
+      class << self
+        def included(klass)
+          klass.instance_eval do
+
+            extend KnifeCloudformation::Knife::Base::ClassMethods
+            include KnifeCloudformation::Knife::Base::InstanceMethods
+            include KnifeCloudformation::Utils::JSON
+            include KnifeCloudformation::Utils::AnimalStrings
+            include KnifeCloudformation::Utils::Output
+
+            deps do
+              Chef::Knife.new.configure_chef
+              require 'miasma'
+              Chef::Config[:knife][:cloudformation] ||= Mash.new
+              Chef::Config[:knife][:cloudformation][:credentials] ||= Mash.new
+              Chef::Config[:knife][:cloudformation][:options] ||= Mash.new
+              Chef::Config[:knife][:cloudformation][:ignore_parameters] = []
+              %w(poll interactive_parameters).each do |key|
+                if(Chef::Config[:knife][:cloudformation][key].nil?)
+                  Chef::Config[:knife][:cloudformation][key] = true
+                end
+              end
+            end
+
+            option(:credentials,
+              :short => '-S CREDENTIALS',
+              :long => '--credentials CREDENTIALS',
+              :description => 'Miasma API options. Comma delimited or used multiple times. (-S "aws_access_key_id=MYKEY")',
+              :proc => lambda {|val|
+                val.split(',').each do |pair|
+                  key, value = pair.split('=')
+                  Chef::Config[:knife][:cloudformation][:credentials][key] = value
+                end
+              }
+            )
+
+            option(:ignore_parameter,
+              :long => '--ignore-parameter PARAMETER_NAME',
+              :description => 'Parameter to ignore during modifications (can be used multiple times)',
+              :proc => lambda{|val| Chef::Config[:knife][:cloudformation][:ignore_parameters].push(val).uniq! }
+            )
+
+            # Populate up the hashes so they are available for knife config
+            # with issues of nils
+            ['knife.cloudformation.credentials', 'knife.cloudformation.options'].each do |stack|
+              stack.split('.').inject(Chef::Config) do |memo, item|
+                memo[item.to_sym] = Mash.new unless memo[item.to_sym]
+                memo[item.to_sym]
+              end
+            end
+
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/knife-cloudformation/knife/stack.rb

@@ -0,0 +1,94 @@
+require 'knife-cloudformation'
+require 'sparkle_formation'
+
+module KnifeCloudformation
+  module Knife
+    # Stack handling helper methods
+    module Stack
+
+      module InstanceMethods
+
+        # maximum number of attempts to get valid parameter value
+        MAX_PARAMETER_ATTEMPTS = 5
+
+        # Prompt for parameter values and store result
+        #
+        # @param stack [Hash] stack template
+        # @return [Hash]
+        def populate_parameters!(stack)
+          if(Chef::Config[:knife][:cloudformation][:interactive_parameters])
+            if(stack['Parameters'] || stack['parameters'])
+              Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
+              stack.fetch('Parameters', stack.fetch('parameters', {})).each do |k,v|
+                next if Chef::Config[:knife][:cloudformation][:options][:parameters][k]
+                attempt = 0
+                valid = false
+                until(valid)
+                  attempt += 1
+                  default = Chef::Config[:knife][:cloudformation][:options][:parameters][k] || v['Default'] || v['default']
+                  answer = ui.ask_question("#{k.split(/([A-Z]+[^A-Z]*)/).find_all{|s|!s.empty?}.join(' ')}: ", :default => default)
+                  validation = KnifeCloudformation::Utils::StackParameterValidator.validate(answer, v)
+                  if(validation == true)
+                    Chef::Config[:knife][:cloudformation][:options][:parameters][k] = answer
+                    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 KnifeCloudformation::Knife::Stack::ClassMethods
+          include KnifeCloudformation::Knife::Stack::InstanceMethods
+
+          option(:parameter,
+            :short => '-p KEY:VALUE',
+            :long => '--parameter KEY:VALUE',
+            :description => 'Set parameter. Can be used multiple times.',
+            :proc => lambda {|val|
+              parts = val.split(':')
+              key = parts.first
+              value = parts[1, parts.size].join(':')
+              Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
+              Chef::Config[:knife][:cloudformation][:options][:parameters][key] = value
+            }
+          )
+          option(:polling,
+            :long => '--[no-]poll',
+            :description => 'Enable stack event polling.',
+            :boolean => true,
+            :default => true,
+            :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:poll] = val }
+          )
+          option(:interactive_parameters,
+            :long => '--[no-]parameter-prompts',
+            :boolean => true,
+            :default => true,
+            :description => 'Do not prompt for input on dynamic parameters',
+            :proc => lambda{|val| Chef::Config[:knife][:cloudformation][:interactive_parameters] = val }
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/knife-cloudformation/knife/template.rb

@@ -0,0 +1,174 @@
+require 'knife-cloudformation'
+require 'sparkle_formation'
+
+module KnifeCloudformation
+  module Knife
+    # 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(Chef::Config[:knife][:cloudformation][:template])
+            set_paths_and_discover_file!
+            unless(File.exists?(Chef::Config[:knife][:cloudformation][:file].to_s))
+              unless(args.include?(:allow_missing))
+                ui.fatal "Invalid formation file path provided: #{Chef::Config[:knife][:cloudformation][:file]}"
+                exit 1
+              end
+            end
+          end
+          if(Chef::Config[:knife][:cloudformation][:template])
+            Chef::Config[:knife][:cloudformation][:template]
+          elsif(Chef::Config[:knife][:cloudformation][:file])
+            if(Chef::Config[:knife][:cloudformation][:processing])
+              SparkleFormation.compile(Chef::Config[:knife][:cloudformation][:file])
+            else
+              _from_json(File.read(Chef::Config[:knife][:cloudformation][:file]))
+            end
+          end
+        end
+
+        # Apply template translation
+        #
+        # @param template [Hash]
+        # @return [Hash]
+        def translate_template(template)
+          if(klass_name = Chef::Config[:knife][:cloudformation][:translate])
+            klass = SparkleFormation::Translation.const_get(camel(klass_name))
+            args = {
+              :parameters => Chef::Config[:knife][:cloudformation][:options][:parameters]
+            }
+            if(chunk_size = Chef::Config[:knife][:cloudformation][: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(Chef::Config[:knife][:cloudformation][:base_directory])
+            SparkleFormation.components_path = File.join(
+              Chef::Config[:knife][:cloudformation][:base_directory], 'components'
+            )
+            SparkleFormation.dynamics_path = File.join(
+              Chef::Config[:knife][:cloudformation][:base_directory], 'dynamics'
+            )
+          end
+          if(!Chef::Config[:knife][:cloudformation][:file] && Chef::Config[:knife][:cloudformation][:file_path_prompt])
+            root = File.expand_path(
+              Chef::Config[:knife][:cloudformation].fetch(:base_directory,
+                File.join(Dir.pwd, 'cloudformation')
+              )
+            ).split('/')
+            bucket = root.pop
+            root = root.join('/')
+            directory = File.join(root, bucket)
+            Chef::Config[:knife][:cloudformation][:file] = prompt_for_file(directory,
+              :directories_name => 'Collections',
+              :files_name => 'Templates',
+              :ignore_directories => TEMPLATE_IGNORE_DIRECTORIES
+            )
+          else
+            unless(Pathname(Chef::Config[:knife][:cloudformation][:file].to_s).absolute?)
+              base_dir = Chef::Config[:knife][:cloudformation][:base_directory].to_s
+              file = Chef::Config[:knife][:cloudformation][:file].to_s
+              pwd = Dir.pwd
+              Chef::Config[:knife][:cloudformation][: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 KnifeCloudformation::Knife::Template::ClassMethods
+          include KnifeCloudformation::Knife::Template::InstanceMethods
+          include KnifeCloudformation::Utils::PathSelector
+
+          option(:processing,
+            :long => '--[no-]processing',
+            :description => 'Call the unicorns and explode the glitter bombs',
+            :boolean => true,
+            :default => false,
+            :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:processing] = val }
+          )
+          option(:file,
+            :short => '-f PATH',
+            :long => '--file PATH',
+            :description => 'Path to Cloud Formation to process',
+            :proc => lambda {|val|
+              Chef::Config[:knife][:cloudformation][:file] = val
+            }
+          )
+          option(:file_path_prompt,
+            :long => '--[no-]file-path-prompt',
+            :description => 'Interactive prompt for template path discovery',
+            :boolean => true,
+            :default => true,
+            :proc => lambda {|val|
+              Chef::Config[:knife][:cloudformation][:file_path_prompt] = val
+            }
+          )
+          option(:base_directory,
+            :long => '--cloudformation-directory PATH',
+            :description => 'Path to cloudformation directory',
+            :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:base_directory] = val}
+          )
+          option(:no_base_directory,
+            :long => '--no-cloudformation-directory',
+            :description => 'Unset any value used for cloudformation path',
+            :proc => lambda {|*val| Chef::Config[:knife][:cloudformation][:base_directory] = nil}
+          )
+          option(:translate,
+            :long => '--translate PROVIDER',
+            :description => 'Translate generated template to given provider',
+            :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:translate] = val}
+          )
+          option(:translate_chunk,
+            :long => '--translate-chunk-size SIZE',
+            :description => 'Chunk length for serialization',
+            :proc => lambda {|val| Chef::Config[:knife][:cloudformation][:translate_chunk_size] = val}
+          )
+
+          Chef::Config[:knife][:cloudformation][:file_path_prompt] = true
+
+        end
+
+      end
+
+    end
+  end
+end