knife-cloudformation 0.1.22 → 0.2.0

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

@@ -0,0 +1,28 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Utils
+
+    # Helper methods for string format modification
+    module AnimalStrings
+
+      # Camel case string
+      #
+      # @param string [String]
+      # @return [String]
+      def camel(string)
+        string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
+      end
+
+      # Snake case string
+      #
+      # @param string [String]
+      # @return [Symbol]
+      def snake(string)
+        string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Utils
+    # Debug helpers
+    module Debug
+      # Output helpers
+      module Output
+        # Write debug message
+        #
+        # @param msg [String]
+        def debug(msg)
+          puts "<KnifeCloudformation>: #{msg}" if ENV['DEBUG']
+        end
+      end
+
+      class << self
+        # Load module into class
+        #
+        # @param klass [Class]
+        def included(klass)
+          klass.class_eval do
+            include Output
+            extend Output
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Utils
+
+    # JSON helper methods
+    module JSON
+
+      # Attempt to load chef JSON compat helper
+      #
+      # @return [TrueClass, FalseClass] chef compat helper available
+      def try_json_compat
+        unless(@_json_loaded)
+          begin
+            require 'chef/json_compat'
+          rescue
+            require "#{ENV['RUBY_JSON_LIB'] || 'json'}"
+          end
+          @_json_loaded = true
+        end
+        defined?(Chef::JSONCompat)
+      end
+
+      # Convert to JSON
+      #
+      # @param thing [Object]
+      # @return [String]
+      def _to_json(thing)
+        if(try_json_compat)
+          Chef::JSONCompat.to_json(thing)
+        else
+          JSON.dump(thing)
+        end
+      end
+
+      # Load JSON data
+      #
+      # @param thing [String]
+      # @return [Object]
+      def _from_json(thing)
+        if(try_json_compat)
+          Chef::JSONCompat.from_json(thing)
+        else
+          JSON.read(thing)
+        end
+      end
+
+      # Format object into pretty JSON
+      #
+      # @param thing [Object]
+      # @return [String]
+      def _format_json(thing)
+        thing = _from_json(thing) if thing.is_a?(String)
+        if(try_json_compat)
+          Chef::JSONCompat.to_json_pretty(thing)
+        else
+          JSON.pretty_generate(thing)
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Utils
+
+    # Storage helpers
+    module ObjectStorage
+
+      # Write to file
+      #
+      # @param object [Object]
+      # @param path [String] path to write object
+      # @param directory [Miasma::Models::Storage::Directory]
+      # @return [String] file path
+      def file_store(object, path, directory)
+        raise NotImplementedError.new 'Internal updated required! :('
+        content = object.is_a?(String) ? object : Utils._format_json(object)
+        directory.files.create(
+          :identity => path,
+          :body => content
+        )
+        loc = directory.service.service.name.split('::').last.downcase
+        "#{loc}://#{directory.identity}/#{path}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'knife-cloudformation'
+
+module KnifeCloudformation
+  module Utils
+    # Output Helpers
+    module Output
+
+      # Process things and return items
+      #
+      # @param things [Array] items to process
+      # @param args [Hash] options
+      # @option args [TrueClass, FalseClass] :flat flatten result array
+      # @option args [Array] :attributes attributes to extract
+      # @todo this was extracted from events and needs to be cleaned up
+      def process(things, args={})
+        @event_ids ||= []
+        processed = things.reverse.map do |thing|
+          next if @event_ids.include?(thing['id'])
+          @event_ids.push(thing['id']).compact!
+          if(args[:attributes])
+            args[:attributes].map do |key|
+              thing[key].to_s
+            end
+          else
+            thing.values
+          end
+        end
+        args[:flat] ? processed.flatten : processed
+      end
+
+      # Generate formatted titles
+      #
+      # @param thing [Object] thing being processed
+      # @param args [Hash]
+      # @option args [Array] :attributes
+      # @return [Array<String>] formatted titles
+      def get_titles(thing, args={})
+        attrs = args[:attributes] || []
+        if(attrs.empty?)
+          hash = thing.is_a?(Array) ? thing.first : thing
+          hash ||= {}
+          attrs = hash.keys
+        end
+        titles = attrs.map do |key|
+          camel(key).gsub(/([a-z])([A-Z])/, '\1 \2')
+        end.compact
+        if(args[:format])
+          titles.map{|s| @ui.color(s, :bold)}
+        else
+          titles
+        end
+      end
+
+      # Output stack related things in nice format
+      #
+      # @param stack [String] name of stack
+      # @param things [Array] things to display
+      # @param what [String] description of things for output
+      # @param args [Symbol] options (:ignore_empty_output)
+      def things_output(stack, things, what, *args)
+        unless(args.include?(:no_title))
+          output = get_titles(things, :format => true, :attributes => allowed_attributes)
+        else
+          output = []
+        end
+        columns = allowed_attributes.size
+        output += process(things, :flat => true, :attributes => allowed_attributes)
+        output.compact!
+        if(output.empty?)
+          ui.warn 'No information found' unless args.include?(:ignore_empty_output)
+        else
+          ui.info "#{what.to_s.capitalize} for stack: #{ui.color(stack, :bold)}" if stack
+          ui.info "#{ui.list(output, :uneven_columns_across, columns)}"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,271 @@
+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