knife-cloudformation 0.2.24 → 0.5.0

data/lib/knife-cloudformation/utils/path_selector.rb

@@ -1,99 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # Helper methods for path selection
-    module PathSelector
-
-      # Humanize the base name of path
-      #
-      # @param path [String]
-      # @return [String]
-      def humanize_path_basename(path)
-        File.basename(path).sub(
-          File.extname(path), ''
-        ).split(/[-_]/).map(&:capitalize).join(' ')
-      end
-
-      # Prompt user for file selection
-      #
-      # @param directory [String] path to directory
-      # @param opts [Hash] options
-      # @option opts [Array<String>] :ignore_directories directory names
-      # @option opts [String] :directories_name title for directories
-      # @option opts [String] :files_name title for files
-      # @option opts [String] :filter_prefix only return results matching filter
-      # @return [String] file path
-      def prompt_for_file(directory, opts={})
-        file_list = Dir.glob(File.join(directory, '**', '**', '*')).find_all do |file|
-          File.file?(file)
-        end
-        if(opts[:filter_prefix])
-          file_list = file_list.find_all do |file|
-            file.start_with?(options[:filter_prefix])
-          end
-        end
-        directories = file_list.map do |file|
-          File.dirname(file)
-        end.uniq
-        files = file_list.find_all do |path|
-          path.sub(directory, '').split('/').size == 2
-        end
-        if(opts[:ignore_directories])
-          directories.delete_if do |dir|
-            opts[:ignore_directories].include?(File.basename(dir))
-          end
-        end
-        if(directories.empty? && files.empty?)
-          ui.fatal 'No formation paths discoverable!'
-        else
-          output = ['Please select an entry']
-          output << '(or directory to list):' unless directories.empty?
-          ui.info output.join(' ')
-          output.clear
-          idx = 1
-          valid = {}
-          unless(directories.empty?)
-            output << ui.color("#{opts.fetch(:directories_name, 'Directories')}:", :bold)
-            directories.each do |dir|
-              valid[idx] = {:path => dir, :type => :directory}
-              output << [idx, humanize_path_basename(dir)]
-              idx += 1
-            end
-          end
-          unless(files.empty?)
-            output << ui.color("#{opts.fetch(:files_name, 'Files')}:", :bold)
-            files.each do |file|
-              valid[idx] = {:path => file, :type => :file}
-              output << [idx, humanize_path_basename(file)]
-              idx += 1
-            end
-          end
-          max = idx.to_s.length
-          output.map! do |o|
-            if(o.is_a?(Array))
-              "  #{o.first}.#{' ' * (max - o.first.to_s.length)} #{o.last}"
-            else
-              o
-            end
-          end
-          ui.info "#{output.join("\n")}\n"
-          response = ask_question('Enter selection: ').to_i
-          unless(valid[response])
-            ui.fatal 'How about using a real value'
-            exit 1
-          else
-            entry = valid[response.to_i]
-            if(entry[:type] == :directory)
-              prompt_for_file(entry[:path], opts)
-            else
-              "/#{entry[:path]}"
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/knife-cloudformation/utils/ssher.rb

@@ -1,29 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # Helper methods for SSH interactions
-    module Ssher
-
-      # Retrieve file from remote node
-      #
-      # @param address [String]
-      # @param user [String]
-      # @param path [String] remote file path
-      # @param ssh_opts [Hash]
-      # @return [String, NilClass]
-      def remote_file_contents(address, user, path, ssh_opts={})
-        if(path.to_s.strip.empty?)
-          raise ArgumentError.new 'No file path provided!'
-        end
-        require 'net/ssh'
-        content = ''
-        ssh_session = Net::SSH.start(address, user, ssh_opts)
-        content = ssh_session.exec!("sudo cat #{path}")
-        content.empty? ? nil : content
-      end
-
-    end
-  end
-end

data/lib/knife-cloudformation/utils/stack_exporter.rb

@@ -1,271 +0,0 @@
-require 'chef'
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # Stack serialization helper
-    class StackExporter
-
-      include KnifeCloudformation::Utils::AnimalStrings
-      include KnifeCloudformation::Utils::JSON
-
-      # default chef environment name
-      DEFAULT_CHEF_ENVIRONMENT = '_default'
-      # default instance options
-      DEFAULT_OPTIONS = Mash.new(
-        :chef_popsicle => true,
-        :ignored_parameters => ['Environment', 'StackCreator', 'Creator'],
-        :chef_environment_parameter => 'Environment'
-      )
-      # default structure of export payload
-      DEFAULT_EXPORT_STRUCTURE = {
-        :stack => Mash.new(
-          :template => nil,
-          :options => {
-            :parameters => Mash.new,
-            :capabilities => [],
-            :notification_topics => []
-          }
-        ),
-        :generator => {
-          :timestamp => Time.now.to_i,
-          :name => 'knife-cloudformation',
-          :version => KnifeCloudformation::VERSION.version,
-          :provider => nil
-        }
-      }
-
-      # @return [Miasma::Models::Orchestration::Stack]
-      attr_reader :stack
-      # @return [Hash]
-      attr_reader :options
-      # @return [Hash]
-      attr_reader :stack_export
-
-      # Create new instance
-      #
-      # @param stack [Miasma::Models::Orchestration::Stack]
-      # @param options [Hash]
-      # @option options [KnifeCloudformation::Provider] :provider
-      # @option options [TrueClass, FalseClass] :chef_popsicle freeze run list
-      # @option options [Array<String>] :ignored_parameters
-      # @option options [String] :chef_environment_parameter
-      def initialize(stack, options={})
-        @stack = stack
-        @options = DEFAULT_OPTIONS.merge(options)
-        @stack_export = Mash.new
-      end
-
-      # Export stack
-      #
-      # @return [Hash] exported stack
-      def export
-        @stack_export = Mash.new(DEFAULT_EXPORT_STRUCTURE).tap do |stack_export|
-          [:parameters, :capabilities, :notification_topics].each do |key|
-            if(val = stack.send(key))
-              stack_export[:stack][key] = val
-            end
-          end
-          stack_export[:stack][:template] = stack.template
-          stack_export[:generator][:timestamp] = Time.now.to_i
-          stack_export[:generator][:provider] = stack.provider.connection.provider
-          if(chef_popsicle?)
-            freeze_runlists(stack_export)
-          end
-          remove_ignored_parameters(stack_export)
-          stack_export[:stack][:template] = _to_json(
-            stack_export[:stack][:template]
-          )
-        end
-      end
-
-      # Provide query methods on options hash
-      #
-      # @param args [Object] argument list
-      # @return [Object]
-      def method_missing(*args)
-        m = args.first.to_s
-        if(m.end_with?('?') && options.has_key?(k = m.sub('?', '').to_sym))
-          !!options[k]
-        else
-          super
-        end
-      end
-
-      protected
-
-      # Remove parameter values from export that are configured to be
-      # ignored
-      #
-      # @param export [Hash] stack export
-      # @return [Hash]
-      def remove_ignored_parameters(export)
-        options[:ignored_parameters].each do |param|
-          if(export[:stack][:options][:parameters])
-            export[:stack][:options][:parameters].delete(param)
-          end
-        end
-        export
-      end
-
-      # Environment name to use when interacting with Chef
-      #
-      # @param export [Hash] current export state
-      # @return [String] environment name
-      def chef_environment_name(export)
-        if(chef_environment_parameter?)
-          name = export[:stack][:options][:parameters][options[:chef_environment_parameter]]
-        end
-        name || DEFAULT_CHEF_ENVIRONMENT
-      end
-
-      # @return [Chef::Environment]
-      def environment
-        unless(@env)
-          @env = Chef::Environment.load('_default')
-        end
-        @env
-      end
-
-      # Find latest available cookbook version within
-      # the configured environment
-      #
-      # @param cookbook [String] name of cookbook
-      # @return [Chef::Version]
-      def allowed_cookbook_version(cookbook)
-        restriction = environment.cookbook_versions[cookbook]
-        requirement = Gem::Requirement.new(restriction)
-        Chef::CookbookVersion.available_versions(cookbook).detect do |v|
-          requirement.satisfied_by?(Gem::Version.new(v))
-        end
-      end
-
-      # Extract the runlist item. Fully expands roles and provides
-      # version pegged runlist.
-      #
-      # @param item [Chef::RunList::RunListItem, Array<String>]
-      # @return [Hash] new chef configuration hash
-      # @note this will expand all roles
-      def extract_runlist_item(item)
-        rl_item = item.is_a?(Chef::RunList::RunListItem) ? item : Chef::RunList::RunListItem.new(item)
-        static_content = Mash.new(:run_list => [])
-        if(rl_item.recipe?)
-          cookbook, recipe = rl_item.name.split('::')
-          peg_version = allowed_cookbook_version(cookbook)
-          static_content[:run_list] << "recipe[#{[cookbook, recipe || 'default'].join('::')}@#{peg_version}]"
-        elsif(rl_item.role?)
-          role = Chef::Role.load(rl_item.name)
-          role.run_list.each do |item|
-            static_content = Chef::Mixin::DeepMerge.merge(static_content, extract_runlist_item(item))
-          end
-          static_content = Chef::Mixin::DeepMerge.merge(
-            static_content, Chef::Mixin::DeepMerge.merge(role.default_attributes, role.override_attributes)
-          )
-        else
-          raise TypeError.new("Unknown chef run list item encountered: #{rl_item.inspect}")
-        end
-        static_content
-      end
-
-      # Expand any detected chef run lists and freeze them within the
-      # stack template
-      #
-      # @param first_run [Hash] chef first run hash
-      # @return [Hash]
-      def unpack_and_freeze_runlist(first_run)
-        extracted_runlists = first_run['run_list'].map do |item|
-          extract_runlist_item(cf_replace(item))
-        end
-        first_run.delete('run_list')
-        first_run.replace(
-          extracted_runlists.inject(first_run) do |memo, first_run_item|
-            Chef::Mixin::DeepMerge.merge(memo, first_run_item)
-          end
-        )
-      end
-
-      # Freeze chef run lists
-      #
-      # @param exported [Hash] stack export
-      # @return [Hash]
-      def freeze_runlists(exported)
-        first_runs = locate_runlists(exported)
-        first_runs.each do |first_run|
-          unpack_and_freeze_runlist(first_run)
-        end
-        exported
-      end
-
-      # Locate chef run lists within data collection
-      #
-      # @param thing [Enumerable] collection from export
-      # @return [Enumerable] updated collection from export
-      def locate_runlists(thing)
-        result = []
-        case thing
-        when Hash
-          if(thing['content'] && thing['content']['run_list'])
-            result << thing['content']
-          else
-            thing.each do |k,v|
-              result += locate_runlists(v)
-            end
-          end
-        when Array
-          thing.each do |v|
-            result += locate_runlists(v)
-          end
-        end
-        result
-      end
-
-      # Apply cloudformation function to data
-      #
-      # @param hsh [Object] stack template item
-      # @return [Object]
-      def cf_replace(hsh)
-        if(hsh.is_a?(Hash))
-          case hsh.keys.first
-          when 'Fn::Join'
-            cf_join(*hsh.values.first)
-          when 'Ref'
-            cf_ref(hsh.values.first)
-          else
-            hsh
-          end
-        else
-          hsh
-        end
-      end
-
-      # Apply Ref function
-      #
-      # @param ref_name [Hash]
-      # @return [Object] value in parameters
-      def cf_ref(ref_name)
-        if(stack.parameters.has_key?(ref_name))
-          stack.parameters[ref_name]
-        else
-          raise KeyError.new("No parameter found with given reference name (#{ref_name}). " <<
-            "Only parameter based references supported!")
-        end
-      end
-
-      # Apply Join function
-      #
-      # @param delim [String] join delimiter
-      # @param args [String, Hash] items to join
-      # @return [String]
-      def cf_join(delim, args)
-        args.map do |arg|
-          if(arg.is_a?(Hash))
-            cf_replace(arg)
-          else
-            arg.to_s
-          end
-        end.join(delim)
-      end
-    end
-  end
-end

data/lib/knife-cloudformation/utils/stack_parameter_scrubber.rb

@@ -1,37 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-    # Helper for scrubbing stack parameters
-    class StackParameterScrubber
-
-      class << self
-
-        # Validate attributes within Parameter blocks
-        ALLOWED_PARAMETER_ATTRIBUTES = %w(
-          Type Default NoEcho AllowedValues AllowedPattern
-          MaxLength MinLength MaxValue MinValue Description
-          ConstraintDescription
-        )
-
-        # Clean the parameters of the template
-        #
-        # @param template [Hash]
-        # @return [Hash] template
-        def scrub!(template)
-          parameters = template['Parameters']
-          if(parameters)
-            parameters.each do |name, options|
-              options.delete_if do |attribute, value|
-                !ALLOWED_PARAMETER_ATTRIBUTES.include?(attribute)
-              end
-            end
-            template['Parameters'] = parameters
-          end
-          template
-        end
-
-      end
-    end
-  end
-end

data/lib/knife-cloudformation/utils/stack_parameter_validator.rb

@@ -1,124 +0,0 @@
-require 'knife-cloudformation'
-
-module KnifeCloudformation
-  module Utils
-
-    # Helper utility for validating stack parameters
-    class StackParameterValidator
-      class << self
-
-        include KnifeCloudformation::Utils::AnimalStrings
-
-        # Validate a parameters
-        #
-        # @param value [Object] value for parameter
-        # @param parameter_definition [Hash]
-        # @option parameter_definition [Array<String>] 'AllowedValues'
-        # @option parameter_definition [String] 'AllowedPattern'
-        # @option parameter_definition [String, Integer] 'MaxLength'
-        # @option parameter_definition [String, Integer] 'MinLength'
-        # @option parameter_definition [String, Integer] 'MaxValue'
-        # @option parameter_definition [String, Integer] 'MinValue'
-        # @return [TrueClass, Array<String>] true if valid. array of string errors if invalid
-        def validate(value, parameter_definition)
-          return [[:blank, 'Value cannot be blank']] if value.to_s.strip.empty?
-          result = %w(AllowedValues AllowedPattern MaxLength MinLength MaxValue MinValue).map do |key|
-            if(parameter_definition[key])
-              res = self.send(snake(key), value, parameter_definition)
-              res == true ? true : [snake(key), res]
-            else
-              true
-            end
-          end
-          result.delete_if{|x| x == true}
-          result.empty? ? true : result
-        end
-
-        # Parameter is within allowed values
-        #
-        # @param value [String]
-        # @param pdef [Hash] parameter definition
-        # @option pdef [Array<String>] 'AllowedValues'
-        # @return [TrueClass, String]
-        def allowed_values(value, pdef)
-          if(pdef['AllowedValues'].include?(value))
-            true
-          else
-            "Not an allowed value: #{pdef['AllowedValues'].join(', ')}"
-          end
-        end
-
-        # Parameter matches allowed pattern
-        #
-        # @param value [String]
-        # @param pdef [Hash] parameter definition
-        # @option pdef [String] 'AllowedPattern'
-        # @return [TrueClass, String]
-        def allowed_pattern(value, pdef)
-          if(value.match(/#{pdef['AllowedPattern']}/))
-            true
-          else
-            "Not a valid pattern. Must match: #{pdef['AllowedPattern']}"
-          end
-        end
-
-        # Parameter length is less than or equal to max length
-        #
-        # @param value [String, Integer]
-        # @param pdef [Hash] parameter definition
-        # @option pdef [String] 'MaxLength'
-        # @return [TrueClass, String]
-        def max_length(value, pdef)
-          if(value.length <= pdef['MaxLength'].to_i)
-            true
-          else
-            "Value must not exceed #{pdef['MaxLength']} characters"
-          end
-        end
-
-        # Parameter length is greater than or equal to min length
-        #
-        # @param value [String]
-        # @param pdef [Hash] parameter definition
-        # @option pdef [String] 'MinLength'
-        # @return [TrueClass, String]
-        def min_length(value, pdef)
-          if(value.length >= pdef['MinLength'].to_i)
-            true
-          else
-            "Value must be at least #{pdef['MinLength']} characters"
-          end
-        end
-
-        # Parameter value is less than or equal to max value
-        #
-        # @param value [String]
-        # @param pdef [Hash] parameter definition
-        # @option pdef [String] 'MaxValue'
-        # @return [TrueClass, String]
-        def max_value(value, pdef)
-          if(value.to_i <= pdef['MaxValue'].to_i)
-            true
-          else
-            "Value must not be greater than #{pdef['MaxValue']}"
-          end
-        end
-
-        # Parameter value is greater than or equal to min value
-        #
-        # @param value [String]
-        # @param pdef [Hash] parameter definition
-        # @option pdef [String] 'MinValue'
-        # @return [TrueClass, String]
-        def min_value(value, pdef)
-          if(value.to_i >= pdef['MinValue'].to_i)
-            true
-          else
-            "Value must not be less than #{pdef['MinValue']}"
-          end
-        end
-
-      end
-    end
-  end
-end