knife-cloudformation 0.2.24 → 0.5.0

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

@@ -1,197 +0,0 @@
-require 'knife-cloudformation'
-require 'sparkle_formation'
-
-module KnifeCloudformation
-  module Knife
-    # Stack handling helper methods
-    module Stack
-
-      module InstanceMethods
-
-        # un-packed 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)
-          action = self.class.name.downcase.end_with?('create') ? :create : :update
-          remote_stacks = Chef::Config[:knife][:cloudformation].
-            fetch(action, {}).fetch(:apply_stacks, [])
-          remote_stacks.each do |stack_name|
-            remote_stack = provider.connection.stacks.get(stack_name)
-            apply_nested_stacks!(remote_stack, stack)
-            if(remote_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] nested stack
-        # @param stack [Miasma::Models::Orchestration::Stack] current stack
-        # @return [Miasma::Models::Orchestration::Stack]
-        # @todo ported from a proto branch and needs to be refactored.
-        #   this implementation is some what shady
-        def apply_nested_stacks!(remote_stack, stack)
-          remote_stack.resources.all.each do |resource|
-            if(resource.type == 'AWS::CloudFormation::Stack')
-              nested_stack = provider.connection.stacks.get(resource.id)
-              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})"
-            exit 1
-          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)
-
-          # @todo move this init into setup
-          Chef::Config[:knife][:cloudformation][action.to_sym] ||= Mash.new
-          Chef::Config[:knife][:cloudformation][action.to_sym][:apply_stacks] ||= []
-
-          orig_options = Chef::Config[:knife][:cloudformation][:options].dup
-          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']
-            Chef::Config[:knife][:cloudformation][:options] = orig_options.dup
-
-            klass = Chef::Knife.const_get("Cloudformation#{action.to_s.capitalize}")
-            nested_stack_runner = klass.new
-            nested_stack_runner.config = config.dup
-            nested_stack_runner.name_args.push(nested_stack_name)
-            Chef::Config[:knife][:cloudformation][:template] = nested_stack_template
-            nested_stack_runner.run
-            unless(config[:print_only])
-              Chef::Config[:knife][:cloudformation][action.to_sym][:apply_stacks].push(nested_stack_name).uniq!
-            end
-            Chef::Config[:knife][:cloudformation][: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(Chef::Config[:knife][:cloudformation][:interactive_parameters])
-            if(stack['Parameters'])
-              Chef::Config[:knife][:cloudformation][:options][:parameters] ||= Mash.new
-              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].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 = 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

@@ -1,213 +0,0 @@
-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])
-              sf = SparkleFormation.compile(Chef::Config[:knife][:cloudformation][: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? && Chef::Config[:knife][:cloudformation][:apply_nesting])
-                sf.apply_nesting do |stack_name, stack_definition|
-                  bucket = provider.connection.api_for(:storage).buckets.get(
-                    Chef::Config[:knife][:cloudformation][: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(KnifeCloudformation::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(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}
-          )
-          option(:apply_nesting,
-            :long => '--[no-]apply-nesting',
-            :description => 'Apply stack nesting',
-            :default => false,
-            :boolean => true,
-            :proc => lambda{|val| Chef::Config[:knife][:cloudformation][:apply_nesting] = val}
-          )
-          option(:nesting_bucket,
-            :long => '--nesting-bucket',
-            :description => 'Bucket to use for storing nested stack templates',
-            :proc => lambda{|val| Chef::Config[:knife][:cloudformation][:nesting_bucket] = val}
-          )
-
-          Chef::Config[:knife][:cloudformation][:file_path_prompt] = true
-
-        end
-
-      end
-
-    end
-  end
-end

data/lib/knife-cloudformation/monkey_patch.rb

@@ -1,8 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  # Container for monkey patches
-  module MonkeyPatch
-    autoload :Stack, 'knife-cloudformation/monkey_patch/stack'
-  end
-end

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

@@ -1,195 +0,0 @@
-require 'base64'
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module MonkeyPatch
-
-    # Expand stack model functionality
-    module Stack
-
-      include KnifeCloudformation::Utils::AnimalStrings
-
-      ## Status helpers
-
-      # Check for state suffix
-      #
-      # @param args [String, Symbol] state suffix to check for (multiple allowed)
-      # @return [TrueClass, FalseClass] true if any matches found in argument list
-      def status_ends_with?(*args)
-        stat = status.to_s.downcase
-        !!args.map(&:to_s).map(&:downcase).detect do |suffix|
-          stat.end_with?(suffix)
-        end
-      end
-
-      # Check for state prefix
-      #
-      # @param args [String, Symbol] state prefix to check for (multiple allowed)
-      # @return [TrueClass, FalseClass] true if any matches found in argument list
-      def status_starts_with?(*args)
-        stat = status.to_s.downcase
-        !!args.map(&:to_s).map(&:downcase).detect do |prefix|
-          stat.start_with?(prefix)
-        end
-      end
-
-      # Check for state inclusion
-      #
-      # @param args [String, Symbol] state string to check for (multiple allowed)
-      # @return [TrueClass, FalseClass] true if any matches found in argument list
-      def status_includes?(*args)
-        stat = status.to_s.downcase
-        !!args.map(&:to_s).map(&:downcase).detect do |string|
-          stat.include?(string)
-        end
-      end
-
-      # @return [TrueClass, FalseClass] stack is in progress
-      def in_progress?
-        status_ends_with?(:in_progress)
-      end
-
-      # @return [TrueClass, FalseClass] stack is in complete state
-      def complete?
-        status_ends_with?(:complete, :failed)
-      end
-
-      # @return [TrueClass, FalseClass] stack is failed state
-      def failed?
-        status_ends_with?(:failed) ||
-          (status_includes?(:rollback) && status_ends_with?(:complete))
-      end
-
-      # @return [TrueClass, FalseClass] stack is in success state
-      def success?
-        !failed? && complete?
-      end
-
-      # @return [TrueClass, FalseClass] stack is creating
-      def creating?
-        in_progress? && status_starts_with?(:create)
-      end
-
-      # @return [TrueClass, FalseClass] stack is deleting
-      def deleting?
-        in_progress? && status_starts_with?(:delete)
-      end
-
-      # @return [TrueClass, FalseClass] stack is updating
-      def updating?
-        in_progress? && status_starts_with?(:update)
-      end
-
-      # @return [TrueClass, FalseClass] stack is rolling back
-      def rollbacking?
-        in_progress? && status_starts_with?(:rollback)
-      end
-
-      # @return [String] action currently being performed
-      def performing
-        if(in_progress?)
-          status.to_s.downcase.split('_').first.to_sym
-        end
-      end
-
-      ### Color coders
-
-      # @return [TrueClass, FalseClass] stack is in red state
-      def red?
-        failed? || deleting?
-      end
-
-      # @return [TrueClass, FalseClass] stack is in green state
-      def green?
-        success?
-      end
-
-      # @return [TrueClass, FalseClass] stack is in yellow state
-      def yellow?
-        !red? && !green?
-      end
-
-      # Provides color of stack state. Red is an error state, yellow
-      # is a warning state and green is a success state
-      #
-      # @return [Symbol] color of state (:red, :yellow, :green)
-      def color_state
-        red? ? :red : green? ? :green : :yellow
-      end
-
-      # Provides text of stack state. Danger is an error state, warning
-      # is a warning state and success is a success state
-      #
-      # @return [Symbol] color of state (:danger, :warning, :success)
-      def text_state
-        red? ? :danger : green? ? :success : :warning
-      end
-
-      # @return [String] URL safe encoded stack id
-      def encoded_id
-        Base64.urlsafe_encode64(id)
-      end
-
-      # Whole number representation of current completion
-      #
-      # @param min [Integer] lowest allowed return value (defaults 5)
-      # @return [Integer] percent complete (0..100)
-      def percent_complete(min = 5)
-        if(in_progress?)
-          total_resources = load_template.fetch('Resources', []).size
-          total_complete = resources.all.find_all do |resource|
-            resource.resource_status.downcase.end_with?('complete')
-          end.size
-          result = ((total_complete.to_f / total_resources) * 100).to_i
-          result > min.to_i ? result : min
-        else
-          100
-        end
-      end
-
-      # Apply stack outputs to current stack parameters
-      #
-      # @param remote_stack [Miasma::Orchestration::Stack]
-      # @return [self]
-      # @note setting `DisableApply` within parameter hash will
-      #   prevent parameters being overridden
-      def apply_stack(remote_stack)
-        default_key = 'Default'
-        stack_parameters = template['Parameters']
-        valid_parameters = Hash[
-          stack_parameters.map do |key, val|
-            unless(val['DisableApply'])
-              [snake(key), key]
-            end
-          end.compact
-        ]
-        if(defined?(Chef::Config) && Chef::Config[:knife][:cloudformation][:ignore_parameters])
-          valid_parameters = Hash[
-            valid_parameters.map do |snake_param, camel_param|
-              unless(Chef::Config[:knife][:cloudformation][:ignore_parameters].include?(camel_param))
-                [snake_param, camel_param]
-              end
-            end.compact
-          ]
-        end
-        if(persisted?)
-          remote_stack.outputs.each do |output|
-            if(param_key = valid_parameters[snake(output.key)])
-              parameters.merge!(param_key => output.value)
-            end
-          end
-        else
-          remote_stack.outputs.each do |output|
-            if(param_key = valid_parameters[snake(output.key)])
-              stack_parameters[param_key][default_key] = output.value
-            end
-          end
-        end
-      end
-
-    end
-  end
-end
-
-# Infect miasma
-Miasma::Models::Orchestration::Stack.send(:include, KnifeCloudformation::MonkeyPatch::Stack)