racker 0.1.0

data/lib/racker/builders/google.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'racker/builders/builder'
+
+module Racker
+  module Builders
+    # This is the Google builder
+    class Google < Racker::Builders::Builder
+      def to_packer(name, config)
+        log = Log4r::Logger['racker']
+        log.debug("Entering #{self.class}.#{__method__}")
+        config = super(name, config)
+
+        # There are no special cases at this point
+        
+        # %w().each do |key|
+        #   if config.key? key
+        #     log.info("Converting #{key} to packer value...")
+        #     config[key] = convert_hash_to_packer_value(config[key])
+        #   end
+        # end
+
+        log.debug("Leaving #{self.class}.#{__method__}")
+        config
+      end
+    end
+  end
+end

data/lib/racker/builders/openstack.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'racker/builders/builder'
+
+module Racker
+  module Builders
+    # This is the OpenStack builder
+    class OpenStack < Racker::Builders::Builder
+      def to_packer(name, config)
+        log = Log4r::Logger['racker']
+        log.debug("Entering #{self.class}.#{__method__}")
+        config = super(name, config)
+
+        # There are no special cases at this point
+
+        # %w().each do |key|
+        #   if config.key? key
+        #     log.info("Converting #{key} to packer value...")
+        #     config[key] = convert_hash_to_packer_value(config[key])
+        #   end
+        # end
+
+        log.debug("Leaving #{self.class}.#{__method__}")
+        config
+      end
+    end
+  end
+end

data/lib/racker/builders/qemu.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'racker/builders/builder'
+
+module Racker
+  module Builders
+    # This is the QEMU builder
+    class QEMU < Racker::Builders::Builder
+      def to_packer(name, config)
+        log = Log4r::Logger['racker']
+        log.debug("Entering #{self.class}.#{__method__}")
+        config = super(name, config)
+
+        %w(boot_command floppy_files iso_urls qemuargs).each do |key|
+          if config.key? key
+            log.info("Converting #{key} to packer value...")
+            config[key] = convert_hash_to_packer_value(config[key])
+          end
+        end
+
+        log.debug("Leaving #{self.class}.#{__method__}")
+        config
+      end
+    end
+  end
+end

data/lib/racker/builders/virtualbox.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'racker/builders/builder'
+
+module Racker
+  module Builders
+    # This is the Virtualbox builder
+    class Virtualbox < Racker::Builders::Builder
+      def to_packer(name, config)
+        log = Log4r::Logger['racker']
+        log.debug("Entering #{self.class}.#{__method__}")
+        config = super(name, config)
+
+        %w(boot_command floppy_files iso_urls vboxmanage).each do |key|
+          if config.key? key
+            log.info("Converting #{key} to packer value...")
+            config[key] = convert_hash_to_packer_value(config[key])
+          end
+        end
+
+        log.debug("Leaving #{self.class}.#{__method__}")
+        config
+      end
+    end
+  end
+end

data/lib/racker/builders/vmware.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'racker/builders/builder'
+
+module Racker
+  module Builders
+    # This is the VMware builder
+    class VMware < Racker::Builders::Builder
+      def to_packer(name, config)
+        log = Log4r::Logger['racker']
+        log.debug("Entering #{self.class}.#{__method__}")
+        config = super(name, config)
+
+        %w(boot_command floppy_files iso_urls vboxmanage).each do |key|
+          if config.key? key
+            log.info("Converting #{key} to packer value...")
+            config[key] = convert_hash_to_packer_value(config[key])
+          end
+        end
+
+        log.debug("Leaving #{self.class}.#{__method__}")
+        config
+      end
+    end
+  end
+end

data/lib/racker/cli.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+require 'optparse'
+require 'racker/processor'
+require 'racker/version'
+require 'log4r'
+
+module Racker
+  # The CLI is a class responsible for handling the command line interface
+  # logic.
+  class CLI
+    attr_reader :options
+
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def execute!
+      # Get the global logger
+      log = Log4r::Logger['racker']
+
+      # Parse our arguments
+      option_parser.parse!(@argv)
+
+      # Set the logging level specified by the command line
+      log.level = get_log4r_level(options[:log_level])
+      log.info("Log level set to: #{options[:log_level]}")
+
+      # Display the options if a minimum of 1 template and an output file is not provided
+      if @argv.length < 2
+        puts option_parser 
+        Kernel.exit!(1)
+      end
+
+      # Set the output file to the last arg
+      options[:output] = @argv.pop
+      log.debug("Output file set to: #{options[:output]}")
+
+      # Set the input files to the remaining args
+      options[:templates] = @argv
+
+      # Run through Racker
+      log.debug('Executing the Racker Processor...')
+      Processor.new(options).execute!
+      log.debug('Processing complete.')
+
+      # Thats all folks!
+      puts "Processing complete! Packer file generated: #{options[:output]}"
+
+      return 0
+    end
+   
+    private
+
+    def get_log4r_level(level)
+      case level
+      when /fatal/
+        Log4r::FATAL
+      when /error/
+        Log4r::ERROR
+      when /warn/
+        Log4r::WARN
+      when /info/
+        Log4r::INFO
+      when /debug/
+        Log4r::DEBUG
+      else
+        Log4r::INFO
+      end
+    end
+
+    def options
+      @options ||= {
+        log_level:     :warn,
+        output:        '',
+        templates:     [], 
+      }
+    end
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: #{opts.program_name} [options] [TEMPLATE1, TEMPLATE2, ...] OUTPUT"
+        
+        opts.on('-l', '--log-level [LEVEL]', [:fatal, :error, :warn, :info, :debug], 'Set log level') do |v|
+          options[:log_level] = v
+        end
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts option_parser
+          Kernel.exit!(0)
+        end
+
+        opts.on_tail('-v', '--version', "Show #{opts.program_name} version") do
+          puts Racker::Version.version
+          Kernel.exit!(0)
+        end
+      end
+    end
+  end
+end

data/lib/racker/processor.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'json'
+require 'racker/template'
+require 'pp'
+
+module Racker
+  # This class handles command line options.
+  class Processor
+
+    CONFIGURE_MUTEX = Mutex.new
+
+    def initialize(options)
+      @options = options
+    end
+
+    def execute!
+      # Get the global logger
+      log = Log4r::Logger['racker']
+      
+      # Verify that the templates exist
+      @options[:templates].each do |template|
+        raise "File does not exist!  (#{template})" unless ::File.exists?(template)
+      end
+
+      # Check that the output directory exists
+      output_dir = File.dirname(File.expand_path(@options[:output]))
+
+      # If the output directory doesnt exist
+      log.info('Creating the output directory if it does not exist...')
+      FileUtils.mkdir_p output_dir unless File.exists? output_dir
+
+      # Load the templates
+      templates = []
+
+      # Load the template procs
+      log.info('Loading racker templates...')
+      template_procs = load(@options[:templates])
+
+      # Load the actual templates
+      log.info('Processing racker templates...')
+      template_procs.each do |version,proc|
+        # Create the new template
+        template = Racker::Template.new
+
+        # Run the block with the template
+        proc.call(template)
+
+        # Store the template
+        templates << template
+      end
+      log.info('Racker template processing complete.')
+
+      # Get the first template and merge each subsequent one on the latest
+      log.info('Merging racker templates...')
+      current_template = templates.shift
+
+      # Overlay the templates
+      templates.each do |template|
+        current_template = current_template.deep_merge!(template, {:knockout_prefix => '--'})
+      end
+      
+      # Compact the residual template to remove nils
+      log.info('Compacting racker template...')
+      compact_template = current_template.compact(:recurse => true)
+
+      # Write the compact template out to file
+      File.open(@options[:output], 'w') do |file|
+        log.info('Writing packer template...') 
+        file.write(JSON.pretty_generate(compact_template.to_packer))
+        log.info('Writing packer template complete.') 
+      end
+    end
+
+    def load(templates)
+      return capture_templates do
+        templates.each do |template|
+          puts "Loading template file: #{template}"
+          Kernel.load template
+        end
+      end
+    end
+
+    # This is a class method so the templates can load it
+    def self.register_template(version='1',&block)
+      @@last_procs ||= []
+      @@last_procs << [version, block]
+    end
+
+    def capture_templates
+      CONFIGURE_MUTEX.synchronize do
+        @@last_procs = []
+
+        yield
+
+        return @@last_procs
+      end
+    end
+  end
+end

data/lib/racker/smash/deep_merge_modified.rb

@@ -0,0 +1,210 @@
+module DeepMergeModified
+
+  class InvalidParameter < StandardError; end
+
+  DEFAULT_FIELD_KNOCKOUT_PREFIX = '--'
+
+  # Deep Merge core documentation.
+  # deep_merge! method permits merging of arbitrary child elements. The two top level
+  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+  # of child elements. These child elements to not have to be of the same types.
+  # Where child elements are of the same type, deep_merge will attempt to merge them together.
+  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+  # the destination element with the contents of the source element at that level.
+  # So if you have two hashes like this:
+  #   source = {:x => [1,2,3], :y => 2}
+  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+  #   dest.deep_merge!(source)
+  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+  # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+  # To avoid this, use "deep_merge" (no bang/exclamation mark)
+  #
+  # Options:
+  #   Options are specified in the last parameter passed, which should be in hash format:
+  #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+  #   :preserve_unmergeables  DEFAULT: false
+  #      Set to true to skip any unmergeable elements from source
+  #   :knockout_prefix        DEFAULT: nil
+  #      Set to string value to signify prefix which deletes elements from existing element
+  #   :sort_merged_arrays     DEFAULT: false
+  #      Set to true to sort all arrays that are merged together
+  #   :unpack_arrays          DEFAULT: nil
+  #      Set to string value to run "Array::join" then "String::split" against all arrays
+  #   :merge_hash_arrays      DEFAULT: false
+  #      Set to true to merge hashes within arrays
+  #   :merge_debug            DEFAULT: false
+  #      Set to true to get console output of merge process for debugging
+  #
+  # Selected Options Details:
+  # :knockout_prefix => The purpose of this is to provide a way to remove elements
+  #   from existing Hash by specifying them in a special way in incoming hash
+  #    source = {:x => ['--1', '2']}
+  #    dest   = {:x => ['1', '3']}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ['2','3']}
+  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
+  #   the entire element to be removed:
+  #    source = {:x => '--'}
+  #    dest   = {:x => [1,2,3]}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ""}
+  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
+  #   in as strings and to be converted into discrete array elements
+  #   irsource = {:x => ['1,2,3', '4']}
+  #   dest   = {:x => ['5','6','7,8']}
+  #   dest.deep_merge!(source, {:unpack_arrays => ','})
+  #   Results: {:x => ['1','2','3','4','5','6','7','8'}
+  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox
+  #    to pass multiple values from within a single HTML element
+  #
+  # :merge_hash_arrays => merge hashes within arrays
+  #   source = {:x => [{:y => 1}]}
+  #   dest   = {:x => [{:z => 2}]}
+  #   dest.deep_merge!(source, {:merge_hash_arrays => true})
+  #   Results: {:x => [{:y => 1, :z => 2}]}
+  # 
+  # There are many tests for this library - and you can learn more about the features
+  # and usages of deep_merge! by just browsing the test examples
+  def self.deep_merge!(source, dest, options = {})
+    # turn on this line for stdout debugging text
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || nil
+    raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
+    raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
+    # if present: we will split and join arrays on this char before merging
+    array_split_char = options[:unpack_arrays] || false
+    # request that we sort together any arrays when they are merged
+    sort_merged_arrays = options[:sort_merged_arrays] || false
+    # request that arrays of hashes are merged together
+    merge_hash_arrays = options[:merge_hash_arrays] || false
+    di = options[:debug_indent] || ''
+    # do nothing if source is nil
+    return dest if source.nil?
+    # if dest doesn't exist, then simply copy source to it
+    if !(dest) && overwrite_unmergeable
+      dest = source; return dest
+    end
+
+    puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
+    if source.kind_of?(Hash)
+      puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      source.each do |src_key, src_value|
+        if dest.kind_of?(Hash)
+          puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
+          if dest[src_key]
+            puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
+            dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
+          else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
+            puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
+            # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
+            begin
+              src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
+            rescue TypeError
+              src_dup = src_value
+            end
+            dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
+          end
+        else # dest isn't a hash, so we overwrite it completely (if permitted)
+          if overwrite_unmergeable
+            puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
+            dest = overwrite_unmergeables(source, dest, options)
+          end
+        end
+      end
+    elsif source.kind_of?(Array)
+      puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      # if we are instructed, join/split any source arrays before processing
+      if array_split_char
+        puts "#{di} split/join on source: #{source.inspect}" if merge_debug
+        source = source.join(array_split_char).split(array_split_char)
+        if dest.kind_of?(Array)
+          dest = dest.join(array_split_char).split(array_split_char)
+        end
+      end
+      # if there's a naked knockout_prefix in source, that means we are to truncate dest
+      if source.index(knockout_prefix)
+        dest = clear_or_nil(dest); source.delete(knockout_prefix)
+      end
+      if dest.kind_of?(Array)
+        if knockout_prefix
+          print "#{di} knocking out: " if merge_debug
+          # remove knockout prefix items from both source and dest
+          source.delete_if do |ko_item|
+            retval = false
+            item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
+            if item != ko_item
+              print "#{ko_item} - " if merge_debug
+              dest.delete(item)
+              dest.delete(ko_item)
+              retval = true
+            end
+            retval
+          end
+          puts if merge_debug
+        end
+        puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+        source_all_hashes = source.all? { |i| i.kind_of?(Hash) }
+        dest_all_hashes = dest.all? { |i| i.kind_of?(Hash) }
+        if merge_hash_arrays && source_all_hashes && dest_all_hashes
+          # merge hashes in lists
+          list = []
+          dest.each_index do |i|
+            list[i] = deep_merge!(source[i] || {}, dest[i],
+                                  options.merge(:debug_indent => di + '  '))
+          end
+          list += source[dest.count..-1] if source.count > dest.count
+          dest = list
+        else
+          dest = dest | source
+        end
+        dest.sort! if sort_merged_arrays
+      elsif overwrite_unmergeable
+        puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = overwrite_unmergeables(source, dest, options)
+      end
+    else # src_hash is not an array or hash, so we'll have to overwrite dest
+      puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      dest = overwrite_unmergeables(source, dest, options)
+    end
+    puts "#{di}Returning #{dest.inspect}" if merge_debug
+    dest
+  end # deep_merge!
+
+  # allows deep_merge! to uniformly handle overwriting of unmergeable entities
+  def self.overwrite_unmergeables(source, dest, options)
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || false
+    di = options[:debug_indent] || ''
+    if knockout_prefix && overwrite_unmergeable
+      if source.kind_of?(String) # remove knockout string from source before overwriting dest
+        src_tmp = source.gsub(%r{^#{knockout_prefix}},"")
+      elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
+        src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
+      else
+        src_tmp = source
+      end
+      if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
+        puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = src_tmp
+      else # if we do find a knockout_prefix, then we just delete dest
+        puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
+        dest = nil
+      end
+    elsif overwrite_unmergeable
+      dest = source
+    end
+    dest
+  end
+
+  def self.clear_or_nil(obj)
+    if obj.respond_to?(:clear)
+      obj.clear
+    else
+      obj = nil
+    end
+    obj
+  end
+
+end # module DeepMergeModified