racker 0.1.6 → 0.2.0

data/lib/racker/cli.rb

@@ -2,12 +2,15 @@
 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
+    include Racker::LogSupport
+
+    STDOUT_TOKEN = '-'
+
     attr_reader :options
 
     def initialize(argv)
@@ -15,74 +18,60 @@ module Racker
     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]}")
+      Racker::LogSupport.level = 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 
+        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 output file to the last arg. A single dash can be supplied to
+      # indicate that the compiled template should be written to STDOUT. Output
+      # to STDOUT assumes the quiet option.
+      options[:output] = output = @argv.pop
+      logger.debug("Output file set to: #{output}")
+
+      # Output to STDOUT assumes quiet mode
+      @options[:quiet] = true if output == STDOUT_TOKEN
 
       # 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.')
+      logger.debug('Executing the Racker Processor...')
+      template = Processor.new(options).execute!
+
+      write(output, template)
 
       # Thats all folks!
+      logger.debug('Processing complete.')
       puts "Processing complete!" unless options[:quiet]
       puts "Packer file generated: #{options[:output]}" unless options[:quiet]
 
       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
+    private
 
     def options
       @options ||= {
         log_level:     :warn,
-        knockout:      '~~', 
+        knockout:      '~~',
         output:        '',
         templates:     [],
-        quiet:         false, 
+        quiet:         false,
       }
     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
@@ -106,5 +95,41 @@ module Racker
         end
       end
     end
+
+    private
+
+    def write(output_path, template)
+      if output_path == STDOUT_TOKEN
+        write_to_stdout(template)
+      else
+        write_to_file(template, output_path)
+      end
+      true
+    end
+
+    def write_to_file(template, path)
+      path = File.expand_path(path)
+      output_dir = File.dirname(path)
+
+      # Create output directory if it does not exist
+      unless File.directory?(output_dir)
+        logger.info(%Q[Creating output directory "#{output_dir}"])
+        FileUtils.mkdir_p(output_dir)
+      end
+
+      File.open(path, 'w') { |file| write_to_stream(template, file, path) }
+    end
+
+    def write_to_stdout(template)
+      write_to_stream(template, $stdout, :STDOUT)
+    end
+
+    def write_to_stream(template, stream, stream_name)
+      logger.info("Writing packer template to #{stream_name}")
+      stream.write(template)
+      stream.flush if stream.respond_to?(:flush)
+      logger.info("Writing packer template to #{stream_name} complete.")
+    end
+
   end
 end

data/lib/racker/log_support.rb

@@ -0,0 +1,47 @@
+require 'log4r'
+
+module Racker
+  module LogSupport
+    unless Log4r::Logger['racker']
+      # Create the initial logger
+      logger = Log4r::Logger.new('racker')
+
+      # Set the output to STDOUT
+      logger.outputters = Log4r::Outputter.stdout
+
+      # We set the initial log level to ERROR
+      logger.level = Log4r::ERROR
+    end
+
+    def self.level=(level)
+      log_level = log4r_level_for(level)
+      logger.level = log_level
+      logger.info("Log level set to: #{log_level}")
+    end
+
+    def self.log4r_level_for(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 self.logger
+      Log4r::Logger['racker']
+    end
+
+    def logger
+      Racker::LogSupport.logger
+    end
+  end
+end

data/lib/racker/processor.rb

@@ -8,6 +8,7 @@ require 'pp'
 module Racker
   # This class handles command line options.
   class Processor
+    include Racker::LogSupport
 
     CONFIGURE_MUTEX = Mutex.new
 
@@ -16,30 +17,20 @@ module Racker
     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...')
+      logger.info('Loading racker templates...')
       template_procs = load(@options[:templates])
 
       # Load the actual templates
-      log.info('Processing racker templates...')
+      logger.info('Processing racker templates...')
       template_procs.each do |version,proc|
         # Create the new template
         template = Racker::Template.new
@@ -50,27 +41,23 @@ module Racker
         # Store the template
         templates << template
       end
-      log.info('Racker template processing complete.')
+      logger.info('Racker template processing complete.')
 
       # Get the first template and merge each subsequent one on the latest
-      log.info('Merging racker templates...')
+      logger.info('Merging racker templates...')
       current_template = templates.shift
 
       # Overlay the templates
       templates.each do |template|
         current_template = current_template.deep_merge!(template, {:knockout_prefix => @options[:knockout]})
       end
-      
+
       # Compact the residual template to remove nils
-      log.info('Compacting racker template...')
+      logger.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
+      # Pretty-print the JSON template
+      JSON.pretty_generate(compact_template.to_packer)
     end
 
     def load(templates)
@@ -98,4 +85,4 @@ module Racker
       end
     end
   end
-end
+end

data/lib/racker/smash/deep_merge_modified.rb

@@ -62,7 +62,7 @@ module DeepMergeModified
   #   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 = {})

data/lib/racker/template.rb

@@ -7,6 +7,7 @@ require 'racker/builders/docker'
 require 'racker/builders/google'
 require 'racker/builders/null'
 require 'racker/builders/openstack'
+require 'racker/builders/parallels'
 require 'racker/builders/qemu'
 require 'racker/builders/virtualbox'
 require 'racker/builders/vmware'
@@ -14,22 +15,21 @@ require 'racker/builders/vmware'
 module Racker
   # This class handles the bulk of the legwork working with Racker templates
   class Template < Smash
+    include Racker::LogSupport
+
     # This formats the template into packer format hash
     def to_packer
-      # Get the global logger
-      log = Log4r::Logger['racker']
-      
       # Create the new smash
       packer = Smash.new
 
       # Variables
       packer['variables'] = self['variables'].dup unless self['variables'].nil? || self['variables'].empty?
-      
+
       # Builders
       packer['builders'] = [] unless self['builders'].nil? || self['builders'].empty?
-      log.info("Processing builders...")
+      logger.info("Processing builders...")
       self['builders'].each do |name,config|
-        log.info("Processing builder: #{name} with type: #{config['type']}")
+        logger.info("Processing builder: #{name} with type: #{config['type']}")
 
         # Get the builder for this config
         builder = get_builder(config['type'])
@@ -40,19 +40,19 @@ module Racker
 
       # Provisioners
       packer['provisioners'] = [] unless self['provisioners'].nil? || self['provisioners'].empty?
-      log.info("Processing provisioners...")
+      logger.info("Processing provisioners...")
       self['provisioners'].sort.map do |index, provisioners|
         provisioners.each do |name,config|
-          log.debug("Processing provisioner: #{name}")
+          logger.debug("Processing provisioner: #{name}")
          packer['provisioners'] << config.dup
         end
       end
 
       # Post-Processors
       packer['post-processors'] = [] unless self['postprocessors'].nil? || self['postprocessors'].empty?
-      log.info("Processing post-processors...")
+      logger.info("Processing post-processors...")
       self['postprocessors'].each do |name,config|
-        log.debug("Processing post-processor: #{name}")
+        logger.debug("Processing post-processor: #{name}")
         packer['post-processors'] << config.dup unless config.nil?
       end
 

data/lib/racker/version.rb

@@ -4,8 +4,8 @@ module Racker
   # This defines the version of the gem
   module Version
     MAJOR = 0
-    MINOR = 1
-    PATCH = 6
+    MINOR = 2
+    PATCH = 0
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/spec/fixtures/high_priority_template.rb

@@ -0,0 +1,6 @@
+Racker::Processor.register_template do |t|
+  t.variables = {
+    :iso_url => 'priority.img',
+    :password => '~~',
+  }
+end

data/spec/fixtures/low_priority_template.rb

@@ -0,0 +1,7 @@
+Racker::Processor.register_template do |t|
+  t.variables = {
+    :iso_url => 'os.img',
+    :password => 'password',
+    :nil => nil,
+  }
+end

data/spec/integration/output_to_file_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe :output_to_file do
+  before(:all) do
+    @output_path = "/tmp/#{SecureRandom.uuid}/this_directory_should_not_exist/template.json"
+    @instance = Racker::CLI.new(['-q', fixture_path('low_priority_template.rb'), @output_path])
+  end
+
+  context 'when successful' do
+    it 'writes the computed template to the given path' do
+      output_dir = File.dirname(@output_path)
+      FileUtils.rm_rf(output_dir) if Dir.exists?(output_dir)
+
+      @instance.execute!
+      expect(File.exists?(@output_path)).to eq(true)
+
+      result = JSON.parse(File.read(@output_path))
+      expect(result).to eq(parsed_low_priority_template)
+    end
+  end
+end

data/spec/integration/output_to_stdout_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe :output_to_stdout do
+  before(:all) do
+    @instance = Racker::CLI.new([fixture_path('low_priority_template.rb'), '-'])
+  end
+
+  context 'when successful' do
+    it 'writes the computed template to $stdout' do
+      pretty_output = JSON.pretty_generate(parsed_low_priority_template)
+      expect(@instance).to receive(:puts).never
+      expect($stdout).to receive(:write).with(pretty_output)
+      @instance.execute!
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'racker'
+
+class RSpec::Core::ExampleGroup
+  FIXTURE_DIR = File.expand_path('../fixtures', __FILE__)
+  PARSED_LOW_PRIORITY_TEMPLATE = {
+    'variables' => {
+      'iso_url' => 'os.img',
+      'password' => 'password',
+    },
+  }.freeze
+
+  def fixture_path(filename)
+    File.join(FIXTURE_DIR, filename.to_s)
+  end
+
+  def parsed_low_priority_template
+    PARSED_LOW_PRIORITY_TEMPLATE
+  end
+end

data/spec/unit/cli_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+RSpec.describe Racker::CLI do
+
+  context '#execute!' do
+    it 'exits with a status of 1 if fewer than 2 arguments were received' do
+      allow(Kernel).to receive(:exit!)
+
+      instance = Racker::CLI.new(['template.rb'])
+      allow(instance).to receive(:puts)
+
+      # This next call is going to break somewhere because we stubbed the exit!
+      # call, so catch any error that occurs.
+      instance.execute! rescue nil
+
+      # set expextation on puts to silence output
+      expect(instance).to have_received(:puts)
+      expect(Kernel).to have_received(:exit!).with(1)
+    end
+
+    context 'with valid options' do
+      before(:each) do
+        @immutable_argv = ['template.rb', 'environment.rb', 'template.json'].freeze
+        @argv = @immutable_argv.dup
+        @instance = Racker::CLI.new(@argv)
+        @options = @instance.send(:options)
+        @options[:quiet] = true
+        # Prevent fake file from being written
+        allow(File).to receive(:open)
+      end
+
+      it 'uses the last argument for the value of the output option' do
+        allow_any_instance_of(Racker::Processor).to receive(:execute!)
+        @instance.execute!
+        expect(@options[:output]).to eq(@immutable_argv.last)
+      end
+
+      it 'uses all arguments except the last for the value of the templates option' do
+        allow_any_instance_of(Racker::Processor).to receive(:execute!)
+        @instance.execute!
+        expect(@options[:templates]).to eq(@immutable_argv[0..-2])
+      end
+
+      it 'initializes and executes a new Racker::Processor with the given options' do
+        processor_instance = Racker::Processor.new(@options)
+        expect(Racker::Processor).to receive(:new) { processor_instance }.with(@options)
+        expect(processor_instance).to receive(:execute!)
+        @instance.execute!
+      end
+
+      it 'outputs no message when quieted' do
+        @options[:quiet] = true
+        allow_any_instance_of(Racker::Processor).to receive(:execute!)
+        expect(@instance).not_to receive(:puts)
+        @instance.execute!
+      end
+
+      it 'outputs a message upon success when not quieted' do
+        @options[:quiet] = false
+        allow_any_instance_of(Racker::Processor).to receive(:execute!)
+        expect(@instance).to receive(:puts).at_least(1)
+        @instance.execute!
+      end
+
+      it 'returns 0 on success' do
+        allow_any_instance_of(Racker::Processor).to receive(:execute!)
+        expect(@instance.execute!).to eq(0)
+      end
+    end
+  end
+
+  context '#initialize' do
+    it 'sets the @argv instance variable to the provided argument' do
+      instance = described_class.new(argv = [])
+      expect(instance.instance_variable_get(:@argv).object_id).to eq(argv.object_id)
+    end
+  end
+
+  context '#option_parser' do
+    before(:each) { @instance = described_class.new([]) }
+
+    it 'returns a new default OptionParser if none exists' do
+      expect(@instance.instance_variable_get(:@option_parser)).to eq(nil)
+      expect(@instance.send(:option_parser)).to be_an(OptionParser)
+    end
+
+    it 'returns the same OptionParser on subsequent calls' do
+      first_option_parser = @instance.send(:option_parser)
+      second_option_parser = @instance.send(:option_parser)
+      expect(second_option_parser).to be(first_option_parser)
+    end
+  end
+
+  context '#options' do
+    before(:each) { @instance = described_class.new([]) }
+
+    it 'returns a Hash of default options if none exists' do
+      expect(@instance.instance_variable_get(:@options)).to eq(nil)
+      options = @instance.send(:options)
+      expect(options).to eq({
+        log_level:     :warn,
+        knockout:      '~~',
+        output:        '',
+        templates:     [],
+        quiet:         false,
+      })
+    end
+
+    it 'returns the same Hash on subsequent calls' do
+      first_options = @instance.send(:options)
+      second_options = @instance.send(:options)
+      expect(second_options).to be(first_options)
+    end
+  end
+
+  context 'option parser' do
+    before(:all) { @instance = described_class.new([]) }
+    before(:each) do
+      @instance.instance_variable_set(:@option_parser, nil)
+      @instance.instance_variable_set(:@options, nil)
+      @parser = @instance.send(:option_parser)
+      @options = @instance.send(:options)
+    end
+
+    context 'log_level' do
+      %w[-l --log-level].each do |format|
+        it "is triggered by the #{format} arg" do
+          @options.delete(:log_level)
+          @parser.parse!(%W[#{format} fatal])
+          expect(@options[:log_level]).to be(:fatal)
+        end
+      end
+
+      %w[debug error fatal info warn].each do |log_level|
+        it "supports a log level of #{log_level}" do
+          @options.delete(:log_level)
+          @parser.parse!(%W[-l #{log_level}])
+          expect(@options[:log_level]).to be(log_level.to_sym)
+        end
+      end
+
+      it 'defaults invalid log levels to nil' do
+        @options.delete(:log_level)
+        @parser.parse!(%W[-l foo])
+        expect(@options[:log_level]).to be(nil)
+      end
+    end
+
+    context 'knockout' do
+      %w[-k --knockout].each do |format|
+        it "is triggered by the #{format} arg" do
+          @options.delete(:knockout)
+          @parser.parse!(%W[#{format} xxx])
+          expect(@options[:knockout]).to eq('xxx')
+        end
+      end
+    end
+
+    context 'quiet' do
+      %w[-q --quiet].each do |format|
+        it "is triggered by the #{format} arg" do
+          @options.delete(:quiet)
+          @parser.parse!([format])
+          expect(@options[:quiet]).to eq(true)
+        end
+      end
+    end
+
+    context 'help' do
+      %w[-h --help].each do |format|
+        it "is triggered by the #{format} arg" do
+          expect(@instance).to receive(:puts)
+          expect(Kernel).to receive(:exit!)
+          @parser.parse!([format])
+        end
+      end
+
+      it 'outputs help then exits with a status of 0' do
+        expect(@instance).to receive(:puts)
+        expect(Kernel).to receive(:exit!).with(0)
+        @parser.parse!(['--help'])
+      end
+    end
+
+    context 'version' do
+      %w[-v --version].each do |format|
+        it "is triggered by the #{format} arg" do
+          expect(@instance).to receive(:puts)
+          expect(Kernel).to receive(:exit!)
+          @parser.parse!([format])
+        end
+      end
+
+      it 'outputs the version then exits with a status of 0' do
+        expect(@instance).to receive(:puts)
+        expect(Kernel).to receive(:exit!).with(0)
+        @parser.parse!(['--version'])
+      end
+    end
+  end
+end